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 // Init the parameters with the default values
659 bool aIsASCII_STL = true;
660 bool toCreateGroups = false;
662 toCreateGroups = resMgr->booleanValue( "SMESH", "auto_groups", false );
663 bool toOverwrite = true;
664 bool toFindOutDim = true;
666 QString aFilter, aTitle = QObject::tr("SMESH_EXPORT_MESH");
667 QString anInitialPath = "";
668 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
669 anInitialPath = QDir::currentPath();
671 QList< QPair< GEOM::ListOfFields_var, QString > > aFieldList;
673 // Get a file name to write in and additional otions
674 if ( isUNV || isDAT || isGMF ) // Export w/o options
677 aFilter = QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)";
679 aFilter = QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)";
681 aFilter = QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" +
682 ";;" + QObject::tr( "GMF_BINARY_FILES_FILTER" ) + " (*.meshb)";
683 if ( anInitialPath.isEmpty() ) anInitialPath = SUIT_FileDlg::getLastVisitedPath();
684 aFilename = SUIT_FileDlg::getFileName(SMESHGUI::desktop(),
685 anInitialPath + QString("/") + aMeshName,
686 aFilter, aTitle, false);
688 else if ( isCGNS )// Export to CGNS
690 const char* theByTypeResource = "cgns_group_elems_by_type";
691 toCreateGroups = SMESHGUI::resourceMgr()->booleanValue( "SMESH", theByTypeResource, false );
693 QStringList checkBoxes;
694 checkBoxes << QObject::tr("CGNS_EXPORT_ELEMS_BY_TYPE");
696 SalomeApp_CheckFileDlg* fd =
697 new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true );
698 fd->setWindowTitle( aTitle );
699 fd->setNameFilter( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
700 if ( !anInitialPath.isEmpty() )
701 fd->setDirectory( anInitialPath );
702 fd->selectFile(aMeshName);
703 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
704 fd->setValidator( fv );
705 fd->SetChecked( toCreateGroups, 0 );
708 aFilename = fd->selectedFile();
709 toOverwrite = fv->isOverwrite();
710 toCreateGroups = fd->IsChecked(0);
711 SMESHGUI::resourceMgr()->setValue("SMESH", theByTypeResource, toCreateGroups );
715 else if ( isSTL ) // Export to STL
717 QMap<QString, int> aFilterMap;
718 aFilterMap.insert( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)", 1 );
719 aFilterMap.insert( QObject::tr( "STL_BIN_FILES_FILTER" ) + " (*.stl)", 0 );
722 QMap<QString, int>::const_iterator it = aFilterMap.begin();
723 for ( ; it != aFilterMap.end(); ++it )
724 filters.push_back( it.key() );
726 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
727 fd->setWindowTitle( aTitle );
728 fd->setNameFilters( filters );
729 fd->selectNameFilter( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
730 if ( !anInitialPath.isEmpty() )
731 fd->setDirectory( anInitialPath );
732 fd->selectFile(aMeshName);
736 aFilename = fd->selectedFile();
737 aIsASCII_STL = (aFilterMap[fd->selectedNameFilter()]) == 1 ? true: false;
742 else if ( isMED || isSAUV ) // Export to MED or SAUV
746 filters << QObject::tr( "MED_FILES_FILTER" ) + " (*.med)";
749 filters << QObject::tr( "SAUV_FILES_FILTER" ) + " (*.sauv *.sauve)";
752 QStringList checkBoxes;
753 checkBoxes << QObject::tr("SMESH_AUTO_GROUPS") << QObject::tr("SMESH_AUTO_DIM");
755 SMESHGUI_FieldSelectorWdg* fieldSelWdg = new SMESHGUI_FieldSelectorWdg();
756 QList< QWidget* > wdgList;
757 if ( fieldSelWdg->GetAllFields( aMeshList, aFieldList ))
758 wdgList.append( fieldSelWdg );
760 SalomeApp_CheckFileDlg* fd =
761 new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true, wdgList );
762 fd->setWindowTitle( aTitle );
763 fd->setNameFilters( filters );
764 fd->SetChecked( toCreateGroups, 0 );
765 fd->SetChecked( toFindOutDim, 1 );
766 if ( !anInitialPath.isEmpty() )
767 fd->setDirectory( anInitialPath );
768 fd->selectFile(aMeshName);
771 QListView *lview = fd->findChild<QListView*>("listView");
773 lview->setMinimumHeight(200);
775 QTreeView *tview = fd->findChild<QTreeView*>("treeView");
777 tview->setMinimumHeight(200);
780 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
781 fd->setValidator( fv );
786 aFilename = fd->selectedFile();
788 aFilename = QString::null;
791 toOverwrite = fv->isOverwrite();
793 if ( !aFilename.isEmpty() ) {
795 // can't append to an existing using other format
796 bool isVersionOk = SMESHGUI::GetSMESHGen()->CheckCompatibility( aFilename.toUtf8().constData() );
797 if ( !isVersionOk ) {
798 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
799 QObject::tr("SMESH_WRN_WARNING"),
800 QObject::tr("SMESH_EXPORT_MED_VERSION_COLLISION").arg(aFilename),
801 QObject::tr("SMESH_BUT_YES"),
802 QObject::tr("SMESH_BUT_NO"), 0, 1);
809 QStringList aMeshNamesCollisionList;
810 SMESH::string_array_var aMeshNames = SMESHGUI::GetSMESHGen()->GetMeshNames( aFilename.toUtf8().constData() );
811 for( int i = 0, n = aMeshNames->length(); i < n; i++ ) {
812 QString anExistingMeshName( aMeshNames[ i ] );
813 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
814 QString anExportMeshName = (*aMeshIter).second;
815 if( anExportMeshName == anExistingMeshName ) {
816 aMeshNamesCollisionList.append( anExportMeshName );
821 if( !aMeshNamesCollisionList.isEmpty() ) {
822 QString aMeshNamesCollisionString = aMeshNamesCollisionList.join( ", " );
823 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
824 QObject::tr("SMESH_WRN_WARNING"),
825 QObject::tr("SMESH_EXPORT_MED_MESH_NAMES_COLLISION").arg(aMeshNamesCollisionString),
826 QObject::tr("SMESH_BUT_YES"),
827 QObject::tr("SMESH_BUT_NO"),
828 QObject::tr("SMESH_BUT_CANCEL"), 0, 2);
837 toCreateGroups = fd->IsChecked(0);
838 toFindOutDim = fd->IsChecked(1);
839 fieldSelWdg->GetSelectedFields();
840 if ( !fieldSelWdg->parent() )
851 if ( !aFilename.isEmpty() ) {
852 // Check whether the file already exists and delete it if yes
853 QFile aFile( aFilename );
854 if ( aFile.exists() && toOverwrite )
856 SUIT_OverrideCursor wc;
859 // Renumbering is not needed since SMDS redesign in V6.2.0 (Nov 2010)
860 // bool Renumber = false;
861 // // PAL 14172 : Check of we have to renumber or not from the preferences before export
863 // Renumber= resMgr->booleanValue("renumbering");
865 // SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
866 // aMeshEditor->RenumberNodes();
867 // aMeshEditor->RenumberElements();
868 // if ( SMESHGUI::automaticUpdate() )
869 // SMESH::UpdateView();
873 aMeshIter = aMeshList.begin();
874 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
876 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
877 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
878 const GEOM::ListOfFields& fields = aFieldList[ aMeshIndex ].first.in();
879 const QString& geoAssFields = aFieldList[ aMeshIndex ].second;
880 const bool hasFields = ( fields.length() || !geoAssFields.isEmpty() );
881 if ( !hasFields && aMeshOrGroup->_is_equivalent( aMeshItem ))
882 aMeshItem->ExportMED( aFilename.toUtf8().data(), toCreateGroups,
883 toOverwrite && aMeshIndex == 0, toFindOutDim );
885 aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups,
886 toOverwrite && aMeshIndex == 0, toFindOutDim,
887 fields, geoAssFields.toLatin1().data() );
892 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ )
894 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
895 if( !aMeshItem->_is_nil() )
896 aMeshItem->ExportSAUV( aFilename.toUtf8().data(), toCreateGroups );
901 if ( aMeshOrGroup->_is_equivalent( aMesh ))
902 aMesh->ExportDAT( aFilename.toUtf8().data() );
904 aMesh->ExportPartToDAT( aMeshOrGroup, aFilename.toUtf8().data() );
908 if ( aMeshOrGroup->_is_equivalent( aMesh ))
909 aMesh->ExportUNV( aFilename.toUtf8().data() );
911 aMesh->ExportPartToUNV( aMeshOrGroup, aFilename.toUtf8().data() );
915 if ( aMeshOrGroup->_is_equivalent( aMesh ))
916 aMesh->ExportSTL( aFilename.toUtf8().data(), aIsASCII_STL );
918 aMesh->ExportPartToSTL( aMeshOrGroup, aFilename.toUtf8().data(), aIsASCII_STL );
922 aMeshIter = aMeshList.begin();
923 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
925 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
926 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
927 aMeshItem->ExportCGNS( aMeshOrGroup,
928 aFilename.toUtf8().data(),
929 toOverwrite && aMeshIndex == 0,
935 toCreateGroups = true;
936 aMesh->ExportGMF( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups );
939 catch (const SALOME::SALOME_Exception& S_ex){
941 SUIT_MessageBox::warning(SMESHGUI::desktop(),
942 QObject::tr("SMESH_WRN_WARNING"),
943 QObject::tr("SMESH_EXPORT_FAILED"));
949 inline void InverseEntityMode(unsigned int& theOutputMode,
950 unsigned int theMode)
952 bool anIsNotPresent = ~theOutputMode & theMode;
954 theOutputMode |= theMode;
956 theOutputMode &= ~theMode;
959 void SetDisplayEntity(int theCommandID)
961 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
962 SALOME_ListIO selected;
964 aSel->selectedObjects( selected );
966 if ( selected.Extent() >= 1 ) {
967 SUIT_OverrideCursor wc;
968 SALOME_ListIteratorOfListIO It( selected );
969 for( ; It.More(); It.Next()){
970 Handle(SALOME_InteractiveObject) IObject = It.Value();
971 if(IObject->hasEntry()){
972 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
973 unsigned int aMode = anActor->GetEntityMode();
974 switch(theCommandID){
975 case SMESHOp::OpDE0DElements: InverseEntityMode(aMode,SMESH_Actor::e0DElements); break;
976 case SMESHOp::OpDEEdges: InverseEntityMode(aMode,SMESH_Actor::eEdges); break;
977 case SMESHOp::OpDEFaces: InverseEntityMode(aMode,SMESH_Actor::eFaces); break;
978 case SMESHOp::OpDEVolumes: InverseEntityMode(aMode,SMESH_Actor::eVolumes); break;
979 case SMESHOp::OpDEBalls: InverseEntityMode(aMode,SMESH_Actor::eBallElem); break;
980 case SMESHOp::OpDEAllEntity: aMode = SMESH_Actor::eAllEntity; break;
983 anActor->SetEntityMode(aMode);
992 SalomeApp_Application* app =
993 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
997 LightApp_SelectionMgr* aSel = app->selectionMgr();
998 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
999 if ( !aSel || !appStudy )
1002 SALOME_ListIO selected;
1003 aSel->selectedObjects( selected );
1004 if ( selected.IsEmpty() )
1007 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1009 _PTR(Study) aStudy = appStudy->studyDS();
1010 _PTR(SObject) aMainSObject = aStudy->FindObjectID( anIObject->getEntry() );
1011 SMESH::SMESH_Mesh_var aMainObject = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1012 if ( aMainObject->_is_nil() )
1015 SUIT_OverrideCursor wc;
1017 aMainObject->SetAutoColor( true ); // mesh groups are re-colored here
1019 QList<SALOMEDS::Color> aReservedColors;
1021 SMESH::ListOfGroups aListOfGroups = *aMainObject->GetGroups();
1022 for ( int i = 0, n = aListOfGroups.length(); i < n; i++ )
1024 SMESH::SMESH_GroupBase_var aGroupObject = aListOfGroups[i];
1026 #ifdef SIMPLE_AUTOCOLOR // simplified algorithm for auto-colors
1027 SALOMEDS::Color aColor = SMESHGUI::getPredefinedUniqueColor();
1028 #else // old algorithm for auto-colors
1029 SALOMEDS::Color aColor = SMESHGUI::getUniqueColor( aReservedColors );
1030 aReservedColors.append( aColor );
1031 #endif // SIMPLE_AUTOCOLOR
1032 aGroupObject->SetColor( aColor );
1034 _PTR(SObject) aGroupSObject = SMESH::FindSObject(aGroupObject);
1035 if ( aGroupSObject ) {
1038 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry(aGroupSObject->GetID().c_str())) {
1039 switch ( aGroupObject->GetType ()) {
1041 anActor->SetNodeColor( aColor.R, aColor.G, aColor.B ); break;
1043 anActor->SetEdgeColor( aColor.R, aColor.G, aColor.B ); break;
1045 anActor->Set0DColor( aColor.R, aColor.G, aColor.B ); break;
1047 anActor->SetBallColor( aColor.R, aColor.G, aColor.B ); break;
1049 SMESH::GetColor("SMESH", "volume_color", c, delta, "255,0,170|-100");
1050 anActor->SetVolumeColor( aColor.R, aColor.G, aColor.B, delta ); break;
1053 SMESH::GetColor("SMESH", "fill_color", c, delta, "0,170,255|-100");
1054 anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B, delta );
1060 SMESH::RepaintCurrentView();
1063 void OverallMeshQuality()
1065 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1066 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1067 SALOME_ListIO selected;
1069 aSel->selectedObjects( selected );
1071 if ( selected.IsEmpty() ) return;
1072 SALOME_ListIteratorOfListIO It( selected );
1073 for ( ; It.More(); It.Next() ) {
1074 SMESHGUI_CtrlInfoDlg* ctrlDlg = new SMESHGUI_CtrlInfoDlg( SMESHGUI::desktop() );
1075 ctrlDlg->showInfo( It.Value() );
1080 QString functorToString( SMESH::Controls::FunctorPtr f )
1082 QString type = QObject::tr( "UNKNOWN_CONTROL" );
1083 if ( dynamic_cast< SMESH::Controls::Volume* >( f.get() ) )
1084 type = QObject::tr( "VOLUME_3D_ELEMENTS" );
1085 else if ( dynamic_cast< SMESH::Controls::MaxElementLength2D* >( f.get() ) )
1086 type = QObject::tr( "MAX_ELEMENT_LENGTH_2D" );
1087 else if ( dynamic_cast< SMESH::Controls::MaxElementLength3D* >( f.get() ) )
1088 type = QObject::tr( "MAX_ELEMENT_LENGTH_3D" );
1089 else if ( dynamic_cast< SMESH::Controls::MinimumAngle* >( f.get() ) )
1090 type = QObject::tr( "MINIMUMANGLE_ELEMENTS" );
1091 else if ( dynamic_cast< SMESH::Controls::AspectRatio* >( f.get() ) )
1092 type = QObject::tr( "ASPECTRATIO_ELEMENTS" );
1093 else if ( dynamic_cast< SMESH::Controls::AspectRatio3D* >( f.get() ) )
1094 type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" );
1095 else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) )
1096 type = QObject::tr( "WARP_ELEMENTS" );
1097 else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) )
1098 type = QObject::tr( "TAPER_ELEMENTS" );
1099 else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) )
1100 type = QObject::tr( "SKEW_ELEMENTS" );
1101 else if ( dynamic_cast< SMESH::Controls::Area* >( f.get() ) )
1102 type = QObject::tr( "AREA_ELEMENTS" );
1103 else if ( dynamic_cast< SMESH::Controls::Length* >( f.get() ) )
1104 type = QObject::tr( "LENGTH_EDGES" );
1105 else if ( dynamic_cast< SMESH::Controls::Length2D* >( f.get() ) )
1106 type = QObject::tr( "LENGTH2D_EDGES" );
1107 else if ( dynamic_cast< SMESH::Controls::Deflection2D* >( f.get() ) )
1108 type = QObject::tr( "DEFLECTION2D_FACES" );
1109 else if ( dynamic_cast< SMESH::Controls::MultiConnection* >( f.get() ) )
1110 type = QObject::tr( "MULTI_BORDERS" );
1111 else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) )
1112 type = QObject::tr( "MULTI2D_BORDERS" );
1113 else if ( dynamic_cast< SMESH::Controls::FreeNodes* >( f.get() ) )
1114 type = QObject::tr( "FREE_NODES" );
1115 else if ( dynamic_cast< SMESH::Controls::FreeEdges* >( f.get() ) )
1116 type = QObject::tr( "FREE_EDGES" );
1117 else if ( dynamic_cast< SMESH::Controls::FreeBorders* >( f.get() ) )
1118 type = QObject::tr( "FREE_BORDERS" );
1119 else if ( dynamic_cast< SMESH::Controls::FreeFaces* >( f.get() ) )
1120 type = QObject::tr( "FREE_FACES" );
1121 else if ( dynamic_cast< SMESH::Controls::BareBorderVolume* >( f.get() ) )
1122 type = QObject::tr( "BARE_BORDER_VOLUME" );
1123 else if ( dynamic_cast< SMESH::Controls::BareBorderFace* >( f.get() ) )
1124 type = QObject::tr( "BARE_BORDER_FACE" );
1125 else if ( dynamic_cast< SMESH::Controls::OverConstrainedVolume* >( f.get() ) )
1126 type = QObject::tr( "OVER_CONSTRAINED_VOLUME" );
1127 else if ( dynamic_cast< SMESH::Controls::OverConstrainedFace* >( f.get() ) )
1128 type = QObject::tr( "OVER_CONSTRAINED_FACE" );
1129 else if ( dynamic_cast< SMESH::Controls::CoincidentNodes* >( f.get() ) )
1130 type = QObject::tr( "EQUAL_NODE" );
1131 else if ( dynamic_cast< SMESH::Controls::CoincidentElements1D* >( f.get() ) )
1132 type = QObject::tr( "EQUAL_EDGE" );
1133 else if ( dynamic_cast< SMESH::Controls::CoincidentElements2D* >( f.get() ) )
1134 type = QObject::tr( "EQUAL_FACE" );
1135 else if ( dynamic_cast< SMESH::Controls::CoincidentElements3D* >( f.get() ) )
1136 type = QObject::tr( "EQUAL_VOLUME" );
1137 else if ( dynamic_cast< SMESH::Controls::NodeConnectivityNumber* >( f.get() ) )
1138 type = QObject::tr( "NODE_CONNECTIVITY_NB" );
1142 void SaveDistribution()
1144 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1145 SALOME_ListIO selected;
1147 aSel->selectedObjects( selected );
1149 if ( selected.Extent() == 1 ) {
1150 Handle(SALOME_InteractiveObject) anIO = selected.First();
1151 if ( anIO->hasEntry() ) {
1152 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1154 anActor->GetScalarBarActor() &&
1155 anActor->GetControlMode() != SMESH_Actor::eNone )
1157 SMESH_ScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor();
1158 SMESH::Controls::FunctorPtr aFunctor = anActor->GetFunctor();
1159 if ( aScalarBarActor && aFunctor ) {
1160 SMESH::Controls::NumericalFunctor* aNumFun =
1161 dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
1163 std::vector<int> elements;
1164 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
1165 if ( mesh->_is_nil() ) {
1166 SMESH::SMESH_IDSource_var idSource =
1167 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
1168 if ( !idSource->_is_nil() )
1170 SMESH::long_array_var ids = idSource->GetIDs();
1171 elements.resize( ids->length() );
1172 for ( unsigned i = 0; i < elements.size(); ++i )
1173 elements[i] = ids[i];
1176 int nbIntervals = aScalarBarActor->GetMaximumNumberOfColors();
1177 vtkLookupTable* lookupTable =
1178 static_cast<vtkLookupTable*>(aScalarBarActor->GetLookupTable());
1179 double * minmax = lookupTable->GetRange();
1180 bool isLogarithmic = lookupTable->GetScale() == VTK_SCALE_LOG10;
1181 std::vector<int> nbEvents;
1182 std::vector<double> funValues;
1183 aNumFun->GetHistogram( nbIntervals, nbEvents, funValues,
1184 elements, minmax, isLogarithmic );
1185 QString anInitialPath = "";
1186 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
1187 anInitialPath = QDir::currentPath();
1188 QString aMeshName = anIO->getName();
1190 filter.append( QObject::tr( "TEXT_FILES_FILTER" ) + " (*.txt)" );
1191 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
1192 QString aFilename = anInitialPath + "/" + aMeshName + "_" +
1193 functorToString( aFunctor ).toLower().simplified().replace( QRegExp( " |-" ), "_" ) + ".txt";
1194 aFilename = SUIT_FileDlg::getFileName( SMESHGUI::desktop(),
1197 QObject::tr( "SMESH_SAVE_DISTRIBUTION" ),
1199 if ( !aFilename.isEmpty() ) {
1200 QFile f( aFilename );
1201 if ( f.open( QFile::WriteOnly | QFile::Truncate ) ) {
1202 QTextStream out( &f );
1203 out << "# Mesh: " << aMeshName << endl;
1204 out << "# Control: " << functorToString( aFunctor ) << endl;
1206 out.setFieldWidth( 10 );
1207 for ( int i = 0; i < (int)qMin( nbEvents.size(), funValues.size()-1 ); i++ )
1208 out << funValues[i] << "\t" << funValues[i+1] << "\t" << nbEvents[i] << endl;
1219 void ShowElement( int theCommandID )
1221 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1222 SALOME_ListIO selected;
1224 aSel->selectedObjects( selected );
1226 if ( selected.Extent() == 1 ) {
1227 Handle(SALOME_InteractiveObject) anIO = selected.First();
1228 if ( anIO->hasEntry() ) {
1229 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1231 anActor->GetScalarBarActor() &&
1232 anActor->GetControlMode() != SMESH_Actor::eNone )
1234 SMESH_ScalarBarActor *aScalarBarActor = anActor->GetScalarBarActor();
1235 if ( theCommandID == SMESHOp::OpShowDistribution ) {
1236 aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility());
1238 else if ( theCommandID == SMESHOp::OpShowScalarBar ) {
1239 aScalarBarActor->SetVisibility( !aScalarBarActor->GetVisibility());
1246 #ifndef DISABLE_PLOT2DVIEWER
1247 void PlotDistribution()
1249 SalomeApp_Application* app =
1250 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1254 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1255 SALOME_ListIO selected;
1257 aSel->selectedObjects( selected );
1259 if ( selected.Extent() == 1 ) {
1260 Handle(SALOME_InteractiveObject) anIO = selected.First();
1261 if ( anIO->hasEntry() ) {
1262 //Find Actor by entry before getting Plot2d viewer,
1263 //because after call getViewManager( Plot2d_Viewer::Type(), true ) active window is Plot2d Viewer
1264 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1266 SUIT_ViewManager* aViewManager =
1267 app->getViewManager( Plot2d_Viewer::Type(), true ); // create if necessary
1271 SPlot2d_Viewer* aView = dynamic_cast<SPlot2d_Viewer*>(aViewManager->getViewModel());
1275 Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
1279 if ( anActor && anActor->GetControlMode() != SMESH_Actor::eNone )
1281 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1282 QString functorName = functorToString( anActor->GetFunctor());
1283 QString aHistogramName("%1 : %2");
1284 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1285 aHistogram->setName(aHistogramName);
1286 aHistogram->setHorTitle(functorName);
1287 aHistogram->setVerTitle(QObject::tr("DISTRIBUTION_NB_ENT"));
1288 aPlot->displayObject(aHistogram, true);
1293 #endif //DISABLE_PLOT2DVIEWER
1295 void DisableAutoColor()
1297 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1298 SALOME_ListIO selected;
1300 aSel->selectedObjects( selected );
1302 if ( selected.Extent() ) {
1303 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1304 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1305 if ( !aMesh->_is_nil() ) {
1306 aMesh->SetAutoColor( false );
1313 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1314 SALOME_ListIO selected;
1316 aSel->selectedObjects( selected );
1317 if ( selected.Extent() )
1319 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1320 _PTR(Study) aStudy = SMESH::getStudy();
1321 _PTR(SObject) aSObj = aStudy->FindObjectID(anIObject->getEntry());
1323 if ( aStudy->GetUseCaseBuilder()->SortChildren( aSObj, true/*AscendingOrder*/ ) ) {
1324 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1331 void SetDisplayMode(int theCommandID, VTK::MarkerMap& theMarkerMap)
1333 SALOME_ListIO selected;
1334 SalomeApp_Application* app =
1335 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1339 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1340 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1341 if ( !aSel || !appStudy )
1344 if ( theCommandID == SMESHOp::OpClipping ) { // Clipping dialog can be activated without selection
1345 if ( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
1346 aModule->EmitSignalDeactivateDialog();
1347 if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
1348 (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
1353 aSel->selectedObjects( selected );
1355 if ( selected.Extent() >= 1 )
1357 switch ( theCommandID ) {
1358 case SMESHOp::OpTransparency:
1360 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1361 (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
1364 case SMESHOp::OpProperties:
1367 QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
1368 QColor orientationColor, outlineColor, volumeColor;
1369 int deltaF = 0, deltaV = 0;
1372 double ballScale = 1.0;
1374 int outlineWidth = 1;
1375 double shrinkCoef = 0.0;
1376 double orientationScale = 0.0;
1377 bool orientation3d = false;
1378 VTK::MarkerType markerType = VTK::MT_NONE;
1379 VTK::MarkerScale markerScale = VTK::MS_NONE;
1381 bool hasNodes = false;
1382 int presentEntities = 0;
1383 bool firstTime = true;
1385 SALOME_ListIteratorOfListIO It( selected );
1386 for ( ; It.More(); It.Next() ) {
1387 Handle(SALOME_InteractiveObject) IObject = It.Value();
1388 if ( !IObject->hasEntry() ) continue;
1389 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1390 if ( !anActor || !anActor->GetObject() ) continue;
1393 // nodes: color, marker
1394 anActor->GetNodeColor( color[0], color[1], color[2] );
1395 nodeColor.setRgbF( color[0], color[1], color[2] );
1396 markerType = anActor->GetMarkerType();
1397 markerScale = anActor->GetMarkerScale();
1398 markerId = anActor->GetMarkerTexture();
1399 // edges: color, width
1400 anActor->GetEdgeColor( color[0], color[1], color[2] );
1401 edgeColor.setRgbF( color[0], color[1], color[2] );
1402 edgeWidth = qMax( (int)anActor->GetLineWidth(), 1 ); // minimum allowed width is 1
1403 // faces: front color, back color (delta)
1404 anActor->GetSufaceColor( color[0], color[1], color[2], deltaF );
1405 faceColor.setRgbF( color[0], color[1], color[2] );
1406 // faces: front color, back color (delta)
1407 anActor->GetVolumeColor( color[0], color[1], color[2], deltaV );
1408 volumeColor.setRgbF( color[0], color[1], color[2] );
1409 // 0d elements: color, size
1410 anActor->Get0DColor( color[0], color[1], color[2] );
1411 elem0dColor.setRgbF( color[0], color[1], color[2] );
1412 elem0dSize = qMax( (int)anActor->Get0DSize(), 1 ); // minimum allowed size is 1
1413 // balls: color, size
1414 anActor->GetBallColor( color[0], color[1], color[2] );
1415 ballColor.setRgbF( color[0], color[1], color[2] );
1416 //ballSize = qMax( (int)anActor->GetBallSize(), 1 ); // minimum allowed size is 1
1417 ballScale = qMax( (double)anActor->GetBallScale(), 1e-2 ); // minimum allowed scale is 1e-2
1419 anActor->GetOutlineColor( color[0], color[1], color[2] );
1420 outlineColor.setRgbF( color[0], color[1], color[2] );
1421 outlineWidth = qMax( (int)anActor->GetOutlineWidth(), 1 ); // minimum allowed width is 1
1422 // orientation vectors: color, scale, 3d flag
1423 anActor->GetFacesOrientationColor( color[0], color[1], color[2] );
1424 orientationColor.setRgbF( color[0], color[1], color[2] );
1425 orientationScale = anActor->GetFacesOrientationScale();
1426 orientation3d = anActor->GetFacesOrientation3DVectors();
1428 shrinkCoef = anActor->GetShrinkFactor();
1431 firstTime = false; // we only take properties from first object (for performance reasons)
1434 hasNodes = anActor->GetObject()->GetNbEntities( SMDSAbs_Node );
1435 if ( !(presentEntities & SMESH_Actor::eEdges) && anActor->GetObject()->GetNbEntities( SMDSAbs_Edge ) )
1436 presentEntities = presentEntities | SMESH_Actor::eEdges;
1437 if ( !(presentEntities & SMESH_Actor::eFaces) && anActor->GetObject()->GetNbEntities( SMDSAbs_Face ) )
1438 presentEntities = presentEntities | SMESH_Actor::eFaces;
1439 if ( !(presentEntities & SMESH_Actor::eVolumes) && anActor->GetObject()->GetNbEntities( SMDSAbs_Volume ) )
1440 presentEntities = presentEntities | SMESH_Actor::eVolumes;
1441 if ( !(presentEntities & SMESH_Actor::e0DElements) && anActor->GetObject()->GetNbEntities( SMDSAbs_0DElement ) )
1442 presentEntities = presentEntities | SMESH_Actor::e0DElements;
1443 if ( !(presentEntities & SMESH_Actor::eBallElem) && anActor->GetObject()->GetNbEntities( SMDSAbs_Ball ) )
1444 presentEntities = presentEntities | SMESH_Actor::eBallElem;
1446 // as we know that all types of elements are present, we can exit the loop
1447 if ( presentEntities == SMESH_Actor::eAllEntity )
1451 SMESHGUI_PropertiesDlg dlg( theMarkerMap, SMESHGUI::desktop() );
1452 // nodes: color, marker
1453 dlg.setNodeColor( nodeColor );
1454 if( markerType != VTK::MT_USER )
1455 dlg.setNodeMarker( markerType, markerScale );
1457 dlg.setNodeCustomMarker( markerId );
1458 // edges: color, line width
1459 dlg.setEdgeColor( edgeColor );
1460 dlg.setEdgeWidth( edgeWidth );
1461 // faces: front color, back color
1462 dlg.setFaceColor( faceColor, deltaF );
1463 // volumes: normal color, reversed color
1464 dlg.setVolumeColor( volumeColor, deltaV );
1465 // outlines: color, line width
1466 dlg.setOutlineColor( outlineColor );
1467 dlg.setOutlineWidth( outlineWidth );
1468 // 0d elements: color, size
1469 dlg.setElem0dColor( elem0dColor );
1470 dlg.setElem0dSize( elem0dSize );
1471 // balls: color, size
1472 dlg.setBallColor( ballColor );
1473 //dlg.setBallSize( ballSize );
1474 dlg.setBallScale( ballScale );
1475 // orientation: color, scale, 3d flag
1476 dlg.setOrientationColor( orientationColor );
1477 dlg.setOrientationSize( int( orientationScale * 100. ) );
1478 dlg.setOrientation3d( orientation3d );
1479 // shrink: scale factor
1480 dlg.setShrinkCoef( int( shrinkCoef * 100. ) );
1481 // hide unused controls
1482 dlg.showControls( presentEntities, hasNodes );
1485 nodeColor = dlg.nodeColor();
1486 markerType = dlg.nodeMarkerType();
1487 markerScale = dlg.nodeMarkerScale();
1488 markerId = dlg.nodeMarkerId();
1489 edgeColor = dlg.edgeColor();
1490 edgeWidth = dlg.edgeWidth();
1491 faceColor = dlg.faceColor();
1492 deltaF = dlg.faceColorDelta();
1493 volumeColor = dlg.volumeColor();
1494 deltaV = dlg.volumeColorDelta();
1495 outlineColor = dlg.outlineColor();
1496 outlineWidth = dlg.outlineWidth();
1497 elem0dColor = dlg.elem0dColor();
1498 elem0dSize = dlg.elem0dSize();
1499 ballColor = dlg.ballColor();
1500 // ballSize = dlg.ballSize();
1501 ballScale = dlg.ballScale();
1502 orientationColor = dlg.orientationColor();
1503 orientationScale = dlg.orientationSize() / 100.;
1504 orientation3d = dlg.orientation3d();
1505 shrinkCoef = dlg.shrinkCoef() / 100.;
1507 // store point markers that might be changed by the user
1508 theMarkerMap = dlg.customMarkers();
1510 // set properties from dialog box to the presentations
1511 SALOME_ListIteratorOfListIO It( selected );
1512 for ( ; It.More(); It.Next() ) {
1513 Handle(SALOME_InteractiveObject) IObject = It.Value();
1514 if ( !IObject->hasEntry() ) continue;
1515 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1516 if ( !anActor ) continue;
1518 // nodes: color, marker
1519 anActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
1520 if ( markerType != VTK::MT_USER ) {
1521 anActor->SetMarkerStd( markerType, markerScale );
1524 VTK::MarkerMap::const_iterator iter = theMarkerMap.find( markerId );
1525 if ( iter != theMarkerMap.end() )
1526 anActor->SetMarkerTexture( markerId, iter->second.second );
1528 // volumes: normal color, reversed color (delta)
1529 anActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
1530 // faces: front color, back color (delta)
1531 anActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
1532 // edges: color, width
1533 anActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
1534 anActor->SetLineWidth( edgeWidth );
1536 anActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
1537 anActor->SetOutlineWidth( outlineWidth );
1538 // 0D elements: color, size
1539 anActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
1540 anActor->Set0DSize( elem0dSize );
1541 // balls: color, size
1542 anActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
1543 // anActor->SetBallSize( ballSize );
1544 anActor->SetBallScale( ballScale );
1545 // orientation: color, scale, 3d flag
1546 anActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
1547 anActor->SetFacesOrientationScale( orientationScale );
1548 anActor->SetFacesOrientation3DVectors( orientation3d );
1550 anActor->SetShrinkFactor( shrinkCoef );
1552 // for groups, set also proper color
1553 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1554 if ( !aGroupObject->_is_nil() ) {
1555 SMESH::ElementType anElementType = aGroupObject->GetType();
1557 switch( anElementType ) {
1559 aColor = nodeColor; break;
1561 aColor = edgeColor; break;
1563 aColor = faceColor; break;
1565 aColor = volumeColor; break;
1567 aColor = elem0dColor; break;
1569 aColor = ballColor; break;
1573 if ( aColor.isValid() ) {
1574 SALOMEDS::Color aGroupColor;
1575 aGroupColor.R = aColor.redF();
1576 aGroupColor.G = aColor.greenF();
1577 aGroupColor.B = aColor.blueF();
1578 aGroupObject->SetColor( aGroupColor );
1580 } // if ( !aGroupObject->_is_nil() )
1581 } // for ( ; It.More(); It.Next() )
1582 SMESH::RepaintCurrentView();
1583 } // if ( dlg.exec() )
1585 } // case SMESHOp::OpProperties:
1586 } // switch(theCommandID)
1587 SUIT_OverrideCursor wc;
1588 SALOME_ListIteratorOfListIO It( selected );
1589 for( ; It.More(); It.Next()){
1590 Handle(SALOME_InteractiveObject) IObject = It.Value();
1591 if(IObject->hasEntry()){
1592 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1593 switch(theCommandID){
1594 case SMESHOp::OpDMWireframe:
1595 anActor->SetRepresentation(SMESH_Actor::eEdge);
1597 case SMESHOp::OpDMShading:
1598 anActor->SetRepresentation(SMESH_Actor::eSurface);
1600 case SMESHOp::OpDMShrink:
1601 if(anActor->IsShrunk())
1602 anActor->UnShrink();
1604 anActor->SetShrink();
1606 case SMESHOp::OpDMNodes:
1607 anActor->SetRepresentation(SMESH_Actor::ePoint);
1609 case SMESHOp::OpRepresentationLines:
1610 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1611 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1613 case SMESHOp::OpRepresentationArcs:
1614 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1615 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1621 SMESH::RepaintCurrentView();
1625 int ActionToControl( int theID, bool theReversed )
1627 NCollection_DoubleMap<int,int> ActionControl;
1628 ActionControl.Bind( 0, SMESH_Actor::eNone );
1629 ActionControl.Bind( SMESHOp::OpFreeNode, SMESH_Actor::eFreeNodes );
1630 ActionControl.Bind( SMESHOp::OpEqualNode, SMESH_Actor::eCoincidentNodes );
1631 ActionControl.Bind( SMESHOp::OpNodeConnectivityNb, SMESH_Actor::eNodeConnectivityNb );
1632 ActionControl.Bind( SMESHOp::OpFreeEdge, SMESH_Actor::eFreeEdges );
1633 ActionControl.Bind( SMESHOp::OpFreeBorder, SMESH_Actor::eFreeBorders );
1634 ActionControl.Bind( SMESHOp::OpLength, SMESH_Actor::eLength );
1635 ActionControl.Bind( SMESHOp::OpConnection, SMESH_Actor::eMultiConnection );
1636 ActionControl.Bind( SMESHOp::OpEqualEdge, SMESH_Actor::eCoincidentElems1D );
1637 ActionControl.Bind( SMESHOp::OpFreeFace, SMESH_Actor::eFreeFaces );
1638 ActionControl.Bind( SMESHOp::OpBareBorderFace, SMESH_Actor::eBareBorderFace );
1639 ActionControl.Bind( SMESHOp::OpOverConstrainedFace, SMESH_Actor::eOverConstrainedFace );
1640 ActionControl.Bind( SMESHOp::OpLength2D, SMESH_Actor::eLength2D );
1641 ActionControl.Bind( SMESHOp::OpDeflection2D, SMESH_Actor::eDeflection2D );
1642 ActionControl.Bind( SMESHOp::OpConnection2D, SMESH_Actor::eMultiConnection2D );
1643 ActionControl.Bind( SMESHOp::OpArea, SMESH_Actor::eArea );
1644 ActionControl.Bind( SMESHOp::OpTaper, SMESH_Actor::eTaper );
1645 ActionControl.Bind( SMESHOp::OpAspectRatio, SMESH_Actor::eAspectRatio );
1646 ActionControl.Bind( SMESHOp::OpMinimumAngle, SMESH_Actor::eMinimumAngle );
1647 ActionControl.Bind( SMESHOp::OpWarpingAngle, SMESH_Actor::eWarping );
1648 ActionControl.Bind( SMESHOp::OpSkew, SMESH_Actor::eSkew );
1649 ActionControl.Bind( SMESHOp::OpMaxElementLength2D, SMESH_Actor::eMaxElementLength2D );
1650 ActionControl.Bind( SMESHOp::OpEqualFace, SMESH_Actor::eCoincidentElems2D );
1651 ActionControl.Bind( SMESHOp::OpAspectRatio3D, SMESH_Actor::eAspectRatio3D );
1652 ActionControl.Bind( SMESHOp::OpVolume, SMESH_Actor::eVolume3D );
1653 ActionControl.Bind( SMESHOp::OpMaxElementLength3D, SMESH_Actor::eMaxElementLength3D );
1654 ActionControl.Bind( SMESHOp::OpBareBorderVolume, SMESH_Actor::eBareBorderVolume );
1655 ActionControl.Bind( SMESHOp::OpOverConstrainedVolume, SMESH_Actor::eOverConstrainedVolume );
1656 ActionControl.Bind( SMESHOp::OpEqualVolume, SMESH_Actor::eCoincidentElems3D );
1659 return ActionControl.IsBound2( theID ) ? ActionControl.Find2( theID ) : 0;
1660 return ActionControl.IsBound1( theID ) ? ActionControl.Find1( theID ) : 0;
1663 void Control( int theCommandID )
1665 SMESH_Actor::eControl aControl = SMESH_Actor::eControl( ActionToControl( theCommandID ));
1666 _PTR(Study) aStudy = SMESH::getStudy();
1668 SALOME_ListIO selected;
1669 if ( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
1670 aSel->selectedObjects( selected );
1672 if ( !selected.IsEmpty() ) {
1673 SALOME_ListIteratorOfListIO It(selected);
1674 for ( ; It.More(); It.Next())
1676 Handle(SALOME_InteractiveObject) anIO = It.Value();
1677 if ( !anIO.IsNull() ) {
1678 _PTR(SObject) SO = aStudy->FindObjectID( It.Value()->getEntry() );
1680 CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
1681 SMESH::SMESH_IDSource_var anIDSrc = SMESH::SMESH_IDSource::_narrow( aObject );
1682 if ( !anIDSrc->_is_nil() ) {
1683 SMESH_Actor *anActor = SMESH::FindActorByEntry( anIO->getEntry());
1684 if (( !anActor && selected.Extent() == 1 ) &&
1685 ( anActor = SMESH::CreateActor( anIO->getEntry() )))
1687 anActor->SetControlMode( aControl );
1688 SMESH::DisplayActor( SMESH::GetCurrentVtkView(), anActor );
1689 SMESH::UpdateView ( SMESH::eDisplay, anIO->getEntry() );
1693 if ( anActor->GetControlMode() != aControl )
1694 anActor->SetControlMode( aControl );
1695 QString functorName = functorToString( anActor->GetFunctor() );
1696 int anEntitiesCount = anActor->GetNumberControlEntities();
1697 if (anEntitiesCount >= 0)
1698 functorName = functorName + ": " + QString::number(anEntitiesCount);
1699 anActor->GetScalarBarActor()->SetTitle( functorName.toLatin1().constData() );
1700 SMESH::RepaintCurrentView();
1701 #ifndef DISABLE_PLOT2DVIEWER
1702 if ( anActor->GetPlot2Histogram() ) {
1703 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1704 QString aHistogramName("%1 : %2");
1705 aHistogramName = aHistogramName.arg( anIO->getName() ).arg( functorName );
1706 aHistogram->setName( aHistogramName );
1707 aHistogram->setHorTitle( functorName );
1708 SMESH::ProcessIn2DViewers( anActor );
1720 bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1721 SMESH::MeshObjectType theType,
1722 const QString theInTypeName,
1723 QString & theOutTypeName)
1725 SMESH_TypeFilter aTypeFilter( theType );
1727 if ( !theIO.IsNull() )
1729 entry = theIO->getEntry();
1730 LightApp_DataOwner owner( entry );
1731 if ( aTypeFilter.isOk( &owner )) {
1732 theOutTypeName = theInTypeName;
1740 QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1742 _PTR(Study) aStudy = SMESH::getStudy();
1743 _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1745 _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1746 CORBA::String_var anID = aSComp->GetID().c_str();
1747 if ( !strcmp(anID.in(),theIO->getEntry()) )
1753 CheckOIType ( theIO, SMESH::HYPOTHESIS, "Hypothesis", aTypeName ) ||
1754 CheckOIType ( theIO, SMESH::ALGORITHM, "Algorithm", aTypeName ) ||
1755 CheckOIType ( theIO, SMESH::MESH, "Mesh", aTypeName ) ||
1756 CheckOIType ( theIO, SMESH::SUBMESH, "SubMesh", aTypeName ) ||
1757 CheckOIType ( theIO, SMESH::GROUP, "Group", aTypeName )
1765 // QString CheckHomogeneousSelection()
1767 // LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1768 // SALOME_ListIO selected;
1770 // aSel->selectedObjects( selected );
1772 // QString RefType = CheckTypeObject(selected.First());
1773 // SALOME_ListIteratorOfListIO It(selected);
1774 // for ( ; It.More(); It.Next())
1776 // Handle(SALOME_InteractiveObject) IObject = It.Value();
1777 // QString Type = CheckTypeObject(IObject);
1778 // if ( Type.compare(RefType) != 0 )
1779 // return "Heterogeneous Selection";
1785 uint randomize( uint size )
1787 static bool initialized = false;
1788 if ( !initialized ) {
1789 qsrand( QDateTime::currentDateTime().toTime_t() );
1793 v = uint( (double)( v ) / RAND_MAX * size );
1794 v = qMax( uint(0), qMin ( v, size-1 ) );
1800 void SMESHGUI::OnEditDelete()
1802 // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1803 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1804 SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1806 _PTR(Study) aStudy = SMESH::getStudy();
1807 _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1808 _PTR(GenericAttribute) anAttr;
1809 _PTR(AttributeIOR) anIOR;
1811 int objectCount = 0;
1813 QString aParentComponent = QString::null;
1815 for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1817 Handle(SALOME_InteractiveObject) anIO = anIt.Value();
1818 if ( anIO.IsNull() ) continue;
1820 QString father = "unknown";
1822 _PTR(SObject) aSO = aStudy->FindObjectID( anIO->getEntry() );
1824 father = QString::fromStdString( aSO->GetFatherComponent()->ComponentDataType() );
1825 // check if object is reference
1826 _PTR(SObject) aRefSObj;
1827 aNameList.append("\n - ");
1828 if ( aSO->ReferencedObject( aRefSObj ) ) {
1829 QString aRefName = QString::fromStdString ( aRefSObj->GetName() );
1830 aNameList.append( aRefName );
1831 father = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1834 aNameList.append(anIO->getName());
1838 if( aParentComponent.isNull() )
1839 aParentComponent = father;
1840 else if( !aParentComponent.isEmpty() && aParentComponent!=father )
1841 aParentComponent = "";
1844 if ( objectCount == 0 )
1845 return; // No Valid Objects Selected
1847 if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
1848 SUIT_MessageBox::warning( SMESHGUI::desktop(),
1849 QObject::tr("ERR_ERROR"),
1850 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
1853 // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
1854 if (SUIT_MessageBox::warning
1855 (SMESHGUI::desktop(),
1856 QObject::tr("SMESH_WRN_WARNING"),
1857 QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
1858 SUIT_MessageBox::Yes | SUIT_MessageBox::No,
1859 SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
1862 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1864 // Put the whole hierarchy of sub-objects of the selected SO's into a list and
1865 // then treat them all starting from the deepest objects (at list back)
1866 std::list< _PTR(SObject) > listSO;
1867 SALOME_ListIteratorOfListIO It(selected);
1868 for( ; It.More(); It.Next()) // loop on selected IO's
1870 Handle(SALOME_InteractiveObject) IObject = It.Value();
1871 if(IObject->hasEntry()) {
1872 _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
1874 // disable removal of "SMESH" component object
1875 if(aSO->FindAttribute(anAttr, "AttributeIOR")){
1877 if ( engineIOR() == anIOR->Value().c_str() )
1880 //Check the referenced object
1881 _PTR(SObject) aRefSObject;
1882 if ( aSO && aSO->ReferencedObject( aRefSObject ) )
1883 aSO = aRefSObject; // Delete main Object instead of reference
1885 listSO.push_back( aSO );
1886 std::list< _PTR(SObject) >::iterator itSO = --listSO.end();
1887 for ( ; itSO != listSO.end(); ++itSO ) {
1888 _PTR(ChildIterator) it = aStudy->NewChildIterator( *itSO );
1889 for (it->InitEx(false); it->More(); it->Next())
1890 listSO.push_back( it->Value() );
1894 // Check if none of objects to delete is referred from outside
1895 std::list< _PTR(SObject) >::reverse_iterator ritSO;
1896 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1898 _PTR(SObject) SO = *ritSO;
1899 if ( !SO ) continue;
1900 std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( *ritSO );
1901 for (size_t i = 0; i < aReferences.size(); i++) {
1902 _PTR(SComponent) aComponent = aReferences[i]->GetFatherComponent();
1903 std::string type = aComponent->ComponentDataType();
1904 if ( type != "SMESH" )
1906 SUIT_MessageBox::warning( anApp->desktop(),
1907 QObject::tr("WRN_WARNING"),
1908 QObject::tr("DEP_OBJECT") );
1909 return; // outside SMESH, there is an object depending on a SMESH object
1914 // Call mesh->Clear() to prevent loading mesh from file caused by hypotheses removal
1915 for( It.Initialize( selected ); It.More(); It.Next()) // loop on selected IO's
1917 Handle(SALOME_InteractiveObject) IObject = It.Value();
1918 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface< SMESH::SMESH_Mesh >( IObject );
1919 if ( !mesh->_is_nil() )
1923 // Treat SO's in the list starting from the back
1924 aStudyBuilder->NewCommand(); // There is a transaction
1925 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1927 _PTR(SObject) SO = *ritSO;
1928 if ( !SO ) continue;
1929 std::string anEntry = SO->GetID();
1931 /** Erase graphical object and remove all its data **/
1932 if(SO->FindAttribute(anAttr, "AttributeIOR")) {
1933 SMESH::RemoveVisualObjectWithActors( anEntry.c_str(), true);
1935 /** Remove an object from data structures **/
1936 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
1937 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
1938 if ( !aGroup->_is_nil() ) { // DELETE GROUP
1939 SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
1940 aMesh->RemoveGroup( aGroup );
1942 else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
1943 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
1944 aMesh->RemoveSubMesh( aSubMesh );
1946 _PTR(SObject) aMeshSO = SMESH::FindSObject(aMesh);
1948 SMESH::ModifiedMesh(aMeshSO, false, aMesh->NbNodes()==0);
1951 Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
1952 ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
1953 QString objType = CheckTypeObject(IObject);
1954 if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
1955 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
1956 aStudyBuilder->RemoveObjectWithChildren( SO );
1958 else {// default action: remove SObject from the study
1959 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
1960 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
1962 aStudyBuilder->RemoveObjectWithChildren( SO );
1966 } /* listSO back loop */
1968 aStudyBuilder->CommitCommand();
1970 /* Clear any previous selection */
1972 aSel->setSelectedObjects( l1 );
1974 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1978 SMESHGUI_EXPORT CAM_Module* createModule()
1980 return new SMESHGUI();
1983 SMESHGUI_EXPORT char* getModuleVersion() {
1984 return (char*)SMESH_VERSION_STR;
1988 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
1990 //=============================================================================
1994 //=============================================================================
1995 SMESHGUI::SMESHGUI() :
1996 SalomeApp_Module( "SMESH" )
1998 if ( CORBA::is_nil( myComponentSMESH ) )
2000 CORBA::Boolean anIsEmbeddedMode;
2001 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
2002 //MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
2004 // 0019923: EDF 765 SMESH : default values of hypothesis
2005 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
2006 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
2007 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
2008 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
2009 myComponentSMESH->SetDefaultNbSegments( nbSeg );
2011 const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif", "default_grp_color" };
2012 for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
2013 if ( aResourceMgr->hasValue( "SMESH", options[i] ))
2015 QString val = aResourceMgr->stringValue( "SMESH", options[i] );
2016 myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
2020 myActiveDialogBox = 0;
2021 myFilterLibraryDlg = 0;
2025 myEventCallbackCommand = vtkCallbackCommand::New();
2026 myEventCallbackCommand->Delete();
2027 myEventCallbackCommand->SetClientData( this );
2028 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
2031 /* load resources for all available meshers */
2032 SMESH::InitAvailableHypotheses();
2035 //=============================================================================
2039 //=============================================================================
2040 SMESHGUI::~SMESHGUI()
2044 //=============================================================================
2048 //=============================================================================
2049 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
2051 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2053 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
2058 //=============================================================================
2062 //=============================================================================
2063 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
2065 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2069 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2070 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2071 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2072 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2073 return autoUpdate && !exceeded;
2076 //=============================================================================
2080 //=============================================================================
2081 bool SMESHGUI::automaticUpdate( SMESH::SMESH_IDSource_ptr theMesh,
2082 int* entities, bool* limitExceeded, int* hidden, long* nbElements )
2084 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2088 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2089 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2090 bool incrementalLimit = resMgr->booleanValue( "SMESH", "incremental_limit", false );
2092 SMESH::long_array_var info = theMesh->GetMeshInfo();
2093 long nbOdElems = info[SMDSEntity_0D];
2094 long nbEdges = info[SMDSEntity_Edge] + info[SMDSEntity_Quad_Edge];
2095 long nbFaces = info[SMDSEntity_Triangle] + info[SMDSEntity_Quad_Triangle] + info[SMDSEntity_BiQuad_Triangle] +
2096 info[SMDSEntity_Quadrangle] + info[SMDSEntity_Quad_Quadrangle] + info[SMDSEntity_BiQuad_Quadrangle] +
2097 info[SMDSEntity_Polygon] + info[SMDSEntity_Quad_Polygon];
2098 long nbVolumes = info[SMDSEntity_Tetra] + info[SMDSEntity_Quad_Tetra] +
2099 info[SMDSEntity_Hexa] + info[SMDSEntity_Quad_Hexa] + info[SMDSEntity_TriQuad_Hexa] +
2100 info[SMDSEntity_Pyramid] + info[SMDSEntity_Quad_Pyramid] +
2101 info[SMDSEntity_Penta] + info[SMDSEntity_Quad_Penta] + info[SMDSEntity_BiQuad_Penta] +
2102 info[SMDSEntity_Polyhedra] +
2103 info[SMDSEntity_Hexagonal_Prism];
2104 long nbBalls = info[SMDSEntity_Ball];
2106 long requestedSize = nbOdElems + nbBalls + nbEdges + nbFaces + nbVolumes;
2107 *nbElements = requestedSize;
2109 *entities = SMESH_Actor::eAllEntity;
2112 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2114 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2116 if ( incrementalLimit ) {
2119 if ( nbOdElems > 0 ) {
2120 if ( total + nbOdElems > updateLimit ) {
2121 *entities = *entities & ~SMESH_Actor::e0DElements;
2122 *hidden = *hidden | SMESH_Actor::e0DElements;
2129 if ( nbEdges > 0 ) {
2130 if ( total + nbEdges > updateLimit ) {
2131 *entities = *entities & ~SMESH_Actor::eEdges;
2132 *hidden = *hidden | SMESH_Actor::eEdges;
2139 if ( nbFaces > 0 ) {
2140 if ( total + nbFaces > updateLimit ) {
2141 *entities = *entities & ~SMESH_Actor::eFaces;
2142 *hidden = *hidden | SMESH_Actor::eFaces;
2149 if ( nbVolumes > 0 ) {
2150 if ( total + nbVolumes > updateLimit ) {
2151 *entities = *entities & ~SMESH_Actor::eVolumes;
2152 *hidden = *hidden | SMESH_Actor::eVolumes;
2159 if ( nbBalls > 0 ) {
2160 if ( total + nbBalls > updateLimit ) {
2161 *entities = *entities & ~SMESH_Actor::eBallElem;
2162 *hidden = *hidden | SMESH_Actor::eBallElem;
2170 return autoUpdate && !exceeded;
2173 //=============================================================================
2177 //=============================================================================
2178 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
2180 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
2183 //=============================================================================
2187 //=============================================================================
2188 SMESHGUI* SMESHGUI::GetSMESHGUI()
2190 SMESHGUI* smeshMod = 0;
2191 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
2194 CAM_Module* module = app->module( "Mesh" );
2195 smeshMod = dynamic_cast<SMESHGUI*>( module );
2203 Standard_EXPORT SMESHGUI* GetComponentGUI()
2205 return SMESHGUI::GetSMESHGUI();
2209 //=============================================================================
2213 //=============================================================================
2214 void SMESHGUI::SetState(int aState)
2219 //=============================================================================
2223 //=============================================================================
2224 void SMESHGUI::ResetState()
2229 //=============================================================================
2233 //=============================================================================
2234 void SMESHGUI::EmitSignalDeactivateDialog()
2236 emit SignalDeactivateActiveDialog();
2239 //=============================================================================
2243 //=============================================================================
2244 void SMESHGUI::EmitSignalStudyFrameChanged()
2246 emit SignalStudyFrameChanged();
2249 //=============================================================================
2253 //=============================================================================
2254 void SMESHGUI::EmitSignalCloseAllDialogs()
2256 emit SignalCloseAllDialogs();
2259 //=============================================================================
2263 //=============================================================================
2264 void SMESHGUI::EmitSignalVisibilityChanged()
2266 emit SignalVisibilityChanged();
2269 //=============================================================================
2273 //=============================================================================
2274 void SMESHGUI::EmitSignalCloseView()
2276 emit SignalCloseView();
2279 //=============================================================================
2283 //=============================================================================
2284 void SMESHGUI::EmitSignalActivatedViewManager()
2286 emit SignalActivatedViewManager();
2289 //=============================================================================
2293 //=============================================================================
2294 QDialog *SMESHGUI::GetActiveDialogBox()
2296 return myActiveDialogBox;
2299 //=============================================================================
2303 //=============================================================================
2304 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2306 myActiveDialogBox = (QDialog *) aDlg;
2310 //=============================================================================
2314 //=============================================================================
2315 SUIT_Desktop* SMESHGUI::desktop()
2317 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2319 return app->desktop();
2324 //=============================================================================
2328 //=============================================================================
2329 SalomeApp_Study* SMESHGUI::activeStudy()
2331 SUIT_Application* app = SUIT_Session::session()->activeApplication();
2333 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2338 //=============================================================================
2342 //=============================================================================
2343 void SMESHGUI::Modified( bool theIsUpdateActions )
2345 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2346 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2347 appStudy->Modified();
2348 if( theIsUpdateActions )
2349 app->updateActions();
2354 //=============================================================================
2358 //=============================================================================
2359 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2361 /* Here the position is on the bottom right corner - 10 */
2362 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2364 SUIT_Desktop *PP = desktop();
2365 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2366 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2371 * \brief Verifies whether study of operation is locked
2372 * \param theMess - specifies whether message box must be shown if study is locked
2373 * \return State of study.
2375 * Verifies whether study of operation is locked. If second parameter is TRUE and study
2376 * is locked when corresponding message box appears
2378 bool SMESHGUI::isStudyLocked( bool theMessage )
2380 if ( SMESH::getStudy()->GetProperties()->IsLocked() )
2383 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2384 QObject::tr( "WRN_WARNING" ),
2385 QObject::tr( "WRN_STUDY_LOCKED" ) );
2391 //=============================================================================
2395 //=============================================================================
2396 bool SMESHGUI::OnGUIEvent( int theCommandID )
2398 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2402 SUIT_ResourceMgr* mgr = resourceMgr();
2406 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2407 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2409 //QAction* act = action( theCommandID );
2411 switch (theCommandID) {
2412 case SMESHOp::OpDelete:
2413 if(isStudyLocked()) break;
2416 case SMESHOp::OpImportDAT:
2417 case SMESHOp::OpImportUNV:
2418 case SMESHOp::OpImportMED:
2419 case SMESHOp::OpImportSTL:
2420 case SMESHOp::OpImportCGNS:
2421 case SMESHOp::OpImportSAUV:
2422 case SMESHOp::OpImportGMF:
2423 case SMESHOp::OpPopupImportDAT:
2424 case SMESHOp::OpPopupImportUNV:
2425 case SMESHOp::OpPopupImportMED:
2426 case SMESHOp::OpPopupImportSTL:
2427 case SMESHOp::OpPopupImportCGNS:
2428 case SMESHOp::OpPopupImportSAUV:
2429 case SMESHOp::OpPopupImportGMF:
2431 if(isStudyLocked()) break;
2432 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2436 case SMESHOp::OpFileInformation:
2438 SALOME_ListIO selected;
2439 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2441 aSel->selectedObjects( selected );
2442 if( selected.Extent() )
2444 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2445 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2446 if ( !aMesh->_is_nil() )
2448 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2454 case SMESHOp::OpExportDAT:
2455 case SMESHOp::OpExportMED:
2456 case SMESHOp::OpExportUNV:
2457 case SMESHOp::OpExportSTL:
2458 case SMESHOp::OpExportCGNS:
2459 case SMESHOp::OpExportSAUV:
2460 case SMESHOp::OpExportGMF:
2461 case SMESHOp::OpPopupExportDAT:
2462 case SMESHOp::OpPopupExportMED:
2463 case SMESHOp::OpPopupExportUNV:
2464 case SMESHOp::OpPopupExportSTL:
2465 case SMESHOp::OpPopupExportCGNS:
2466 case SMESHOp::OpPopupExportSAUV:
2467 case SMESHOp::OpPopupExportGMF:
2469 ::ExportMeshToFile(theCommandID);
2473 case SMESHOp::OpReset: // SCALAR BAR
2475 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2476 SALOME_ListIO selected;
2478 aSel->selectedObjects( selected );
2480 SALOME_ListIteratorOfListIO it(selected);
2481 for( ; it.More(); it.Next()) {
2482 Handle(SALOME_InteractiveObject) anIO = it.Value();
2483 if( anIO->hasEntry() ) {
2484 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2485 anActor->SetControlMode( SMESH_Actor::eNone );
2486 #ifndef DISABLE_PLOT2DVIEWER
2487 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2492 SMESH::UpdateView();
2495 case SMESHOp::OpScalarBarProperties:
2497 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2500 case SMESHOp::OpShowScalarBar:
2502 // show/hide scalar bar
2503 ::ShowElement(theCommandID);
2506 case SMESHOp::OpSaveDistribution:
2508 // dump control distribution data to the text file
2509 ::SaveDistribution();
2513 case SMESHOp::OpShowDistribution:
2515 // show/hide distribution
2516 ::ShowElement(theCommandID);
2520 #ifndef DISABLE_PLOT2DVIEWER
2521 case SMESHOp::OpPlotDistribution:
2523 // plot distribution
2524 ::PlotDistribution();
2530 case SMESHOp::OpAutoColor:
2534 case SMESHOp::OpDisableAutoColor:
2535 ::DisableAutoColor();
2538 case SMESHOp::OpClipping:
2539 case SMESHOp::OpTransparency:
2540 case SMESHOp::OpProperties: // Display preferences (colors, shrink size, line width, ...)
2543 case SMESHOp::OpDMWireframe:
2544 case SMESHOp::OpDMShading:
2545 case SMESHOp::OpDMNodes:
2546 case SMESHOp::OpDMShrink:
2547 ::SetDisplayMode(theCommandID, myMarkerMap);
2550 //2D quadratic representation
2551 case SMESHOp::OpRepresentationLines:
2552 case SMESHOp::OpRepresentationArcs:
2553 ::SetDisplayMode(theCommandID, myMarkerMap);
2557 case SMESHOp::OpDE0DElements:
2558 case SMESHOp::OpDEEdges:
2559 case SMESHOp::OpDEFaces:
2560 case SMESHOp::OpDEVolumes:
2561 case SMESHOp::OpDEBalls:
2562 case SMESHOp::OpDEAllEntity:
2563 ::SetDisplayEntity(theCommandID);
2566 // Choose entities to be displayed
2567 case SMESHOp::OpDEChoose:
2569 ( new SMESHGUI_DisplayEntitiesDlg( SMESHGUI::desktop() ) )->exec();
2573 case SMESHOp::OpOrientationOnFaces:
2575 SUIT_OverrideCursor wc;
2576 LightApp_SelectionMgr* mgr = selectionMgr();
2577 SALOME_ListIO selected; mgr->selectedObjects( selected );
2579 SALOME_ListIteratorOfListIO it(selected);
2580 for( ; it.More(); it.Next()) {
2581 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2582 if(anIObject->hasEntry()) {
2583 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2584 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2591 case SMESHOp::OpUpdate:
2593 if(isStudyLocked()) break;
2594 SUIT_OverrideCursor wc;
2597 SMESH::UpdateView();
2599 catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2600 SMESH::OnVisuException();
2602 catch (...) { // PAL16774 (Crash after display of many groups)
2603 SMESH::OnVisuException();
2607 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2608 aSel->selectedObjects( l );
2609 aSel->setSelectedObjects( l );
2613 case SMESHOp::OpHide:
2614 case SMESHOp::OpShow:
2615 case SMESHOp::OpShowOnly:
2617 SUIT_OverrideCursor wc;
2618 SMESH::EDisplaing anAction;
2619 switch (theCommandID) {
2620 case SMESHOp::OpHide: anAction = SMESH::eErase; break;
2621 case SMESHOp::OpShow: anAction = SMESH::eDisplay; break;
2622 case SMESHOp::OpShowOnly: anAction = SMESH::eDisplayOnly; break;
2625 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2626 SALOME_ListIO sel_objects, to_process;
2628 aSel->selectedObjects( sel_objects );
2630 if ( theCommandID==SMESHOp::OpShowOnly )
2632 //MESSAGE("anAction = SMESH::eDisplayOnly");
2633 startOperation( myEraseAll );
2636 extractContainers( sel_objects, to_process );
2641 SALOME_ListIteratorOfListIO It( to_process );
2642 for ( ; It.More(); It.Next())
2644 Handle(SALOME_InteractiveObject) IOS = It.Value();
2645 if ( IOS->hasEntry() )
2647 if ( !SMESH::UpdateView( anAction, IOS->getEntry() )) {
2648 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2649 break; // PAL16774 (Crash after display of many groups)
2651 if (anAction == SMESH::eDisplayOnly)
2652 anAction = SMESH::eDisplay;
2657 // PAL13338 + PAL15161 -->
2658 if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !isStudyLocked()) {
2659 SMESH::UpdateView();
2660 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2662 // PAL13338 + PAL15161 <--
2664 catch (...) { // PAL16774 (Crash after display of many groups)
2665 SMESH::OnVisuException();
2668 if (anAction == SMESH::eErase) {
2670 aSel->setSelectedObjects( l1 );
2673 aSel->setSelectedObjects( to_process );
2678 case SMESHOp::OpNode:
2680 if(isStudyLocked()) break;
2683 EmitSignalDeactivateDialog();
2685 ( new SMESHGUI_NodesDlg( this ) )->show();
2688 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"),tr("SMESH_WRN_VIEWER_VTK"));
2693 case SMESHOp::OpCreateMesh:
2694 case SMESHOp::OpCreateSubMesh:
2695 case SMESHOp::OpEditMeshOrSubMesh:
2696 case SMESHOp::OpEditMesh:
2697 case SMESHOp::OpEditSubMesh:
2698 case SMESHOp::OpCompute:
2699 case SMESHOp::OpComputeSubMesh:
2700 case SMESHOp::OpPreCompute:
2701 case SMESHOp::OpEvaluate:
2702 case SMESHOp::OpMeshOrder:
2703 startOperation( theCommandID );
2705 case SMESHOp::OpCopyMesh:
2707 if (isStudyLocked()) break;
2708 EmitSignalDeactivateDialog();
2709 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2712 case SMESHOp::OpBuildCompoundMesh:
2714 if (isStudyLocked()) break;
2715 EmitSignalDeactivateDialog();
2716 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2720 case SMESHOp::OpDiagonalInversion:
2721 case SMESHOp::OpUnionOfTwoTriangle:
2725 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2729 if ( isStudyLocked() )
2732 /*Standard_Boolean aRes;
2733 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2734 if ( aMesh->_is_nil() )
2736 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2737 tr( "SMESH_BAD_SELECTION" ) );
2741 EmitSignalDeactivateDialog();
2742 if ( theCommandID == SMESHOp::OpDiagonalInversion )
2743 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2745 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2748 case SMESHOp::OpOrientation:
2749 case SMESHOp::OpUnionOfTriangles:
2750 case SMESHOp::OpCuttingOfQuadrangles:
2751 case SMESHOp::OpSplitVolumes:
2755 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2759 if ( isStudyLocked() )
2762 EmitSignalDeactivateDialog();
2763 SMESHGUI_MultiEditDlg* aDlg = NULL;
2764 if ( theCommandID == SMESHOp::OpOrientation )
2765 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2766 else if ( theCommandID == SMESHOp::OpUnionOfTriangles )
2767 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2768 else if ( theCommandID == SMESHOp::OpSplitVolumes )
2769 aDlg = new SMESHGUI_SplitVolumesDlg(this);
2771 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2776 case SMESHOp::OpSmoothing:
2778 if(isStudyLocked()) break;
2780 EmitSignalDeactivateDialog();
2781 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2784 SUIT_MessageBox::warning(desktop(), tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2788 case SMESHOp::OpExtrusion:
2790 if (isStudyLocked()) break;
2792 EmitSignalDeactivateDialog();
2793 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2795 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2799 case SMESHOp::OpExtrusionAlongAPath:
2801 if (isStudyLocked()) break;
2803 EmitSignalDeactivateDialog();
2804 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2806 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2810 case SMESHOp::OpRevolution:
2812 if(isStudyLocked()) break;
2814 EmitSignalDeactivateDialog();
2815 ( new SMESHGUI_RevolutionDlg( this ) )->show();
2818 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2822 case SMESHOp::OpPatternMapping:
2824 if ( isStudyLocked() )
2828 EmitSignalDeactivateDialog();
2829 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2832 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2836 case SMESHOp::OpSplitBiQuadratic:
2837 case SMESHOp::OpConvertMeshToQuadratic:
2838 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
2839 case SMESHOp::OpReorientFaces:
2840 case SMESHOp::OpCreateGeometryGroup:
2842 startOperation( theCommandID );
2845 case SMESHOp::OpCreateGroup:
2849 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2853 if(isStudyLocked()) break;
2854 EmitSignalDeactivateDialog();
2855 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2857 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2858 SALOME_ListIO selected;
2860 aSel->selectedObjects( selected );
2862 int nbSel = selected.Extent();
2864 // check if mesh is selected
2865 aMesh = SMESH::GetMeshByIO( selected.First() );
2867 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2872 case SMESHOp::OpConstructGroup:
2876 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2880 if(isStudyLocked()) break;
2881 EmitSignalDeactivateDialog();
2883 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2884 SALOME_ListIO selected;
2886 aSel->selectedObjects( selected );
2888 int nbSel = selected.Extent();
2890 // check if submesh is selected
2891 Handle(SALOME_InteractiveObject) IObject = selected.First();
2892 if (IObject->hasEntry()) {
2893 _PTR(SObject) aSObj = SMESH::getStudy()->FindObjectID(IObject->getEntry());
2895 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2896 if (!aSubMesh->_is_nil()) {
2898 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2899 // get submesh elements list by types
2900 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2901 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2902 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2903 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2904 // create group for each type o elements
2905 QString aName = IObject->getName();
2906 QStringList anEntryList;
2907 if (aNodes->length() > 0) {
2908 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2909 aGroup->Add(aNodes.inout());
2910 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2911 anEntryList.append( aSObject->GetID().c_str() );
2913 if (aEdges->length() > 0) {
2914 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2915 aGroup->Add(aEdges.inout());
2916 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2917 anEntryList.append( aSObject->GetID().c_str() );
2919 if (aFaces->length() > 0) {
2920 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2921 aGroup->Add(aFaces.inout());
2922 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2923 anEntryList.append( aSObject->GetID().c_str() );
2925 if (aVolumes->length() > 0) {
2926 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2927 aGroup->Add(aVolumes.inout());
2928 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2929 anEntryList.append( aSObject->GetID().c_str() );
2932 anApp->browseObjects( anEntryList );
2934 catch(const SALOME::SALOME_Exception & S_ex){
2935 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2942 SUIT_MessageBox::warning(desktop(),
2943 tr("SMESH_WRN_WARNING"),
2944 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
2949 case SMESHOp::OpEditGroup:
2953 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2957 if(isStudyLocked()) break;
2958 EmitSignalDeactivateDialog();
2960 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2961 SALOME_ListIO selected;
2963 aSel->selectedObjects( selected );
2965 SALOME_ListIteratorOfListIO It (selected);
2966 int nbSelectedGroups = 0;
2967 for ( ; It.More(); It.Next() )
2969 SMESH::SMESH_GroupBase_var aGroup =
2970 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
2971 if (!aGroup->_is_nil()) {
2973 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
2977 if (nbSelectedGroups == 0)
2979 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
2985 case SMESHOp::OpAddElemGroupPopup: // Add elements to group
2987 if(isStudyLocked()) break;
2988 if (myState == 800) {
2989 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2990 if (aDlg) aDlg->onAdd();
2995 case SMESHOp::OpRemoveElemGroupPopup: // Remove elements from group
2997 if(isStudyLocked()) break;
2998 if (myState == 800) {
2999 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3000 if (aDlg) aDlg->onRemove();
3005 case SMESHOp::OpEditGeomGroupAsGroup:
3009 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3013 if(isStudyLocked()) break;
3014 EmitSignalDeactivateDialog();
3016 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3017 SALOME_ListIO selected;
3019 aSel->selectedObjects( selected );
3021 SALOME_ListIteratorOfListIO It (selected);
3022 for ( ; It.More(); It.Next() )
3024 SMESH::SMESH_GroupOnGeom_var aGroup =
3025 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
3026 if (!aGroup->_is_nil()) {
3027 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3032 SMESH::SMESH_GroupOnFilter_var aGroup =
3033 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
3034 if (!aGroup->_is_nil()) {
3035 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3043 case SMESHOp::OpUnionGroups:
3044 case SMESHOp::OpIntersectGroups:
3045 case SMESHOp::OpCutGroups:
3049 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3053 if ( isStudyLocked() )
3056 EmitSignalDeactivateDialog();
3058 SMESHGUI_GroupOpDlg* aDlg = 0;
3059 if ( theCommandID == SMESHOp::OpUnionGroups )
3060 aDlg = new SMESHGUI_UnionGroupsDlg( this );
3061 else if ( theCommandID == SMESHOp::OpIntersectGroups )
3062 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3064 aDlg = new SMESHGUI_CutGroupsDlg( this );
3071 case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
3073 if ( isStudyLocked() )
3076 EmitSignalDeactivateDialog();
3077 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3083 case SMESHOp::OpDeleteGroup: // Delete groups with their contents
3087 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3091 if ( isStudyLocked() )
3094 EmitSignalDeactivateDialog();
3096 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3100 case SMESHOp::OpMeshInformation:
3101 case SMESHOp::OpWhatIs:
3103 int page = theCommandID == SMESHOp::OpMeshInformation ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3104 EmitSignalDeactivateDialog();
3105 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3106 SALOME_ListIO selected;
3108 aSel->selectedObjects( selected );
3110 if ( selected.Extent() > 1 ) { // a dlg for each IO
3111 SALOME_ListIteratorOfListIO It( selected );
3112 for ( ; It.More(); It.Next() ) {
3113 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3114 dlg->showInfo( It.Value() );
3119 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3125 case SMESHOp::OpFindElementByPoint:
3127 startOperation( theCommandID );
3131 case SMESHOp::OpEditHypothesis:
3133 if(isStudyLocked()) break;
3135 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3136 SALOME_ListIO selected;
3138 aSel->selectedObjects( selected );
3140 int nbSel = selected.Extent();
3143 Handle(SALOME_InteractiveObject) anIObject = selected.First();
3144 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3146 if ( !aHypothesis->_is_nil() )
3148 SMESHGUI_GenericHypothesisCreator* aCreator =
3149 SMESH::GetHypothesisCreator( SMESH::toQStr( aHypothesis->GetName() ));
3152 // set geometry of mesh and sub-mesh to aCreator
3153 aSel->selectedObjects( selected, "", /*convertReferences=*/false);
3154 if ( selected.Extent() == 1 )
3156 QString subGeomID, meshGeomID;
3157 Handle(SALOME_InteractiveObject) hypIO = selected.First();
3158 if ( SMESH::GetGeomEntries( hypIO, subGeomID, meshGeomID ))
3160 if ( subGeomID.isEmpty() ) subGeomID = meshGeomID;
3161 aCreator->setShapeEntry( subGeomID );
3162 aCreator->setMainShapeEntry( meshGeomID );
3166 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3176 case SMESHOp::OpUnassign: // REMOVE HYPOTHESIS / ALGORITHMS
3178 if(isStudyLocked()) break;
3179 SUIT_OverrideCursor wc;
3181 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3182 SALOME_ListIO selected;
3184 aSel->selectedObjects( selected, QString::null, false );
3186 SALOME_ListIteratorOfListIO It(selected);
3187 for (int i = 0; It.More(); It.Next(), i++) {
3188 Handle(SALOME_InteractiveObject) IObject = It.Value();
3189 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3192 aSel->setSelectedObjects( l1 );
3197 case SMESHOp::OpElem0D:
3198 case SMESHOp::OpBall:
3199 case SMESHOp::OpEdge:
3200 case SMESHOp::OpTriangle:
3201 case SMESHOp::OpQuadrangle:
3202 case SMESHOp::OpPolygon:
3203 case SMESHOp::OpTetrahedron:
3204 case SMESHOp::OpHexahedron:
3205 case SMESHOp::OpPentahedron:
3206 case SMESHOp::OpPyramid:
3207 case SMESHOp::OpHexagonalPrism:
3209 if(isStudyLocked()) break;
3211 EmitSignalDeactivateDialog();
3212 SMDSAbs_EntityType type = SMDSEntity_Edge;
3213 switch (theCommandID) {
3214 case SMESHOp::OpElem0D: type = SMDSEntity_0D; break;
3215 case SMESHOp::OpBall: type = SMDSEntity_Ball; break;
3216 case SMESHOp::OpTriangle: type = SMDSEntity_Triangle; break;
3217 case SMESHOp::OpQuadrangle: type = SMDSEntity_Quadrangle; break;
3218 case SMESHOp::OpTetrahedron: type = SMDSEntity_Tetra; break;
3219 case SMESHOp::OpPolygon: type = SMDSEntity_Polygon; break;
3220 case SMESHOp::OpHexahedron: type = SMDSEntity_Hexa; break;
3221 case SMESHOp::OpPentahedron: type = SMDSEntity_Penta; break;
3222 case SMESHOp::OpPyramid: type = SMDSEntity_Pyramid; break;
3223 case SMESHOp::OpHexagonalPrism: type = SMDSEntity_Hexagonal_Prism; break;
3226 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3229 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3233 case SMESHOp::OpPolyhedron:
3235 if(isStudyLocked()) break;
3237 EmitSignalDeactivateDialog();
3238 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3241 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3245 case SMESHOp::OpQuadraticEdge:
3246 case SMESHOp::OpQuadraticTriangle:
3247 case SMESHOp::OpBiQuadraticTriangle:
3248 case SMESHOp::OpQuadraticQuadrangle:
3249 case SMESHOp::OpBiQuadraticQuadrangle:
3250 case SMESHOp::OpQuadraticPolygon:
3251 case SMESHOp::OpQuadraticTetrahedron:
3252 case SMESHOp::OpQuadraticPyramid:
3253 case SMESHOp::OpQuadraticPentahedron:
3254 case SMESHOp::OpBiQuadraticPentahedron:
3255 case SMESHOp::OpQuadraticHexahedron:
3256 case SMESHOp::OpTriQuadraticHexahedron:
3258 if(isStudyLocked()) break;
3260 EmitSignalDeactivateDialog();
3261 SMDSAbs_EntityType type = SMDSEntity_Last;
3263 switch (theCommandID) {
3264 case SMESHOp::OpQuadraticEdge: type = SMDSEntity_Quad_Edge; break;
3265 case SMESHOp::OpQuadraticTriangle: type = SMDSEntity_Quad_Triangle; break;
3266 case SMESHOp::OpBiQuadraticTriangle: type = SMDSEntity_BiQuad_Triangle; break;
3267 case SMESHOp::OpQuadraticQuadrangle: type = SMDSEntity_Quad_Quadrangle; break;
3268 case SMESHOp::OpBiQuadraticQuadrangle: type = SMDSEntity_BiQuad_Quadrangle; break;
3269 case SMESHOp::OpQuadraticPolygon: type = SMDSEntity_Quad_Polygon; break;
3270 case SMESHOp::OpQuadraticTetrahedron: type = SMDSEntity_Quad_Tetra; break;
3271 case SMESHOp::OpQuadraticPyramid: type = SMDSEntity_Quad_Pyramid; break;
3272 case SMESHOp::OpQuadraticPentahedron: type = SMDSEntity_Quad_Penta; break;
3273 case SMESHOp::OpBiQuadraticPentahedron: type = SMDSEntity_BiQuad_Penta; break;
3274 case SMESHOp::OpQuadraticHexahedron: type = SMDSEntity_Quad_Hexa; break;
3275 case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
3278 if ( type != SMDSEntity_Last )
3279 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3282 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3283 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3287 case SMESHOp::OpRemoveNodes:
3289 if(isStudyLocked()) break;
3291 EmitSignalDeactivateDialog();
3292 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3295 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3296 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3300 case SMESHOp::OpRemoveElements: // REMOVES ELEMENTS
3302 if(isStudyLocked()) break;
3304 EmitSignalDeactivateDialog();
3305 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3309 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3310 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3314 case SMESHOp::OpClearMesh: {
3316 if(isStudyLocked()) break;
3318 SALOME_ListIO selected;
3319 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3320 aSel->selectedObjects( selected );
3322 SUIT_OverrideCursor wc;
3323 SALOME_ListIteratorOfListIO It (selected);
3324 for ( ; It.More(); It.Next() )
3326 Handle(SALOME_InteractiveObject) IOS = It.Value();
3327 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3328 if ( aMesh->_is_nil()) continue;
3331 if ( aMesh->NbNodes() == 0 ) // imported mesh is not empty
3332 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3333 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3334 SMESH::ModifiedMesh( aMeshSObj, false, true);
3335 // hide groups and submeshes
3336 _PTR(ChildIterator) anIter =
3337 SMESH::getStudy()->NewChildIterator( aMeshSObj );
3338 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3340 _PTR(SObject) so = anIter->Value();
3341 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3344 catch (const SALOME::SALOME_Exception& S_ex){
3346 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3350 SMESH::UpdateView();
3354 case SMESHOp::OpRemoveOrphanNodes:
3356 if(isStudyLocked()) break;
3357 SALOME_ListIO selected;
3358 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3359 aSel->selectedObjects( selected );
3360 if ( selected.Extent() == 1 ) {
3361 Handle(SALOME_InteractiveObject) anIO = selected.First();
3362 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3363 if ( !aMesh->_is_nil() ) {
3364 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3365 tr( "SMESH_WARNING" ),
3366 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3367 SUIT_MessageBox::Yes |
3368 SUIT_MessageBox::No,
3369 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3372 SUIT_OverrideCursor wc;
3373 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3374 int removed = aMeshEditor->RemoveOrphanNodes();
3375 SUIT_MessageBox::information(SMESHGUI::desktop(),
3376 tr("SMESH_INFORMATION"),
3377 tr("NB_NODES_REMOVED").arg(removed));
3378 if ( removed > 0 ) {
3379 SMESH::UpdateView();
3380 SMESHGUI::Modified();
3383 catch (const SALOME::SALOME_Exception& S_ex) {
3384 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3393 case SMESHOp::OpRenumberingNodes:
3395 if(isStudyLocked()) break;
3397 EmitSignalDeactivateDialog();
3398 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3402 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3403 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3407 case SMESHOp::OpRenumberingElements:
3409 if(isStudyLocked()) break;
3411 EmitSignalDeactivateDialog();
3412 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3416 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3417 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3421 case SMESHOp::OpTranslation:
3423 if(isStudyLocked()) break;
3425 EmitSignalDeactivateDialog();
3426 ( new SMESHGUI_TranslationDlg( this ) )->show();
3429 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3430 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3434 case SMESHOp::OpRotation:
3436 if(isStudyLocked()) break;
3438 EmitSignalDeactivateDialog();
3439 ( new SMESHGUI_RotationDlg( this ) )->show();
3442 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3443 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3447 case SMESHOp::OpSymmetry:
3449 if(isStudyLocked()) break;
3451 EmitSignalDeactivateDialog();
3452 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3455 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3456 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3460 case SMESHOp::OpScale:
3462 if(isStudyLocked()) break;
3464 EmitSignalDeactivateDialog();
3465 ( new SMESHGUI_ScaleDlg( this ) )->show();
3468 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3469 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3474 case SMESHOp::OpOffset:
3476 if(isStudyLocked()) break;
3478 EmitSignalDeactivateDialog();
3479 ( new SMESHGUI_OffsetDlg( this ) )->show();
3482 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3483 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3488 case SMESHOp::OpSewing:
3490 if(isStudyLocked()) break;
3492 EmitSignalDeactivateDialog();
3493 ( new SMESHGUI_SewingDlg( this ) )->show();
3496 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3497 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3501 case SMESHOp::OpMergeNodes:
3503 if(isStudyLocked()) break;
3505 EmitSignalDeactivateDialog();
3506 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3509 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3510 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3514 case SMESHOp::OpMergeElements:
3516 if (isStudyLocked()) break;
3518 EmitSignalDeactivateDialog();
3519 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3521 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3522 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3527 case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
3528 startOperation( SMESHOp::OpMoveNode );
3531 case SMESHOp::OpDuplicateNodes:
3533 if(isStudyLocked()) break;
3535 EmitSignalDeactivateDialog();
3536 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3539 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3540 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3545 case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
3546 startOperation( SMESHOp::OpElem0DOnElemNodes );
3549 case SMESHOp::OpSelectFiltersLibrary: // Library of selection filters
3551 static QList<int> aTypes;
3552 if ( aTypes.isEmpty() )
3554 aTypes.append( SMESH::NODE );
3555 aTypes.append( SMESH::EDGE );
3556 aTypes.append( SMESH::FACE );
3557 aTypes.append( SMESH::VOLUME );
3559 if (!myFilterLibraryDlg)
3560 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3561 else if (myFilterLibraryDlg->isHidden())
3562 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3563 myFilterLibraryDlg->raise();
3567 case SMESHOp::OpFreeNode:
3568 case SMESHOp::OpEqualNode:
3569 case SMESHOp::OpNodeConnectivityNb:
3570 case SMESHOp::OpFreeEdge:
3571 case SMESHOp::OpFreeBorder:
3572 case SMESHOp::OpLength:
3573 case SMESHOp::OpConnection:
3574 case SMESHOp::OpEqualEdge:
3575 case SMESHOp::OpFreeFace:
3576 case SMESHOp::OpBareBorderFace:
3577 case SMESHOp::OpOverConstrainedFace:
3578 case SMESHOp::OpLength2D:
3579 case SMESHOp::OpDeflection2D:
3580 case SMESHOp::OpConnection2D:
3581 case SMESHOp::OpArea:
3582 case SMESHOp::OpTaper:
3583 case SMESHOp::OpAspectRatio:
3584 case SMESHOp::OpMinimumAngle:
3585 case SMESHOp::OpWarpingAngle:
3586 case SMESHOp::OpSkew:
3587 case SMESHOp::OpMaxElementLength2D:
3588 case SMESHOp::OpEqualFace:
3589 case SMESHOp::OpAspectRatio3D:
3590 case SMESHOp::OpVolume:
3591 case SMESHOp::OpMaxElementLength3D:
3592 case SMESHOp::OpBareBorderVolume:
3593 case SMESHOp::OpOverConstrainedVolume:
3594 case SMESHOp::OpEqualVolume:
3597 LightApp_SelectionMgr* mgr = selectionMgr();
3598 SALOME_ListIO selected; mgr->selectedObjects( selected );
3600 if( !selected.IsEmpty() ) {
3601 SUIT_OverrideCursor wc;
3602 ::Control( theCommandID );
3605 SUIT_MessageBox::warning(desktop(),
3606 tr( "SMESH_WRN_WARNING" ),
3607 tr( "SMESH_BAD_SELECTION" ) );
3611 SUIT_MessageBox::warning(desktop(),
3612 tr( "SMESH_WRN_WARNING" ),
3613 tr( "NOT_A_VTK_VIEWER" ) );
3616 case SMESHOp::OpOverallMeshQuality:
3617 OverallMeshQuality();
3619 case SMESHOp::OpNumberingNodes:
3621 SUIT_OverrideCursor wc;
3622 LightApp_SelectionMgr* mgr = selectionMgr();
3623 SALOME_ListIO selected; mgr->selectedObjects( selected );
3625 SALOME_ListIteratorOfListIO it(selected);
3626 for( ; it.More(); it.Next()) {
3627 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3628 if(anIObject->hasEntry()) {
3629 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3630 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3636 case SMESHOp::OpNumberingElements:
3638 SUIT_OverrideCursor wc;
3639 LightApp_SelectionMgr* mgr = selectionMgr();
3640 SALOME_ListIO selected; mgr->selectedObjects( selected );
3642 SALOME_ListIteratorOfListIO it(selected);
3643 for( ; it.More(); it.Next()) {
3644 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3645 if(anIObject->hasEntry())
3646 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3647 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3652 case SMESHOp::OpPropertiesLength:
3653 case SMESHOp::OpPropertiesArea:
3654 case SMESHOp::OpPropertiesVolume:
3655 case SMESHOp::OpMinimumDistance:
3656 case SMESHOp::OpBoundingBox:
3658 int page = SMESHGUI_MeasureDlg::MinDistance;
3659 if ( theCommandID == SMESHOp::OpBoundingBox )
3660 page = SMESHGUI_MeasureDlg::BoundingBox;
3661 else if ( theCommandID == SMESHOp::OpPropertiesLength )
3662 page = SMESHGUI_MeasureDlg::Length;
3663 else if ( theCommandID == SMESHOp::OpPropertiesArea )
3664 page = SMESHGUI_MeasureDlg::Area;
3665 else if ( theCommandID == SMESHOp::OpPropertiesVolume )
3666 page = SMESHGUI_MeasureDlg::Volume;
3668 EmitSignalDeactivateDialog();
3669 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3673 case SMESHOp::OpSortChild:
3679 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3680 //updateObjBrowser();
3684 //=============================================================================
3688 //=============================================================================
3689 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3694 //=============================================================================
3698 //=============================================================================
3699 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3704 //=============================================================================
3708 //=============================================================================
3709 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3714 //=============================================================================
3715 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3716 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3718 //=============================================================================
3719 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3720 SUIT_ViewWindow* wnd )
3722 if(theIO->hasEntry()){
3723 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3724 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3728 //=======================================================================
3729 // function : createSMESHAction
3731 //=======================================================================
3732 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3733 const int key, const bool toggle, const QString& shortcutAction )
3736 QWidget* parent = application()->desktop();
3737 SUIT_ResourceMgr* resMgr = resourceMgr();
3739 if ( !icon_id.isEmpty() )
3740 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3742 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3743 if ( !pix.isNull() )
3744 icon = QIcon( pix );
3746 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3747 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3748 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3750 createAction( id, tooltip, icon, menu, status_bar, key, parent,
3751 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3754 //=======================================================================
3755 // function : createPopupItem
3757 //=======================================================================
3758 void SMESHGUI::createPopupItem( const int id,
3759 const QString& clients,
3760 const QString& types,
3761 const QString& theRule,
3764 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3765 popupMgr()->insert( action( id ), pId, 0 );
3767 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3768 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
3769 QString rule = "(%1) and (%2) and (%3)";
3770 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3771 if( clients.isEmpty() )
3772 rule = rule.arg( QString( "true" ) );
3774 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3775 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3778 bool cont = myRules.contains( id );
3780 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3782 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3783 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3786 //=======================================================================
3787 // function : initialize
3789 //=======================================================================
3790 void SMESHGUI::initialize( CAM_Application* app )
3792 SalomeApp_Module::initialize( app );
3794 // SUIT_ResourceMgr* mgr = app->resourceMgr();
3796 /* Automatic Update flag */
3797 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3799 // ----- create actions --------------
3801 //createSMESHAction( SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
3802 createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_I) );
3803 createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
3804 createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL" );
3806 createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
3808 createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
3809 createSMESHAction( SMESHOp::OpImportGMF, "IMPORT_GMF" );
3810 createSMESHAction( SMESHOp::OpPopupImportUNV, "IMPORT_UNV");
3811 createSMESHAction( SMESHOp::OpPopupImportMED, "IMPORT_MED");
3812 createSMESHAction( SMESHOp::OpPopupImportSTL, "IMPORT_STL" );
3814 createSMESHAction( SMESHOp::OpPopupImportCGNS, "IMPORT_CGNS" );
3816 createSMESHAction( SMESHOp::OpPopupImportSAUV, "IMPORT_SAUV" );
3817 createSMESHAction( SMESHOp::OpPopupImportGMF, "IMPORT_GMF" );
3819 createSMESHAction( SMESHOp::OpExportDAT, "DAT" );
3820 createSMESHAction( SMESHOp::OpExportMED, "MED" );
3821 createSMESHAction( SMESHOp::OpExportUNV, "UNV" );
3822 createSMESHAction( SMESHOp::OpExportSTL, "STL" );
3824 createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
3826 createSMESHAction( SMESHOp::OpExportSAUV, "SAUV");
3827 createSMESHAction( SMESHOp::OpExportGMF, "GMF" );
3828 createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
3829 createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
3830 createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
3831 createSMESHAction( SMESHOp::OpPopupExportSTL, "STL" );
3833 createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
3835 createSMESHAction( SMESHOp::OpPopupExportSAUV, "SAUV");
3836 createSMESHAction( SMESHOp::OpPopupExportGMF, "GMF" );
3837 createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
3838 createSMESHAction( SMESHOp::OpDelete, "DELETE", "ICON_DELETE", Qt::Key_Delete );
3839 createSMESHAction( SMESHOp::OpSelectFiltersLibrary, "SEL_FILTER_LIB" );
3840 createSMESHAction( SMESHOp::OpCreateMesh, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
3841 createSMESHAction( SMESHOp::OpCreateSubMesh, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
3842 createSMESHAction( SMESHOp::OpEditMeshOrSubMesh, "EDIT_MESHSUBMESH", "ICON_DLG_EDIT_MESH" );
3843 createSMESHAction( SMESHOp::OpEditMesh, "EDIT_MESH", "ICON_DLG_EDIT_MESH" );
3844 createSMESHAction( SMESHOp::OpEditSubMesh, "EDIT_SUBMESH", "ICON_DLG_EDIT_MESH" );
3845 createSMESHAction( SMESHOp::OpBuildCompoundMesh, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
3846 createSMESHAction( SMESHOp::OpCopyMesh, "COPY_MESH", "ICON_COPY_MESH" );
3847 createSMESHAction( SMESHOp::OpCompute, "COMPUTE", "ICON_COMPUTE" );
3848 createSMESHAction( SMESHOp::OpComputeSubMesh, "COMPUTE_SUBMESH", "ICON_COMPUTE" );
3849 createSMESHAction( SMESHOp::OpPreCompute, "PRECOMPUTE", "ICON_PRECOMPUTE" );
3850 createSMESHAction( SMESHOp::OpEvaluate, "EVALUATE", "ICON_EVALUATE" );
3851 createSMESHAction( SMESHOp::OpMeshOrder, "MESH_ORDER", "ICON_MESH_ORDER");
3852 createSMESHAction( SMESHOp::OpCreateGroup, "CREATE_GROUP", "ICON_CREATE_GROUP" );
3853 createSMESHAction( SMESHOp::OpCreateGeometryGroup, "CREATE_GEO_GROUP", "ICON_CREATE_GEO_GROUP" );
3854 createSMESHAction( SMESHOp::OpConstructGroup, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
3855 createSMESHAction( SMESHOp::OpEditGroup, "EDIT_GROUP", "ICON_EDIT_GROUP" );
3856 createSMESHAction( SMESHOp::OpEditGeomGroupAsGroup, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3857 createSMESHAction( SMESHOp::OpUnionGroups, "UN_GROUP", "ICON_UNION" );
3858 createSMESHAction( SMESHOp::OpIntersectGroups, "INT_GROUP", "ICON_INTERSECT" );
3859 createSMESHAction( SMESHOp::OpCutGroups, "CUT_GROUP", "ICON_CUT" );
3860 createSMESHAction( SMESHOp::OpGroupUnderlyingElem, "UNDERLYING_ELEMS", "ICON_UNDERLYING_ELEMS" );
3861 createSMESHAction( SMESHOp::OpAddElemGroupPopup, "ADD_TO_GROUP" );
3862 createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE_FROM_GROUP" );
3863 createSMESHAction( SMESHOp::OpDeleteGroup, "DEL_GROUP", "ICON_DEL_GROUP" );
3864 createSMESHAction( SMESHOp::OpMeshInformation , "ADV_INFO", "ICON_ADV_INFO" );
3865 //createSMESHAction( SMESHOp::OpStdInfo, "STD_INFO", "ICON_STD_INFO" );
3866 //createSMESHAction( SMESHOp::OpWhatIs, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3867 createSMESHAction( SMESHOp::OpFindElementByPoint, "FIND_ELEM", "ICON_FIND_ELEM" );
3869 createSMESHAction( SMESHOp::OpFreeNode, "FREE_NODE", "ICON_FREE_NODE", 0, true );
3870 createSMESHAction( SMESHOp::OpEqualNode, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
3871 createSMESHAction( SMESHOp::OpNodeConnectivityNb, "NODE_CONNECTIVITY_NB", "ICON_NODE_CONN_NB", 0, true );
3872 createSMESHAction( SMESHOp::OpFreeEdge, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
3873 createSMESHAction( SMESHOp::OpFreeBorder, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
3874 createSMESHAction( SMESHOp::OpLength, "LENGTH", "ICON_LENGTH", 0, true );
3875 createSMESHAction( SMESHOp::OpConnection, "CONNECTION", "ICON_CONNECTION", 0, true );
3876 createSMESHAction( SMESHOp::OpEqualEdge, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
3877 createSMESHAction( SMESHOp::OpFreeFace, "FREE_FACES", "ICON_FREE_FACES", 0, true );
3878 createSMESHAction( SMESHOp::OpBareBorderFace, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
3879 createSMESHAction( SMESHOp::OpOverConstrainedFace, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
3880 createSMESHAction( SMESHOp::OpLength2D, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
3881 createSMESHAction( SMESHOp::OpDeflection2D, "DEFLECTION_2D", "ICON_DEFLECTION_2D", 0, true );
3882 createSMESHAction( SMESHOp::OpConnection2D, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
3883 createSMESHAction( SMESHOp::OpArea, "AREA", "ICON_AREA", 0, true );
3884 createSMESHAction( SMESHOp::OpTaper, "TAPER", "ICON_TAPER", 0, true );
3885 createSMESHAction( SMESHOp::OpAspectRatio, "ASPECT", "ICON_ASPECT", 0, true );
3886 createSMESHAction( SMESHOp::OpMinimumAngle, "MIN_ANG", "ICON_ANGLE", 0, true );
3887 createSMESHAction( SMESHOp::OpWarpingAngle, "WARP", "ICON_WARP", 0, true );
3888 createSMESHAction( SMESHOp::OpSkew, "SKEW", "ICON_SKEW", 0, true );
3889 createSMESHAction( SMESHOp::OpMaxElementLength2D, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
3890 createSMESHAction( SMESHOp::OpEqualFace, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
3891 createSMESHAction( SMESHOp::OpAspectRatio3D, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
3892 createSMESHAction( SMESHOp::OpVolume, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
3893 createSMESHAction( SMESHOp::OpMaxElementLength3D, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
3894 createSMESHAction( SMESHOp::OpBareBorderVolume, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
3895 createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
3896 createSMESHAction( SMESHOp::OpEqualVolume, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
3897 createSMESHAction( SMESHOp::OpOverallMeshQuality, "OVERALL_MESH_QUALITY", "ICON_OVL_MESH_QUALITY" );
3899 createSMESHAction( SMESHOp::OpNode, "NODE", "ICON_DLG_NODE" );
3900 createSMESHAction( SMESHOp::OpElem0D, "ELEM0D", "ICON_DLG_ELEM0D" );
3901 createSMESHAction( SMESHOp::OpElem0DOnElemNodes, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
3902 createSMESHAction( SMESHOp::OpBall, "BALL", "ICON_DLG_BALL" );
3903 createSMESHAction( SMESHOp::OpEdge, "EDGE", "ICON_DLG_EDGE" );
3904 createSMESHAction( SMESHOp::OpTriangle, "TRIANGLE", "ICON_DLG_TRIANGLE" );
3905 createSMESHAction( SMESHOp::OpQuadrangle, "QUAD", "ICON_DLG_QUADRANGLE" );
3906 createSMESHAction( SMESHOp::OpPolygon, "POLYGON", "ICON_DLG_POLYGON" );
3907 createSMESHAction( SMESHOp::OpTetrahedron, "TETRA", "ICON_DLG_TETRAS" );
3908 createSMESHAction( SMESHOp::OpHexahedron, "HEXA", "ICON_DLG_HEXAS" );
3909 createSMESHAction( SMESHOp::OpPentahedron, "PENTA", "ICON_DLG_PENTA" );
3910 createSMESHAction( SMESHOp::OpPyramid , "PYRAMID", "ICON_DLG_PYRAMID" );
3911 createSMESHAction( SMESHOp::OpHexagonalPrism, "OCTA", "ICON_DLG_OCTA" );
3912 createSMESHAction( SMESHOp::OpPolyhedron, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
3913 createSMESHAction( SMESHOp::OpQuadraticEdge, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
3914 createSMESHAction( SMESHOp::OpQuadraticTriangle, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
3915 createSMESHAction( SMESHOp::OpBiQuadraticTriangle, "BIQUADRATIC_TRIANGLE", "ICON_DLG_BIQUADRATIC_TRIANGLE" );
3916 createSMESHAction( SMESHOp::OpQuadraticQuadrangle, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
3917 createSMESHAction( SMESHOp::OpBiQuadraticQuadrangle, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
3918 createSMESHAction( SMESHOp::OpQuadraticPolygon, "QUADRATIC_POLYGON", "ICON_DLG_QUADRATIC_POLYGON" );
3919 createSMESHAction( SMESHOp::OpQuadraticTetrahedron, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
3920 createSMESHAction( SMESHOp::OpQuadraticPyramid, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
3921 createSMESHAction( SMESHOp::OpQuadraticPentahedron, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
3922 createSMESHAction( SMESHOp::OpBiQuadraticPentahedron, "BIQUADRATIC_PENTAHEDRON", "ICON_DLG_BIQUADRATIC_PENTAHEDRON" );
3923 createSMESHAction( SMESHOp::OpQuadraticHexahedron, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
3924 createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
3926 createSMESHAction( SMESHOp::OpRemoveNodes, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
3927 createSMESHAction( SMESHOp::OpRemoveElements, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
3928 createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
3929 createSMESHAction( SMESHOp::OpClearMesh, "CLEAR_MESH", "ICON_CLEAR_MESH" );
3931 //createSMESHAction( SMESHOp::OpRenumberingNodes, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
3932 //createSMESHAction( SMESHOp::OpRenumberingElements, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
3934 createSMESHAction( SMESHOp::OpTranslation, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
3935 createSMESHAction( SMESHOp::OpRotation, "ROT", "ICON_DLG_MESH_ROTATION" );
3936 createSMESHAction( SMESHOp::OpSymmetry, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
3937 createSMESHAction( SMESHOp::OpScale, "SCALE", "ICON_DLG_MESH_SCALE" );
3938 createSMESHAction( SMESHOp::OpOffset, "OFFSET", "ICON_DLG_MESH_OFFSET" );
3939 createSMESHAction( SMESHOp::OpSewing, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
3940 createSMESHAction( SMESHOp::OpMergeNodes, "MERGE", "ICON_SMESH_MERGE_NODES" );
3941 createSMESHAction( SMESHOp::OpMergeElements, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
3942 createSMESHAction( SMESHOp::OpMoveNode, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
3943 createSMESHAction( SMESHOp::OpDuplicateNodes, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
3944 createSMESHAction( SMESHOp::OpDiagonalInversion, "INV", "ICON_DLG_MESH_DIAGONAL" );
3945 createSMESHAction( SMESHOp::OpUnionOfTwoTriangle, "UNION2", "ICON_UNION2TRI" );
3946 createSMESHAction( SMESHOp::OpOrientation, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
3947 createSMESHAction( SMESHOp::OpReorientFaces, "REORIENT_2D", "ICON_REORIENT_2D" );
3948 createSMESHAction( SMESHOp::OpUnionOfTriangles, "UNION", "ICON_UNIONTRI" );
3949 createSMESHAction( SMESHOp::OpCuttingOfQuadrangles, "CUT", "ICON_CUTQUAD" );
3950 createSMESHAction( SMESHOp::OpSplitVolumes, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
3951 createSMESHAction( SMESHOp::OpSplitBiQuadratic, "SPLIT_BIQUAD", "ICON_SPLIT_BIQUAD" );
3952 createSMESHAction( SMESHOp::OpSmoothing, "SMOOTH", "ICON_DLG_SMOOTHING" );
3953 createSMESHAction( SMESHOp::OpExtrusion, "EXTRUSION", "ICON_EXTRUSION" );
3954 createSMESHAction( SMESHOp::OpExtrusionAlongAPath, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
3955 createSMESHAction( SMESHOp::OpRevolution, "REVOLUTION", "ICON_REVOLUTION" );
3956 createSMESHAction( SMESHOp::OpPatternMapping, "MAP", "ICON_MAP" );
3957 createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
3958 createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D", "ICON_2D_FROM_3D" );
3960 createSMESHAction( SMESHOp::OpReset, "RESET" );
3961 createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
3962 createSMESHAction( SMESHOp::OpShowScalarBar, "SHOW_SCALAR_BAR","",0, true );
3963 createSMESHAction( SMESHOp::OpSaveDistribution, "SAVE_DISTRIBUTION" );
3964 createSMESHAction( SMESHOp::OpShowDistribution, "SHOW_DISTRIBUTION","",0, true );
3965 #ifndef DISABLE_PLOT2DVIEWER
3966 createSMESHAction( SMESHOp::OpPlotDistribution, "PLOT_DISTRIBUTION" );
3968 createSMESHAction( SMESHOp::OpDMWireframe, "WIRE", "ICON_WIRE", 0, true );
3969 createSMESHAction( SMESHOp::OpDMShading, "SHADE", "ICON_SHADE", 0, true );
3970 createSMESHAction( SMESHOp::OpDMNodes, "NODES", "ICON_POINTS", 0, true );
3971 createSMESHAction( SMESHOp::OpDMShrink, "SHRINK", "ICON_SHRINK", 0, true );
3972 createSMESHAction( SMESHOp::OpUpdate, "UPDATE", "ICON_UPDATE" );
3973 createSMESHAction( SMESHOp::OpDE0DElements, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
3974 createSMESHAction( SMESHOp::OpDEEdges, "EDGES", "ICON_DLG_EDGE", 0, true );
3975 createSMESHAction( SMESHOp::OpDEFaces, "FACES", "ICON_DLG_TRIANGLE", 0, true );
3976 createSMESHAction( SMESHOp::OpDEVolumes, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
3977 createSMESHAction( SMESHOp::OpDEBalls, "BALLS", "ICON_DLG_BALL", 0, true );
3978 createSMESHAction( SMESHOp::OpDEChoose, "CHOOSE", "ICON_DLG_CHOOSE", 0, false );
3979 createSMESHAction( SMESHOp::OpDEAllEntity, "ALL", "ICON_DLG_CHOOSE_ALL", 0, false );
3980 createSMESHAction( SMESHOp::OpOrientationOnFaces, "FACE_ORIENTATION", "", 0, true );
3982 createSMESHAction( SMESHOp::OpRepresentationLines, "LINE_REPRESENTATION", "", 0, true );
3983 createSMESHAction( SMESHOp::OpRepresentationArcs, "ARC_REPRESENTATION", "", 0, true );
3985 createSMESHAction( SMESHOp::OpEditHypothesis, "EDIT_HYPO" );
3986 createSMESHAction( SMESHOp::OpUnassign, "UNASSIGN" );
3987 createSMESHAction( SMESHOp::OpNumberingNodes, "NUM_NODES", "", 0, true );
3988 createSMESHAction( SMESHOp::OpNumberingElements, "NUM_ELEMENTS", "", 0, true );
3989 createSMESHAction( SMESHOp::OpProperties, "COLORS" );
3990 createSMESHAction( SMESHOp::OpTransparency, "TRANSP" );
3991 createSMESHAction( SMESHOp::OpClipping, "CLIP" );
3992 createSMESHAction( SMESHOp::OpAutoColor, "AUTO_COLOR" );
3993 createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
3995 createSMESHAction( SMESHOp::OpMinimumDistance, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
3996 createSMESHAction( SMESHOp::OpBoundingBox, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
3997 createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH", "ICON_MEASURE_LENGTH" );
3998 createSMESHAction( SMESHOp::OpPropertiesArea, "MEASURE_AREA", "ICON_MEASURE_AREA" );
3999 createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME", "ICON_MEASURE_VOLUME" );
4001 createSMESHAction( SMESHOp::OpHide, "HIDE", "ICON_HIDE" );
4002 createSMESHAction( SMESHOp::OpShow, "SHOW", "ICON_SHOW" );
4003 createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
4005 createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
4007 QList<int> aCtrlActions;
4008 aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode
4009 << SMESHOp::OpNodeConnectivityNb // node controls
4010 << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
4011 << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge // edge controls
4012 << SMESHOp::OpDeflection2D
4013 << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
4014 << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
4015 << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
4016 << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
4017 << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace // face controls
4018 << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
4019 << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
4020 << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume; // volume controls
4021 QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
4022 aCtrlGroup->setExclusive( true );
4023 for( int i = 0; i < aCtrlActions.size(); i++ )
4024 aCtrlGroup->addAction( action( aCtrlActions[i] ) );
4026 // ----- create menu --------------
4027 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
4028 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
4029 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
4030 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
4031 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
4032 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
4033 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
4034 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
4036 createMenu( separator(), fileId );
4038 QMenu* nodeMenu = new QMenu(); QMenu* edgeMenu = new QMenu();
4039 QMenu* faceMenu = new QMenu(); QMenu* volumeMenu = new QMenu();
4040 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
4041 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
4042 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10, -1, nodeMenu ),
4043 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10, -1, edgeMenu ),
4044 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10, -1, faceMenu ),
4045 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10, -1, volumeMenu ),
4046 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
4047 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
4048 //renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
4049 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
4050 basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
4052 //createMenu( SMESHOp::OpImportDAT, importId, -1 );
4053 createMenu( SMESHOp::OpImportUNV, importId, -1 );
4054 createMenu( SMESHOp::OpImportMED, importId, -1 );
4055 createMenu( SMESHOp::OpImportSTL, importId, -1 );
4057 createMenu( SMESHOp::OpImportCGNS, importId, -1 );
4059 createMenu( SMESHOp::OpImportSAUV, importId, -1 );
4060 createMenu( SMESHOp::OpImportGMF, importId, -1 );
4061 createMenu( SMESHOp::OpExportDAT, exportId, -1 );
4062 createMenu( SMESHOp::OpExportMED, exportId, -1 );
4063 createMenu( SMESHOp::OpExportUNV, exportId, -1 );
4064 createMenu( SMESHOp::OpExportSTL, exportId, -1 );
4066 createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
4068 createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
4069 createMenu( SMESHOp::OpExportGMF, exportId, -1 );
4070 createMenu( separator(), fileId, 10 );
4072 createMenu( SMESHOp::OpDelete, editId, -1 );
4074 createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
4076 createMenu( SMESHOp::OpCreateMesh, meshId, -1 ); // "Mesh" menu
4077 createMenu( SMESHOp::OpCreateSubMesh, meshId, -1 );
4078 createMenu( SMESHOp::OpEditMeshOrSubMesh, meshId, -1 );
4079 createMenu( SMESHOp::OpBuildCompoundMesh, meshId, -1 );
4080 createMenu( SMESHOp::OpCopyMesh, meshId, -1 );
4081 createMenu( separator(), meshId, -1 );
4082 createMenu( SMESHOp::OpCompute, meshId, -1 );
4083 createMenu( SMESHOp::OpPreCompute, meshId, -1 );
4084 createMenu( SMESHOp::OpEvaluate, meshId, -1 );
4085 createMenu( SMESHOp::OpMeshOrder, meshId, -1 );
4086 createMenu( separator(), meshId, -1 );
4087 createMenu( SMESHOp::OpCreateGroup, meshId, -1 );
4088 createMenu( SMESHOp::OpCreateGeometryGroup, meshId, -1 );
4089 createMenu( SMESHOp::OpConstructGroup, meshId, -1 );
4090 createMenu( SMESHOp::OpEditGroup, meshId, -1 );
4091 createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4092 createMenu( separator(), meshId, -1 );
4093 createMenu( SMESHOp::OpUnionGroups, meshId, -1 );
4094 createMenu( SMESHOp::OpIntersectGroups, meshId, -1 );
4095 createMenu( SMESHOp::OpCutGroups, meshId, -1 );
4096 createMenu( separator(), meshId, -1 );
4097 createMenu( SMESHOp::OpGroupUnderlyingElem, meshId, -1 );
4098 createMenu( separator(), meshId, -1 );
4099 createMenu( SMESHOp::OpMeshInformation, meshId, -1 );
4100 //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4101 //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4102 createMenu( SMESHOp::OpFindElementByPoint, meshId, -1 );
4103 createMenu( separator(), meshId, -1 );
4105 createMenu( SMESHOp::OpFreeNode, nodeId, -1 );
4106 createMenu( SMESHOp::OpEqualNode, nodeId, -1 );
4107 //createMenu( SMESHOp::OpNodeConnectivityNb, nodeId, -1 );
4108 createMenu( SMESHOp::OpFreeBorder, edgeId, -1 );
4109 createMenu( SMESHOp::OpLength, edgeId, -1 );
4110 createMenu( SMESHOp::OpConnection, edgeId, -1 );
4111 createMenu( SMESHOp::OpEqualEdge, edgeId, -1 );
4112 createMenu( SMESHOp::OpFreeEdge, faceId, -1 );
4113 createMenu( SMESHOp::OpFreeFace, faceId, -1 );
4114 createMenu( SMESHOp::OpBareBorderFace, faceId, -1 );
4115 createMenu( SMESHOp::OpOverConstrainedFace, faceId, -1 );
4116 createMenu( SMESHOp::OpLength2D, faceId, -1 );
4117 createMenu( SMESHOp::OpConnection2D, faceId, -1 );
4118 createMenu( SMESHOp::OpArea, faceId, -1 );
4119 createMenu( SMESHOp::OpTaper, faceId, -1 );
4120 createMenu( SMESHOp::OpAspectRatio, faceId, -1 );
4121 createMenu( SMESHOp::OpMinimumAngle, faceId, -1 );
4122 createMenu( SMESHOp::OpWarpingAngle, faceId, -1 );
4123 createMenu( SMESHOp::OpSkew, faceId, -1 );
4124 createMenu( SMESHOp::OpMaxElementLength2D, faceId, -1 );
4125 createMenu( SMESHOp::OpEqualFace, faceId, -1 );
4126 createMenu( SMESHOp::OpDeflection2D, faceId, -1 );
4127 createMenu( SMESHOp::OpAspectRatio3D, volumeId, -1 );
4128 createMenu( SMESHOp::OpVolume, volumeId, -1 );
4129 createMenu( SMESHOp::OpMaxElementLength3D, volumeId, -1 );
4130 createMenu( SMESHOp::OpBareBorderVolume, volumeId, -1 );
4131 createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4132 createMenu( SMESHOp::OpEqualVolume, volumeId, -1 );
4133 createMenu( separator(), ctrlId, -1 );
4134 createMenu( SMESHOp::OpReset, ctrlId, -1 );
4135 createMenu( separator(), ctrlId, -1 );
4136 createMenu( SMESHOp::OpOverallMeshQuality, ctrlId, -1 );
4138 createMenu( SMESHOp::OpNode, addId, -1 );
4139 createMenu( SMESHOp::OpElem0D, addId, -1 );
4140 createMenu( SMESHOp::OpElem0DOnElemNodes, addId, -1 );
4141 createMenu( SMESHOp::OpBall, addId, -1 );
4142 createMenu( SMESHOp::OpEdge, addId, -1 );
4143 createMenu( SMESHOp::OpTriangle, addId, -1 );
4144 createMenu( SMESHOp::OpQuadrangle, addId, -1 );
4145 createMenu( SMESHOp::OpPolygon, addId, -1 );
4146 createMenu( SMESHOp::OpTetrahedron, addId, -1 );
4147 createMenu( SMESHOp::OpHexahedron, addId, -1 );
4148 createMenu( SMESHOp::OpPentahedron, addId, -1 );
4149 createMenu( SMESHOp::OpPyramid, addId, -1 );
4150 createMenu( SMESHOp::OpHexagonalPrism, addId, -1 );
4151 createMenu( SMESHOp::OpPolyhedron, addId, -1 );
4152 createMenu( separator(), addId, -1 );
4153 createMenu( SMESHOp::OpQuadraticEdge, addId, -1 );
4154 createMenu( SMESHOp::OpQuadraticTriangle, addId, -1 );
4155 createMenu( SMESHOp::OpBiQuadraticTriangle , addId, -1 );
4156 createMenu( SMESHOp::OpQuadraticQuadrangle, addId, -1 );
4157 createMenu( SMESHOp::OpBiQuadraticQuadrangle, addId, -1 );
4158 createMenu( SMESHOp::OpQuadraticPolygon, addId, -1 );
4159 createMenu( SMESHOp::OpQuadraticTetrahedron, addId, -1 );
4160 createMenu( SMESHOp::OpQuadraticPyramid, addId, -1 );
4161 createMenu( SMESHOp::OpQuadraticPentahedron, addId, -1 );
4162 createMenu( SMESHOp::OpBiQuadraticPentahedron, addId, -1 );
4163 createMenu( SMESHOp::OpQuadraticHexahedron, addId, -1 );
4164 createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4166 createMenu( SMESHOp::OpRemoveNodes, removeId, -1 );
4167 createMenu( SMESHOp::OpRemoveElements, removeId, -1 );
4168 createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4169 createMenu( separator(), removeId, -1 );
4170 createMenu( SMESHOp::OpDeleteGroup, removeId, -1 );
4171 createMenu( separator(), removeId, -1 );
4172 createMenu( SMESHOp::OpClearMesh, removeId, -1 );
4174 //createMenu( SMESHOp::OpRenumberingNodes, renumId, -1 );
4175 //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4177 createMenu( SMESHOp::OpMergeNodes, transfId, -1 );
4178 createMenu( SMESHOp::OpMergeElements, transfId, -1 );
4179 createMenu( SMESHOp::OpTranslation, transfId, -1 );
4180 createMenu( SMESHOp::OpRotation, transfId, -1 );
4181 createMenu( SMESHOp::OpSymmetry, transfId, -1 );
4182 createMenu( SMESHOp::OpScale, transfId, -1 );
4183 createMenu( SMESHOp::OpOffset, transfId, -1 );
4184 createMenu( SMESHOp::OpSewing, transfId, -1 );
4185 createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4187 createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4188 createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4189 createMenu( SMESHOp::OpExtrusion, modifyId, -1 );
4190 createMenu( SMESHOp::OpExtrusionAlongAPath, modifyId, -1 );
4191 createMenu( SMESHOp::OpRevolution, modifyId, -1 );
4192 createMenu( SMESHOp::OpOrientation, modifyId, -1 );
4193 createMenu( SMESHOp::OpReorientFaces, modifyId, -1 );
4194 createMenu( SMESHOp::OpMoveNode, modifyId, -1 );
4195 createMenu( SMESHOp::OpDiagonalInversion, modifyId, -1 );
4196 createMenu( SMESHOp::OpUnionOfTwoTriangle, modifyId, -1 );
4197 createMenu( SMESHOp::OpUnionOfTriangles, modifyId, -1 );
4198 createMenu( SMESHOp::OpCuttingOfQuadrangles, modifyId, -1 );
4199 createMenu( SMESHOp::OpSplitVolumes, modifyId, -1 );
4200 createMenu( SMESHOp::OpSplitBiQuadratic, modifyId, -1 );
4201 createMenu( SMESHOp::OpSmoothing, modifyId, -1 );
4202 createMenu( SMESHOp::OpPatternMapping, modifyId, -1 );
4204 createMenu( SMESHOp::OpMinimumDistance, measureId, -1 );
4205 createMenu( SMESHOp::OpBoundingBox, measureId, -1 );
4206 createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4207 createMenu( SMESHOp::OpPropertiesArea, basicPropId, -1 );
4208 createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4209 createMenu( SMESHOp::OpUpdate, viewId, -1 );
4211 connect( nodeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4212 connect( edgeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4213 connect( faceMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4214 connect( volumeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4216 // ----- create toolbars --------------
4217 int meshTb = createTool( tr( "TB_MESH" ), QString( "SMESHMeshToolbar" ) ),
4218 info = createTool( tr( "TB_INFO" ), QString( "SMESHInformationToolbar" ) ),
4219 groupTb = createTool( tr( "TB_GROUP" ), QString( "SMESHGroupToolbar" ) ),
4220 ctrl0dTb = createTool( tr( "TB_CTRL0D" ), QString( "SMESHNodeControlsToolbar" ) ),
4221 ctrl1dTb = createTool( tr( "TB_CTRL1D" ), QString( "SMESHEdgeControlsToolbar" ) ),
4222 ctrl2dTb = createTool( tr( "TB_CTRL2D" ), QString( "SMESHFaceControlsToolbar" ) ),
4223 ctrl3dTb = createTool( tr( "TB_CTRL3D" ), QString( "SMESHVolumeControlsToolbar" ) ),
4224 addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ),
4225 addNonElemTb = createTool( tr( "TB_ADDNON" ), QString( "SMESHAddElementToolbar" ) ),
4226 remTb = createTool( tr( "TB_REM" ), QString( "SMESHRemoveToolbar" ) ),
4227 //renumbTb = createTool( tr( "TB_RENUMBER" ), QString( "SMESHRenumberingToolbar" ) ),
4228 transformTb = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ),
4229 modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ),
4230 measuremTb = createTool( tr( "TB_MEASUREM" ), QString( "SMESHMeasurementsToolbar" ) ),
4231 dispModeTb = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4233 createTool( SMESHOp::OpCreateMesh, meshTb );
4234 createTool( SMESHOp::OpCreateSubMesh, meshTb );
4235 createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4236 createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4237 createTool( SMESHOp::OpCopyMesh, meshTb );
4238 createTool( separator(), meshTb );
4239 createTool( SMESHOp::OpCompute, meshTb );
4240 createTool( SMESHOp::OpPreCompute, meshTb );
4241 createTool( SMESHOp::OpEvaluate, meshTb );
4242 createTool( SMESHOp::OpMeshOrder, meshTb );
4244 createTool( SMESHOp::OpCreateGroup, groupTb );
4245 createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4246 createTool( SMESHOp::OpConstructGroup, groupTb );
4247 createTool( SMESHOp::OpEditGroup, groupTb );
4249 createTool( SMESHOp::OpMeshInformation, info );
4250 //createTool( SMESHOp::OpStdInfo, meshTb );
4251 //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4252 createTool( SMESHOp::OpFindElementByPoint, info );
4254 createTool( SMESHOp::OpFreeNode, ctrl0dTb );
4255 createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4256 //createTool( SMESHOp::OpNodeConnectivityNb, ctrl0dTb );
4258 createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4259 createTool( SMESHOp::OpLength, ctrl1dTb );
4260 createTool( SMESHOp::OpConnection, ctrl1dTb );
4261 createTool( SMESHOp::OpEqualEdge, ctrl1dTb );
4263 createTool( SMESHOp::OpFreeEdge, ctrl2dTb );
4264 createTool( SMESHOp::OpFreeFace, ctrl2dTb );
4265 createTool( SMESHOp::OpBareBorderFace, ctrl2dTb );
4266 createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4267 createTool( SMESHOp::OpLength2D, ctrl2dTb );
4268 createTool( SMESHOp::OpConnection2D, ctrl2dTb );
4269 createTool( SMESHOp::OpArea, ctrl2dTb );
4270 createTool( SMESHOp::OpTaper, ctrl2dTb );
4271 createTool( SMESHOp::OpAspectRatio, ctrl2dTb );
4272 createTool( SMESHOp::OpMinimumAngle, ctrl2dTb );
4273 createTool( SMESHOp::OpWarpingAngle, ctrl2dTb );
4274 createTool( SMESHOp::OpSkew, ctrl2dTb );
4275 createTool( SMESHOp::OpMaxElementLength2D, ctrl2dTb );
4276 createTool( SMESHOp::OpEqualFace, ctrl2dTb );
4277 createTool( SMESHOp::OpDeflection2D, ctrl2dTb );
4279 createTool( SMESHOp::OpAspectRatio3D, ctrl3dTb );
4280 createTool( SMESHOp::OpVolume, ctrl3dTb );
4281 createTool( SMESHOp::OpMaxElementLength3D, ctrl3dTb );
4282 createTool( SMESHOp::OpBareBorderVolume, ctrl3dTb );
4283 createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
4284 createTool( SMESHOp::OpEqualVolume, ctrl3dTb );
4286 createTool( SMESHOp::OpNode, addElemTb );
4287 createTool( SMESHOp::OpElem0D, addElemTb );
4288 createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4289 createTool( SMESHOp::OpBall, addElemTb );
4290 createTool( SMESHOp::OpEdge, addElemTb );
4291 createTool( SMESHOp::OpTriangle, addElemTb );
4292 createTool( SMESHOp::OpQuadrangle, addElemTb );
4293 createTool( SMESHOp::OpPolygon, addElemTb );
4294 createTool( SMESHOp::OpTetrahedron, addElemTb );
4295 createTool( SMESHOp::OpHexahedron, addElemTb );
4296 createTool( SMESHOp::OpPentahedron, addElemTb );
4297 createTool( SMESHOp::OpPyramid, addElemTb );
4298 createTool( SMESHOp::OpHexagonalPrism, addElemTb );
4299 createTool( SMESHOp::OpPolyhedron, addElemTb );
4301 createTool( SMESHOp::OpQuadraticEdge, addNonElemTb );
4302 createTool( SMESHOp::OpQuadraticTriangle, addNonElemTb );
4303 createTool( SMESHOp::OpBiQuadraticTriangle, addNonElemTb );
4304 createTool( SMESHOp::OpQuadraticQuadrangle, addNonElemTb );
4305 createTool( SMESHOp::OpBiQuadraticQuadrangle, addNonElemTb );
4306 createTool( SMESHOp::OpQuadraticPolygon, addNonElemTb );
4307 createTool( SMESHOp::OpQuadraticTetrahedron, addNonElemTb );
4308 createTool( SMESHOp::OpQuadraticPyramid, addNonElemTb );
4309 createTool( SMESHOp::OpQuadraticPentahedron, addNonElemTb );
4310 createTool( SMESHOp::OpBiQuadraticPentahedron, addNonElemTb );
4311 createTool( SMESHOp::OpQuadraticHexahedron, addNonElemTb );
4312 createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4314 createTool( SMESHOp::OpRemoveNodes, remTb );
4315 createTool( SMESHOp::OpRemoveElements, remTb );
4316 createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4317 createTool( SMESHOp::OpClearMesh, remTb );
4319 //createTool( SMESHOp::OpRenumberingNodes, renumbTb );
4320 //createTool( SMESHOp::OpRenumberingElements, renumbTb );
4322 createTool( SMESHOp::OpMergeNodes, transformTb );
4323 createTool( SMESHOp::OpMergeElements, transformTb );
4324 createTool( SMESHOp::OpTranslation, transformTb );
4325 createTool( SMESHOp::OpRotation, transformTb );
4326 createTool( SMESHOp::OpSymmetry, transformTb );
4327 createTool( SMESHOp::OpScale, transformTb );
4328 createTool( SMESHOp::OpOffset, transformTb );
4329 createTool( SMESHOp::OpSewing, transformTb );
4330 createTool( SMESHOp::OpDuplicateNodes, transformTb );
4332 createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4333 createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4334 createTool( SMESHOp::OpExtrusion, modifyTb );
4335 createTool( SMESHOp::OpExtrusionAlongAPath, modifyTb );
4336 createTool( SMESHOp::OpRevolution, modifyTb );
4337 createTool( SMESHOp::OpOrientation, modifyTb );
4338 createTool( SMESHOp::OpReorientFaces, modifyTb );
4339 createTool( SMESHOp::OpMoveNode, modifyTb );
4340 createTool( SMESHOp::OpDiagonalInversion, modifyTb );
4341 createTool( SMESHOp::OpUnionOfTwoTriangle, modifyTb );
4342 createTool( SMESHOp::OpUnionOfTriangles, modifyTb );
4343 createTool( SMESHOp::OpCuttingOfQuadrangles, modifyTb );
4344 createTool( SMESHOp::OpSplitVolumes, modifyTb );
4345 createTool( SMESHOp::OpSplitBiQuadratic, modifyTb );
4346 createTool( SMESHOp::OpSmoothing, modifyTb );
4347 createTool( SMESHOp::OpPatternMapping, modifyTb );
4349 createTool( SMESHOp::OpMinimumDistance, measuremTb );
4351 createTool( SMESHOp::OpUpdate, dispModeTb );
4353 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4354 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4358 OB = "'ObjectBrowser'",
4359 View = "'" + SVTK_Viewer::Type() + "'",
4361 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4362 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4363 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4364 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4365 smesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::COMPONENT ) ),
4366 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4367 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4368 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4369 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4370 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4371 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4372 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4374 mesh_part = mesh + " " + subMesh + " " + group,
4375 mesh_group = mesh + " " + group,
4376 mesh_submesh = mesh + " " + subMesh,
4377 hyp_alg = hypo + " " + algo;
4379 // popup for object browser
4381 isInvisible("not( isVisible )"),
4382 isEmpty("numberOfNodes = 0"),
4383 isNotEmpty("numberOfNodes <> 0"),
4385 // has nodes, edges, etc in VISIBLE! actor
4386 hasNodes("(numberOfNodes > 0 ) && hasActor"),
4387 hasElems("(count( elemTypes ) > 0)"),
4388 hasDifferentElems("(count( elemTypes ) > 1)"),
4389 hasDifferentObjElems("(count( objElemTypes ) > 1)"),
4390 hasBalls("({'BallElem'} in elemTypes)"),
4391 hasElems0d("({'Elem0d'} in elemTypes)"),
4392 hasEdges("({'Edge'} in elemTypes)"),
4393 hasFaces("({'Face'} in elemTypes)"),
4394 hasVolumes("({'Volume'} in elemTypes)"),
4395 hasFacesOrVolumes("(({'Face'} in elemTypes) || ({'Volume'} in elemTypes)) ");
4397 createPopupItem( SMESHOp::OpFileInformation, OB, mesh, "&& selcount=1 && isImported" );
4398 createPopupItem( SMESHOp::OpCreateSubMesh, OB, mesh, "&& hasGeomReference");
4399 createPopupItem( SMESHOp::OpEditMesh, OB, mesh, "&& selcount=1" );
4400 createPopupItem( SMESHOp::OpEditSubMesh, OB, subMesh, "&& selcount=1 && hasGeomReference" );
4401 createPopupItem( SMESHOp::OpEditGroup, OB, group );
4402 createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4404 popupMgr()->insert( separator(), -1, 0 );
4405 createPopupItem( SMESHOp::OpCompute, OB, mesh, "&& selcount=1 && isComputable" );
4406 createPopupItem( SMESHOp::OpComputeSubMesh, OB, subMesh, "&& selcount=1 && isComputable" );
4407 createPopupItem( SMESHOp::OpPreCompute, OB, mesh, "&& selcount=1 && isPreComputable" );
4408 createPopupItem( SMESHOp::OpEvaluate, OB, mesh, "&& selcount=1 && isComputable" );
4409 createPopupItem( SMESHOp::OpMeshOrder, OB, mesh, "&& selcount=1 && isComputable && hasGeomReference" );
4410 createPopupItem( SMESHOp::OpUpdate, OB, mesh_part );
4411 createPopupItem( SMESHOp::OpMeshInformation, OB, mesh_part );
4412 createPopupItem( SMESHOp::OpFindElementByPoint,OB, mesh_group, "&& selcount=1" );
4413 createPopupItem( SMESHOp::OpOverallMeshQuality,OB, mesh_part );
4414 popupMgr()->insert( separator(), -1, 0 );
4415 createPopupItem( SMESHOp::OpCreateGroup, OB, mesh, "&& selcount=1" );
4416 createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh, "&& selcount=1 && hasGeomReference" );
4417 createPopupItem( SMESHOp::OpConstructGroup, OB, subMesh );
4418 popupMgr()->insert( separator(), -1, 0 );
4419 createPopupItem( SMESHOp::OpEditHypothesis, OB, hypo, "&& isEditableHyp");
4420 createPopupItem( SMESHOp::OpUnassign, OB, hyp_alg );
4421 popupMgr()->insert( separator(), -1, 0 );
4422 createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh_submesh );
4423 createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh_group, "&& selcount=1 && dim>=2");
4424 popupMgr()->insert( separator(), -1, 0 );
4425 createPopupItem( SMESHOp::OpClearMesh, OB, mesh );
4426 //popupMgr()->insert( separator(), -1, 0 );
4428 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4429 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4430 QString only_one_2D = only_one_non_empty + " && dim>1";
4432 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4433 createPopupItem( SMESHOp::OpPopupExportMED, OB, mesh_group, multiple_non_empty, anId );
4434 createPopupItem( SMESHOp::OpPopupExportUNV, OB, mesh_group, only_one_non_empty, anId );
4435 createPopupItem( SMESHOp::OpPopupExportSTL, OB, mesh_group, only_one_2D, anId );
4437 createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4439 createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, only_one_non_empty, anId );
4440 createPopupItem( SMESHOp::OpPopupExportGMF, OB, mesh_group, only_one_non_empty, anId );
4441 createPopupItem( SMESHOp::OpPopupExportDAT, OB, mesh_group, only_one_non_empty, anId );
4442 createPopupItem( SMESHOp::OpDelete, OB, mesh_part + " " + hyp_alg );
4443 createPopupItem( SMESHOp::OpDeleteGroup, OB, group );
4445 anId = popupMgr()->insert( tr( "MEN_IMPORT" ), -1, -1 ); // IMPORT submenu
4446 createPopupItem( SMESHOp::OpPopupImportMED, OB, smesh, "", anId );
4447 createPopupItem( SMESHOp::OpPopupImportUNV, OB, smesh, "", anId );
4448 createPopupItem( SMESHOp::OpPopupImportSTL, OB, smesh, "", anId );
4450 createPopupItem( SMESHOp::OpPopupImportCGNS, OB, smesh, "", anId );
4452 createPopupItem( SMESHOp::OpPopupImportSAUV, OB, smesh, "", anId );
4453 createPopupItem( SMESHOp::OpPopupImportGMF, OB, smesh, "", anId );
4454 createPopupItem( SMESHOp::OpPopupImportDAT, OB, smesh, "", anId );
4455 popupMgr()->insert( separator(), -1, 0 );
4458 createPopupItem( SMESHOp::OpEditGroup, View, group );
4459 createPopupItem( SMESHOp::OpAddElemGroupPopup, View, elems, "&& guiState = 800" );
4460 createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems, "&& guiState = 800" );
4462 popupMgr()->insert( separator(), -1, 0 );
4463 createPopupItem( SMESHOp::OpUpdate, View, mesh_part );
4464 createPopupItem( SMESHOp::OpMeshInformation, View, mesh_part );
4465 createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4466 createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh );
4467 popupMgr()->insert( separator(), -1, 0 );
4469 createPopupItem( SMESHOp::OpAutoColor, OB + " " + View, mesh, "&& (not isAutoColor)" );
4470 createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4471 popupMgr()->insert( separator(), -1, 0 );
4473 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4474 QString aType = QString( "%1type in {%2}" ).arg( lc );
4475 aType = aType.arg( mesh_part );
4476 QString aMeshInVTK = aClient + "&&" + aType;
4478 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4479 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4480 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4482 //-------------------------------------------------
4484 //-------------------------------------------------
4485 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4487 popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4488 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4489 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4491 popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4492 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4493 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4495 popupMgr()->insert( separator(), -1, -1 );
4497 //-------------------------------------------------
4499 //-------------------------------------------------
4500 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4502 popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4503 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4504 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4506 popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4507 popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4508 popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4510 popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4511 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4512 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4514 popupMgr()->insert( separator(), anId, -1 );
4516 popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4517 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4518 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4520 //-------------------------------------------------
4522 //-------------------------------------------------
4523 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4525 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4527 popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4528 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4529 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4531 popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4532 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4533 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4535 popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4536 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4537 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4539 popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4540 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4541 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4543 popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4544 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4545 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4547 popupMgr()->insert( separator(), anId, -1 );
4549 popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4550 popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&& $type in {" + mesh + "} &&" + hasDifferentObjElems, QtxPopupMgr::VisibleRule );
4552 popupMgr()->insert( separator(), anId, -1 );
4554 popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4555 popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4558 //-------------------------------------------------
4559 // Representation of the 2D Quadratic elements
4560 //-------------------------------------------------
4561 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4562 popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4563 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "&& isVisible && isQuadratic",QtxPopupMgr::VisibleRule );
4564 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4566 popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4567 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "&& isVisible && isQuadratic", QtxPopupMgr::VisibleRule );
4568 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4570 //-------------------------------------------------
4571 // Orientation of faces
4572 //-------------------------------------------------
4573 popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4574 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4575 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4577 //-------------------------------------------------
4579 //-------------------------------------------------
4580 popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4581 popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4583 //-------------------------------------------------
4585 //-------------------------------------------------
4586 popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4587 popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4589 //-------------------------------------------------
4591 //-------------------------------------------------
4593 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4594 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4595 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4596 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4598 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4600 popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4601 popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4603 popupMgr()->insert( separator(), anId, -1 );
4605 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4607 popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4608 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4609 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4611 popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4612 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4613 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4615 // popupMgr()->insert( action( SMESHOp::OpNodeConnectivityNb ), aSubId, -1 );
4616 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4617 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), "controlMode = 'eNodeConnectivityNb'", QtxPopupMgr::ToggleRule );
4619 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4621 popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4622 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVTK + "&&" + hasEdges + "&&" + hasFacesOrVolumes, QtxPopupMgr::VisibleRule );
4623 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4625 popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4626 popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4627 popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4629 popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4630 popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4631 popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4632 popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4633 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4634 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4636 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4638 popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4639 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4640 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4642 popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4643 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4644 QtxPopupMgr::VisibleRule );
4645 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4647 popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4648 popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4649 popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4651 popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4652 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4653 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4655 popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
4656 popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4657 popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4659 popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
4660 popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4661 popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4663 popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
4664 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4665 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4667 popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
4668 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4669 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4671 popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
4672 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4673 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4675 popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
4676 popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4677 popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4679 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
4680 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4681 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4683 popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
4684 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4685 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4687 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
4688 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4689 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4691 popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
4692 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4693 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4695 popupMgr()->insert ( action( SMESHOp::OpDeflection2D ), aSubId, -1 );
4696 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), aMeshInVtkHasFaces + " && hasGeomReference", QtxPopupMgr::VisibleRule );
4697 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), "controlMode = 'eDeflection2D'", QtxPopupMgr::ToggleRule );
4699 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4701 popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D ), aSubId, -1 );
4702 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4703 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4705 popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
4706 popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4707 popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4709 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
4710 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4711 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4713 popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
4714 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4715 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4717 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
4718 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4719 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4721 popupMgr()->insert ( action( SMESHOp::OpEqualVolume ), aSubId, -1 );
4722 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4723 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4725 popupMgr()->insert( separator(), anId, -1 );
4727 popupMgr()->insert( action( SMESHOp::OpShowScalarBar ), anId, -1 );
4728 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4729 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone' && isScalarBarVisible", QtxPopupMgr::ToggleRule );
4730 popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
4731 popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4733 popupMgr()->insert( separator(), anId, -1 );
4735 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4737 popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
4738 popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4740 popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
4741 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4742 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isScalarBarVisible && isDistributionVisible", QtxPopupMgr::ToggleRule);
4744 #ifndef DISABLE_PLOT2DVIEWER
4745 popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
4746 popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4749 //-------------------------------------------------
4751 //-------------------------------------------------
4752 popupMgr()->insert( separator(), -1, -1 );
4753 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4754 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4755 popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
4756 popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4758 popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
4759 popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4761 popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
4762 popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4764 popupMgr()->insert( separator(), -1, -1 );
4766 //-------------------------------------------------
4768 //-------------------------------------------------
4769 popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
4770 popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4772 popupMgr()->insert( separator(), -1, -1 );
4774 popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
4775 popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
4776 popupMgr()->insert( separator(), -1, -1 );
4778 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4779 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4781 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4782 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4785 //================================================================================
4787 * \brief Return true if SMESH or GEOM objects are selected.
4788 * Is called form LightApp_Module::activateModule() which clear selection if
4789 * not isSelectionCompatible()
4791 //================================================================================
4793 bool SMESHGUI::isSelectionCompatible()
4795 bool isCompatible = true;
4796 SALOME_ListIO selected;
4797 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4798 Sel->selectedObjects( selected );
4800 SALOME_ListIteratorOfListIO It( selected );
4801 for ( ; isCompatible && It.More(); It.Next())
4803 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4804 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4806 return isCompatible;
4810 bool SMESHGUI::reusableOperation( const int id )
4812 // compute, evaluate and precompute are not reusable operations
4813 return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate ) ? false : SalomeApp_Module::reusableOperation( id );
4816 bool SMESHGUI::activateModule( SUIT_Study* study )
4818 bool res = SalomeApp_Module::activateModule( study );
4820 setMenuShown( true );
4821 setToolShown( true );
4823 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4824 PyGILState_STATE gstate = PyGILState_Ensure();
4825 PyObject* pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4826 if ( !pluginsmanager ) {
4830 PyObject* result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toUtf8().data(),tr("SMESH_PLUGINS_OTHER").toUtf8().data());
4835 PyGILState_Release(gstate);
4836 // end of SMESH plugins loading
4838 // Reset actions accelerator keys
4839 action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
4841 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4842 GetSMESHGen()->UpdateStudy();
4844 // get all view currently opened in the study and connect their signals to
4845 // the corresponding slots of the class.
4846 SUIT_Desktop* aDesk = study->application()->desktop();
4848 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4849 SUIT_ViewWindow* wnd;
4850 foreach ( wnd, wndList )
4854 Py_XDECREF(pluginsmanager);
4858 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4860 setMenuShown( false );
4861 setToolShown( false );
4863 EmitSignalCloseAllDialogs();
4865 // Unset actions accelerator keys
4866 action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
4868 return SalomeApp_Module::deactivateModule( study );
4871 void SMESHGUI::studyClosed( SUIT_Study* s )
4875 SMESH::RemoveVisuData();
4876 SalomeApp_Module::studyClosed( s );
4879 void SMESHGUI::OnGUIEvent()
4881 const QObject* obj = sender();
4882 if ( !obj || !obj->inherits( "QAction" ) )
4884 int id = actionId((QAction*)obj);
4889 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4891 if ( CORBA::is_nil( myComponentSMESH ) )
4893 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4894 return aGUI.myComponentSMESH;
4896 return myComponentSMESH;
4899 QString SMESHGUI::engineIOR() const
4901 CORBA::ORB_var anORB = getApp()->orb();
4902 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4903 return QString( anIOR.in() );
4906 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4908 SalomeApp_Module::contextMenuPopup( client, menu, title );
4910 selectionMgr()->selectedObjects( lst );
4911 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4912 Handle(SALOME_InteractiveObject) io = lst.First();
4913 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4914 _PTR(Study) study = appStudy->studyDS();
4915 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4917 QString aName = QString( SMESH::fromUtf8(obj->GetName()) );
4918 while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4919 aName.remove( (aName.length() - 1), 1 );
4925 LightApp_Selection* SMESHGUI::createSelection() const
4927 return new SMESHGUI_Selection();
4930 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4932 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4933 aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
4934 #ifndef DISABLE_PYCONSOLE
4935 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4939 void SMESHGUI::viewManagers( QStringList& list ) const
4941 list.append( SVTK_Viewer::Type() );
4944 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4946 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4947 SMESH::UpdateSelectionProp( this );
4949 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
4950 for(int i = 0; i < aViews.count() ; i++){
4951 SUIT_ViewWindow *sf = aViews[i];
4954 EmitSignalActivatedViewManager();
4958 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
4960 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
4961 myClippingPlaneInfoMap.erase( theViewManager );
4964 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
4966 theActor->AddObserver( SMESH::DeleteActorEvent,
4967 myEventCallbackCommand.GetPointer(),
4971 void SMESHGUI::ProcessEvents( vtkObject* theObject,
4972 unsigned long theEvent,
4973 void* theClientData,
4976 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
4977 if( theObject && (int) theEvent == SMESH::DeleteActorEvent ) {
4978 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
4979 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
4980 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
4981 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
4982 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
4983 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
4984 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
4985 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
4986 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
4987 SMESH::TActorList::iterator anIter3 = anActorList.begin();
4988 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
4989 if( anActor == *anIter3 ) {
4990 anActorList.erase( anIter3 );
5001 void SMESHGUI::createPreferences()
5003 // General tab ------------------------------------------------------------------------
5004 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
5006 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
5007 setPreferenceProperty( autoUpdate, "columns", 2 );
5008 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
5009 setPreferenceProperty( lim, "min", 0 );
5010 setPreferenceProperty( lim, "max", 100000000 );
5011 setPreferenceProperty( lim, "step", 1000 );
5012 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5013 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
5015 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
5016 setPreferenceProperty( dispgroup, "columns", 2 );
5017 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
5019 modes.append( tr("MEN_WIRE") );
5020 modes.append( tr("MEN_SHADE") );
5021 modes.append( tr("MEN_NODES") );
5022 modes.append( tr("MEN_SHRINK") );
5023 QList<QVariant> indices;
5024 indices.append( 0 );
5025 indices.append( 1 );
5026 indices.append( 2 );
5027 indices.append( 3 );
5028 setPreferenceProperty( dispmode, "strings", modes );
5029 setPreferenceProperty( dispmode, "indexes", indices );
5031 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
5032 setPreferenceProperty( arcgroup, "columns", 2 );
5033 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
5034 QStringList quadraticModes;
5035 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
5036 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
5038 indices.append( 0 );
5039 indices.append( 1 );
5040 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
5041 setPreferenceProperty( quadraticmode, "indexes", indices );
5043 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
5044 "SMESH", "max_angle" );
5045 setPreferenceProperty( maxAngle, "min", 1 );
5046 setPreferenceProperty( maxAngle, "max", 90 );
5048 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
5049 setPreferenceProperty( qaGroup, "columns", 2 );
5050 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
5051 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
5052 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
5053 setPreferenceProperty( prec, "min", 0 );
5054 setPreferenceProperty( prec, "max", 100 );
5055 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
5056 setPreferenceProperty( doubleNodesTol, "precision", 10 );
5057 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
5058 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
5059 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
5062 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
5063 setPreferenceProperty( exportgroup, "columns", 2 );
5064 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
5065 addPreference( tr( "PREF_SHOW_WARN" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "show_warning" );
5066 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
5068 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
5069 setPreferenceProperty( computeGroup, "columns", 2 );
5070 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
5072 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5073 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5074 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5076 indices.append( 0 );
5077 indices.append( 1 );
5078 indices.append( 2 );
5079 setPreferenceProperty( notifyMode, "strings", modes );
5080 setPreferenceProperty( notifyMode, "indexes", indices );
5082 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5083 setPreferenceProperty( infoGroup, "columns", 2 );
5084 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5086 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5087 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5089 indices.append( 0 );
5090 indices.append( 1 );
5091 setPreferenceProperty( elemInfo, "strings", modes );
5092 setPreferenceProperty( elemInfo, "indexes", indices );
5093 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5094 setPreferenceProperty( nodesLim, "min", 0 );
5095 setPreferenceProperty( nodesLim, "max", 10000000 );
5096 setPreferenceProperty( nodesLim, "step", 10000 );
5097 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5098 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5099 setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5100 setPreferenceProperty( ctrlLim, "min", 0 );
5101 setPreferenceProperty( ctrlLim, "max", 10000000 );
5102 setPreferenceProperty( ctrlLim, "step", 1000 );
5103 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5104 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5105 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5106 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5107 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5109 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5110 setPreferenceProperty( segGroup, "columns", 2 );
5111 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5112 "SMESH", "segmentation" );
5113 setPreferenceProperty( segLen, "min", 1 );
5114 setPreferenceProperty( segLen, "max", 10000000 );
5115 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5116 "SMESH", "nb_segments_per_edge" );
5117 setPreferenceProperty( nbSeg, "min", 1 );
5118 setPreferenceProperty( nbSeg, "max", 10000000 );
5120 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5121 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5122 "SMESH", "forget_mesh_on_hyp_modif" );
5125 // Quantities with individual precision settings
5126 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5127 setPreferenceProperty( precGroup, "columns", 2 );
5129 const int nbQuantities = 6;
5130 int precs[nbQuantities], ii = 0;
5131 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5132 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5133 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5134 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5135 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5136 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5137 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5138 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5139 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5140 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5141 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5142 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5144 // Set property for precision value for spinboxes
5145 for ( ii = 0; ii < nbQuantities; ii++ ){
5146 setPreferenceProperty( precs[ii], "min", -14 );
5147 setPreferenceProperty( precs[ii], "max", 14 );
5148 setPreferenceProperty( precs[ii], "precision", 2 );
5151 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5152 setPreferenceProperty( previewGroup, "columns", 2 );
5153 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5154 setPreferenceProperty( chunkSize, "min", 1 );
5155 setPreferenceProperty( chunkSize, "max", 1000 );
5156 setPreferenceProperty( chunkSize, "step", 50 );
5158 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5159 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5161 // Mesh tab ------------------------------------------------------------------------
5162 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5163 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5164 setPreferenceProperty( nodeGroup, "columns", 3 );
5166 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5168 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5170 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5171 QList<QVariant> aMarkerTypeIndicesList;
5172 QList<QVariant> aMarkerTypeIconsList;
5173 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5174 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5175 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5176 aMarkerTypeIndicesList << i;
5177 aMarkerTypeIconsList << pixmap;
5179 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5180 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
5182 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5184 QList<QVariant> aMarkerScaleIndicesList;
5185 QStringList aMarkerScaleValuesList;
5186 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5187 aMarkerScaleIndicesList << i;
5188 //aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5189 aMarkerScaleValuesList << QString::number( i );
5191 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5192 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5194 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5195 //setPreferenceProperty( elemGroup, "columns", 2 );
5197 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5198 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5199 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5200 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5201 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5202 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5203 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5204 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5205 addPreference( tr( "PREF_PREVIEW_COLOR" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5208 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5209 setPreferenceProperty( grpGroup, "columns", 2 );
5211 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5212 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5214 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5215 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5216 /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5217 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5218 double ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5219 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5220 double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5221 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5222 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
5223 LightApp_Preferences::IntSpin, "SMESH", "element_width");
5224 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5225 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5226 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5227 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5229 setPreferenceProperty( size0d, "min", 1 );
5230 setPreferenceProperty( size0d, "max", 10 );
5232 // setPreferenceProperty( ballSize, "min", 1 );
5233 // setPreferenceProperty( ballSize, "max", 10 );
5235 setPreferenceProperty( ballDiameter, "min", 1e-7 );
5236 setPreferenceProperty( ballDiameter, "max", 1e9 );
5237 setPreferenceProperty( ballDiameter, "step", 0.1 );
5239 setPreferenceProperty( ballScale, "min", 1e-2 );
5240 setPreferenceProperty( ballScale, "max", 1e7 );
5241 setPreferenceProperty( ballScale, "step", 0.5 );
5243 setPreferenceProperty( elemW, "min", 1 );
5244 setPreferenceProperty( elemW, "max", 5 );
5246 setPreferenceProperty( outW, "min", 1 );
5247 setPreferenceProperty( outW, "max", 5 );
5249 setPreferenceProperty( shrink, "min", 0 );
5250 setPreferenceProperty( shrink, "max", 100 );
5252 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5253 setPreferenceProperty( numGroup, "columns", 2 );
5255 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5256 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5258 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5259 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5261 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5262 setPreferenceProperty( orientGroup, "columns", 1 );
5264 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5265 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5267 setPreferenceProperty( orientScale, "min", 0.05 );
5268 setPreferenceProperty( orientScale, "max", 0.5 );
5269 setPreferenceProperty( orientScale, "step", 0.05 );
5271 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5273 // Selection tab ------------------------------------------------------------------------
5274 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5276 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5277 setPreferenceProperty( selGroup, "columns", 2 );
5279 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5280 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5282 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5283 setPreferenceProperty( preGroup, "columns", 2 );
5285 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5287 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5288 setPreferenceProperty( precSelGroup, "columns", 2 );
5290 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5291 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5292 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5294 // Scalar Bar tab ------------------------------------------------------------------------
5295 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5296 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5297 setPreferenceProperty( fontGr, "columns", 2 );
5299 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5300 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5302 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5303 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5305 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5306 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5308 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5309 setPreferenceProperty( numcol, "min", 2 );
5310 setPreferenceProperty( numcol, "max", 256 );
5312 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5313 setPreferenceProperty( numlab, "min", 2 );
5314 setPreferenceProperty( numlab, "max", 65 );
5316 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5317 setPreferenceProperty( orientGr, "columns", 2 );
5318 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5319 QStringList orients;
5320 orients.append( tr( "SMESH_VERTICAL" ) );
5321 orients.append( tr( "SMESH_HORIZONTAL" ) );
5322 indices.clear(); indices.append( 0 ); indices.append( 1 );
5323 setPreferenceProperty( orient, "strings", orients );
5324 setPreferenceProperty( orient, "indexes", indices );
5326 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5327 setPreferenceProperty( posVSizeGr, "columns", 2 );
5328 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5329 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5330 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5331 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5332 setPreferenceProperty( xv, "step", 0.1 );
5333 setPreferenceProperty( xv, "min", 0.0 );
5334 setPreferenceProperty( xv, "max", 1.0 );
5335 setPreferenceProperty( yv, "step", 0.1 );
5336 setPreferenceProperty( yv, "min", 0.0 );
5337 setPreferenceProperty( yv, "max", 1.0 );
5338 setPreferenceProperty( wv, "step", 0.1 );
5339 setPreferenceProperty( wv, "min", 0.0 );
5340 setPreferenceProperty( wv, "max", 1.0 );
5341 setPreferenceProperty( hv, "min", 0.0 );
5342 setPreferenceProperty( hv, "max", 1.0 );
5343 setPreferenceProperty( hv, "step", 0.1 );
5345 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5346 setPreferenceProperty( posHSizeGr, "columns", 2 );
5347 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5348 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5349 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5350 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5351 setPreferenceProperty( xv, "min", 0.0 );
5352 setPreferenceProperty( xv, "max", 1.0 );
5353 setPreferenceProperty( xv, "step", 0.1 );
5354 setPreferenceProperty( xh, "min", 0.0 );
5355 setPreferenceProperty( xh, "max", 1.0 );
5356 setPreferenceProperty( xh, "step", 0.1 );
5357 setPreferenceProperty( yh, "min", 0.0 );
5358 setPreferenceProperty( yh, "max", 1.0 );
5359 setPreferenceProperty( yh, "step", 0.1 );
5360 setPreferenceProperty( wh, "min", 0.0 );
5361 setPreferenceProperty( wh, "max", 1.0 );
5362 setPreferenceProperty( wh, "step", 0.1 );
5363 setPreferenceProperty( hh, "min", 0.0 );
5364 setPreferenceProperty( hh, "max", 1.0 );
5365 setPreferenceProperty( hh, "step", 0.1 );
5367 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5368 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5369 setPreferenceProperty( distributionGr, "columns", 3 );
5371 types.append( tr( "SMESH_MONOCOLOR" ) );
5372 types.append( tr( "SMESH_MULTICOLOR" ) );
5373 indices.clear(); indices.append( 0 ); indices.append( 1 );
5374 setPreferenceProperty( coloringType, "strings", types );
5375 setPreferenceProperty( coloringType, "indexes", indices );
5376 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5380 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5382 if ( sect=="SMESH" ) {
5383 float sbX1 = 0.01, sbY1 = 0.01, sbW = 0.08, sbH = 0.08;
5384 float aTol = 1.00000009999999;
5385 std::string aWarning;
5386 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5388 if ( name== "selection_object_color" ||
5389 name=="selection_element_color" ||
5390 name== "highlight_color" ||
5391 name=="selection_precision_node" ||
5392 name=="selection_precision_element" ||
5393 name=="selection_precision_object" )
5395 SMESH::UpdateSelectionProp( this );
5397 else if (name == "scalar_bar_vertical_x" || name == "scalar_bar_vertical_width")
5399 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5400 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5401 if ( sbX1+sbW > aTol ) {
5402 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5405 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5406 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5409 else if (name == "scalar_bar_vertical_y" || name == "scalar_bar_vertical_height" )
5411 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5412 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5413 if ( sbY1 + sbH > aTol ) {
5414 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5415 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5416 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5419 else if (name == "scalar_bar_horizontal_x" || name == "scalar_bar_horizontal_width")
5421 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5422 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5423 if ( sbX1 + sbW > aTol ) {
5424 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5427 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5428 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5431 else if (name == "scalar_bar_horizontal_y" || name == "scalar_bar_horizontal_height")
5433 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5434 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5435 if ( sbY1 + sbH > aTol ) {
5436 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5439 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5440 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5443 else if ( name == "segmentation" )
5445 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5446 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5448 else if ( name == "nb_segments_per_edge" )
5450 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5451 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5453 else if ( name == "historical_python_dump" || name == "forget_mesh_on_hyp_modif" || name == "default_grp_color" )
5455 QString val = aResourceMgr->stringValue( "SMESH", name );
5456 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5458 else if ( name == "numbering_node_color" || name == "numbering_node_font" )
5460 SMESH::UpdateFontProp( this );
5462 else if ( name == "numbering_elem_color" || name == "numbering_elem_font" )
5464 SMESH::UpdateFontProp( this );
5467 if ( aWarning.size() != 0 ) {
5468 aWarning += "The default values are applied instead.";
5469 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5470 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5471 QObject::tr(aWarning.c_str()));
5476 //================================================================================
5478 * \brief Update something in accordance with update flags
5479 * \param theFlags - update flags
5481 * Update viewer or/and object browser etc. in accordance with update flags ( see
5482 * LightApp_UpdateFlags enumeration ).
5484 //================================================================================
5485 void SMESHGUI::update( const int flags )
5487 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5488 SMESH::UpdateView();
5490 SalomeApp_Module::update( flags );
5493 //================================================================================
5495 * \brief Set default selection mode
5497 * SLOT called when operation committed. Sets default selection mode
5499 //================================================================================
5500 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5502 SVTK_ViewWindow* vtkWnd =
5503 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5505 vtkWnd->SetSelectionMode( ActorSelection );
5508 //================================================================================
5510 * \brief Set default selection mode
5512 * SLOT called when operation aborted. Sets default selection mode
5514 //================================================================================
5515 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5517 SVTK_ViewWindow* vtkWnd =
5518 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5520 vtkWnd->SetSelectionMode( ActorSelection );
5523 //================================================================================
5525 * \brief Creates operation with given identifier
5526 * \param id - identifier of operation to be started
5527 * \return Pointer on created operation or NULL if operation is not created
5529 * Virtual method redefined from the base class creates operation with given id.
5530 * It is called called automatically from startOperation method of base class.
5532 //================================================================================
5533 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5535 LightApp_Operation* op = 0;
5536 // to do : create operation here
5539 case SMESHOp::OpSplitBiQuadratic:
5540 op = new SMESHGUI_SplitBiQuadOp();
5542 case SMESHOp::OpConvertMeshToQuadratic:
5543 op = new SMESHGUI_ConvToQuadOp();
5545 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5546 op = new SMESHGUI_Make2DFrom3DOp();
5548 case SMESHOp::OpReorientFaces:
5549 op = new SMESHGUI_ReorientFacesOp();
5551 case SMESHOp::OpCreateMesh:
5552 op = new SMESHGUI_MeshOp( true, true );
5554 case SMESHOp::OpCreateSubMesh:
5555 op = new SMESHGUI_MeshOp( true, false );
5557 case SMESHOp::OpEditMeshOrSubMesh:
5558 case SMESHOp::OpEditMesh:
5559 case SMESHOp::OpEditSubMesh:
5560 op = new SMESHGUI_MeshOp( false );
5562 case SMESHOp::OpCompute:
5563 case SMESHOp::OpComputeSubMesh:
5564 op = new SMESHGUI_ComputeOp();
5566 case SMESHOp::OpPreCompute:
5567 op = new SMESHGUI_PrecomputeOp();
5569 case SMESHOp::OpEvaluate:
5570 op = new SMESHGUI_EvaluateOp();
5572 case SMESHOp::OpMeshOrder:
5573 op = new SMESHGUI_MeshOrderOp();
5575 case SMESHOp::OpCreateGeometryGroup:
5576 op = new SMESHGUI_GroupOnShapeOp();
5578 case SMESHOp::OpFindElementByPoint:
5579 op = new SMESHGUI_FindElemByPointOp();
5581 case SMESHOp::OpMoveNode: // Make mesh pass through point
5582 op = new SMESHGUI_MakeNodeAtPointOp();
5584 case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
5585 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5592 op = SalomeApp_Module::createOperation( id );
5596 //================================================================================
5598 * \brief Stops current operations and starts a given one
5599 * \param id - The id of the operation to start
5601 //================================================================================
5603 void SMESHGUI::switchToOperation(int id)
5605 activeStudy()->abortAllOperations();
5606 startOperation( id );
5609 LightApp_Displayer* SMESHGUI::displayer()
5612 myDisplayer = new SMESHGUI_Displayer( getApp() );
5616 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5619 int aTolerance = 64;
5620 int anIterations = 0;
5626 if( anIterations % aPeriod == 0 )
5629 if( aTolerance < 1 )
5633 aHue = (int)( 360.0 * rand() / RAND_MAX );
5636 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5637 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5638 for( ; it != itEnd; ++it )
5640 SALOMEDS::Color anAutoColor = *it;
5641 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5644 aQColor.getHsv( &h, &s, &v );
5645 if( abs( h - aHue ) < aTolerance )
5657 aColor.setHsv( aHue, 255, 255 );
5659 SALOMEDS::Color aSColor;
5660 aSColor.R = aColor.redF();
5661 aSColor.G = aColor.greenF();
5662 aSColor.B = aColor.blueF();
5667 const char* gSeparator = "_"; // character used to separate parameter names
5668 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5669 const char* gPathSep = "|"; // character used to separate paths
5672 * \brief Store visual parameters
5674 * This method is called just before the study document is saved.
5675 * Store visual parameters in AttributeParameter attribue(s)
5677 void SMESHGUI::storeVisualParameters (int savePoint)
5680 Kernel_Utils::Localizer loc;
5682 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5683 if (!appStudy || !appStudy->studyDS())
5685 _PTR(Study) studyDS = appStudy->studyDS();
5687 // componentName is used for encoding of entries when storing them in IParameters
5688 std::string componentName = myComponentSMESH->ComponentDataType();
5689 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5690 //if (!aSComponent) return;
5693 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5694 componentName.c_str(),
5696 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5698 // store custom markers
5699 if( !myMarkerMap.empty() )
5701 VTK::MarkerMap::const_iterator anIter = myMarkerMap.begin();
5702 for( ; anIter != myMarkerMap.end(); anIter++ )
5704 int anId = anIter->first;
5705 VTK::MarkerData aMarkerData = anIter->second;
5706 std::string aMarkerFileName = aMarkerData.first;
5707 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5708 if( aMarkerTexture.size() < 3 )
5709 continue; // should contain at least width, height and the first value
5711 QString aPropertyName( "texture" );
5712 aPropertyName += gSeparator;
5713 aPropertyName += QString::number( anId );
5715 QString aPropertyValue = aMarkerFileName.c_str();
5716 aPropertyValue += gPathSep;
5718 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5719 ushort aWidth = *aTextureIter++;
5720 ushort aHeight = *aTextureIter++;
5721 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5722 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5723 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5724 aPropertyValue += QString::number( *aTextureIter );
5726 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5730 // viewers counters are used for storing view_numbers in IParameters
5733 // main cycle to store parameters of displayed objects
5734 QList<SUIT_ViewManager*> lst;
5735 QList<SUIT_ViewManager*>::Iterator it;
5736 getApp()->viewManagers(lst);
5737 for (it = lst.begin(); it != lst.end(); it++)
5739 SUIT_ViewManager* vman = *it;
5740 QString vType = vman->getType();
5742 // saving VTK actors properties
5743 if (vType == SVTK_Viewer::Type())
5745 // store the clipping planes attached to the view manager
5746 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5747 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5748 if( anIter != myClippingPlaneInfoMap.end() )
5749 aClippingPlaneInfoList = anIter->second;
5751 if( !aClippingPlaneInfoList.empty() ) {
5752 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5753 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5755 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5756 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5758 QString aPropertyName( "ClippingPlane" );
5759 aPropertyName += gSeparator;
5760 aPropertyName += QString::number( vtkViewers );
5761 aPropertyName += gSeparator;
5762 aPropertyName += QString::number( anId );
5764 QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
5765 aPropertyValue += gDigitsSep;
5766 aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
5767 aPropertyValue += gDigitsSep;
5768 if ( aPlane->PlaneMode == SMESH::Absolute ) {
5769 aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
5770 aPropertyValue += gDigitsSep;
5771 aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
5772 aPropertyValue += gDigitsSep;
5773 aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
5774 aPropertyValue += gDigitsSep;
5775 aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
5776 aPropertyValue += gDigitsSep;
5777 aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
5778 aPropertyValue += gDigitsSep;
5779 aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
5780 aPropertyValue += gDigitsSep;
5781 aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
5783 else if ( aPlane->PlaneMode == SMESH::Relative ) {
5784 aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
5785 aPropertyValue += gDigitsSep;
5786 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5787 aPropertyValue += gDigitsSep;
5788 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5789 aPropertyValue += gDigitsSep;
5790 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5793 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5797 QVector<SUIT_ViewWindow*> views = vman->getViews();
5798 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5800 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5802 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5803 vtkActorCollection* allActors = aCopy.GetActors();
5804 allActors->InitTraversal();
5805 while (vtkActor* actor = allActors->GetNextActor())
5807 if (actor->GetVisibility()) // store only visible actors
5809 SMESH_Actor* aSmeshActor = 0;
5810 if (actor->IsA("SMESH_Actor"))
5811 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5812 if (aSmeshActor && aSmeshActor->hasIO())
5814 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5817 // entry is "encoded" = it does NOT contain component address,
5818 // since it is a subject to change on next component loading
5819 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5821 std::string param, vtkParam = vType.toLatin1().data();
5822 vtkParam += gSeparator;
5823 vtkParam += QString::number(vtkViewers).toLatin1().data();
5824 vtkParam += gSeparator;
5827 param = vtkParam + "Visibility";
5828 ip->setParameter(entry, param, "On");
5831 param = vtkParam + "Representation";
5832 ip->setParameter(entry, param, QString::number
5833 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5836 param = vtkParam + "IsShrunk";
5837 ip->setParameter(entry, param, QString::number
5838 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5840 // Displayed entities
5841 unsigned int aMode = aSmeshActor->GetEntityMode();
5842 bool isE = aMode & SMESH_Actor::eEdges;
5843 bool isF = aMode & SMESH_Actor::eFaces;
5844 bool isV = aMode & SMESH_Actor::eVolumes;
5845 bool is0d = aMode & SMESH_Actor::e0DElements;
5846 bool isB = aMode & SMESH_Actor::eBallElem;
5848 QString modeStr ("e");
5849 modeStr += gDigitsSep; modeStr += QString::number(isE);
5850 modeStr += gDigitsSep; modeStr += "f";
5851 modeStr += gDigitsSep; modeStr += QString::number(isF);
5852 modeStr += gDigitsSep; modeStr += "v";
5853 modeStr += gDigitsSep; modeStr += QString::number(isV);
5854 modeStr += gDigitsSep; modeStr += "0d";
5855 modeStr += gDigitsSep; modeStr += QString::number(is0d);
5856 modeStr += gDigitsSep; modeStr += "b";
5857 modeStr += gDigitsSep; modeStr += QString::number(isB);
5859 param = vtkParam + "Entities";
5860 ip->setParameter(entry, param, modeStr.toLatin1().data());
5866 aSmeshActor->GetSufaceColor(r, g, b, delta);
5867 QStringList colorStr;
5868 colorStr << "surface";
5869 colorStr << QString::number(r);
5870 colorStr << QString::number(g);
5871 colorStr << QString::number(b);
5873 colorStr << "backsurface";
5874 colorStr << QString::number(delta);
5876 aSmeshActor->GetVolumeColor(r, g, b, delta);
5877 colorStr << "volume";
5878 colorStr << QString::number(r);
5879 colorStr << QString::number(g);
5880 colorStr << QString::number(b);
5881 colorStr << QString::number(delta);
5883 aSmeshActor->GetEdgeColor(r, g, b);
5885 colorStr << QString::number(r);
5886 colorStr << QString::number(g);
5887 colorStr << QString::number(b);
5889 aSmeshActor->GetNodeColor(r, g, b);
5891 colorStr << QString::number(r);
5892 colorStr << QString::number(g);
5893 colorStr << QString::number(b);
5895 aSmeshActor->GetOutlineColor(r, g, b);
5896 colorStr << "outline";
5897 colorStr << QString::number(r);
5898 colorStr << QString::number(g);
5899 colorStr << QString::number(b);
5901 aSmeshActor->Get0DColor(r, g, b);
5902 colorStr << "elem0d";
5903 colorStr << QString::number(r);
5904 colorStr << QString::number(g);
5905 colorStr << QString::number(b);
5907 aSmeshActor->GetBallColor(r, g, b);
5909 colorStr << QString::number(r);
5910 colorStr << QString::number(g);
5911 colorStr << QString::number(b);
5913 aSmeshActor->GetFacesOrientationColor(r, g, b);
5914 colorStr << "orientation";
5915 colorStr << QString::number(r);
5916 colorStr << QString::number(g);
5917 colorStr << QString::number(b);
5919 param = vtkParam + "Colors";
5920 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
5923 QStringList sizeStr;
5925 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
5926 sizeStr << "outline";
5927 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
5928 sizeStr << "elem0d";
5929 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
5931 //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
5932 sizeStr << QString::number((double)aSmeshActor->GetBallSize());
5933 sizeStr << QString::number((double)aSmeshActor->GetBallScale());
5934 sizeStr << "shrink";
5935 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
5936 sizeStr << "orientation";
5937 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
5938 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
5940 param = vtkParam + "Sizes";
5941 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
5946 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5947 if( aMarkerType == VTK::MT_USER ) {
5948 markerStr += "custom";
5949 markerStr += gDigitsSep;
5950 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
5954 markerStr += gDigitsSep;
5955 markerStr += QString::number( (int)aMarkerType );
5956 markerStr += gDigitsSep;
5957 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
5960 param = vtkParam + "PointMarker";
5961 ip->setParameter(entry, param, markerStr.toLatin1().data());
5964 param = vtkParam + "Opacity";
5965 ip->setParameter(entry, param,
5966 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
5969 param = vtkParam + "ClippingPlane";
5971 if( !aClippingPlaneInfoList.empty() ) {
5972 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
5973 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
5975 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
5976 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
5977 SMESH::TActorList::iterator anIter2 = anActorList.begin();
5978 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
5979 if( aSmeshActor == *anIter2 ) {
5980 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
5981 QString::number( anId ).toLatin1().constData() );
5988 ip->setParameter( entry, param, "Off" );
5989 } // if (io->hasEntry())
5990 } // SMESH_Actor && hasIO
5992 } // while.. actors traversal
5996 } // if (SVTK view model)
5997 } // for (viewManagers)
6000 // data structures for clipping planes processing
6004 bool isOpenGLClipping;
6005 vtkIdType RelativeOrientation;
6008 int AbsoluteOrientation;
6009 double X, Y, Z, Dx, Dy, Dz;
6011 typedef std::list<TPlaneData> TPlaneDataList;
6012 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
6014 typedef std::list<vtkActor*> TActorList;
6017 TActorList ActorList;
6018 SUIT_ViewManager* ViewManager;
6020 typedef std::list<TPlaneInfo> TPlaneInfoList;
6021 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
6024 * \brief Restore visual parameters
6026 * This method is called after the study document is opened.
6027 * Restore visual parameters from AttributeParameter attribue(s)
6029 void SMESHGUI::restoreVisualParameters (int savePoint)
6032 Kernel_Utils::Localizer loc;
6034 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6035 if (!appStudy || !appStudy->studyDS())
6037 _PTR(Study) studyDS = appStudy->studyDS();
6039 // componentName is used for encoding of entries when storing them in IParameters
6040 std::string componentName = myComponentSMESH->ComponentDataType();
6041 //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
6042 //if (!aSComponent) return;
6045 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6046 componentName.c_str(),
6048 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6050 // restore custom markers and map of clipping planes
6051 TPlaneDataMap aPlaneDataMap;
6053 std::vector<std::string> properties = ip->getProperties();
6054 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
6056 std::string property = *propIt;
6057 QString aPropertyName( property.c_str() );
6058 QString aPropertyValue( ip->getProperty( property ).c_str() );
6060 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
6061 if( aPropertyNameList.isEmpty() )
6064 QString aPropertyType = aPropertyNameList[0];
6065 if( aPropertyType == "texture" )
6067 if( aPropertyNameList.size() != 2 )
6071 int anId = aPropertyNameList[1].toInt( &ok );
6072 if( !ok || anId < 1 )
6075 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
6076 if( aPropertyValueList.size() != 2 )
6079 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
6080 QString aMarkerTextureString = aPropertyValueList[1];
6081 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
6082 if( aMarkerTextureStringList.size() != 3 )
6086 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6091 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6095 VTK::MarkerTexture aMarkerTexture;
6096 aMarkerTexture.push_back( aWidth );
6097 aMarkerTexture.push_back( aHeight );
6099 QString aMarkerTextureData = aMarkerTextureStringList[2];
6100 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6102 QChar aChar = aMarkerTextureData.at( i );
6103 if( aChar.isDigit() )
6104 aMarkerTexture.push_back( aChar.digitValue() );
6107 myMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6109 else if( aPropertyType == "ClippingPlane" )
6111 if( aPropertyNameList.size() != 3 )
6115 int aViewId = aPropertyNameList[1].toInt( &ok );
6116 if( !ok || aViewId < 0 )
6120 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6121 if( !ok || aClippingPlaneId < 0 )
6124 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6125 if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6128 TPlaneData aPlaneData;
6129 aPlaneData.AbsoluteOrientation = false;
6130 aPlaneData.RelativeOrientation = 0;
6131 aPlaneData.Distance = aPlaneData.Angle[0] = aPlaneData.Angle[1] = 0;
6132 aPlaneData.X = aPlaneData.Y = aPlaneData.Z = 0;
6133 aPlaneData.Dx = aPlaneData.Dy = aPlaneData.Dz = 0;
6135 aPlaneData.Id = aClippingPlaneId;
6138 aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6143 aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6147 if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6150 aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6155 aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6160 aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6165 aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6170 aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6175 aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6180 aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6184 else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6186 aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6191 aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6196 aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6201 aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6206 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6207 aPlaneDataList.push_back( aPlaneData );
6211 TPlaneInfoMap aPlaneInfoMap;
6213 std::vector<std::string> entries = ip->getEntries();
6215 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6217 // entry is a normal entry - it should be "decoded" (setting base address of component)
6218 QString entry (ip->decodeEntry(*entIt).c_str());
6220 // Check that the entry corresponds to a real object in the Study
6221 // as the object may be deleted or modified after the visual state is saved.
6222 _PTR(SObject) so = studyDS->FindObjectID(entry.toUtf8().data());
6223 if (!so) continue; //Skip the not existent entry
6225 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6226 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6228 std::vector<std::string>::iterator namesIt = paramNames.begin();
6229 std::vector<std::string>::iterator valuesIt = paramValues.begin();
6231 // actors are stored in a map after displaying of them for
6232 // quicker access in the future: map < viewID to actor >
6233 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6235 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6237 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6238 // '_' is used as separator and should not be used in viewer type or parameter names.
6239 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6240 if (lst.size() != 3)
6243 QString viewerTypStr = lst[0];
6244 QString viewIndexStr = lst[1];
6245 QString paramNameStr = lst[2];
6248 int viewIndex = viewIndexStr.toUInt(&ok);
6249 if (!ok) // bad conversion of view index to integer
6253 if (viewerTypStr == SVTK_Viewer::Type())
6255 SMESH_Actor* aSmeshActor = 0;
6256 if (vtkActors.IsBound(viewIndex))
6257 aSmeshActor = vtkActors.Find(viewIndex);
6259 QList<SUIT_ViewManager*> lst;
6260 getApp()->viewManagers(viewerTypStr, lst);
6262 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6263 SUIT_ViewManager* vman = NULL;
6264 if (viewIndex >= 0 && viewIndex < lst.count())
6265 vman = lst.at(viewIndex);
6267 if (paramNameStr == "Visibility")
6269 if (!aSmeshActor && displayer() && vman)
6271 SUIT_ViewModel* vmodel = vman->getViewModel();
6272 // SVTK view model can be casted to SALOME_View
6273 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6275 // store displayed actor in a temporary map for quicker
6276 // access later when restoring other parameters
6277 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6278 vtkRenderer* Renderer = vtkView->getRenderer();
6279 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6280 vtkActorCollection* theActors = aCopy.GetActors();
6281 theActors->InitTraversal();
6282 bool isFound = false;
6283 vtkActor *ac = theActors->GetNextActor();
6284 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6285 if (ac->IsA("SMESH_Actor")) {
6286 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6287 if (aGeomAc->hasIO()) {
6288 Handle(SALOME_InteractiveObject) io = aGeomAc->getIO();
6289 if (io->hasEntry() && strcmp(io->getEntry(), entry.toUtf8().data()) == 0) {
6291 vtkActors.Bind(viewIndex, aGeomAc);
6297 } // if (paramNameStr == "Visibility")
6300 // the rest properties "work" with SMESH_Actor
6303 QString val ((*valuesIt).c_str());
6306 if (paramNameStr == "Representation") {
6307 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6310 else if (paramNameStr == "IsShrunk") {
6312 if (!aSmeshActor->IsShrunk())
6313 aSmeshActor->SetShrink();
6316 if (aSmeshActor->IsShrunk())
6317 aSmeshActor->UnShrink();
6320 // Displayed entities
6321 else if (paramNameStr == "Entities") {
6322 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6323 int aEntityMode = SMESH_Actor::eAllEntity;
6324 for ( int i = 0; i < mode.count(); i+=2 ) {
6325 if ( i < mode.count()-1 ) {
6326 QString type = mode[i];
6327 bool val = mode[i+1].toInt();
6328 if ( type == "e" && !val )
6329 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6330 else if ( type == "f" && !val )
6331 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6332 else if ( type == "v" && !val )
6333 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6334 else if ( type == "0d" && !val )
6335 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6336 else if ( type == "b" && !val )
6337 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6340 aSmeshActor->SetEntityMode( aEntityMode );
6343 else if (paramNameStr == "Colors") {
6344 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6351 QColor outlineColor;
6352 QColor orientationColor;
6358 // below lines are required to get default values for delta coefficients
6359 // of backface color for faces and color of reversed volumes
6360 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
6361 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6362 for ( int i = 0; i < colors.count(); i++ ) {
6363 QString type = colors[i];
6364 if ( type == "surface" ) {
6365 // face color is set by 3 values r:g:b, where
6366 // - r,g,b - is rgb color components
6367 if ( i+1 >= colors.count() ) break; // format error
6368 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6369 if ( i+2 >= colors.count() ) break; // format error
6370 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6371 if ( i+3 >= colors.count() ) break; // format error
6372 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6373 faceColor.setRgbF( r, g, b );
6376 else if ( type == "backsurface" ) {
6377 // backface color can be defined in several ways
6378 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6379 // - in latest versions, it is set as delta coefficient
6380 bool rgbOk = false, deltaOk;
6381 if ( i+1 >= colors.count() ) break; // format error
6382 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6383 int delta = colors[i+1].toInt( &deltaOk );
6385 if ( i+1 < colors.count() ) // index is shifted to 1
6386 g = colors[i+1].toDouble( &rgbOk );
6387 if ( rgbOk ) i++; // shift index
6388 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6389 b = colors[i+1].toDouble( &rgbOk );
6391 // - as currently there's no way to set directly backsurface color as it was before,
6392 // we ignore old dump where r,g,b triple was set
6393 // - also we check that delta parameter is set properly
6394 if ( !rgbOk && deltaOk )
6397 else if ( type == "volume" ) {
6398 // volume color is set by 4 values r:g:b:delta, where
6399 // - r,g,b - is a normal volume rgb color components
6400 // - delta - is a reversed volume color delta coefficient
6401 if ( i+1 >= colors.count() ) break; // format error
6402 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6403 if ( i+2 >= colors.count() ) break; // format error
6404 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6405 if ( i+3 >= colors.count() ) break; // format error
6406 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6407 if ( i+4 >= colors.count() ) break; // format error
6408 int delta = colors[i+4].toInt( &bOk );
6409 if ( !bOk ) break; // format error
6410 volumeColor.setRgbF( r, g, b );
6414 else if ( type == "edge" ) {
6415 // edge color is set by 3 values r:g:b, where
6416 // - r,g,b - is rgb color components
6417 if ( i+1 >= colors.count() ) break; // format error
6418 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6419 if ( i+2 >= colors.count() ) break; // format error
6420 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6421 if ( i+3 >= colors.count() ) break; // format error
6422 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6423 edgeColor.setRgbF( r, g, b );
6426 else if ( type == "node" ) {
6427 // node color is set by 3 values r:g:b, where
6428 // - r,g,b - is rgb color components
6429 if ( i+1 >= colors.count() ) break; // format error
6430 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6431 if ( i+2 >= colors.count() ) break; // format error
6432 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6433 if ( i+3 >= colors.count() ) break; // format error
6434 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6435 nodeColor.setRgbF( r, g, b );
6438 else if ( type == "elem0d" ) {
6439 // 0d element color is set by 3 values r:g:b, where
6440 // - r,g,b - is rgb color components
6441 if ( i+1 >= colors.count() ) break; // format error
6442 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6443 if ( i+2 >= colors.count() ) break; // format error
6444 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6445 if ( i+3 >= colors.count() ) break; // format error
6446 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6447 elem0dColor.setRgbF( r, g, b );
6450 else if ( type == "ball" ) {
6451 // ball color is set by 3 values r:g:b, where
6452 // - r,g,b - is rgb color components
6453 if ( i+1 >= colors.count() ) break; // format error
6454 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6455 if ( i+2 >= colors.count() ) break; // format error
6456 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6457 if ( i+3 >= colors.count() ) break; // format error
6458 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6459 ballColor.setRgbF( r, g, b );
6462 else if ( type == "outline" ) {
6463 // outline color is set by 3 values r:g:b, where
6464 // - r,g,b - is rgb color components
6465 if ( i+1 >= colors.count() ) break; // format error
6466 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6467 if ( i+2 >= colors.count() ) break; // format error
6468 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6469 if ( i+3 >= colors.count() ) break; // format error
6470 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6471 outlineColor.setRgbF( r, g, b );
6474 else if ( type == "orientation" ) {
6475 // orientation color is set by 3 values r:g:b, where
6476 // - r,g,b - is rgb color components
6477 if ( i+1 >= colors.count() ) break; // format error
6478 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6479 if ( i+2 >= colors.count() ) break; // format error
6480 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6481 if ( i+3 >= colors.count() ) break; // format error
6482 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6483 orientationColor.setRgbF( r, g, b );
6488 if ( nodeColor.isValid() )
6489 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6491 if ( edgeColor.isValid() )
6492 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6494 if ( faceColor.isValid() )
6495 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6497 if ( volumeColor.isValid() )
6498 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6499 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6500 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6502 if ( elem0dColor.isValid() )
6503 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6505 if ( ballColor.isValid() )
6506 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6508 if ( outlineColor.isValid() )
6509 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6510 // orientation color
6511 if ( orientationColor.isValid() )
6512 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6515 else if (paramNameStr == "Sizes") {
6516 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6519 int outlineWidth = -1;
6520 int elem0dSize = -1;
6521 //int ballSize = -1;
6522 double ballDiameter = -1.0;
6523 double ballScale = -1.0;
6524 double shrinkSize = -1;
6525 double orientationSize = -1;
6526 bool orientation3d = false;
6527 for ( int i = 0; i < sizes.count(); i++ ) {
6528 QString type = sizes[i];
6529 if ( type == "line" ) {
6530 // line (wireframe) width is given as single integer value
6531 if ( i+1 >= sizes.count() ) break; // format error
6532 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6536 if ( type == "outline" ) {
6537 // outline width is given as single integer value
6538 if ( i+1 >= sizes.count() ) break; // format error
6539 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6543 else if ( type == "elem0d" ) {
6544 // 0d element size is given as single integer value
6545 if ( i+1 >= sizes.count() ) break; // format error
6546 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6550 else if ( type == "ball" ) {
6551 // balls are specified by two values: size:scale, where
6552 // - size - is a integer value specifying size
6553 // - scale - is a double value specifying scale factor
6554 if ( i+1 >= sizes.count() ) break; // format error
6555 //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6556 double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6557 if ( i+2 >= sizes.count() ) break; // format error
6558 double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6564 else if ( type == "shrink" ) {
6565 // shrink factor is given as single floating point value
6566 if ( i+1 >= sizes.count() ) break; // format error
6567 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6571 else if ( type == "orientation" ) {
6572 // orientation vectors are specified by two values size:3d, where
6573 // - size - is a floating point value specifying scale factor
6574 // - 3d - is a boolean
6575 if ( i+1 >= sizes.count() ) break; // format error
6576 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6577 if ( i+2 >= sizes.count() ) break; // format error
6578 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6579 orientationSize = v1;
6580 orientation3d = (bool)v2;
6584 // line (wireframe) width
6585 if ( lineWidth > 0 )
6586 aSmeshActor->SetLineWidth( lineWidth );
6588 if ( outlineWidth > 0 )
6589 aSmeshActor->SetOutlineWidth( outlineWidth );
6590 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6591 aSmeshActor->SetOutlineWidth( lineWidth );
6593 if ( elem0dSize > 0 )
6594 aSmeshActor->Set0DSize( elem0dSize );
6596 /*if ( ballSize > 0 )
6597 aSmeshActor->SetBallSize( ballSize );*/
6599 if ( ballDiameter > 0 )
6600 aSmeshActor->SetBallSize( ballDiameter );
6602 if ( ballScale > 0.0 )
6603 aSmeshActor->SetBallScale( ballScale );
6605 if ( shrinkSize > 0 )
6606 aSmeshActor->SetShrinkFactor( shrinkSize );
6607 // orientation vectors
6608 if ( orientationSize > 0 ) {
6609 aSmeshActor->SetFacesOrientationScale( orientationSize );
6610 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6614 else if (paramNameStr == "PointMarker") {
6615 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6616 if( data.count() >= 2 ) {
6618 int aParam1 = data[1].toInt( &ok );
6620 if( data[0] == "std" && data.count() == 3 ) {
6621 int aParam2 = data[2].toInt( &ok );
6622 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6624 else if( data[0] == "custom" ) {
6625 VTK::MarkerMap::const_iterator markerIt = myMarkerMap.find( aParam1 );
6626 if( markerIt != myMarkerMap.end() ) {
6627 VTK::MarkerData aMarkerData = markerIt->second;
6628 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6635 else if (paramNameStr == "Opacity") {
6636 aSmeshActor->SetOpacity(val.toFloat());
6639 else if (paramNameStr.startsWith("ClippingPlane")) {
6640 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6641 // old format - val looks like "Off" or "1:0:0:0.5:0:0"
6642 // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
6643 // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
6644 // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
6645 // new format - val looks like "Off" or "0" (plane id)
6646 // (note: in new format "Off" value is used only for consistency,
6647 // so it is processed together with values in old format)
6648 bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
6649 if( anIsOldFormat ) {
6650 if (paramNameStr == "ClippingPlane1" || val == "Off")
6651 aSmeshActor->RemoveAllClippingPlanes();
6653 QList<SUIT_ViewManager*> lst;
6654 getApp()->viewManagers(viewerTypStr, lst);
6655 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6656 if (viewIndex >= 0 && viewIndex < lst.count()) {
6657 SUIT_ViewManager* vman = lst.at(viewIndex);
6658 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6660 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6662 SMESH::TActorList anActorList;
6663 anActorList.push_back( aSmeshActor );
6664 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
6665 aPlane->myViewWindow = vtkView;
6666 SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
6667 aPlane->PlaneMode = aMode;
6668 bool isOpenGLClipping = ( bool )vals[1].toInt();
6669 aPlane->IsOpenGLClipping = isOpenGLClipping;
6670 if ( aMode == SMESH::Absolute ) {
6671 aPlane->myAbsoluteOrientation = vals[2].toInt();
6672 aPlane->X = vals[3].toFloat();
6673 aPlane->Y = vals[4].toFloat();
6674 aPlane->Z = vals[5].toFloat();
6675 aPlane->Dx = vals[6].toFloat();
6676 aPlane->Dy = vals[7].toFloat();
6677 aPlane->Dz = vals[8].toFloat();
6679 else if ( aMode == SMESH::Relative ) {
6680 aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
6681 aPlane->myDistance = vals[3].toFloat();
6682 aPlane->myAngle[0] = vals[4].toFloat();
6683 aPlane->myAngle[1] = vals[5].toFloat();
6687 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6688 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6689 aClippingPlaneInfo.Plane = aPlane;
6690 aClippingPlaneInfo.ActorList = anActorList;
6691 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6699 int aPlaneId = val.toInt( &ok );
6700 if( ok && aPlaneId >= 0 ) {
6701 bool anIsDefinedPlane = false;
6702 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6703 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6704 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6705 TPlaneInfo& aPlaneInfo = *anIter;
6706 if( aPlaneInfo.PlaneId == aPlaneId ) {
6707 aPlaneInfo.ActorList.push_back( aSmeshActor );
6708 anIsDefinedPlane = true;
6712 if( !anIsDefinedPlane ) {
6713 TPlaneInfo aPlaneInfo;
6714 aPlaneInfo.PlaneId = aPlaneId;
6715 aPlaneInfo.ActorList.push_back( aSmeshActor );
6716 aPlaneInfo.ViewManager = vman;
6718 // to make the list sorted by plane id
6719 anIter = aPlaneInfoList.begin();
6720 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6721 const TPlaneInfo& aPlaneInfoRef = *anIter;
6722 if( aPlaneInfoRef.PlaneId > aPlaneId )
6725 aPlaneInfoList.insert( anIter, aPlaneInfo );
6730 } // if (aSmeshActor)
6731 } // other parameters than Visibility
6733 } // for names/parameters iterator
6734 } // for entries iterator
6736 // take into account planes with empty list of actors referred to them
6737 QList<SUIT_ViewManager*> aVMList;
6738 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6740 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6741 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6742 int aViewId = aPlaneDataIter->first;
6743 if( aViewId >= 0 && aViewId < aVMList.count() ) {
6744 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6746 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6748 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6749 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6750 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6751 const TPlaneData& aPlaneData = *anIter2;
6752 int aPlaneId = aPlaneData.Id;
6754 bool anIsFound = false;
6755 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6756 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6757 const TPlaneInfo& aPlaneInfo = *anIter3;
6758 if( aPlaneInfo.PlaneId == aPlaneId ) {
6765 TPlaneInfo aPlaneInfo; // ActorList field is empty
6766 aPlaneInfo.PlaneId = aPlaneId;
6767 aPlaneInfo.ViewManager = aViewManager;
6769 // to make the list sorted by plane id
6770 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6771 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6772 const TPlaneInfo& aPlaneInfoRef = *anIter4;
6773 if( aPlaneInfoRef.PlaneId > aPlaneId )
6776 aPlaneInfoList.insert( anIter4, aPlaneInfo );
6782 // add clipping planes to actors according to the restored parameters
6783 // and update the clipping plane map
6784 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6785 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6786 int aViewId = anIter1->first;
6787 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6789 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6790 if( anIter2 == aPlaneDataMap.end() )
6792 const TPlaneDataList& aPlaneDataList = anIter2->second;
6794 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6795 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6796 const TPlaneInfo& aPlaneInfo = *anIter3;
6797 int aPlaneId = aPlaneInfo.PlaneId;
6798 const TActorList& anActorList = aPlaneInfo.ActorList;
6799 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6803 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6807 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6809 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6810 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6811 const TPlaneData& aPlaneData = *anIter4;
6812 if( aPlaneData.Id == aPlaneId ) {
6813 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
6814 aPlane->myViewWindow = aViewWindow;
6815 aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
6816 aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
6817 if ( aPlane->PlaneMode == SMESH::Absolute ) {
6818 aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
6819 aPlane->X = aPlaneData.X;
6820 aPlane->Y = aPlaneData.Y;
6821 aPlane->Z = aPlaneData.Z;
6822 aPlane->Dx = aPlaneData.Dx;
6823 aPlane->Dy = aPlaneData.Dy;
6824 aPlane->Dz = aPlaneData.Dz;
6826 else if ( aPlane->PlaneMode == SMESH::Relative ) {
6827 aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
6828 aPlane->myDistance = aPlaneData.Distance;
6829 aPlane->myAngle[0] = aPlaneData.Angle[0];
6830 aPlane->myAngle[1] = aPlaneData.Angle[1];
6833 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6834 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6835 aClippingPlaneInfo.Plane = aPlane;
6836 aClippingPlaneInfo.ActorList = anActorList;
6837 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6848 // update all VTK views
6849 QList<SUIT_ViewManager*> lst;
6850 getApp()->viewManagers(lst);
6851 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6852 SUIT_ViewModel* vmodel = (*it)->getViewModel();
6853 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6854 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6855 // set OpenGL clipping planes
6856 VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
6857 vtkActorCollection* anAllActors = aCopy.GetActors();
6858 anAllActors->InitTraversal();
6859 while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
6860 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
6861 anActor->SetOpenGLClippingPlane();
6863 vtkView->getRenderer()->ResetCameraClippingRange();
6870 \brief Adds preferences for dfont of VTK viewer
6872 \param pIf group identifier
6873 \param param parameter
6874 \return identifier of preferences
6876 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
6878 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6880 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6883 fam.append( tr( "SMESH_FONT_ARIAL" ) );
6884 fam.append( tr( "SMESH_FONT_COURIER" ) );
6885 fam.append( tr( "SMESH_FONT_TIMES" ) );
6887 setPreferenceProperty( tfont, "fonts", fam );
6889 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6890 if ( needSize ) f = f | QtxFontEdit::Size;
6891 setPreferenceProperty( tfont, "features", f );
6897 \brief Actions after hypothesis edition
6898 Updates object browser after hypothesis edition
6900 void SMESHGUI::onHypothesisEdit( int result )
6903 SMESHGUI::Modified();
6904 updateObjBrowser( true );
6908 \brief Actions after choosing menu of control modes
6909 Updates control mode actions according to current selection
6911 void SMESHGUI::onUpdateControlActions()
6913 SALOME_ListIO selected;
6914 if ( LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr() )
6915 aSel->selectedObjects( selected );
6917 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
6918 if ( selected.Extent() ) {
6919 if ( selected.First()->hasEntry() ) {
6920 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( selected.First()->getEntry() )) {
6921 aControl = anActor->GetControlMode();
6922 SALOME_ListIteratorOfListIO it(selected);
6923 for ( it.Next(); it.More(); it.Next() ) {
6924 Handle(SALOME_InteractiveObject) anIO = it.Value();
6925 if ( anIO->hasEntry() ) {
6926 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
6927 if ( aControl != anActor->GetControlMode() ) {
6928 aControl = SMESH_Actor::eNone;
6938 int anAction = ActionToControl( aControl, true );
6940 action( anAction )->setChecked( true );
6942 QMenu* send = (QMenu*)sender();
6943 QList<QAction*> actions = send->actions();
6944 for ( int i = 0; i < actions.size(); i++ )
6945 actions[i]->setChecked( false );
6951 \brief Signal handler closing(SUIT_ViewWindow*) of a view
6952 \param pview view being closed
6954 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
6955 #ifndef DISABLE_PLOT2DVIEWER
6956 //Crear all Plot2d Viewers if need.
6957 SMESH::ClearPlot2Viewers(pview);
6959 EmitSignalCloseView();
6962 void SMESHGUI::message( const QString& msg )
6965 QStringList data = msg.split("/");
6966 if ( data.count() > 0 ) {
6967 if ( data.first() == "mesh_loading" ) {
6969 QString entry = data.count() > 1 ? data[1] : QString();
6970 if ( entry.isEmpty() )
6973 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
6975 _PTR(SObject) obj = study->FindObjectID( entry.toUtf8().constData() );
6978 name = SMESH::fromUtf8(obj->GetName());
6979 if ( name.isEmpty() )
6982 if ( data.last() == "stop" )
6983 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
6985 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
6986 QApplication::processEvents();
6992 \brief Connects or disconnects signals about activating and cloning view on the module slots
6993 \param pview view which is connected/disconnected
6995 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
6999 SUIT_ViewManager* viewMgr = pview->getViewManager();
7001 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7002 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7004 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7005 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7010 \brief Return \c true if object can be renamed
7012 bool SMESHGUI::renameAllowed( const QString& entry) const {
7013 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7017 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7021 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
7026 if(appStudy->isComponent(entry) || obj->isReference())
7029 // check type to prevent renaming of inappropriate objects
7030 int aType = SMESHGUI_Selection::type(qPrintable(entry));
7031 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7032 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7033 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7034 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7035 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
7042 Rename object by entry.
7043 \param entry entry of the object
7044 \param name new name of the object
7045 \brief Return \c true if rename operation finished successfully, \c false otherwise.
7047 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
7049 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7053 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7058 _PTR(Study) aStudy = appStudy->studyDS();
7063 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
7065 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
7070 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
7071 _PTR(GenericAttribute) anAttr;
7072 _PTR(AttributeName) aName;
7074 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
7076 // check type to prevent renaming of inappropriate objects
7077 int aType = SMESHGUI_Selection::type( qPrintable(entry));
7078 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7079 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7080 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7081 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7082 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
7083 if ( !name.isEmpty() ) {
7084 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qUtf8Printable(name) );
7086 // update name of group object and its actor
7087 Handle(SALOME_InteractiveObject) IObject =
7088 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
7090 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
7091 if( !aGroupObject->_is_nil() ) {
7092 aGroupObject->SetName( qPrintable(name) );
7093 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
7094 anActor->setName( qUtf8Printable(name) );
7104 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
7106 static QList<QColor> colors;
7108 if ( colors.isEmpty() ) {
7110 for (int s = 0; s < 2 ; s++)
7112 for (int v = 100; v >= 40; v = v - 20)
7114 for (int h = 0; h < 359 ; h = h + 60)
7116 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
7121 static int currentColor = randomize( colors.size() );
7123 SALOMEDS::Color color;
7124 color.R = (double)colors[currentColor].red() / 255.0;
7125 color.G = (double)colors[currentColor].green() / 255.0;
7126 color.B = (double)colors[currentColor].blue() / 255.0;
7128 currentColor = (currentColor+1) % colors.count();