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_Selection.h"
78 #include "SMESHGUI_SewingDlg.h"
79 #include "SMESHGUI_SingleEditDlg.h"
80 #include "SMESHGUI_SmoothingDlg.h"
81 #include "SMESHGUI_SymmetryDlg.h"
82 #include "SMESHGUI_TranslationDlg.h"
83 #include "SMESHGUI_TransparencyDlg.h"
84 #include "SMESHGUI_DisplayEntitiesDlg.h"
85 #include "SMESHGUI_SplitBiQuad.h"
87 #include "SMESHGUI_FilterUtils.h"
88 #include "SMESHGUI_GEOMGenUtils.h"
89 #include "SMESHGUI_GroupUtils.h"
90 #include "SMESHGUI_HypothesesUtils.h"
91 #include "SMESHGUI_MeshUtils.h"
92 #include "SMESHGUI_PatternUtils.h"
93 #include "SMESHGUI_Utils.h"
94 #include "SMESHGUI_VTKUtils.h"
96 #include "SMESH_version.h"
98 #include "SMESH_ControlsDef.hxx"
99 #include "SMESH_Actor.h"
100 #include "SMESH_ActorUtils.h"
101 #include "SMESH_Client.hxx"
102 #include "SMESH_ScalarBarActor.h"
103 #include "SMESH_TypeFilter.hxx"
105 // SALOME GUI includes
106 #include <SalomeApp_Application.h>
107 #include <SalomeApp_CheckFileDlg.h>
108 #include <SalomeApp_DataObject.h>
109 #include <SalomeApp_Study.h>
110 #include <SalomeApp_Tools.h>
112 #include <LightApp_DataOwner.h>
113 #include <LightApp_NameDlg.h>
114 #include <LightApp_Preferences.h>
115 #include <LightApp_SelectionMgr.h>
116 #include <LightApp_UpdateFlags.h>
118 #include <SVTK_ViewManager.h>
119 #include <SVTK_ViewModel.h>
120 #include <SVTK_ViewWindow.h>
122 #include <VTKViewer_Algorithm.h>
124 #include <SUIT_Desktop.h>
125 #include <SUIT_FileDlg.h>
126 #include <SUIT_MessageBox.h>
127 #include <SUIT_OverrideCursor.h>
128 #include <SUIT_ResourceMgr.h>
129 #include <SUIT_Session.h>
131 #include <QtxPopupMgr.h>
132 #include <QtxFontEdit.h>
134 #include <SALOME_ListIO.hxx>
136 #ifndef DISABLE_PLOT2DVIEWER
137 #include <SPlot2d_ViewModel.h>
138 #include <SPlot2d_Histogram.h>
142 #include <SALOMEconfig.h>
143 #include CORBA_CLIENT_HEADER(SALOMEDS_Attributes)
144 #include CORBA_CLIENT_HEADER(SMESH_MeshEditor)
145 #include CORBA_CLIENT_HEADER(SMESH_Measurements)
148 // #define INCLUDE_MENUITEM_DEF // VSR commented ????????
149 #include <QApplication>
151 #include <QTextStream>
156 #include <QDialogButtonBox>
159 #include <boost/shared_ptr.hpp>
162 #include <vtkCallbackCommand.h>
163 #include <vtkCamera.h>
164 #include <vtkLookupTable.h>
165 #include <vtkPlane.h>
166 #include <vtkRenderer.h>
168 // SALOME KERNEL includes
169 #include <SALOMEDSClient_ClientFactory.hxx>
170 #include <SALOMEDSClient_IParameters.hxx>
171 #include <SALOMEDSClient_SComponent.hxx>
172 #include <SALOMEDSClient_StudyBuilder.hxx>
173 #include <SALOMEDS_Study.hxx>
174 #include <SALOMEDS_SObject.hxx>
175 #include "utilities.h"
178 #include <Standard_ErrorHandler.hxx>
179 #include <NCollection_DataMap.hxx>
180 #include <NCollection_DoubleMap.hxx>
182 #include <Basics_Utils.hxx>
184 // Below macro, when uncommented, switches on simplified (more performant) algorithm
185 // of auto-color picking up
186 #define SIMPLE_AUTOCOLOR
191 //=============================================================
192 void ImportMeshesFromFile(SMESH::SMESH_Gen_ptr theComponentMesh,
195 void ExportMeshToFile(int theCommandID);
197 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap);
199 void SetDisplayEntity(int theCommandID);
201 int ActionToControl( int theID, bool theReversed = false );
203 void Control( int theCommandID );
206 //================================================================================
208 * \brief Reads meshes from file
210 //================================================================================
212 void ImportMeshesFromFile( SMESH::SMESH_Gen_ptr theComponentMesh,
216 std::string myExtension;
218 if ( theCommandID == SMESHOp::OpImportMED ) {
219 filter.append( QObject::tr( "MED_FILES_FILTER" ) + " (*.*med)" );
220 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
222 else if ( theCommandID == SMESHOp::OpImportUNV ) {
223 filter.append( QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)" );
225 else if ( theCommandID == SMESHOp::OpImportDAT ) {
226 filter.append( QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)" );
228 else if ( theCommandID == SMESHOp::OpImportSTL ) {
229 filter.append( QObject::tr( "STL_FILES_FILTER" ) + " (*.stl)" );
232 else if ( theCommandID == SMESHOp::OpImportCGNS ) {
233 filter.append( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
236 else if ( theCommandID == SMESHOp::OpImportSAUV ) {
237 filter.append( QObject::tr( "SAUV files (*.sauv*)" ) );
238 filter.append( QObject::tr( "All files (*)" ) );
240 else if ( theCommandID == SMESHOp::OpImportGMF ) {
241 filter.append( QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" );
242 filter.append( QObject::tr( "GMF_BINARY_FILES_FILTER") + " (*.meshb)" );
245 QString anInitialPath = "";
246 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
247 anInitialPath = QDir::currentPath();
249 QStringList filenames;
250 bool toCreateGroups = true;
252 // if ( theCommandID == SMESHOp::OpImportGMF ) { // GMF
253 // SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg
254 // ( SMESHGUI::desktop(), true, QObject::tr("SMESH_REQUIRED_GROUPS"), true, true );
255 // fd->setWindowTitle( QObject::tr( "SMESH_IMPORT_MESH" ) );
256 // fd->setNameFilters( filter );
257 // fd->SetChecked( true );
259 // filenames << fd->selectedFile();
260 // toCreateGroups = fd->IsChecked();
266 filenames = SUIT_FileDlg::getOpenFileNames( SMESHGUI::desktop(),
269 QObject::tr( "SMESH_IMPORT_MESH" ) );
271 if ( filenames.count() > 0 )
273 SUIT_OverrideCursor wc;
274 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
277 QStringList anEntryList;
278 bool isEmpty = false;
279 for ( QStringList::ConstIterator it = filenames.begin(); it != filenames.end(); ++it )
281 QString filename = *it;
282 SMESH::mesh_array_var aMeshes = new SMESH::mesh_array;
284 switch ( theCommandID ) {
285 case SMESHOp::OpImportDAT:
287 // DAT format (currently unsupported)
288 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
289 arg( QObject::tr( "SMESH_ERR_NOT_SUPPORTED_FORMAT" ) ) );
292 case SMESHOp::OpImportUNV:
295 aMeshes->length( 1 );
296 aMeshes[0] = theComponentMesh->CreateMeshesFromUNV( filename.toUtf8().constData() );
297 if ( aMeshes[0]->_is_nil() )
298 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
299 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
302 case SMESHOp::OpImportMED:
305 SMESH::DriverMED_ReadStatus res;
306 aMeshes = theComponentMesh->CreateMeshesFromMED( filename.toUtf8().constData(), res );
307 if ( res != SMESH::DRS_OK ) {
308 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
309 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
313 case SMESHOp::OpImportSTL:
316 aMeshes->length( 1 );
317 aMeshes[0] = theComponentMesh->CreateMeshesFromSTL( filename.toUtf8().constData() );
318 if ( aMeshes[0]->_is_nil() ) {
319 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
320 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
325 case SMESHOp::OpImportCGNS:
328 SMESH::DriverMED_ReadStatus res;
329 aMeshes = theComponentMesh->CreateMeshesFromCGNS( filename.toUtf8().constData(), res );
330 if ( res != SMESH::DRS_OK ) {
331 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
332 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
337 case SMESHOp::OpImportSAUV:
340 SMESH::DriverMED_ReadStatus res;
341 aMeshes = theComponentMesh->CreateMeshesFromSAUV( filename.toUtf8().constData(), res );
342 if ( res != SMESH::DRS_OK ) {
343 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
344 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
348 case SMESHOp::OpImportGMF:
351 SMESH::ComputeError_var res;
352 aMeshes->length( 1 );
353 aMeshes[0] = theComponentMesh->CreateMeshesFromGMF( filename.toUtf8().constData(),
356 if ( res->code != SMESH::DRS_OK ) {
357 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
358 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res->code ).toLatin1().data() ) ) );
359 if ( strlen( res->comment.in() ) > 0 ) {
360 errors.back() += ": ";
361 errors.back() += res->comment.in();
368 catch ( const SALOME::SALOME_Exception& S_ex ) {
369 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
370 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
373 for ( int i = 0, iEnd = aMeshes->length(); i < iEnd; i++ )
375 _PTR(SObject) aMeshSO = SMESH::FindSObject( aMeshes[i] );
377 _PTR(StudyBuilder) aBuilder = aStudy->NewBuilder();
378 _PTR(AttributePixMap) aPixmap = aBuilder->FindOrCreateAttribute( aMeshSO, "AttributePixMap" );
379 aPixmap->SetPixMap( "ICON_SMESH_TREE_MESH_IMPORTED" );
380 if ( theCommandID == SMESHOp::OpImportUNV ) // mesh names aren't taken from the file for UNV import
381 SMESH::SetName( aMeshSO, QFileInfo(filename).fileName() );
383 anEntryList.append( aMeshSO->GetID().c_str() );
391 // update Object browser
392 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
394 // browse to the published meshes
395 if( LightApp_Application* anApp =
396 dynamic_cast<LightApp_Application*>( SUIT_Session::session()->activeApplication() ) )
397 anApp->browseObjects( anEntryList );
399 // show Error message box if there were errors
400 if ( errors.count() > 0 ) {
401 SUIT_MessageBox::critical( SMESHGUI::desktop(),
402 QObject::tr( "SMESH_ERROR" ),
403 QObject::tr( "SMESH_IMPORT_ERRORS" ) + "\n" + errors.join( "\n" ) );
406 // show warning message box, if some imported mesh is empty
408 SUIT_MessageBox::warning( SMESHGUI::desktop(),
409 QObject::tr( "SMESH_WRN_WARNING" ),
410 QObject::tr( "SMESH_DRS_SOME_EMPTY" ) );
415 //================================================================================
417 * \brief Export selected meshes or groups into a file
419 //================================================================================
421 void ExportMeshToFile( int theCommandID )
423 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
424 SALOME_ListIO selected;
426 aSel->selectedObjects( selected );
428 const bool isDAT = ( theCommandID == SMESHOp::OpExportDAT ||
429 theCommandID == SMESHOp::OpPopupExportDAT );
430 const bool isMED = ( theCommandID == SMESHOp::OpExportMED ||
431 theCommandID == SMESHOp::OpPopupExportMED );
432 const bool isUNV = ( theCommandID == SMESHOp::OpExportUNV ||
433 theCommandID == SMESHOp::OpPopupExportUNV );
434 const bool isSTL = ( theCommandID == SMESHOp::OpExportSTL ||
435 theCommandID == SMESHOp::OpPopupExportSTL );
437 const bool isCGNS= ( theCommandID == SMESHOp::OpExportCGNS ||
438 theCommandID == SMESHOp::OpPopupExportCGNS );
440 const bool isCGNS= false;
442 const bool isSAUV= ( theCommandID == SMESHOp::OpExportSAUV ||
443 theCommandID == SMESHOp::OpPopupExportSAUV );
444 const bool isGMF = ( theCommandID == SMESHOp::OpExportGMF ||
445 theCommandID == SMESHOp::OpPopupExportGMF );
447 const bool multiMeshSupported = ( isMED || isCGNS ); // file can hold several meshes
448 if ( selected.Extent() == 0 || ( selected.Extent() > 1 && !multiMeshSupported ))
450 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
451 bool aCheckWarn = true;
453 aCheckWarn = resMgr->booleanValue( "SMESH", "show_warning", false );
454 // get mesh object from selection and check duplication of their names
455 bool hasDuplicatedMeshNames = false;
456 QList< QPair< SMESH::SMESH_IDSource_var, QString > > aMeshList;
457 QList< QPair< SMESH::SMESH_IDSource_var, QString > >::iterator aMeshIter;
458 SALOME_ListIteratorOfListIO It( selected );
459 for( ; It.More(); It.Next() )
461 Handle(SALOME_InteractiveObject) anIObject = It.Value();
462 SMESH::SMESH_IDSource_var aMeshItem =
463 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIObject);
464 if ( aMeshItem->_is_nil() ) {
465 SUIT_MessageBox::warning( SMESHGUI::desktop(),
466 QObject::tr( "SMESH_WRN_WARNING" ),
467 QObject::tr( "SMESH_BAD_MESH_SELECTION" ));
470 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( aMeshItem );
471 if ( aCheckWarn && !aGroup->_is_nil() ) {
472 QMessageBox msgBox(SUIT_MessageBox::Warning,QObject::tr("SMESH_WRN_WARNING"),
473 QObject::tr("SMESH_EXPORT_ONLY_GPOUP"),QMessageBox::StandardButton::NoButton, SMESHGUI::desktop());
474 QCheckBox dontShowCheckBox(QObject::tr("SMESH_WRN_SHOW_DLG_CHECKBOX"));
475 msgBox.addButton(QMessageBox::Ok);
476 msgBox.addButton(QMessageBox::Cancel);
477 msgBox.setDefaultButton(QMessageBox::Cancel);
478 QGridLayout* lt = qobject_cast<QGridLayout*>(msgBox.layout());
479 QDialogButtonBox* btnbox = msgBox.findChild<QDialogButtonBox*>();
480 lt->addWidget(&dontShowCheckBox, lt->rowCount(), lt->columnCount()-1, lt->rowCount(), lt->columnCount());
481 lt->addWidget(btnbox, lt->rowCount(), 0, lt->rowCount(), lt->columnCount());
482 if(msgBox.exec() == QMessageBox::Ok)
484 if(dontShowCheckBox.checkState() == Qt::Checked)
487 resMgr->setValue( "SMESH", "show_warning", false);
495 QString aMeshName = anIObject->getName();
497 // check for name duplications
498 if ( !hasDuplicatedMeshNames )
499 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
500 if( aMeshName == (*aMeshIter).second ) {
501 hasDuplicatedMeshNames = true;
506 aMeshList.append( QPair< SMESH::SMESH_IDSource_var, QString >( aMeshItem, aMeshName ) );
509 if( hasDuplicatedMeshNames && isMED ) {
510 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
511 QObject::tr("SMESH_WRN_WARNING"),
512 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_MESH_NAMES"),
513 QObject::tr("SMESH_BUT_YES"),
514 QObject::tr("SMESH_BUT_NO"), 0, 1);
519 aMeshIter = aMeshList.begin();
520 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
521 SMESH::SMESH_Mesh_var aMesh = aMeshOrGroup->GetMesh();
522 QString aMeshName = (*aMeshIter).second;
524 if ( isMED || isCGNS || isSAUV ) // formats where group names must be unique
526 // check for equal group names within each mesh
527 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
528 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
529 if ( !aMeshItem->_is_nil() && aMeshItem->HasDuplicatedGroupNamesMED()) {
530 int aRet = SUIT_MessageBox::warning
531 (SMESHGUI::desktop(),
532 QObject::tr("SMESH_WRN_WARNING"),
533 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_GRP").arg((*aMeshIter).second),
534 QObject::tr("SMESH_BUT_YES"),
535 QObject::tr("SMESH_BUT_NO"), 0, 1);
542 // Warn the user about presence of not supported elements
544 std::vector< SMESH::EntityType > notSupportedElemTypes, presentNotSupported;
548 notSupportedElemTypes.push_back( SMESH::Entity_0D );
549 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
554 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
555 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
556 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
557 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
558 notSupportedElemTypes.push_back( SMESH::Entity_Pyramid );
559 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
560 notSupportedElemTypes.push_back( SMESH::Entity_0D );
561 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
566 notSupportedElemTypes.push_back( SMESH::Entity_Edge );
567 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Edge );
568 notSupportedElemTypes.push_back( SMESH::Entity_0D );
569 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
574 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
579 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
580 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Triangle );
581 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Quadrangle );
582 notSupportedElemTypes.push_back( SMESH::Entity_TriQuad_Hexa );
583 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
584 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
585 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
586 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
591 notSupportedElemTypes.push_back( SMESH::Entity_0D );
592 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
593 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
594 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Pyramid );
595 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Penta );
596 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
597 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
598 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
599 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
601 if ( ! notSupportedElemTypes.empty() )
603 SMESH::long_array_var nbElems = aMeshOrGroup->GetMeshInfo();
604 for ( size_t iType = 0; iType < notSupportedElemTypes.size(); ++iType )
605 if ( nbElems[ notSupportedElemTypes[ iType ]] > 0 )
606 presentNotSupported.push_back( notSupportedElemTypes[ iType ]);
608 if ( !presentNotSupported.empty() )
611 const char* typeMsg[] = {
612 "SMESH_NODES", "SMESH_ELEMS0D","SMESH_EDGES","SMESH_QUADRATIC_EDGES",
613 "SMESH_TRIANGLES", "SMESH_QUADRATIC_TRIANGLES", "SMESH_BIQUADRATIC_TRIANGLES",
614 "SMESH_QUADRANGLES","SMESH_QUADRATIC_QUADRANGLES", "SMESH_BIQUADRATIC_QUADRANGLES",
615 "SMESH_POLYGONS","SMESH_QUADRATIC_POLYGONS",
616 "SMESH_TETRAHEDRA","SMESH_QUADRATIC_TETRAHEDRONS","SMESH_PYRAMIDS",
617 "SMESH_QUADRATIC_PYRAMIDS","SMESH_HEXAHEDRA","SMESH_QUADRATIC_HEXAHEDRONS",
618 "SMESH_TRIQUADRATIC_HEXAHEDRONS","SMESH_PENTAHEDRA","SMESH_QUADRATIC_PENTAHEDRONS",
619 "SMESH_OCTAHEDRA","SMESH_POLYEDRONS","SMESH_QUADRATIC_POLYEDRONS","SMESH_BALLS"
621 // is typeMsg complete? (compilation failure mains that enum SMDSAbs_EntityType changed)
622 const int nbTypes = sizeof( typeMsg ) / sizeof( const char* );
623 int _assert[( nbTypes == SMESH::Entity_Last ) ? 2 : -1 ]; _assert[0]=_assert[1];
625 QString andStr = " " + QObject::tr("SMESH_AND") + " ", comma(", ");
626 for ( size_t iType = 0; iType < presentNotSupported.size(); ++iType ) {
627 typeNames += QObject::tr( typeMsg[ presentNotSupported[ iType ]]);
628 if ( iType != presentNotSupported.size() - 1 )
629 typeNames += ( iType == presentNotSupported.size() - 2 ) ? andStr : comma;
631 int aRet = SUIT_MessageBox::warning
632 (SMESHGUI::desktop(),
633 QObject::tr("SMESH_WRN_WARNING"),
634 QObject::tr("EXPORT_NOT_SUPPORTED").arg(aMeshName).arg(format).arg(typeNames),
635 QObject::tr("SMESH_BUT_YES"),
636 QObject::tr("SMESH_BUT_NO"), 0, 1);
641 // Get parameters of export operation
644 SMESH::MED_VERSION aFormat = SMESH::MED_V2_2;
645 // Init the parameters with the default values
646 bool aIsASCII_STL = true;
647 bool toCreateGroups = false;
649 toCreateGroups = resMgr->booleanValue( "SMESH", "auto_groups", false );
650 bool toOverwrite = true;
651 bool toFindOutDim = true;
653 QString aFilter, aTitle = QObject::tr("SMESH_EXPORT_MESH");
654 QString anInitialPath = "";
655 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
656 anInitialPath = QDir::currentPath();
658 QList< QPair< GEOM::ListOfFields_var, QString > > aFieldList;
660 // Get a file name to write in and additional otions
661 if ( isUNV || isDAT || isGMF ) // Export w/o options
664 aFilter = QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)";
666 aFilter = QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)";
668 aFilter = QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" +
669 ";;" + QObject::tr( "GMF_BINARY_FILES_FILTER" ) + " (*.meshb)";
670 if ( anInitialPath.isEmpty() ) anInitialPath = SUIT_FileDlg::getLastVisitedPath();
671 aFilename = SUIT_FileDlg::getFileName(SMESHGUI::desktop(),
672 anInitialPath + QString("/") + aMeshName,
673 aFilter, aTitle, false);
675 else if ( isCGNS )// Export to CGNS
677 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
678 fd->setWindowTitle( aTitle );
679 fd->setNameFilter( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
680 if ( !anInitialPath.isEmpty() )
681 fd->setDirectory( anInitialPath );
682 fd->selectFile(aMeshName);
683 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
684 fd->setValidator( fv );
687 aFilename = fd->selectedFile();
688 toOverwrite = fv->isOverwrite();
692 else if ( isSTL ) // Export to STL
694 QMap<QString, int> aFilterMap;
695 aFilterMap.insert( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)", 1 );
696 aFilterMap.insert( QObject::tr( "STL_BIN_FILES_FILTER" ) + " (*.stl)", 0 );
699 QMap<QString, int>::const_iterator it = aFilterMap.begin();
700 for ( ; it != aFilterMap.end(); ++it )
701 filters.push_back( it.key() );
703 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
704 fd->setWindowTitle( aTitle );
705 fd->setNameFilters( filters );
706 fd->selectNameFilter( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
707 if ( !anInitialPath.isEmpty() )
708 fd->setDirectory( anInitialPath );
709 fd->selectFile(aMeshName);
713 aFilename = fd->selectedFile();
714 aIsASCII_STL = (aFilterMap[fd->selectedNameFilter()]) == 1 ? true: false;
719 else if ( isMED || isSAUV ) // Export to MED or SAUV
721 QMap<QString, SMESH::MED_VERSION> aFilterMap;
722 //QString v21 (aMesh->GetVersionString(SMESH::MED_V2_1, 2));
724 QString v22 (aMesh->GetVersionString(SMESH::MED_V2_2, 2));
725 //aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v21 ) + " (*.med)", SMESH::MED_V2_1 );
726 aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v22 ) + " (*.med)", SMESH::MED_V2_2 );
729 aFilterMap.insert("All files (*)", SMESH::MED_V2_1 );
730 aFilterMap.insert("SAUV files (*.sauv)", SMESH::MED_V2_2 );
731 aFilterMap.insert("SAUV files (*.sauve)", SMESH::MED_V2_1 );
735 QString aDefaultFilter;
736 QMap<QString, SMESH::MED_VERSION>::const_iterator it = aFilterMap.begin();
737 for ( ; it != aFilterMap.end(); ++it ) {
738 filters.push_back( it.key() );
739 if (it.value() == SMESH::MED_V2_2)
740 aDefaultFilter = it.key();
742 QStringList checkBoxes;
743 checkBoxes << QObject::tr("SMESH_AUTO_GROUPS") << QObject::tr("SMESH_AUTO_DIM");
745 SMESHGUI_FieldSelectorWdg* fieldSelWdg = new SMESHGUI_FieldSelectorWdg();
746 QList< QWidget* > wdgList;
747 if ( fieldSelWdg->GetAllFeilds( aMeshList, aFieldList ))
748 wdgList.append( fieldSelWdg );
750 SalomeApp_CheckFileDlg* fd =
751 new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true, wdgList );
752 fd->setWindowTitle( aTitle );
753 fd->setNameFilters( filters );
754 fd->selectNameFilter( aDefaultFilter );
755 fd->SetChecked( toCreateGroups, 0 );
756 fd->SetChecked( toFindOutDim, 1 );
757 if ( !anInitialPath.isEmpty() )
758 fd->setDirectory( anInitialPath );
759 fd->selectFile(aMeshName);
762 QListView *lview = fd->findChild<QListView*>("listView");
764 lview->setMinimumHeight(200);
766 QTreeView *tview = fd->findChild<QTreeView*>("treeView");
768 tview->setMinimumHeight(200);
771 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
772 fd->setValidator( fv );
777 aFilename = fd->selectedFile();
779 aFilename = QString::null;
782 aFormat = aFilterMap[fd->selectedNameFilter()];
783 toOverwrite = fv->isOverwrite();
785 if ( !aFilename.isEmpty() ) {
786 // med-2.1 does not support poly elements
787 if ( aFormat==SMESH::MED_V2_1 )
788 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
789 SMESH::SMESH_IDSource_var aMeshItem = (*aMeshIter).first;
790 SMESH::long_array_var nbElems = aMeshItem->GetMeshInfo();
791 if ( nbElems[ SMESH::Entity_Polygon ] + nbElems[ SMESH::Entity_Quad_Polygon ] +
792 nbElems[ SMESH::Entity_Polyhedra ] + nbElems[ SMESH::Entity_Quad_Polyhedra ])
794 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
795 QObject::tr("SMESH_WRN_WARNING"),
796 QObject::tr("SMESH_EXPORT_MED_V2_1").arg((*aMeshIter).second),
797 QObject::tr("SMESH_BUT_YES"),
798 QObject::tr("SMESH_BUT_NO"), 0, 1);
806 // can't append to an existing using other format
807 SMESH::MED_VERSION aVersion = SMESH::MED_V2_1;
808 bool isVersionOk = SMESHGUI::GetSMESHGen()->GetMEDVersion( aFilename.toUtf8().constData(), aVersion );
809 if( !isVersionOk || aVersion != aFormat ) {
810 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
811 QObject::tr("SMESH_WRN_WARNING"),
812 QObject::tr("SMESH_EXPORT_MED_VERSION_COLLISION").arg(aFilename),
813 QObject::tr("SMESH_BUT_YES"),
814 QObject::tr("SMESH_BUT_NO"), 0, 1);
821 QStringList aMeshNamesCollisionList;
822 SMESH::string_array_var aMeshNames = SMESHGUI::GetSMESHGen()->GetMeshNames( aFilename.toUtf8().constData() );
823 for( int i = 0, n = aMeshNames->length(); i < n; i++ ) {
824 QString anExistingMeshName( aMeshNames[ i ] );
825 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
826 QString anExportMeshName = (*aMeshIter).second;
827 if( anExportMeshName == anExistingMeshName ) {
828 aMeshNamesCollisionList.append( anExportMeshName );
833 if( !aMeshNamesCollisionList.isEmpty() ) {
834 QString aMeshNamesCollisionString = aMeshNamesCollisionList.join( ", " );
835 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
836 QObject::tr("SMESH_WRN_WARNING"),
837 QObject::tr("SMESH_EXPORT_MED_MESH_NAMES_COLLISION").arg(aMeshNamesCollisionString),
838 QObject::tr("SMESH_BUT_YES"),
839 QObject::tr("SMESH_BUT_NO"),
840 QObject::tr("SMESH_BUT_CANCEL"), 0, 2);
849 toCreateGroups = fd->IsChecked(0);
850 toFindOutDim = fd->IsChecked(1);
851 fieldSelWdg->GetSelectedFeilds();
852 if ( !fieldSelWdg->parent() )
863 if ( !aFilename.isEmpty() ) {
864 // Check whether the file already exists and delete it if yes
865 QFile aFile( aFilename );
866 if ( aFile.exists() && toOverwrite )
868 SUIT_OverrideCursor wc;
871 // Renumbering is not needed since SMDS redesign in V6.2.0 (Nov 2010)
872 // bool Renumber = false;
873 // // PAL 14172 : Check of we have to renumber or not from the preferences before export
875 // Renumber= resMgr->booleanValue("renumbering");
877 // SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
878 // aMeshEditor->RenumberNodes();
879 // aMeshEditor->RenumberElements();
880 // if ( SMESHGUI::automaticUpdate() )
881 // SMESH::UpdateView();
885 aMeshIter = aMeshList.begin();
886 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
888 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
889 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
890 const GEOM::ListOfFields& fields = aFieldList[ aMeshIndex ].first.in();
891 const QString& geoAssFields = aFieldList[ aMeshIndex ].second;
892 const bool hasFields = ( fields.length() || !geoAssFields.isEmpty() );
893 if ( !hasFields && aMeshOrGroup->_is_equivalent( aMeshItem ))
894 aMeshItem->ExportToMEDX( aFilename.toUtf8().data(), toCreateGroups,
895 aFormat, toOverwrite && aMeshIndex == 0, toFindOutDim );
897 aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups,
898 aFormat, toOverwrite && aMeshIndex == 0, toFindOutDim,
899 fields, geoAssFields.toLatin1().data() );
904 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ )
906 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
907 if( !aMeshItem->_is_nil() )
908 aMeshItem->ExportSAUV( aFilename.toUtf8().data(), toCreateGroups );
913 if ( aMeshOrGroup->_is_equivalent( aMesh ))
914 aMesh->ExportDAT( aFilename.toUtf8().data() );
916 aMesh->ExportPartToDAT( aMeshOrGroup, aFilename.toUtf8().data() );
920 if ( aMeshOrGroup->_is_equivalent( aMesh ))
921 aMesh->ExportUNV( aFilename.toUtf8().data() );
923 aMesh->ExportPartToUNV( aMeshOrGroup, aFilename.toUtf8().data() );
927 if ( aMeshOrGroup->_is_equivalent( aMesh ))
928 aMesh->ExportSTL( aFilename.toUtf8().data(), aIsASCII_STL );
930 aMesh->ExportPartToSTL( aMeshOrGroup, aFilename.toUtf8().data(), aIsASCII_STL );
934 aMeshIter = aMeshList.begin();
935 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
937 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
938 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
939 aMeshItem->ExportCGNS( aMeshOrGroup,
940 aFilename.toUtf8().data(),
941 toOverwrite && aMeshIndex == 0 );
946 toCreateGroups = true;
947 aMesh->ExportGMF( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups );
950 catch (const SALOME::SALOME_Exception& S_ex){
952 SUIT_MessageBox::warning(SMESHGUI::desktop(),
953 QObject::tr("SMESH_WRN_WARNING"),
954 QObject::tr("SMESH_EXPORT_FAILED"));
960 inline void InverseEntityMode(unsigned int& theOutputMode,
961 unsigned int theMode)
963 bool anIsNotPresent = ~theOutputMode & theMode;
965 theOutputMode |= theMode;
967 theOutputMode &= ~theMode;
970 void SetDisplayEntity(int theCommandID)
972 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
973 SALOME_ListIO selected;
975 aSel->selectedObjects( selected );
977 if ( selected.Extent() >= 1 ) {
978 SUIT_OverrideCursor wc;
979 SALOME_ListIteratorOfListIO It( selected );
980 for( ; It.More(); It.Next()){
981 Handle(SALOME_InteractiveObject) IObject = It.Value();
982 if(IObject->hasEntry()){
983 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
984 unsigned int aMode = anActor->GetEntityMode();
985 switch(theCommandID){
986 case SMESHOp::OpDE0DElements: InverseEntityMode(aMode,SMESH_Actor::e0DElements); break;
987 case SMESHOp::OpDEEdges: InverseEntityMode(aMode,SMESH_Actor::eEdges); break;
988 case SMESHOp::OpDEFaces: InverseEntityMode(aMode,SMESH_Actor::eFaces); break;
989 case SMESHOp::OpDEVolumes: InverseEntityMode(aMode,SMESH_Actor::eVolumes); break;
990 case SMESHOp::OpDEBalls: InverseEntityMode(aMode,SMESH_Actor::eBallElem); break;
991 case SMESHOp::OpDEAllEntity: aMode = SMESH_Actor::eAllEntity; break;
994 anActor->SetEntityMode(aMode);
1003 SalomeApp_Application* app =
1004 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1008 LightApp_SelectionMgr* aSel = app->selectionMgr();
1009 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1010 if ( !aSel || !appStudy )
1013 SALOME_ListIO selected;
1014 aSel->selectedObjects( selected );
1015 if ( selected.IsEmpty() )
1018 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1020 _PTR(Study) aStudy = appStudy->studyDS();
1021 _PTR(SObject) aMainSObject = aStudy->FindObjectID( anIObject->getEntry() );
1022 SMESH::SMESH_Mesh_var aMainObject = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1023 if ( aMainObject->_is_nil() )
1026 SUIT_OverrideCursor wc;
1028 aMainObject->SetAutoColor( true ); // mesh groups are re-colored here
1030 QList<SALOMEDS::Color> aReservedColors;
1032 SMESH::ListOfGroups aListOfGroups = *aMainObject->GetGroups();
1033 for ( int i = 0, n = aListOfGroups.length(); i < n; i++ )
1035 SMESH::SMESH_GroupBase_var aGroupObject = aListOfGroups[i];
1037 #ifdef SIMPLE_AUTOCOLOR // simplified algorithm for auto-colors
1038 SALOMEDS::Color aColor = SMESHGUI::getPredefinedUniqueColor();
1039 #else // old algorithm for auto-colors
1040 SALOMEDS::Color aColor = SMESHGUI::getUniqueColor( aReservedColors );
1041 aReservedColors.append( aColor );
1042 #endif // SIMPLE_AUTOCOLOR
1043 aGroupObject->SetColor( aColor );
1045 _PTR(SObject) aGroupSObject = SMESH::FindSObject(aGroupObject);
1046 if ( aGroupSObject ) {
1049 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry(aGroupSObject->GetID().c_str())) {
1050 switch ( aGroupObject->GetType ()) {
1052 anActor->SetNodeColor( aColor.R, aColor.G, aColor.B ); break;
1054 anActor->SetEdgeColor( aColor.R, aColor.G, aColor.B ); break;
1056 anActor->Set0DColor( aColor.R, aColor.G, aColor.B ); break;
1058 anActor->SetBallColor( aColor.R, aColor.G, aColor.B ); break;
1060 SMESH::GetColor("SMESH", "volume_color", c, delta, "255,0,170|-100");
1061 anActor->SetVolumeColor( aColor.R, aColor.G, aColor.B, delta ); break;
1064 SMESH::GetColor("SMESH", "fill_color", c, delta, "0,170,255|-100");
1065 anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B, delta );
1071 SMESH::RepaintCurrentView();
1074 void OverallMeshQuality()
1076 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1077 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1078 SALOME_ListIO selected;
1080 aSel->selectedObjects( selected );
1082 if ( selected.IsEmpty() ) return;
1083 SALOME_ListIteratorOfListIO It( selected );
1084 for ( ; It.More(); It.Next() ) {
1085 SMESHGUI_CtrlInfoDlg* ctrlDlg = new SMESHGUI_CtrlInfoDlg( SMESHGUI::desktop() );
1086 ctrlDlg->showInfo( It.Value() );
1091 QString functorToString( SMESH::Controls::FunctorPtr f )
1093 QString type = QObject::tr( "UNKNOWN_CONTROL" );
1094 if ( dynamic_cast< SMESH::Controls::Volume* >( f.get() ) )
1095 type = QObject::tr( "VOLUME_3D_ELEMENTS" );
1096 else if ( dynamic_cast< SMESH::Controls::MaxElementLength2D* >( f.get() ) )
1097 type = QObject::tr( "MAX_ELEMENT_LENGTH_2D" );
1098 else if ( dynamic_cast< SMESH::Controls::MaxElementLength3D* >( f.get() ) )
1099 type = QObject::tr( "MAX_ELEMENT_LENGTH_3D" );
1100 else if ( dynamic_cast< SMESH::Controls::MinimumAngle* >( f.get() ) )
1101 type = QObject::tr( "MINIMUMANGLE_ELEMENTS" );
1102 else if ( dynamic_cast< SMESH::Controls::AspectRatio* >( f.get() ) )
1103 type = QObject::tr( "ASPECTRATIO_ELEMENTS" );
1104 else if ( dynamic_cast< SMESH::Controls::AspectRatio3D* >( f.get() ) )
1105 type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" );
1106 else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) )
1107 type = QObject::tr( "WARP_ELEMENTS" );
1108 else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) )
1109 type = QObject::tr( "TAPER_ELEMENTS" );
1110 else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) )
1111 type = QObject::tr( "SKEW_ELEMENTS" );
1112 else if ( dynamic_cast< SMESH::Controls::Area* >( f.get() ) )
1113 type = QObject::tr( "AREA_ELEMENTS" );
1114 else if ( dynamic_cast< SMESH::Controls::Length* >( f.get() ) )
1115 type = QObject::tr( "LENGTH_EDGES" );
1116 else if ( dynamic_cast< SMESH::Controls::Length2D* >( f.get() ) )
1117 type = QObject::tr( "LENGTH2D_EDGES" );
1118 else if ( dynamic_cast< SMESH::Controls::MultiConnection* >( f.get() ) )
1119 type = QObject::tr( "MULTI_BORDERS" );
1120 else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) )
1121 type = QObject::tr( "MULTI2D_BORDERS" );
1122 else if ( dynamic_cast< SMESH::Controls::FreeNodes* >( f.get() ) )
1123 type = QObject::tr( "FREE_NODES" );
1124 else if ( dynamic_cast< SMESH::Controls::FreeEdges* >( f.get() ) )
1125 type = QObject::tr( "FREE_EDGES" );
1126 else if ( dynamic_cast< SMESH::Controls::FreeBorders* >( f.get() ) )
1127 type = QObject::tr( "FREE_BORDERS" );
1128 else if ( dynamic_cast< SMESH::Controls::FreeFaces* >( f.get() ) )
1129 type = QObject::tr( "FREE_FACES" );
1130 else if ( dynamic_cast< SMESH::Controls::BareBorderVolume* >( f.get() ) )
1131 type = QObject::tr( "BARE_BORDER_VOLUME" );
1132 else if ( dynamic_cast< SMESH::Controls::BareBorderFace* >( f.get() ) )
1133 type = QObject::tr( "BARE_BORDER_FACE" );
1134 else if ( dynamic_cast< SMESH::Controls::OverConstrainedVolume* >( f.get() ) )
1135 type = QObject::tr( "OVER_CONSTRAINED_VOLUME" );
1136 else if ( dynamic_cast< SMESH::Controls::OverConstrainedFace* >( f.get() ) )
1137 type = QObject::tr( "OVER_CONSTRAINED_FACE" );
1138 else if ( dynamic_cast< SMESH::Controls::CoincidentNodes* >( f.get() ) )
1139 type = QObject::tr( "EQUAL_NODE" );
1140 else if ( dynamic_cast< SMESH::Controls::CoincidentElements1D* >( f.get() ) )
1141 type = QObject::tr( "EQUAL_EDGE" );
1142 else if ( dynamic_cast< SMESH::Controls::CoincidentElements2D* >( f.get() ) )
1143 type = QObject::tr( "EQUAL_FACE" );
1144 else if ( dynamic_cast< SMESH::Controls::CoincidentElements3D* >( f.get() ) )
1145 type = QObject::tr( "EQUAL_VOLUME" );
1146 else if ( dynamic_cast< SMESH::Controls::NodeConnectivityNumber* >( f.get() ) )
1147 type = QObject::tr( "NODE_CONNECTIVITY_NB" );
1151 void SaveDistribution()
1153 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1154 SALOME_ListIO selected;
1156 aSel->selectedObjects( selected );
1158 if ( selected.Extent() == 1 ) {
1159 Handle(SALOME_InteractiveObject) anIO = selected.First();
1160 if ( anIO->hasEntry() ) {
1161 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1163 anActor->GetScalarBarActor() &&
1164 anActor->GetControlMode() != SMESH_Actor::eNone )
1166 SMESH_ScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor();
1167 SMESH::Controls::FunctorPtr aFunctor = anActor->GetFunctor();
1168 if ( aScalarBarActor && aFunctor ) {
1169 SMESH::Controls::NumericalFunctor* aNumFun =
1170 dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
1172 std::vector<int> elements;
1173 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
1174 if ( mesh->_is_nil() ) {
1175 SMESH::SMESH_IDSource_var idSource =
1176 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
1177 if ( !idSource->_is_nil() )
1179 SMESH::long_array_var ids = idSource->GetIDs();
1180 elements.resize( ids->length() );
1181 for ( unsigned i = 0; i < elements.size(); ++i )
1182 elements[i] = ids[i];
1185 int nbIntervals = aScalarBarActor->GetMaximumNumberOfColors();
1186 vtkLookupTable* lookupTable =
1187 static_cast<vtkLookupTable*>(aScalarBarActor->GetLookupTable());
1188 double * minmax = lookupTable->GetRange();
1189 bool isLogarithmic = lookupTable->GetScale() == VTK_SCALE_LOG10;
1190 std::vector<int> nbEvents;
1191 std::vector<double> funValues;
1192 aNumFun->GetHistogram( nbIntervals, nbEvents, funValues,
1193 elements, minmax, isLogarithmic );
1194 QString anInitialPath = "";
1195 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
1196 anInitialPath = QDir::currentPath();
1197 QString aMeshName = anIO->getName();
1199 filter.append( QObject::tr( "TEXT_FILES_FILTER" ) + " (*.txt)" );
1200 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
1201 QString aFilename = anInitialPath + "/" + aMeshName + "_" +
1202 functorToString( aFunctor ).toLower().simplified().replace( QRegExp( " |-" ), "_" ) + ".txt";
1203 aFilename = SUIT_FileDlg::getFileName( SMESHGUI::desktop(),
1206 QObject::tr( "SMESH_SAVE_DISTRIBUTION" ),
1208 if ( !aFilename.isEmpty() ) {
1209 QFile f( aFilename );
1210 if ( f.open( QFile::WriteOnly | QFile::Truncate ) ) {
1211 QTextStream out( &f );
1212 out << "# Mesh: " << aMeshName << endl;
1213 out << "# Control: " << functorToString( aFunctor ) << endl;
1215 out.setFieldWidth( 10 );
1216 for ( int i = 0; i < (int)qMin( nbEvents.size(), funValues.size()-1 ); i++ )
1217 out << funValues[i] << "\t" << funValues[i+1] << "\t" << nbEvents[i] << endl;
1228 void ShowElement( int theCommandID )
1230 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1231 SALOME_ListIO selected;
1233 aSel->selectedObjects( selected );
1235 if ( selected.Extent() == 1 ) {
1236 Handle(SALOME_InteractiveObject) anIO = selected.First();
1237 if ( anIO->hasEntry() ) {
1238 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1240 anActor->GetScalarBarActor() &&
1241 anActor->GetControlMode() != SMESH_Actor::eNone )
1243 SMESH_ScalarBarActor *aScalarBarActor = anActor->GetScalarBarActor();
1244 if ( theCommandID == SMESHOp::OpShowDistribution ) {
1245 aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility());
1247 else if ( theCommandID == SMESHOp::OpShowScalarBar ) {
1248 aScalarBarActor->SetVisibility( !aScalarBarActor->GetVisibility());
1255 #ifndef DISABLE_PLOT2DVIEWER
1256 void PlotDistribution()
1258 SalomeApp_Application* app =
1259 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1263 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1264 SALOME_ListIO selected;
1266 aSel->selectedObjects( selected );
1268 if ( selected.Extent() == 1 ) {
1269 Handle(SALOME_InteractiveObject) anIO = selected.First();
1270 if ( anIO->hasEntry() ) {
1271 //Find Actor by entry before getting Plot2d viewer,
1272 //because after call getViewManager( Plot2d_Viewer::Type(), true ) active window is Plot2d Viewer
1273 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1275 SUIT_ViewManager* aViewManager =
1276 app->getViewManager( Plot2d_Viewer::Type(), true ); // create if necessary
1280 SPlot2d_Viewer* aView = dynamic_cast<SPlot2d_Viewer*>(aViewManager->getViewModel());
1284 Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
1288 if ( anActor && anActor->GetControlMode() != SMESH_Actor::eNone )
1290 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1291 QString functorName = functorToString( anActor->GetFunctor());
1292 QString aHistogramName("%1 : %2");
1293 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1294 aHistogram->setName(aHistogramName);
1295 aHistogram->setHorTitle(functorName);
1296 aHistogram->setVerTitle(QObject::tr("DISTRIBUTION_NB_ENT"));
1297 aPlot->displayObject(aHistogram, true);
1302 #endif //DISABLE_PLOT2DVIEWER
1304 void DisableAutoColor()
1306 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1307 SALOME_ListIO selected;
1309 aSel->selectedObjects( selected );
1311 if ( selected.Extent() ) {
1312 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1313 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1314 if ( !aMesh->_is_nil() ) {
1315 aMesh->SetAutoColor( false );
1322 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1323 SALOME_ListIO selected;
1325 aSel->selectedObjects( selected );
1326 if ( selected.Extent() )
1328 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1329 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1330 _PTR(SObject) aSObj = aStudy->FindObjectID(anIObject->getEntry());
1332 if ( aStudy->GetUseCaseBuilder()->SortChildren( aSObj, true/*AscendingOrder*/ ) ) {
1333 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1340 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap)
1342 SALOME_ListIO selected;
1343 SalomeApp_Application* app =
1344 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1348 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1349 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1350 if ( !aSel || !appStudy )
1353 if ( theCommandID == SMESHOp::OpClipping ) { // Clipping dialog can be activated without selection
1354 if ( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
1355 aModule->EmitSignalDeactivateDialog();
1356 if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
1357 (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
1362 _PTR(Study) aStudy = appStudy->studyDS();
1364 aSel->selectedObjects( selected );
1366 if ( selected.Extent() >= 1 )
1368 switch ( theCommandID ) {
1369 case SMESHOp::OpTransparency:
1371 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1372 (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
1375 case SMESHOp::OpProperties:
1378 QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
1379 QColor orientationColor, outlineColor, volumeColor;
1380 int deltaF = 0, deltaV = 0;
1383 double ballScale = 1.0;
1385 int outlineWidth = 1;
1386 double shrinkCoef = 0.0;
1387 double orientationScale = 0.0;
1388 bool orientation3d = false;
1389 VTK::MarkerType markerType = VTK::MT_NONE;
1390 VTK::MarkerScale markerScale = VTK::MS_NONE;
1392 bool hasNodes = false;
1393 int presentEntities = 0;
1394 bool firstTime = true;
1396 SALOME_ListIteratorOfListIO It( selected );
1397 for ( ; It.More(); It.Next() ) {
1398 Handle(SALOME_InteractiveObject) IObject = It.Value();
1399 if ( !IObject->hasEntry() ) continue;
1400 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1401 if ( !anActor || !anActor->GetObject() ) continue;
1404 // nodes: color, marker
1405 anActor->GetNodeColor( color[0], color[1], color[2] );
1406 nodeColor.setRgbF( color[0], color[1], color[2] );
1407 markerType = anActor->GetMarkerType();
1408 markerScale = anActor->GetMarkerScale();
1409 markerId = anActor->GetMarkerTexture();
1410 // edges: color, width
1411 anActor->GetEdgeColor( color[0], color[1], color[2] );
1412 edgeColor.setRgbF( color[0], color[1], color[2] );
1413 edgeWidth = qMax( (int)anActor->GetLineWidth(), 1 ); // minimum allowed width is 1
1414 // faces: front color, back color (delta)
1415 anActor->GetSufaceColor( color[0], color[1], color[2], deltaF );
1416 faceColor.setRgbF( color[0], color[1], color[2] );
1417 // faces: front color, back color (delta)
1418 anActor->GetVolumeColor( color[0], color[1], color[2], deltaV );
1419 volumeColor.setRgbF( color[0], color[1], color[2] );
1420 // 0d elements: color, size
1421 anActor->Get0DColor( color[0], color[1], color[2] );
1422 elem0dColor.setRgbF( color[0], color[1], color[2] );
1423 elem0dSize = qMax( (int)anActor->Get0DSize(), 1 ); // minimum allowed size is 1
1424 // balls: color, size
1425 anActor->GetBallColor( color[0], color[1], color[2] );
1426 ballColor.setRgbF( color[0], color[1], color[2] );
1427 //ballSize = qMax( (int)anActor->GetBallSize(), 1 ); // minimum allowed size is 1
1428 ballScale = qMax( (double)anActor->GetBallScale(), 1e-2 ); // minimum allowed scale is 1e-2
1430 anActor->GetOutlineColor( color[0], color[1], color[2] );
1431 outlineColor.setRgbF( color[0], color[1], color[2] );
1432 outlineWidth = qMax( (int)anActor->GetOutlineWidth(), 1 ); // minimum allowed width is 1
1433 // orientation vectors: color, scale, 3d flag
1434 anActor->GetFacesOrientationColor( color[0], color[1], color[2] );
1435 orientationColor.setRgbF( color[0], color[1], color[2] );
1436 orientationScale = anActor->GetFacesOrientationScale();
1437 orientation3d = anActor->GetFacesOrientation3DVectors();
1439 shrinkCoef = anActor->GetShrinkFactor();
1442 firstTime = false; // we only take properties from first object (for performance reasons)
1445 hasNodes = anActor->GetObject()->GetNbEntities( SMDSAbs_Node );
1446 if ( !(presentEntities & SMESH_Actor::eEdges) && anActor->GetObject()->GetNbEntities( SMDSAbs_Edge ) )
1447 presentEntities = presentEntities | SMESH_Actor::eEdges;
1448 if ( !(presentEntities & SMESH_Actor::eFaces) && anActor->GetObject()->GetNbEntities( SMDSAbs_Face ) )
1449 presentEntities = presentEntities | SMESH_Actor::eFaces;
1450 if ( !(presentEntities & SMESH_Actor::eVolumes) && anActor->GetObject()->GetNbEntities( SMDSAbs_Volume ) )
1451 presentEntities = presentEntities | SMESH_Actor::eVolumes;
1452 if ( !(presentEntities & SMESH_Actor::e0DElements) && anActor->GetObject()->GetNbEntities( SMDSAbs_0DElement ) )
1453 presentEntities = presentEntities | SMESH_Actor::e0DElements;
1454 if ( !(presentEntities & SMESH_Actor::eBallElem) && anActor->GetObject()->GetNbEntities( SMDSAbs_Ball ) )
1455 presentEntities = presentEntities | SMESH_Actor::eBallElem;
1457 // as we know that all types of elements are present, we can exit the loop
1458 if ( presentEntities == SMESH_Actor::eAllEntity )
1462 SMESHGUI_PropertiesDlg dlg( theMarkerMap[ aStudy->StudyId() ], SMESHGUI::desktop() );
1463 // nodes: color, marker
1464 dlg.setNodeColor( nodeColor );
1465 if( markerType != VTK::MT_USER )
1466 dlg.setNodeMarker( markerType, markerScale );
1468 dlg.setNodeCustomMarker( markerId );
1469 // edges: color, line width
1470 dlg.setEdgeColor( edgeColor );
1471 dlg.setEdgeWidth( edgeWidth );
1472 // faces: front color, back color
1473 dlg.setFaceColor( faceColor, deltaF );
1474 // volumes: normal color, reversed color
1475 dlg.setVolumeColor( volumeColor, deltaV );
1476 // outlines: color, line width
1477 dlg.setOutlineColor( outlineColor );
1478 dlg.setOutlineWidth( outlineWidth );
1479 // 0d elements: color, size
1480 dlg.setElem0dColor( elem0dColor );
1481 dlg.setElem0dSize( elem0dSize );
1482 // balls: color, size
1483 dlg.setBallColor( ballColor );
1484 //dlg.setBallSize( ballSize );
1485 dlg.setBallScale( ballScale );
1486 // orientation: color, scale, 3d flag
1487 dlg.setOrientationColor( orientationColor );
1488 dlg.setOrientationSize( int( orientationScale * 100. ) );
1489 dlg.setOrientation3d( orientation3d );
1490 // shrink: scale factor
1491 dlg.setShrinkCoef( int( shrinkCoef * 100. ) );
1492 // hide unused controls
1493 dlg.showControls( presentEntities, hasNodes );
1496 nodeColor = dlg.nodeColor();
1497 markerType = dlg.nodeMarkerType();
1498 markerScale = dlg.nodeMarkerScale();
1499 markerId = dlg.nodeMarkerId();
1500 edgeColor = dlg.edgeColor();
1501 edgeWidth = dlg.edgeWidth();
1502 faceColor = dlg.faceColor();
1503 deltaF = dlg.faceColorDelta();
1504 volumeColor = dlg.volumeColor();
1505 deltaV = dlg.volumeColorDelta();
1506 outlineColor = dlg.outlineColor();
1507 outlineWidth = dlg.outlineWidth();
1508 elem0dColor = dlg.elem0dColor();
1509 elem0dSize = dlg.elem0dSize();
1510 ballColor = dlg.ballColor();
1511 // ballSize = dlg.ballSize();
1512 ballScale = dlg.ballScale();
1513 orientationColor = dlg.orientationColor();
1514 orientationScale = dlg.orientationSize() / 100.;
1515 orientation3d = dlg.orientation3d();
1516 shrinkCoef = dlg.shrinkCoef() / 100.;
1518 // store point markers map that might be changed by the user
1519 theMarkerMap[ aStudy->StudyId() ] = dlg.customMarkers();
1521 // set properties from dialog box to the presentations
1522 SALOME_ListIteratorOfListIO It( selected );
1523 for ( ; It.More(); It.Next() ) {
1524 Handle(SALOME_InteractiveObject) IObject = It.Value();
1525 if ( !IObject->hasEntry() ) continue;
1526 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1527 if ( !anActor ) continue;
1529 // nodes: color, marker
1530 anActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
1531 if ( markerType != VTK::MT_USER ) {
1532 anActor->SetMarkerStd( markerType, markerScale );
1535 const VTK::MarkerMap& markerMap = theMarkerMap[ aStudy->StudyId() ];
1536 VTK::MarkerMap::const_iterator iter = markerMap.find( markerId );
1537 if ( iter != markerMap.end() )
1538 anActor->SetMarkerTexture( markerId, iter->second.second );
1540 // volumes: normal color, reversed color (delta)
1541 anActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
1542 // faces: front color, back color (delta)
1543 anActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
1544 // edges: color, width
1545 anActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
1546 anActor->SetLineWidth( edgeWidth );
1548 anActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
1549 anActor->SetOutlineWidth( outlineWidth );
1550 // 0D elements: color, size
1551 anActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
1552 anActor->Set0DSize( elem0dSize );
1553 // balls: color, size
1554 anActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
1555 // anActor->SetBallSize( ballSize );
1556 anActor->SetBallScale( ballScale );
1557 // orientation: color, scale, 3d flag
1558 anActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
1559 anActor->SetFacesOrientationScale( orientationScale );
1560 anActor->SetFacesOrientation3DVectors( orientation3d );
1562 anActor->SetShrinkFactor( shrinkCoef );
1564 // for groups, set also proper color
1565 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1566 if ( !aGroupObject->_is_nil() ) {
1567 SMESH::ElementType anElementType = aGroupObject->GetType();
1569 switch( anElementType ) {
1571 aColor = nodeColor; break;
1573 aColor = edgeColor; break;
1575 aColor = faceColor; break;
1577 aColor = volumeColor; break;
1579 aColor = elem0dColor; break;
1581 aColor = ballColor; break;
1585 if ( aColor.isValid() ) {
1586 SALOMEDS::Color aGroupColor;
1587 aGroupColor.R = aColor.redF();
1588 aGroupColor.G = aColor.greenF();
1589 aGroupColor.B = aColor.blueF();
1590 aGroupObject->SetColor( aGroupColor );
1592 } // if ( !aGroupObject->_is_nil() )
1593 } // for ( ; It.More(); It.Next() )
1594 SMESH::RepaintCurrentView();
1595 } // if ( dlg.exec() )
1597 } // case SMESHOp::OpProperties:
1598 } // switch(theCommandID)
1599 SUIT_OverrideCursor wc;
1600 SALOME_ListIteratorOfListIO It( selected );
1601 for( ; It.More(); It.Next()){
1602 Handle(SALOME_InteractiveObject) IObject = It.Value();
1603 if(IObject->hasEntry()){
1604 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1605 switch(theCommandID){
1606 case SMESHOp::OpDMWireframe:
1607 anActor->SetRepresentation(SMESH_Actor::eEdge);
1609 case SMESHOp::OpDMShading:
1610 anActor->SetRepresentation(SMESH_Actor::eSurface);
1612 case SMESHOp::OpDMShrink:
1613 if(anActor->IsShrunk())
1614 anActor->UnShrink();
1616 anActor->SetShrink();
1618 case SMESHOp::OpDMNodes:
1619 anActor->SetRepresentation(SMESH_Actor::ePoint);
1621 case SMESHOp::OpRepresentationLines:
1622 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1623 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1625 case SMESHOp::OpRepresentationArcs:
1626 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1627 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1633 SMESH::RepaintCurrentView();
1637 int ActionToControl( int theID, bool theReversed )
1639 NCollection_DoubleMap<int,int> ActionControl;
1640 ActionControl.Bind( 0, SMESH_Actor::eNone );
1641 ActionControl.Bind( SMESHOp::OpFreeNode, SMESH_Actor::eFreeNodes );
1642 ActionControl.Bind( SMESHOp::OpEqualNode, SMESH_Actor::eCoincidentNodes );
1643 ActionControl.Bind( SMESHOp::OpNodeConnectivityNb, SMESH_Actor::eNodeConnectivityNb );
1644 ActionControl.Bind( SMESHOp::OpFreeEdge, SMESH_Actor::eFreeEdges );
1645 ActionControl.Bind( SMESHOp::OpFreeBorder, SMESH_Actor::eFreeBorders );
1646 ActionControl.Bind( SMESHOp::OpLength, SMESH_Actor::eLength );
1647 ActionControl.Bind( SMESHOp::OpConnection, SMESH_Actor::eMultiConnection );
1648 ActionControl.Bind( SMESHOp::OpEqualEdge, SMESH_Actor::eCoincidentElems1D );
1649 ActionControl.Bind( SMESHOp::OpFreeFace, SMESH_Actor::eFreeFaces );
1650 ActionControl.Bind( SMESHOp::OpBareBorderFace, SMESH_Actor::eBareBorderFace );
1651 ActionControl.Bind( SMESHOp::OpOverConstrainedFace, SMESH_Actor::eOverConstrainedFace );
1652 ActionControl.Bind( SMESHOp::OpLength2D, SMESH_Actor::eLength2D );
1653 ActionControl.Bind( SMESHOp::OpConnection2D, SMESH_Actor::eMultiConnection2D );
1654 ActionControl.Bind( SMESHOp::OpArea, SMESH_Actor::eArea );
1655 ActionControl.Bind( SMESHOp::OpTaper, SMESH_Actor::eTaper );
1656 ActionControl.Bind( SMESHOp::OpAspectRatio, SMESH_Actor::eAspectRatio );
1657 ActionControl.Bind( SMESHOp::OpMinimumAngle, SMESH_Actor::eMinimumAngle );
1658 ActionControl.Bind( SMESHOp::OpWarpingAngle, SMESH_Actor::eWarping );
1659 ActionControl.Bind( SMESHOp::OpSkew, SMESH_Actor::eSkew );
1660 ActionControl.Bind( SMESHOp::OpMaxElementLength2D, SMESH_Actor::eMaxElementLength2D );
1661 ActionControl.Bind( SMESHOp::OpEqualFace, SMESH_Actor::eCoincidentElems2D );
1662 ActionControl.Bind( SMESHOp::OpAspectRatio3D, SMESH_Actor::eAspectRatio3D );
1663 ActionControl.Bind( SMESHOp::OpVolume, SMESH_Actor::eVolume3D );
1664 ActionControl.Bind( SMESHOp::OpMaxElementLength3D, SMESH_Actor::eMaxElementLength3D );
1665 ActionControl.Bind( SMESHOp::OpBareBorderVolume, SMESH_Actor::eBareBorderVolume );
1666 ActionControl.Bind( SMESHOp::OpOverConstrainedVolume, SMESH_Actor::eOverConstrainedVolume );
1667 ActionControl.Bind( SMESHOp::OpEqualVolume, SMESH_Actor::eCoincidentElems3D );
1669 return theReversed ? ActionControl.Find2( theID ) : ActionControl.Find1( theID );
1672 void Control( int theCommandID )
1674 SMESH_Actor::eControl aControl = SMESH_Actor::eControl( ActionToControl( theCommandID ));
1675 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1677 SALOME_ListIO selected;
1678 if ( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
1679 aSel->selectedObjects( selected );
1681 if ( !selected.IsEmpty() ) {
1682 SALOME_ListIteratorOfListIO It(selected);
1683 for ( ; It.More(); It.Next())
1685 Handle(SALOME_InteractiveObject) anIO = It.Value();
1686 if ( !anIO.IsNull() ) {
1687 _PTR(SObject) SO = aStudy->FindObjectID( It.Value()->getEntry() );
1689 CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
1690 SMESH::SMESH_IDSource_var anIDSrc = SMESH::SMESH_IDSource::_narrow( aObject );
1691 if ( !anIDSrc->_is_nil() ) {
1692 SMESH_Actor *anActor = SMESH::FindActorByEntry( anIO->getEntry());
1693 if (( !anActor && selected.Extent() == 1 ) &&
1694 ( anActor = SMESH::CreateActor( aStudy, anIO->getEntry() )))
1696 anActor->SetControlMode( aControl );
1697 SMESH::DisplayActor( SMESH::GetCurrentVtkView(), anActor );
1698 SMESH::UpdateView ( SMESH::eDisplay, anIO->getEntry() );
1702 if ( anActor->GetControlMode() != aControl )
1703 anActor->SetControlMode( aControl );
1704 QString functorName = functorToString( anActor->GetFunctor() );
1705 int anEntitiesCount = anActor->GetNumberControlEntities();
1706 if (anEntitiesCount >= 0)
1707 functorName = functorName + ": " + QString::number(anEntitiesCount);
1708 anActor->GetScalarBarActor()->SetTitle( functorName.toLatin1().constData() );
1709 SMESH::RepaintCurrentView();
1710 #ifndef DISABLE_PLOT2DVIEWER
1711 if ( anActor->GetPlot2Histogram() ) {
1712 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1713 QString aHistogramName("%1 : %2");
1714 aHistogramName = aHistogramName.arg( anIO->getName() ).arg( functorName );
1715 aHistogram->setName( aHistogramName );
1716 aHistogram->setHorTitle( functorName );
1717 SMESH::ProcessIn2DViewers( anActor );
1729 bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1730 SMESH::MeshObjectType theType,
1731 const QString theInTypeName,
1732 QString & theOutTypeName)
1734 SMESH_TypeFilter aTypeFilter( theType );
1736 if ( !theIO.IsNull() )
1738 entry = theIO->getEntry();
1739 LightApp_DataOwner owner( entry );
1740 if ( aTypeFilter.isOk( &owner )) {
1741 theOutTypeName = theInTypeName;
1749 QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1751 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1752 _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1754 _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1755 CORBA::String_var anID = aSComp->GetID().c_str();
1756 if ( !strcmp(anID.in(),theIO->getEntry()) )
1762 CheckOIType ( theIO, SMESH::HYPOTHESIS, "Hypothesis", aTypeName ) ||
1763 CheckOIType ( theIO, SMESH::ALGORITHM, "Algorithm", aTypeName ) ||
1764 CheckOIType ( theIO, SMESH::MESH, "Mesh", aTypeName ) ||
1765 CheckOIType ( theIO, SMESH::SUBMESH, "SubMesh", aTypeName ) ||
1766 CheckOIType ( theIO, SMESH::GROUP, "Group", aTypeName )
1774 // QString CheckHomogeneousSelection()
1776 // LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1777 // SALOME_ListIO selected;
1779 // aSel->selectedObjects( selected );
1781 // QString RefType = CheckTypeObject(selected.First());
1782 // SALOME_ListIteratorOfListIO It(selected);
1783 // for ( ; It.More(); It.Next())
1785 // Handle(SALOME_InteractiveObject) IObject = It.Value();
1786 // QString Type = CheckTypeObject(IObject);
1787 // if ( Type.compare(RefType) != 0 )
1788 // return "Heterogeneous Selection";
1794 uint randomize( uint size )
1796 static bool initialized = false;
1797 if ( !initialized ) {
1798 qsrand( QDateTime::currentDateTime().toTime_t() );
1802 v = uint( (double)( v ) / RAND_MAX * size );
1803 v = qMax( uint(0), qMin ( v, size-1 ) );
1809 void SMESHGUI::OnEditDelete()
1811 // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1812 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1813 SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1815 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1816 _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1817 _PTR(GenericAttribute) anAttr;
1818 _PTR(AttributeIOR) anIOR;
1820 int objectCount = 0;
1822 QString aParentComponent = QString::null;
1823 Handle(SALOME_InteractiveObject) anIO;
1824 for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1826 anIO = anIt.Value();
1827 QString cur = anIO->getComponentDataType();
1828 _PTR(SObject) aSO = aStudy->FindObjectID(anIO->getEntry());
1830 // check if object is reference
1831 _PTR(SObject) aRefSObj;
1832 aNameList.append("\n - ");
1833 if ( aSO->ReferencedObject( aRefSObj ) ) {
1834 QString aRefName = QString::fromStdString ( aRefSObj->GetName() );
1835 aNameList.append( aRefName );
1836 cur = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1839 aNameList.append(anIO->getName());
1843 if( aParentComponent.isNull() )
1844 aParentComponent = cur;
1845 else if( !aParentComponent.isEmpty() && aParentComponent!=cur )
1846 aParentComponent = "";
1849 if ( objectCount == 0 )
1850 return; // No Valid Objects Selected
1852 if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
1853 SUIT_MessageBox::warning( SMESHGUI::desktop(),
1854 QObject::tr("ERR_ERROR"),
1855 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
1858 // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
1859 if (SUIT_MessageBox::warning
1860 (SMESHGUI::desktop(),
1861 QObject::tr("SMESH_WRN_WARNING"),
1862 QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
1863 SUIT_MessageBox::Yes | SUIT_MessageBox::No,
1864 SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
1867 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1869 // Put the whole hierarchy of sub-objects of the selected SO's into a list and
1870 // then treat them all starting from the deepest objects (at list back)
1871 std::list< _PTR(SObject) > listSO;
1872 SALOME_ListIteratorOfListIO It(selected);
1873 for( ; It.More(); It.Next()) // loop on selected IO's
1875 Handle(SALOME_InteractiveObject) IObject = It.Value();
1876 if(IObject->hasEntry()) {
1877 _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
1879 // disable removal of "SMESH" component object
1880 if(aSO->FindAttribute(anAttr, "AttributeIOR")){
1882 if ( engineIOR() == anIOR->Value().c_str() )
1885 //Check the referenced object
1886 _PTR(SObject) aRefSObject;
1887 if ( aSO && aSO->ReferencedObject( aRefSObject ) )
1888 aSO = aRefSObject; // Delete main Object instead of reference
1890 listSO.push_back( aSO );
1891 std::list< _PTR(SObject) >::iterator itSO = --listSO.end();
1892 for ( ; itSO != listSO.end(); ++itSO ) {
1893 _PTR(ChildIterator) it = aStudy->NewChildIterator( *itSO );
1894 for (it->InitEx(false); it->More(); it->Next())
1895 listSO.push_back( it->Value() );
1899 // Check if none of objects to delete is referred from outside
1900 std::list< _PTR(SObject) >::reverse_iterator ritSO;
1901 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1903 _PTR(SObject) SO = *ritSO;
1904 if ( !SO ) continue;
1905 std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( *ritSO );
1906 for (size_t i = 0; i < aReferences.size(); i++) {
1907 _PTR(SComponent) aComponent = aReferences[i]->GetFatherComponent();
1908 std::string type = aComponent->ComponentDataType();
1909 if ( type != "SMESH" )
1911 SUIT_MessageBox::warning( anApp->desktop(),
1912 QObject::tr("WRN_WARNING"),
1913 QObject::tr("DEP_OBJECT") );
1914 return; // outside SMESH, there is an object depending on a SMESH object
1919 // Call mesh->Clear() to prevent loading mesh from file caused by hypotheses removal
1920 for( It.Initialize( selected ); It.More(); It.Next()) // loop on selected IO's
1922 Handle(SALOME_InteractiveObject) IObject = It.Value();
1923 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface< SMESH::SMESH_Mesh >( IObject );
1924 if ( !mesh->_is_nil() )
1928 // Treat SO's in the list starting from the back
1929 aStudyBuilder->NewCommand(); // There is a transaction
1930 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1932 _PTR(SObject) SO = *ritSO;
1933 if ( !SO ) continue;
1934 std::string anEntry = SO->GetID();
1936 /** Erase graphical object and remove all its data **/
1937 if(SO->FindAttribute(anAttr, "AttributeIOR")) {
1938 SMESH::RemoveVisualObjectWithActors( anEntry.c_str(), true);
1940 /** Remove an object from data structures **/
1941 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
1942 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
1943 if ( !aGroup->_is_nil() ) { // DELETE GROUP
1944 SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
1945 aMesh->RemoveGroup( aGroup );
1947 else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
1948 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
1949 aMesh->RemoveSubMesh( aSubMesh );
1951 _PTR(SObject) aMeshSO = SMESH::FindSObject(aMesh);
1953 SMESH::ModifiedMesh(aMeshSO, false, aMesh->NbNodes()==0);
1956 Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
1957 ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
1958 QString objType = CheckTypeObject(IObject);
1959 if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
1960 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
1961 aStudyBuilder->RemoveObjectWithChildren( SO );
1963 else {// default action: remove SObject from the study
1964 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
1965 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
1967 aStudyBuilder->RemoveObjectWithChildren( SO );
1971 } /* listSO back loop */
1973 aStudyBuilder->CommitCommand();
1975 /* Clear any previous selection */
1977 aSel->setSelectedObjects( l1 );
1979 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1983 SMESHGUI_EXPORT CAM_Module* createModule()
1985 return new SMESHGUI();
1988 SMESHGUI_EXPORT char* getModuleVersion() {
1989 return (char*)SMESH_VERSION_STR;
1993 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
1995 //=============================================================================
1999 //=============================================================================
2000 SMESHGUI::SMESHGUI() :
2001 SalomeApp_Module( "SMESH" )
2003 if ( CORBA::is_nil( myComponentSMESH ) )
2005 CORBA::Boolean anIsEmbeddedMode;
2006 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
2007 //MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
2009 // 0019923: EDF 765 SMESH : default values of hypothesis
2010 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
2011 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
2012 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
2013 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
2014 myComponentSMESH->SetDefaultNbSegments( nbSeg );
2016 const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif", "default_grp_color" };
2017 for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
2018 if ( aResourceMgr->hasValue( "SMESH", options[i] ))
2020 QString val = aResourceMgr->stringValue( "SMESH", options[i] );
2021 myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
2025 myActiveDialogBox = 0;
2026 myFilterLibraryDlg = 0;
2030 myEventCallbackCommand = vtkCallbackCommand::New();
2031 myEventCallbackCommand->Delete();
2032 myEventCallbackCommand->SetClientData( this );
2033 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
2036 /* load resources for all available meshers */
2037 SMESH::InitAvailableHypotheses();
2040 //=============================================================================
2044 //=============================================================================
2045 SMESHGUI::~SMESHGUI()
2049 //=============================================================================
2053 //=============================================================================
2054 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
2056 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2058 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
2063 //=============================================================================
2067 //=============================================================================
2068 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
2070 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2074 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2075 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2076 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2077 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2078 return autoUpdate && !exceeded;
2081 //=============================================================================
2085 //=============================================================================
2086 bool SMESHGUI::automaticUpdate( SMESH::SMESH_IDSource_ptr theMesh,
2087 int* entities, bool* limitExceeded, int* hidden, long* nbElements )
2089 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2093 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2094 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2095 bool incrementalLimit = resMgr->booleanValue( "SMESH", "incremental_limit", false );
2097 SMESH::long_array_var info = theMesh->GetMeshInfo();
2098 long nbOdElems = info[SMDSEntity_0D];
2099 long nbEdges = info[SMDSEntity_Edge] + info[SMDSEntity_Quad_Edge];
2100 long nbFaces = info[SMDSEntity_Triangle] + info[SMDSEntity_Quad_Triangle] + info[SMDSEntity_BiQuad_Triangle] +
2101 info[SMDSEntity_Quadrangle] + info[SMDSEntity_Quad_Quadrangle] + info[SMDSEntity_BiQuad_Quadrangle] +
2102 info[SMDSEntity_Polygon] + info[SMDSEntity_Quad_Polygon];
2103 long nbVolumes = info[SMDSEntity_Tetra] + info[SMDSEntity_Quad_Tetra] +
2104 info[SMDSEntity_Hexa] + info[SMDSEntity_Quad_Hexa] + info[SMDSEntity_TriQuad_Hexa] +
2105 info[SMDSEntity_Pyramid] + info[SMDSEntity_Quad_Pyramid] +
2106 info[SMDSEntity_Penta] + info[SMDSEntity_Quad_Penta] +
2107 info[SMDSEntity_Polyhedra] +
2108 info[SMDSEntity_Hexagonal_Prism];
2109 long nbBalls = info[SMDSEntity_Ball];
2111 long requestedSize = nbOdElems + nbBalls + nbEdges + nbFaces + nbVolumes;
2112 *nbElements = requestedSize;
2114 *entities = SMESH_Actor::eAllEntity;
2117 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2119 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2121 if ( incrementalLimit ) {
2124 if ( nbOdElems > 0 ) {
2125 if ( total + nbOdElems > updateLimit ) {
2126 *entities = *entities & ~SMESH_Actor::e0DElements;
2127 *hidden = *hidden | SMESH_Actor::e0DElements;
2134 if ( nbEdges > 0 ) {
2135 if ( total + nbEdges > updateLimit ) {
2136 *entities = *entities & ~SMESH_Actor::eEdges;
2137 *hidden = *hidden | SMESH_Actor::eEdges;
2144 if ( nbFaces > 0 ) {
2145 if ( total + nbFaces > updateLimit ) {
2146 *entities = *entities & ~SMESH_Actor::eFaces;
2147 *hidden = *hidden | SMESH_Actor::eFaces;
2154 if ( nbVolumes > 0 ) {
2155 if ( total + nbVolumes > updateLimit ) {
2156 *entities = *entities & ~SMESH_Actor::eVolumes;
2157 *hidden = *hidden | SMESH_Actor::eVolumes;
2164 if ( nbBalls > 0 ) {
2165 if ( total + nbBalls > updateLimit ) {
2166 *entities = *entities & ~SMESH_Actor::eBallElem;
2167 *hidden = *hidden | SMESH_Actor::eBallElem;
2175 return autoUpdate && !exceeded;
2178 //=============================================================================
2182 //=============================================================================
2183 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
2185 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
2188 //=============================================================================
2192 //=============================================================================
2193 SMESHGUI* SMESHGUI::GetSMESHGUI()
2195 SMESHGUI* smeshMod = 0;
2196 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
2199 CAM_Module* module = app->module( "Mesh" );
2200 smeshMod = dynamic_cast<SMESHGUI*>( module );
2203 if ( smeshMod && smeshMod->application() && smeshMod->application()->activeStudy() )
2205 SalomeApp_Study* study = dynamic_cast<SalomeApp_Study*>( smeshMod->application()->activeStudy() );
2208 _PTR(Study) aStudy = study->studyDS();
2210 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
2219 Standard_EXPORT SMESHGUI* GetComponentGUI()
2221 return SMESHGUI::GetSMESHGUI();
2225 //=============================================================================
2229 //=============================================================================
2230 void SMESHGUI::SetState(int aState)
2235 //=============================================================================
2239 //=============================================================================
2240 void SMESHGUI::ResetState()
2245 //=============================================================================
2249 //=============================================================================
2250 void SMESHGUI::EmitSignalDeactivateDialog()
2252 emit SignalDeactivateActiveDialog();
2255 //=============================================================================
2259 //=============================================================================
2260 void SMESHGUI::EmitSignalStudyFrameChanged()
2262 emit SignalStudyFrameChanged();
2265 //=============================================================================
2269 //=============================================================================
2270 void SMESHGUI::EmitSignalCloseAllDialogs()
2272 emit SignalCloseAllDialogs();
2275 //=============================================================================
2279 //=============================================================================
2280 void SMESHGUI::EmitSignalVisibilityChanged()
2282 emit SignalVisibilityChanged();
2285 //=============================================================================
2289 //=============================================================================
2290 void SMESHGUI::EmitSignalCloseView()
2292 emit SignalCloseView();
2295 //=============================================================================
2299 //=============================================================================
2300 void SMESHGUI::EmitSignalActivatedViewManager()
2302 emit SignalActivatedViewManager();
2305 //=============================================================================
2309 //=============================================================================
2310 QDialog *SMESHGUI::GetActiveDialogBox()
2312 return myActiveDialogBox;
2315 //=============================================================================
2319 //=============================================================================
2320 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2322 myActiveDialogBox = (QDialog *) aDlg;
2326 //=============================================================================
2330 //=============================================================================
2331 SUIT_Desktop* SMESHGUI::desktop()
2333 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2335 return app->desktop();
2340 //=============================================================================
2344 //=============================================================================
2345 SalomeApp_Study* SMESHGUI::activeStudy()
2347 SUIT_Application* app = SUIT_Session::session()->activeApplication();
2349 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2354 //=============================================================================
2358 //=============================================================================
2359 void SMESHGUI::Modified( bool theIsUpdateActions )
2361 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2362 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2363 appStudy->Modified();
2364 if( theIsUpdateActions )
2365 app->updateActions();
2370 //=============================================================================
2374 //=============================================================================
2375 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2377 /* Here the position is on the bottom right corner - 10 */
2378 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2380 SUIT_Desktop *PP = desktop();
2381 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2382 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2386 //=============================================================================
2390 //=============================================================================
2391 static int isStudyLocked(_PTR(Study) theStudy){
2392 return theStudy->GetProperties()->IsLocked();
2395 static bool checkLock(_PTR(Study) theStudy) {
2396 if (isStudyLocked(theStudy)) {
2397 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2398 QObject::tr("WRN_WARNING"),
2399 QObject::tr("WRN_STUDY_LOCKED") );
2405 //=======================================================================
2406 //function : CheckActiveStudyLocked
2408 //=======================================================================
2410 bool SMESHGUI::isActiveStudyLocked()
2412 _PTR(Study) aStudy = activeStudy()->studyDS();
2413 return checkLock( aStudy );
2416 //=============================================================================
2420 //=============================================================================
2421 bool SMESHGUI::OnGUIEvent( int theCommandID )
2423 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2427 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
2428 SUIT_ResourceMgr* mgr = resourceMgr();
2432 if (CORBA::is_nil(GetSMESHGen()->GetCurrentStudy())) {
2433 GetSMESHGen()->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
2436 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2437 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2439 //QAction* act = action( theCommandID );
2441 switch (theCommandID) {
2442 case SMESHOp::OpDelete:
2443 if(checkLock(aStudy)) break;
2446 case SMESHOp::OpImportDAT:
2447 case SMESHOp::OpImportUNV:
2448 case SMESHOp::OpImportMED:
2449 case SMESHOp::OpImportSTL:
2451 case SMESHOp::OpImportCGNS:
2453 case SMESHOp::OpImportSAUV:
2454 case SMESHOp::OpImportGMF:
2456 if(checkLock(aStudy)) break;
2457 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2461 case SMESHOp::OpFileInformation:
2463 SALOME_ListIO selected;
2464 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2466 aSel->selectedObjects( selected );
2467 if( selected.Extent() )
2469 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2470 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2471 if ( !aMesh->_is_nil() )
2473 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2479 case SMESHOp::OpExportDAT:
2480 case SMESHOp::OpExportMED:
2481 case SMESHOp::OpExportUNV:
2482 case SMESHOp::OpExportSTL:
2484 case SMESHOp::OpExportCGNS:
2486 case SMESHOp::OpExportSAUV:
2487 case SMESHOp::OpExportGMF:
2488 case SMESHOp::OpPopupExportDAT:
2489 case SMESHOp::OpPopupExportMED:
2490 case SMESHOp::OpPopupExportUNV:
2491 case SMESHOp::OpPopupExportSTL:
2493 case SMESHOp::OpPopupExportCGNS:
2495 case SMESHOp::OpPopupExportSAUV:
2496 case SMESHOp::OpPopupExportGMF:
2498 ::ExportMeshToFile(theCommandID);
2502 case SMESHOp::OpReset: // SCALAR BAR
2504 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2505 SALOME_ListIO selected;
2507 aSel->selectedObjects( selected );
2509 SALOME_ListIteratorOfListIO it(selected);
2510 for( ; it.More(); it.Next()) {
2511 Handle(SALOME_InteractiveObject) anIO = it.Value();
2512 if( anIO->hasEntry() ) {
2513 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2514 anActor->SetControlMode( SMESH_Actor::eNone );
2515 #ifndef DISABLE_PLOT2DVIEWER
2516 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2521 SMESH::UpdateView();
2524 case SMESHOp::OpScalarBarProperties:
2526 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2529 case SMESHOp::OpShowScalarBar:
2531 // show/hide scalar bar
2532 ::ShowElement(theCommandID);
2535 case SMESHOp::OpSaveDistribution:
2537 // dump control distribution data to the text file
2538 ::SaveDistribution();
2542 case SMESHOp::OpShowDistribution:
2544 // show/hide distribution
2545 ::ShowElement(theCommandID);
2549 #ifndef DISABLE_PLOT2DVIEWER
2550 case SMESHOp::OpPlotDistribution:
2552 // plot distribution
2553 ::PlotDistribution();
2559 case SMESHOp::OpAutoColor:
2563 case SMESHOp::OpDisableAutoColor:
2564 ::DisableAutoColor();
2567 case SMESHOp::OpClipping:
2568 case SMESHOp::OpTransparency:
2569 case SMESHOp::OpProperties: // Display preferences (colors, shrink size, line width, ...)
2572 case SMESHOp::OpDMWireframe:
2573 case SMESHOp::OpDMShading:
2574 case SMESHOp::OpDMNodes:
2575 case SMESHOp::OpDMShrink:
2576 ::SetDisplayMode(theCommandID, myMarkerMap);
2579 //2D quadratic representation
2580 case SMESHOp::OpRepresentationLines:
2581 case SMESHOp::OpRepresentationArcs:
2582 ::SetDisplayMode(theCommandID, myMarkerMap);
2586 case SMESHOp::OpDE0DElements:
2587 case SMESHOp::OpDEEdges:
2588 case SMESHOp::OpDEFaces:
2589 case SMESHOp::OpDEVolumes:
2590 case SMESHOp::OpDEBalls:
2591 case SMESHOp::OpDEAllEntity:
2592 ::SetDisplayEntity(theCommandID);
2595 // Choose entities to be displayed
2596 case SMESHOp::OpDEChoose:
2598 ( new SMESHGUI_DisplayEntitiesDlg( SMESHGUI::desktop() ) )->exec();
2602 case SMESHOp::OpOrientationOnFaces:
2604 SUIT_OverrideCursor wc;
2605 LightApp_SelectionMgr* mgr = selectionMgr();
2606 SALOME_ListIO selected; mgr->selectedObjects( selected );
2608 SALOME_ListIteratorOfListIO it(selected);
2609 for( ; it.More(); it.Next()) {
2610 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2611 if(anIObject->hasEntry()) {
2612 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2613 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2620 case SMESHOp::OpUpdate:
2622 if(checkLock(aStudy)) break;
2623 SUIT_OverrideCursor wc;
2625 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2628 SMESH::UpdateView();
2630 catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2631 SMESH::OnVisuException();
2633 catch (...) { // PAL16774 (Crash after display of many groups)
2634 SMESH::OnVisuException();
2638 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2639 aSel->selectedObjects( l );
2640 aSel->setSelectedObjects( l );
2644 case SMESHOp::OpHide:
2645 case SMESHOp::OpShow:
2646 case SMESHOp::OpShowOnly:
2648 SUIT_OverrideCursor wc;
2649 SMESH::EDisplaing anAction;
2650 switch (theCommandID) {
2651 case SMESHOp::OpHide: anAction = SMESH::eErase; break;
2652 case SMESHOp::OpShow: anAction = SMESH::eDisplay; break;
2653 case SMESHOp::OpShowOnly: anAction = SMESH::eDisplayOnly; break;
2656 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2657 SALOME_ListIO sel_objects, to_process;
2659 aSel->selectedObjects( sel_objects );
2661 if ( theCommandID==SMESHOp::OpShowOnly )
2663 //MESSAGE("anAction = SMESH::eDisplayOnly");
2664 startOperation( myEraseAll );
2667 extractContainers( sel_objects, to_process );
2670 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2674 SALOME_ListIteratorOfListIO It( to_process );
2675 for ( ; It.More(); It.Next())
2677 Handle(SALOME_InteractiveObject) IOS = It.Value();
2678 if ( IOS->hasEntry() )
2680 if ( !SMESH::UpdateView( anAction, IOS->getEntry() )) {
2681 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2682 break; // PAL16774 (Crash after display of many groups)
2684 if (anAction == SMESH::eDisplayOnly)
2685 anAction = SMESH::eDisplay;
2690 // PAL13338 + PAL15161 -->
2691 if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !checkLock(aStudy)) {
2692 SMESH::UpdateView();
2693 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2695 // PAL13338 + PAL15161 <--
2697 catch (...) { // PAL16774 (Crash after display of many groups)
2698 SMESH::OnVisuException();
2701 if (anAction == SMESH::eErase) {
2703 aSel->setSelectedObjects( l1 );
2706 aSel->setSelectedObjects( to_process );
2711 case SMESHOp::OpNode:
2713 if(checkLock(aStudy)) break;
2716 EmitSignalDeactivateDialog();
2718 ( new SMESHGUI_NodesDlg( this ) )->show();
2721 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"),tr("SMESH_WRN_VIEWER_VTK"));
2726 case SMESHOp::OpCreateMesh:
2727 case SMESHOp::OpCreateSubMesh:
2728 case SMESHOp::OpEditMeshOrSubMesh:
2729 case SMESHOp::OpEditMesh:
2730 case SMESHOp::OpEditSubMesh:
2731 case SMESHOp::OpCompute:
2732 case SMESHOp::OpComputeSubMesh:
2733 case SMESHOp::OpPreCompute:
2734 case SMESHOp::OpEvaluate:
2735 case SMESHOp::OpMeshOrder:
2736 startOperation( theCommandID );
2738 case SMESHOp::OpCopyMesh:
2740 if (checkLock(aStudy)) break;
2741 EmitSignalDeactivateDialog();
2742 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2745 case SMESHOp::OpBuildCompoundMesh:
2747 if (checkLock(aStudy)) break;
2748 EmitSignalDeactivateDialog();
2749 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2753 case SMESHOp::OpDiagonalInversion:
2754 case SMESHOp::OpUnionOfTwoTriangle:
2758 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2762 if ( checkLock( aStudy ) )
2765 /*Standard_Boolean aRes;
2766 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2767 if ( aMesh->_is_nil() )
2769 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2770 tr( "SMESH_BAD_SELECTION" ) );
2774 EmitSignalDeactivateDialog();
2775 if ( theCommandID == SMESHOp::OpDiagonalInversion )
2776 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2778 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2781 case SMESHOp::OpOrientation:
2782 case SMESHOp::OpUnionOfTriangles:
2783 case SMESHOp::OpCuttingOfQuadrangles:
2784 case SMESHOp::OpSplitVolumes:
2788 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2792 if ( checkLock( aStudy ) )
2795 EmitSignalDeactivateDialog();
2796 SMESHGUI_MultiEditDlg* aDlg = NULL;
2797 if ( theCommandID == SMESHOp::OpOrientation )
2798 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2799 else if ( theCommandID == SMESHOp::OpUnionOfTriangles )
2800 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2801 else if ( theCommandID == SMESHOp::OpSplitVolumes )
2802 aDlg = new SMESHGUI_SplitVolumesDlg(this);
2804 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2809 case SMESHOp::OpSmoothing:
2811 if(checkLock(aStudy)) break;
2813 EmitSignalDeactivateDialog();
2814 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2817 SUIT_MessageBox::warning(desktop(), tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2821 case SMESHOp::OpExtrusion:
2823 if (checkLock(aStudy)) break;
2825 EmitSignalDeactivateDialog();
2826 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2828 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2832 case SMESHOp::OpExtrusionAlongAPath:
2834 if (checkLock(aStudy)) break;
2836 EmitSignalDeactivateDialog();
2837 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2839 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2843 case SMESHOp::OpRevolution:
2845 if(checkLock(aStudy)) break;
2847 EmitSignalDeactivateDialog();
2848 ( new SMESHGUI_RevolutionDlg( this ) )->show();
2851 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2855 case SMESHOp::OpPatternMapping:
2857 if ( checkLock( aStudy ) )
2861 EmitSignalDeactivateDialog();
2862 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2865 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2869 case SMESHOp::OpSplitBiQuadratic:
2870 case SMESHOp::OpConvertMeshToQuadratic:
2871 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
2872 case SMESHOp::OpReorientFaces:
2873 case SMESHOp::OpCreateGeometryGroup:
2875 startOperation( theCommandID );
2878 case SMESHOp::OpCreateGroup:
2882 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2886 if(checkLock(aStudy)) break;
2887 EmitSignalDeactivateDialog();
2888 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2890 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2891 SALOME_ListIO selected;
2893 aSel->selectedObjects( selected );
2895 int nbSel = selected.Extent();
2897 // check if mesh is selected
2898 aMesh = SMESH::GetMeshByIO( selected.First() );
2900 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2905 case SMESHOp::OpConstructGroup:
2909 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2913 if(checkLock(aStudy)) break;
2914 EmitSignalDeactivateDialog();
2916 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2917 SALOME_ListIO selected;
2919 aSel->selectedObjects( selected );
2921 int nbSel = selected.Extent();
2923 // check if submesh is selected
2924 Handle(SALOME_InteractiveObject) IObject = selected.First();
2925 if (IObject->hasEntry()) {
2926 _PTR(SObject) aSObj = aStudy->FindObjectID(IObject->getEntry());
2928 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2929 if (!aSubMesh->_is_nil()) {
2931 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2932 // get submesh elements list by types
2933 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2934 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2935 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2936 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2937 // create group for each type o elements
2938 QString aName = IObject->getName();
2939 QStringList anEntryList;
2940 if (aNodes->length() > 0) {
2941 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2942 aGroup->Add(aNodes.inout());
2943 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2944 anEntryList.append( aSObject->GetID().c_str() );
2946 if (aEdges->length() > 0) {
2947 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2948 aGroup->Add(aEdges.inout());
2949 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2950 anEntryList.append( aSObject->GetID().c_str() );
2952 if (aFaces->length() > 0) {
2953 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2954 aGroup->Add(aFaces.inout());
2955 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2956 anEntryList.append( aSObject->GetID().c_str() );
2958 if (aVolumes->length() > 0) {
2959 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2960 aGroup->Add(aVolumes.inout());
2961 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2962 anEntryList.append( aSObject->GetID().c_str() );
2965 anApp->browseObjects( anEntryList );
2967 catch(const SALOME::SALOME_Exception & S_ex){
2968 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2975 SUIT_MessageBox::warning(desktop(),
2976 tr("SMESH_WRN_WARNING"),
2977 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
2982 case SMESHOp::OpEditGroup:
2986 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2990 if(checkLock(aStudy)) break;
2991 EmitSignalDeactivateDialog();
2993 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2994 SALOME_ListIO selected;
2996 aSel->selectedObjects( selected );
2998 SALOME_ListIteratorOfListIO It (selected);
2999 int nbSelectedGroups = 0;
3000 for ( ; It.More(); It.Next() )
3002 SMESH::SMESH_GroupBase_var aGroup =
3003 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
3004 if (!aGroup->_is_nil()) {
3006 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
3010 if (nbSelectedGroups == 0)
3012 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
3018 case SMESHOp::OpAddElemGroupPopup: // Add elements to group
3020 if(checkLock(aStudy)) break;
3021 if (myState == 800) {
3022 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3023 if (aDlg) aDlg->onAdd();
3028 case SMESHOp::OpRemoveElemGroupPopup: // Remove elements from group
3030 if(checkLock(aStudy)) break;
3031 if (myState == 800) {
3032 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3033 if (aDlg) aDlg->onRemove();
3038 case SMESHOp::OpEditGeomGroupAsGroup:
3042 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3046 if(checkLock(aStudy)) break;
3047 EmitSignalDeactivateDialog();
3049 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3050 SALOME_ListIO selected;
3052 aSel->selectedObjects( selected );
3054 SALOME_ListIteratorOfListIO It (selected);
3055 for ( ; It.More(); It.Next() )
3057 SMESH::SMESH_GroupOnGeom_var aGroup =
3058 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
3059 if (!aGroup->_is_nil()) {
3060 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3065 SMESH::SMESH_GroupOnFilter_var aGroup =
3066 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
3067 if (!aGroup->_is_nil()) {
3068 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3076 case SMESHOp::OpUnionGroups:
3077 case SMESHOp::OpIntersectGroups:
3078 case SMESHOp::OpCutGroups:
3082 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3086 if ( checkLock( aStudy ) )
3089 EmitSignalDeactivateDialog();
3091 SMESHGUI_GroupOpDlg* aDlg = 0;
3092 if ( theCommandID == SMESHOp::OpUnionGroups )
3093 aDlg = new SMESHGUI_UnionGroupsDlg( this );
3094 else if ( theCommandID == SMESHOp::OpIntersectGroups )
3095 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3097 aDlg = new SMESHGUI_CutGroupsDlg( this );
3104 case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
3106 if ( checkLock( aStudy ) )
3109 EmitSignalDeactivateDialog();
3110 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3116 case SMESHOp::OpDeleteGroup: // Delete groups with their contents
3120 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3124 if ( checkLock( aStudy ) )
3127 EmitSignalDeactivateDialog();
3129 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3133 case SMESHOp::OpMeshInformation:
3134 case SMESHOp::OpWhatIs:
3136 int page = theCommandID == SMESHOp::OpMeshInformation ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3137 EmitSignalDeactivateDialog();
3138 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3139 SALOME_ListIO selected;
3141 aSel->selectedObjects( selected );
3143 if ( selected.Extent() > 1 ) { // a dlg for each IO
3144 SALOME_ListIteratorOfListIO It( selected );
3145 for ( ; It.More(); It.Next() ) {
3146 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3147 dlg->showInfo( It.Value() );
3152 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3158 case SMESHOp::OpFindElementByPoint:
3160 startOperation( theCommandID );
3164 case SMESHOp::OpEditHypothesis:
3166 if(checkLock(aStudy)) break;
3168 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3169 SALOME_ListIO selected;
3171 aSel->selectedObjects( selected );
3173 int nbSel = selected.Extent();
3176 Handle(SALOME_InteractiveObject) anIObject = selected.First();
3177 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3179 if ( !aHypothesis->_is_nil() )
3181 SMESHGUI_GenericHypothesisCreator* aCreator =
3182 SMESH::GetHypothesisCreator( SMESH::toQStr( aHypothesis->GetName() ));
3185 // set geometry of mesh and sub-mesh to aCreator
3186 aSel->selectedObjects( selected, "", /*convertReferences=*/false);
3187 if ( selected.Extent() == 1 )
3189 QString subGeomID, meshGeomID;
3190 Handle(SALOME_InteractiveObject) hypIO = selected.First();
3191 if ( SMESH::GetGeomEntries( hypIO, subGeomID, meshGeomID ))
3193 if ( subGeomID.isEmpty() ) subGeomID = meshGeomID;
3194 aCreator->setShapeEntry( subGeomID );
3195 aCreator->setMainShapeEntry( meshGeomID );
3199 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3209 case SMESHOp::OpUnassign: // REMOVE HYPOTHESIS / ALGORITHMS
3211 if(checkLock(aStudy)) break;
3212 SUIT_OverrideCursor wc;
3214 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3215 SALOME_ListIO selected;
3217 aSel->selectedObjects( selected, QString::null, false );
3219 SALOME_ListIteratorOfListIO It(selected);
3220 for (int i = 0; It.More(); It.Next(), i++) {
3221 Handle(SALOME_InteractiveObject) IObject = It.Value();
3222 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3225 aSel->setSelectedObjects( l1 );
3230 case SMESHOp::OpElem0D:
3231 case SMESHOp::OpBall:
3232 case SMESHOp::OpEdge:
3233 case SMESHOp::OpTriangle:
3234 case SMESHOp::OpQuadrangle:
3235 case SMESHOp::OpPolygon:
3236 case SMESHOp::OpTetrahedron:
3237 case SMESHOp::OpHexahedron:
3238 case SMESHOp::OpPentahedron:
3239 case SMESHOp::OpPyramid:
3240 case SMESHOp::OpHexagonalPrism:
3242 if(checkLock(aStudy)) break;
3244 EmitSignalDeactivateDialog();
3245 SMDSAbs_EntityType type = SMDSEntity_Edge;
3246 switch (theCommandID) {
3247 case SMESHOp::OpElem0D: type = SMDSEntity_0D; break;
3248 case SMESHOp::OpBall: type = SMDSEntity_Ball; break;
3249 case SMESHOp::OpTriangle: type = SMDSEntity_Triangle; break;
3250 case SMESHOp::OpQuadrangle: type = SMDSEntity_Quadrangle; break;
3251 case SMESHOp::OpTetrahedron: type = SMDSEntity_Tetra; break;
3252 case SMESHOp::OpPolygon: type = SMDSEntity_Polygon; break;
3253 case SMESHOp::OpHexahedron: type = SMDSEntity_Hexa; break;
3254 case SMESHOp::OpPentahedron: type = SMDSEntity_Penta; break;
3255 case SMESHOp::OpPyramid: type = SMDSEntity_Pyramid; break;
3256 case SMESHOp::OpHexagonalPrism: type = SMDSEntity_Hexagonal_Prism; break;
3259 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3262 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3266 case SMESHOp::OpPolyhedron:
3268 if(checkLock(aStudy)) break;
3270 EmitSignalDeactivateDialog();
3271 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3274 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3278 case SMESHOp::OpQuadraticEdge:
3279 case SMESHOp::OpQuadraticTriangle:
3280 case SMESHOp::OpBiQuadraticTriangle:
3281 case SMESHOp::OpQuadraticQuadrangle:
3282 case SMESHOp::OpBiQuadraticQuadrangle:
3283 case SMESHOp::OpQuadraticPolygon:
3284 case SMESHOp::OpQuadraticTetrahedron:
3285 case SMESHOp::OpQuadraticPyramid:
3286 case SMESHOp::OpQuadraticPentahedron:
3287 case SMESHOp::OpQuadraticHexahedron:
3288 case SMESHOp::OpTriQuadraticHexahedron:
3290 if(checkLock(aStudy)) break;
3292 EmitSignalDeactivateDialog();
3293 SMDSAbs_EntityType type = SMDSEntity_Last;
3295 switch (theCommandID) {
3296 case SMESHOp::OpQuadraticEdge: type = SMDSEntity_Quad_Edge; break;
3297 case SMESHOp::OpQuadraticTriangle: type = SMDSEntity_Quad_Triangle; break;
3298 case SMESHOp::OpBiQuadraticTriangle: type = SMDSEntity_BiQuad_Triangle; break;
3299 case SMESHOp::OpQuadraticQuadrangle: type = SMDSEntity_Quad_Quadrangle; break;
3300 case SMESHOp::OpBiQuadraticQuadrangle: type = SMDSEntity_BiQuad_Quadrangle; break;
3301 case SMESHOp::OpQuadraticPolygon: type = SMDSEntity_Quad_Polygon; break;
3302 case SMESHOp::OpQuadraticTetrahedron: type = SMDSEntity_Quad_Tetra; break;
3303 case SMESHOp::OpQuadraticPyramid: type = SMDSEntity_Quad_Pyramid; break;
3304 case SMESHOp::OpQuadraticPentahedron: type = SMDSEntity_Quad_Penta; break;
3305 case SMESHOp::OpQuadraticHexahedron: type = SMDSEntity_Quad_Hexa; break;
3306 case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
3309 if ( type != SMDSEntity_Last )
3310 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3313 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3314 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3318 case SMESHOp::OpRemoveNodes:
3320 if(checkLock(aStudy)) break;
3322 EmitSignalDeactivateDialog();
3323 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3326 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3327 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3331 case SMESHOp::OpRemoveElements: // REMOVES ELEMENTS
3333 if(checkLock(aStudy)) break;
3335 EmitSignalDeactivateDialog();
3336 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3340 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3341 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3345 case SMESHOp::OpClearMesh: {
3347 if(checkLock(aStudy)) break;
3349 SALOME_ListIO selected;
3350 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3351 aSel->selectedObjects( selected );
3353 SUIT_OverrideCursor wc;
3354 SALOME_ListIteratorOfListIO It (selected);
3355 for ( ; It.More(); It.Next() )
3357 Handle(SALOME_InteractiveObject) IOS = It.Value();
3358 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3359 if ( aMesh->_is_nil()) continue;
3362 if ( aMesh->NbNodes() == 0 ) // imported mesh is not empty
3363 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3364 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3365 SMESH::ModifiedMesh( aMeshSObj, false, true);
3366 // hide groups and submeshes
3367 _PTR(ChildIterator) anIter =
3368 SMESH::GetActiveStudyDocument()->NewChildIterator( aMeshSObj );
3369 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3371 _PTR(SObject) so = anIter->Value();
3372 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3375 catch (const SALOME::SALOME_Exception& S_ex){
3377 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3381 SMESH::UpdateView();
3385 case SMESHOp::OpRemoveOrphanNodes:
3387 if(checkLock(aStudy)) break;
3388 SALOME_ListIO selected;
3389 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3390 aSel->selectedObjects( selected );
3391 if ( selected.Extent() == 1 ) {
3392 Handle(SALOME_InteractiveObject) anIO = selected.First();
3393 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3394 if ( !aMesh->_is_nil() ) {
3395 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3396 tr( "SMESH_WARNING" ),
3397 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3398 SUIT_MessageBox::Yes |
3399 SUIT_MessageBox::No,
3400 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3403 SUIT_OverrideCursor wc;
3404 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3405 int removed = aMeshEditor->RemoveOrphanNodes();
3406 SUIT_MessageBox::information(SMESHGUI::desktop(),
3407 tr("SMESH_INFORMATION"),
3408 tr("NB_NODES_REMOVED").arg(removed));
3409 if ( removed > 0 ) {
3410 SMESH::UpdateView();
3411 SMESHGUI::Modified();
3414 catch (const SALOME::SALOME_Exception& S_ex) {
3415 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3424 case SMESHOp::OpRenumberingNodes:
3426 if(checkLock(aStudy)) break;
3428 EmitSignalDeactivateDialog();
3429 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3433 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3434 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3438 case SMESHOp::OpRenumberingElements:
3440 if(checkLock(aStudy)) break;
3442 EmitSignalDeactivateDialog();
3443 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3447 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3448 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3452 case SMESHOp::OpTranslation:
3454 if(checkLock(aStudy)) break;
3456 EmitSignalDeactivateDialog();
3457 ( new SMESHGUI_TranslationDlg( this ) )->show();
3460 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3461 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3465 case SMESHOp::OpRotation:
3467 if(checkLock(aStudy)) break;
3469 EmitSignalDeactivateDialog();
3470 ( new SMESHGUI_RotationDlg( this ) )->show();
3473 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3474 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3478 case SMESHOp::OpSymmetry:
3480 if(checkLock(aStudy)) break;
3482 EmitSignalDeactivateDialog();
3483 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3486 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3487 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3491 case SMESHOp::OpScale:
3493 if(checkLock(aStudy)) break;
3495 EmitSignalDeactivateDialog();
3496 ( new SMESHGUI_ScaleDlg( this ) )->show();
3499 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3500 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3505 case SMESHOp::OpSewing:
3507 if(checkLock(aStudy)) break;
3509 EmitSignalDeactivateDialog();
3510 ( new SMESHGUI_SewingDlg( this ) )->show();
3513 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3514 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3518 case SMESHOp::OpMergeNodes:
3520 if(checkLock(aStudy)) break;
3522 EmitSignalDeactivateDialog();
3523 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3526 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3527 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3531 case SMESHOp::OpMergeElements:
3533 if (checkLock(aStudy)) break;
3535 EmitSignalDeactivateDialog();
3536 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3538 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3539 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3544 case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
3545 startOperation( SMESHOp::OpMoveNode );
3548 case SMESHOp::OpDuplicateNodes:
3550 if(checkLock(aStudy)) break;
3552 EmitSignalDeactivateDialog();
3553 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3556 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3557 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3562 case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
3563 startOperation( SMESHOp::OpElem0DOnElemNodes );
3566 case SMESHOp::OpSelectFiltersLibrary: // Library of selection filters
3568 static QList<int> aTypes;
3569 if ( aTypes.isEmpty() )
3571 aTypes.append( SMESH::NODE );
3572 aTypes.append( SMESH::EDGE );
3573 aTypes.append( SMESH::FACE );
3574 aTypes.append( SMESH::VOLUME );
3576 if (!myFilterLibraryDlg)
3577 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3578 else if (myFilterLibraryDlg->isHidden())
3579 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3580 myFilterLibraryDlg->raise();
3584 case SMESHOp::OpFreeNode:
3585 case SMESHOp::OpEqualNode:
3586 case SMESHOp::OpNodeConnectivityNb:
3587 case SMESHOp::OpFreeEdge:
3588 case SMESHOp::OpFreeBorder:
3589 case SMESHOp::OpLength:
3590 case SMESHOp::OpConnection:
3591 case SMESHOp::OpEqualEdge:
3592 case SMESHOp::OpFreeFace:
3593 case SMESHOp::OpBareBorderFace:
3594 case SMESHOp::OpOverConstrainedFace:
3595 case SMESHOp::OpLength2D:
3596 case SMESHOp::OpConnection2D:
3597 case SMESHOp::OpArea:
3598 case SMESHOp::OpTaper:
3599 case SMESHOp::OpAspectRatio:
3600 case SMESHOp::OpMinimumAngle:
3601 case SMESHOp::OpWarpingAngle:
3602 case SMESHOp::OpSkew:
3603 case SMESHOp::OpMaxElementLength2D:
3604 case SMESHOp::OpEqualFace:
3605 case SMESHOp::OpAspectRatio3D:
3606 case SMESHOp::OpVolume:
3607 case SMESHOp::OpMaxElementLength3D:
3608 case SMESHOp::OpBareBorderVolume:
3609 case SMESHOp::OpOverConstrainedVolume:
3610 case SMESHOp::OpEqualVolume:
3613 LightApp_SelectionMgr* mgr = selectionMgr();
3614 SALOME_ListIO selected; mgr->selectedObjects( selected );
3616 if( !selected.IsEmpty() ) {
3617 SUIT_OverrideCursor wc;
3618 ::Control( theCommandID );
3621 SUIT_MessageBox::warning(desktop(),
3622 tr( "SMESH_WRN_WARNING" ),
3623 tr( "SMESH_BAD_SELECTION" ) );
3627 SUIT_MessageBox::warning(desktop(),
3628 tr( "SMESH_WRN_WARNING" ),
3629 tr( "NOT_A_VTK_VIEWER" ) );
3632 case SMESHOp::OpOverallMeshQuality:
3633 OverallMeshQuality();
3635 case SMESHOp::OpNumberingNodes:
3637 SUIT_OverrideCursor wc;
3638 LightApp_SelectionMgr* mgr = selectionMgr();
3639 SALOME_ListIO selected; mgr->selectedObjects( selected );
3641 SALOME_ListIteratorOfListIO it(selected);
3642 for( ; it.More(); it.Next()) {
3643 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3644 if(anIObject->hasEntry()) {
3645 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3646 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3652 case SMESHOp::OpNumberingElements:
3654 SUIT_OverrideCursor wc;
3655 LightApp_SelectionMgr* mgr = selectionMgr();
3656 SALOME_ListIO selected; mgr->selectedObjects( selected );
3658 SALOME_ListIteratorOfListIO it(selected);
3659 for( ; it.More(); it.Next()) {
3660 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3661 if(anIObject->hasEntry())
3662 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3663 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3668 case SMESHOp::OpPropertiesLength:
3669 case SMESHOp::OpPropertiesArea:
3670 case SMESHOp::OpPropertiesVolume:
3671 case SMESHOp::OpMinimumDistance:
3672 case SMESHOp::OpBoundingBox:
3674 int page = SMESHGUI_MeasureDlg::MinDistance;
3675 if ( theCommandID == SMESHOp::OpBoundingBox )
3676 page = SMESHGUI_MeasureDlg::BoundingBox;
3677 else if ( theCommandID == SMESHOp::OpPropertiesLength )
3678 page = SMESHGUI_MeasureDlg::Length;
3679 else if ( theCommandID == SMESHOp::OpPropertiesArea )
3680 page = SMESHGUI_MeasureDlg::Area;
3681 else if ( theCommandID == SMESHOp::OpPropertiesVolume )
3682 page = SMESHGUI_MeasureDlg::Volume;
3684 EmitSignalDeactivateDialog();
3685 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3689 case SMESHOp::OpSortChild:
3695 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3696 //updateObjBrowser();
3700 //=============================================================================
3704 //=============================================================================
3705 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3710 //=============================================================================
3714 //=============================================================================
3715 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3720 //=============================================================================
3724 //=============================================================================
3725 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3730 //=============================================================================
3731 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3732 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3734 //=============================================================================
3735 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3736 SUIT_ViewWindow* wnd )
3738 if(theIO->hasEntry()){
3739 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3740 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3744 //=======================================================================
3745 // function : createSMESHAction
3747 //=======================================================================
3748 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3749 const int key, const bool toggle, const QString& shortcutAction )
3752 QWidget* parent = application()->desktop();
3753 SUIT_ResourceMgr* resMgr = resourceMgr();
3755 if ( !icon_id.isEmpty() )
3756 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3758 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3759 if ( !pix.isNull() )
3760 icon = QIcon( pix );
3762 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3763 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3764 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3766 createAction( id, tooltip, icon, menu, status_bar, key, parent,
3767 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3770 //=======================================================================
3771 // function : createPopupItem
3773 //=======================================================================
3774 void SMESHGUI::createPopupItem( const int id,
3775 const QString& clients,
3776 const QString& types,
3777 const QString& theRule,
3780 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3781 popupMgr()->insert( action( id ), pId, 0 );
3783 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3784 QString dc = "selcount"; // VSR : insetad of QtxPopupSelection::defSelCountParam()
3785 QString rule = "(%1) and (%2) and (%3)";
3786 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3787 if( clients.isEmpty() )
3788 rule = rule.arg( QString( "true" ) );
3790 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3791 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3794 bool cont = myRules.contains( id );
3796 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3798 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3799 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3802 //=======================================================================
3803 // function : initialize
3805 //=======================================================================
3806 void SMESHGUI::initialize( CAM_Application* app )
3808 SalomeApp_Module::initialize( app );
3810 // SUIT_ResourceMgr* mgr = app->resourceMgr();
3812 /* Automatic Update flag */
3813 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3815 // ----- create actions --------------
3817 //createSMESHAction( SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
3818 createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_I) );
3819 createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
3820 //createSMESHAction( 114, "NUM" );
3821 createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL" );
3823 createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
3825 createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
3826 createSMESHAction( SMESHOp::OpImportGMF, "IMPORT_GMF" );
3827 createSMESHAction( SMESHOp::OpExportDAT, "DAT" );
3828 createSMESHAction( SMESHOp::OpExportMED, "MED" );
3829 createSMESHAction( SMESHOp::OpExportUNV, "UNV" );
3830 createSMESHAction( SMESHOp::OpExportSTL, "STL" );
3832 createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
3834 createSMESHAction( SMESHOp::OpExportSAUV, "SAUV");
3835 createSMESHAction( SMESHOp::OpExportGMF, "GMF" );
3836 createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
3837 createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
3838 createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
3839 createSMESHAction( SMESHOp::OpPopupExportSTL, "STL" );
3841 createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
3843 createSMESHAction( SMESHOp::OpPopupExportSAUV, "SAUV");
3844 createSMESHAction( SMESHOp::OpPopupExportGMF, "GMF" );
3845 createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
3846 createSMESHAction( SMESHOp::OpDelete, "DELETE", "ICON_DELETE", Qt::Key_Delete );
3847 createSMESHAction( SMESHOp::OpSelectFiltersLibrary, "SEL_FILTER_LIB" );
3848 createSMESHAction( SMESHOp::OpCreateMesh, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
3849 createSMESHAction( SMESHOp::OpCreateSubMesh, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
3850 createSMESHAction( SMESHOp::OpEditMeshOrSubMesh, "EDIT_MESHSUBMESH", "ICON_DLG_EDIT_MESH" );
3851 createSMESHAction( SMESHOp::OpEditMesh, "EDIT_MESH", "ICON_DLG_EDIT_MESH" );
3852 createSMESHAction( SMESHOp::OpEditSubMesh, "EDIT_SUBMESH", "ICON_DLG_EDIT_MESH" );
3853 createSMESHAction( SMESHOp::OpBuildCompoundMesh, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
3854 createSMESHAction( SMESHOp::OpCopyMesh, "COPY_MESH", "ICON_COPY_MESH" );
3855 createSMESHAction( SMESHOp::OpCompute, "COMPUTE", "ICON_COMPUTE" );
3856 createSMESHAction( SMESHOp::OpComputeSubMesh, "COMPUTE_SUBMESH", "ICON_COMPUTE" );
3857 createSMESHAction( SMESHOp::OpPreCompute, "PRECOMPUTE", "ICON_PRECOMPUTE" );
3858 createSMESHAction( SMESHOp::OpEvaluate, "EVALUATE", "ICON_EVALUATE" );
3859 createSMESHAction( SMESHOp::OpMeshOrder, "MESH_ORDER", "ICON_MESH_ORDER");
3860 createSMESHAction( SMESHOp::OpCreateGroup, "CREATE_GROUP", "ICON_CREATE_GROUP" );
3861 createSMESHAction( SMESHOp::OpCreateGeometryGroup, "CREATE_GEO_GROUP", "ICON_CREATE_GEO_GROUP" );
3862 createSMESHAction( SMESHOp::OpConstructGroup, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
3863 createSMESHAction( SMESHOp::OpEditGroup, "EDIT_GROUP", "ICON_EDIT_GROUP" );
3864 createSMESHAction( SMESHOp::OpEditGeomGroupAsGroup, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3865 createSMESHAction( SMESHOp::OpUnionGroups, "UN_GROUP", "ICON_UNION" );
3866 createSMESHAction( SMESHOp::OpIntersectGroups, "INT_GROUP", "ICON_INTERSECT" );
3867 createSMESHAction( SMESHOp::OpCutGroups, "CUT_GROUP", "ICON_CUT" );
3868 createSMESHAction( SMESHOp::OpGroupUnderlyingElem, "UNDERLYING_ELEMS", "ICON_UNDERLYING_ELEMS" );
3869 createSMESHAction( SMESHOp::OpAddElemGroupPopup, "ADD" );
3870 createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE" );
3871 createSMESHAction( SMESHOp::OpDeleteGroup, "DEL_GROUP", "ICON_DEL_GROUP" );
3872 createSMESHAction( SMESHOp::OpMeshInformation , "ADV_INFO", "ICON_ADV_INFO" );
3873 //createSMESHAction( SMESHOp::OpStdInfo, "STD_INFO", "ICON_STD_INFO" );
3874 //createSMESHAction( SMESHOp::OpWhatIs, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3875 createSMESHAction( SMESHOp::OpFindElementByPoint, "FIND_ELEM", "ICON_FIND_ELEM" );
3877 createSMESHAction( SMESHOp::OpFreeNode, "FREE_NODE", "ICON_FREE_NODE", 0, true );
3878 createSMESHAction( SMESHOp::OpEqualNode, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
3879 createSMESHAction( SMESHOp::OpNodeConnectivityNb, "NODE_CONNECTIVITY_NB", "ICON_NODE_CONN_NB", 0, true );
3880 createSMESHAction( SMESHOp::OpFreeEdge, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
3881 createSMESHAction( SMESHOp::OpFreeBorder, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
3882 createSMESHAction( SMESHOp::OpLength, "LENGTH", "ICON_LENGTH", 0, true );
3883 createSMESHAction( SMESHOp::OpConnection, "CONNECTION", "ICON_CONNECTION", 0, true );
3884 createSMESHAction( SMESHOp::OpEqualEdge, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
3885 createSMESHAction( SMESHOp::OpFreeFace, "FREE_FACES", "ICON_FREE_FACES", 0, true );
3886 createSMESHAction( SMESHOp::OpBareBorderFace, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
3887 createSMESHAction( SMESHOp::OpOverConstrainedFace, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
3888 createSMESHAction( SMESHOp::OpLength2D, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
3889 createSMESHAction( SMESHOp::OpConnection2D, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
3890 createSMESHAction( SMESHOp::OpArea, "AREA", "ICON_AREA", 0, true );
3891 createSMESHAction( SMESHOp::OpTaper, "TAPER", "ICON_TAPER", 0, true );
3892 createSMESHAction( SMESHOp::OpAspectRatio, "ASPECT", "ICON_ASPECT", 0, true );
3893 createSMESHAction( SMESHOp::OpMinimumAngle, "MIN_ANG", "ICON_ANGLE", 0, true );
3894 createSMESHAction( SMESHOp::OpWarpingAngle, "WARP", "ICON_WARP", 0, true );
3895 createSMESHAction( SMESHOp::OpSkew, "SKEW", "ICON_SKEW", 0, true );
3896 createSMESHAction( SMESHOp::OpMaxElementLength2D, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
3897 createSMESHAction( SMESHOp::OpEqualFace, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
3898 createSMESHAction( SMESHOp::OpAspectRatio3D, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
3899 createSMESHAction( SMESHOp::OpVolume, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
3900 createSMESHAction( SMESHOp::OpMaxElementLength3D, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
3901 createSMESHAction( SMESHOp::OpBareBorderVolume, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
3902 createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
3903 createSMESHAction( SMESHOp::OpEqualVolume, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
3904 createSMESHAction( SMESHOp::OpOverallMeshQuality, "OVERALL_MESH_QUALITY" );
3906 createSMESHAction( SMESHOp::OpNode, "NODE", "ICON_DLG_NODE" );
3907 createSMESHAction( SMESHOp::OpElem0D, "ELEM0D", "ICON_DLG_ELEM0D" );
3908 createSMESHAction( SMESHOp::OpElem0DOnElemNodes, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
3909 createSMESHAction( SMESHOp::OpBall, "BALL", "ICON_DLG_BALL" );
3910 createSMESHAction( SMESHOp::OpEdge, "EDGE", "ICON_DLG_EDGE" );
3911 createSMESHAction( SMESHOp::OpTriangle, "TRIANGLE", "ICON_DLG_TRIANGLE" );
3912 createSMESHAction( SMESHOp::OpQuadrangle, "QUAD", "ICON_DLG_QUADRANGLE" );
3913 createSMESHAction( SMESHOp::OpPolygon, "POLYGON", "ICON_DLG_POLYGON" );
3914 createSMESHAction( SMESHOp::OpTetrahedron, "TETRA", "ICON_DLG_TETRAS" );
3915 createSMESHAction( SMESHOp::OpHexahedron, "HEXA", "ICON_DLG_HEXAS" );
3916 createSMESHAction( SMESHOp::OpPentahedron, "PENTA", "ICON_DLG_PENTA" );
3917 createSMESHAction( SMESHOp::OpPyramid , "PYRAMID", "ICON_DLG_PYRAMID" );
3918 createSMESHAction( SMESHOp::OpHexagonalPrism, "OCTA", "ICON_DLG_OCTA" );
3919 createSMESHAction( SMESHOp::OpPolyhedron, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
3920 createSMESHAction( SMESHOp::OpQuadraticEdge, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
3921 createSMESHAction( SMESHOp::OpQuadraticTriangle, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
3922 createSMESHAction( SMESHOp::OpBiQuadraticTriangle, "BIQUADRATIC_TRIANGLE", "ICON_DLG_BIQUADRATIC_TRIANGLE" );
3923 createSMESHAction( SMESHOp::OpQuadraticQuadrangle, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
3924 createSMESHAction( SMESHOp::OpBiQuadraticQuadrangle, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
3925 createSMESHAction( SMESHOp::OpQuadraticPolygon, "QUADRATIC_POLYGON", "ICON_DLG_QUADRATIC_POLYGON" );
3926 createSMESHAction( SMESHOp::OpQuadraticTetrahedron, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
3927 createSMESHAction( SMESHOp::OpQuadraticPyramid, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
3928 createSMESHAction( SMESHOp::OpQuadraticPentahedron, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
3929 createSMESHAction( SMESHOp::OpQuadraticHexahedron, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
3930 createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
3932 createSMESHAction( SMESHOp::OpRemoveNodes, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
3933 createSMESHAction( SMESHOp::OpRemoveElements, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
3934 createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
3935 createSMESHAction( SMESHOp::OpClearMesh, "CLEAR_MESH", "ICON_CLEAR_MESH" );
3937 //createSMESHAction( SMESHOp::OpRenumberingNodes, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
3938 //createSMESHAction( SMESHOp::OpRenumberingElements, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
3940 createSMESHAction( SMESHOp::OpTranslation, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
3941 createSMESHAction( SMESHOp::OpRotation, "ROT", "ICON_DLG_MESH_ROTATION" );
3942 createSMESHAction( SMESHOp::OpSymmetry, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
3943 createSMESHAction( SMESHOp::OpScale, "SCALE", "ICON_DLG_MESH_SCALE" );
3944 createSMESHAction( SMESHOp::OpSewing, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
3945 createSMESHAction( SMESHOp::OpMergeNodes, "MERGE", "ICON_SMESH_MERGE_NODES" );
3946 createSMESHAction( SMESHOp::OpMergeElements, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
3947 createSMESHAction( SMESHOp::OpMoveNode, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
3948 createSMESHAction( SMESHOp::OpDuplicateNodes, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
3949 createSMESHAction( SMESHOp::OpDiagonalInversion, "INV", "ICON_DLG_MESH_DIAGONAL" );
3950 createSMESHAction( SMESHOp::OpUnionOfTwoTriangle, "UNION2", "ICON_UNION2TRI" );
3951 createSMESHAction( SMESHOp::OpOrientation, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
3952 createSMESHAction( SMESHOp::OpReorientFaces, "REORIENT_2D", "ICON_REORIENT_2D" );
3953 createSMESHAction( SMESHOp::OpUnionOfTriangles, "UNION", "ICON_UNIONTRI" );
3954 createSMESHAction( SMESHOp::OpCuttingOfQuadrangles, "CUT", "ICON_CUTQUAD" );
3955 createSMESHAction( SMESHOp::OpSplitVolumes, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
3956 createSMESHAction( SMESHOp::OpSplitBiQuadratic, "SPLIT_BIQUAD", "ICON_SPLIT_BIQUAD" );
3957 createSMESHAction( SMESHOp::OpSmoothing, "SMOOTH", "ICON_DLG_SMOOTHING" );
3958 createSMESHAction( SMESHOp::OpExtrusion, "EXTRUSION", "ICON_EXTRUSION" );
3959 createSMESHAction( SMESHOp::OpExtrusionAlongAPath, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
3960 createSMESHAction( SMESHOp::OpRevolution, "REVOLUTION", "ICON_REVOLUTION" );
3961 createSMESHAction( SMESHOp::OpPatternMapping, "MAP", "ICON_MAP" );
3962 createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
3963 createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D", "ICON_2D_FROM_3D" );
3965 createSMESHAction( SMESHOp::OpReset, "RESET" );
3966 createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
3967 createSMESHAction( SMESHOp::OpShowScalarBar, "SHOW_SCALAR_BAR","",0, true );
3968 createSMESHAction( SMESHOp::OpSaveDistribution, "SAVE_DISTRIBUTION" );
3969 createSMESHAction( SMESHOp::OpShowDistribution, "SHOW_DISTRIBUTION","",0, true );
3970 #ifndef DISABLE_PLOT2DVIEWER
3971 createSMESHAction( SMESHOp::OpPlotDistribution, "PLOT_DISTRIBUTION" );
3973 createSMESHAction( SMESHOp::OpDMWireframe, "WIRE", "ICON_WIRE", 0, true );
3974 createSMESHAction( SMESHOp::OpDMShading, "SHADE", "ICON_SHADE", 0, true );
3975 createSMESHAction( SMESHOp::OpDMNodes, "NODES", "ICON_POINTS", 0, true );
3976 createSMESHAction( SMESHOp::OpDMShrink, "SHRINK", "ICON_SHRINK", 0, true );
3977 createSMESHAction( SMESHOp::OpUpdate, "UPDATE", "ICON_UPDATE" );
3978 createSMESHAction( SMESHOp::OpDE0DElements, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
3979 createSMESHAction( SMESHOp::OpDEEdges, "EDGES", "ICON_DLG_EDGE", 0, true );
3980 createSMESHAction( SMESHOp::OpDEFaces, "FACES", "ICON_DLG_TRIANGLE", 0, true );
3981 createSMESHAction( SMESHOp::OpDEVolumes, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
3982 createSMESHAction( SMESHOp::OpDEBalls, "BALLS", "ICON_DLG_BALL", 0, true );
3983 createSMESHAction( SMESHOp::OpDEChoose, "CHOOSE", "ICON_DLG_CHOOSE", 0, false );
3984 createSMESHAction( SMESHOp::OpDEAllEntity, "ALL", "ICON_DLG_CHOOSE_ALL", 0, false );
3985 createSMESHAction( SMESHOp::OpOrientationOnFaces, "FACE_ORIENTATION", "", 0, true );
3987 createSMESHAction( SMESHOp::OpRepresentationLines, "LINE_REPRESENTATION", "", 0, true );
3988 createSMESHAction( SMESHOp::OpRepresentationArcs, "ARC_REPRESENTATION", "", 0, true );
3990 createSMESHAction( SMESHOp::OpEditHypothesis, "EDIT_HYPO" );
3991 createSMESHAction( SMESHOp::OpUnassign, "UNASSIGN" );
3992 createSMESHAction( SMESHOp::OpNumberingNodes, "NUM_NODES", "", 0, true );
3993 createSMESHAction( SMESHOp::OpNumberingElements, "NUM_ELEMENTS", "", 0, true );
3994 createSMESHAction( SMESHOp::OpProperties, "COLORS" );
3995 createSMESHAction( SMESHOp::OpTransparency, "TRANSP" );
3996 createSMESHAction( SMESHOp::OpClipping, "CLIP" );
3997 createSMESHAction( SMESHOp::OpAutoColor, "AUTO_COLOR" );
3998 createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
4000 createSMESHAction( SMESHOp::OpMinimumDistance, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
4001 createSMESHAction( SMESHOp::OpBoundingBox, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
4002 createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH", "ICON_MEASURE_LENGTH" );
4003 createSMESHAction( SMESHOp::OpPropertiesArea, "MEASURE_AREA", "ICON_MEASURE_AREA" );
4004 createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME", "ICON_MEASURE_VOLUME" );
4006 createSMESHAction( SMESHOp::OpHide, "HIDE" );
4007 createSMESHAction( SMESHOp::OpShow, "SHOW" );
4008 createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
4010 createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
4012 QList<int> aCtrlActions;
4013 aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode
4014 << SMESHOp::OpNodeConnectivityNb // node controls
4015 << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
4016 << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge // edge controls
4017 << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
4018 << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
4019 << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
4020 << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
4021 << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace // face controls
4022 << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
4023 << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
4024 << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume; // volume controls
4025 QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
4026 aCtrlGroup->setExclusive( true );
4027 for( int i = 0; i < aCtrlActions.size(); i++ )
4028 aCtrlGroup->addAction( action( aCtrlActions[i] ) );
4030 // ----- create menu --------------
4031 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
4032 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
4033 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
4034 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
4035 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
4036 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
4037 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
4038 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
4040 createMenu( separator(), fileId );
4042 QMenu* nodeMenu = new QMenu(); QMenu* edgeMenu = new QMenu();
4043 QMenu* faceMenu = new QMenu(); QMenu* volumeMenu = new QMenu();
4044 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
4045 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
4046 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10, -1, nodeMenu ),
4047 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10, -1, edgeMenu ),
4048 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10, -1, faceMenu ),
4049 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10, -1, volumeMenu ),
4050 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
4051 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
4052 //renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
4053 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
4054 basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
4056 //createMenu( SMESHOp::OpImportDAT, importId, -1 );
4057 createMenu( SMESHOp::OpImportUNV, importId, -1 );
4058 createMenu( SMESHOp::OpImportMED, importId, -1 );
4059 createMenu( SMESHOp::OpImportSTL, importId, -1 );
4061 createMenu( SMESHOp::OpImportCGNS, importId, -1 );
4063 createMenu( SMESHOp::OpImportSAUV, importId, -1 );
4064 createMenu( SMESHOp::OpImportGMF, importId, -1 );
4065 createMenu( SMESHOp::OpExportDAT, exportId, -1 );
4066 createMenu( SMESHOp::OpExportMED, exportId, -1 );
4067 createMenu( SMESHOp::OpExportUNV, exportId, -1 );
4068 createMenu( SMESHOp::OpExportSTL, exportId, -1 );
4070 createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
4072 createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
4073 createMenu( SMESHOp::OpExportGMF, exportId, -1 );
4074 createMenu( separator(), fileId, 10 );
4076 createMenu( SMESHOp::OpDelete, editId, -1 );
4078 createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
4080 createMenu( SMESHOp::OpCreateMesh, meshId, -1 ); // "Mesh" menu
4081 createMenu( SMESHOp::OpCreateSubMesh, meshId, -1 );
4082 createMenu( SMESHOp::OpEditMeshOrSubMesh, meshId, -1 );
4083 createMenu( SMESHOp::OpBuildCompoundMesh, meshId, -1 );
4084 createMenu( SMESHOp::OpCopyMesh, meshId, -1 );
4085 createMenu( separator(), meshId, -1 );
4086 createMenu( SMESHOp::OpCompute, meshId, -1 );
4087 createMenu( SMESHOp::OpPreCompute, meshId, -1 );
4088 createMenu( SMESHOp::OpEvaluate, meshId, -1 );
4089 createMenu( SMESHOp::OpMeshOrder, meshId, -1 );
4090 createMenu( separator(), meshId, -1 );
4091 createMenu( SMESHOp::OpCreateGroup, meshId, -1 );
4092 createMenu( SMESHOp::OpCreateGeometryGroup, meshId, -1 );
4093 createMenu( SMESHOp::OpConstructGroup, meshId, -1 );
4094 createMenu( SMESHOp::OpEditGroup, meshId, -1 );
4095 createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4096 createMenu( separator(), meshId, -1 );
4097 createMenu( SMESHOp::OpUnionGroups, meshId, -1 );
4098 createMenu( SMESHOp::OpIntersectGroups, meshId, -1 );
4099 createMenu( SMESHOp::OpCutGroups, meshId, -1 );
4100 createMenu( separator(), meshId, -1 );
4101 createMenu( SMESHOp::OpGroupUnderlyingElem, meshId, -1 );
4102 createMenu( separator(), meshId, -1 );
4103 createMenu( SMESHOp::OpMeshInformation, meshId, -1 );
4104 //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4105 //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4106 createMenu( SMESHOp::OpFindElementByPoint, meshId, -1 );
4107 createMenu( separator(), meshId, -1 );
4109 createMenu( SMESHOp::OpFreeNode, nodeId, -1 );
4110 createMenu( SMESHOp::OpEqualNode, nodeId, -1 );
4111 //createMenu( SMESHOp::OpNodeConnectivityNb, nodeId, -1 );
4112 createMenu( SMESHOp::OpFreeBorder, edgeId, -1 );
4113 createMenu( SMESHOp::OpLength, edgeId, -1 );
4114 createMenu( SMESHOp::OpConnection, edgeId, -1 );
4115 createMenu( SMESHOp::OpEqualEdge, edgeId, -1 );
4116 createMenu( SMESHOp::OpFreeEdge, faceId, -1 );
4117 createMenu( SMESHOp::OpFreeFace, faceId, -1 );
4118 createMenu( SMESHOp::OpBareBorderFace, faceId, -1 );
4119 createMenu( SMESHOp::OpOverConstrainedFace, faceId, -1 );
4120 createMenu( SMESHOp::OpLength2D, faceId, -1 );
4121 createMenu( SMESHOp::OpConnection2D, faceId, -1 );
4122 createMenu( SMESHOp::OpArea, faceId, -1 );
4123 createMenu( SMESHOp::OpTaper, faceId, -1 );
4124 createMenu( SMESHOp::OpAspectRatio, faceId, -1 );
4125 createMenu( SMESHOp::OpMinimumAngle, faceId, -1 );
4126 createMenu( SMESHOp::OpWarpingAngle, faceId, -1 );
4127 createMenu( SMESHOp::OpSkew, faceId, -1 );
4128 createMenu( SMESHOp::OpMaxElementLength2D, faceId, -1 );
4129 createMenu( SMESHOp::OpEqualFace, faceId, -1 );
4130 createMenu( SMESHOp::OpAspectRatio3D, volumeId, -1 );
4131 createMenu( SMESHOp::OpVolume, volumeId, -1 );
4132 createMenu( SMESHOp::OpMaxElementLength3D, volumeId, -1 );
4133 createMenu( SMESHOp::OpBareBorderVolume, volumeId, -1 );
4134 createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4135 createMenu( SMESHOp::OpEqualVolume, volumeId, -1 );
4136 createMenu( separator(), ctrlId, -1 );
4137 createMenu( SMESHOp::OpReset, ctrlId, -1 );
4138 createMenu( separator(), ctrlId, -1 );
4139 createMenu( SMESHOp::OpOverallMeshQuality, ctrlId, -1 );
4141 createMenu( SMESHOp::OpNode, addId, -1 );
4142 createMenu( SMESHOp::OpElem0D, addId, -1 );
4143 createMenu( SMESHOp::OpElem0DOnElemNodes, addId, -1 );
4144 createMenu( SMESHOp::OpBall, addId, -1 );
4145 createMenu( SMESHOp::OpEdge, addId, -1 );
4146 createMenu( SMESHOp::OpTriangle, addId, -1 );
4147 createMenu( SMESHOp::OpQuadrangle, addId, -1 );
4148 createMenu( SMESHOp::OpPolygon, addId, -1 );
4149 createMenu( SMESHOp::OpTetrahedron, addId, -1 );
4150 createMenu( SMESHOp::OpHexahedron, addId, -1 );
4151 createMenu( SMESHOp::OpPentahedron, addId, -1 );
4152 createMenu( SMESHOp::OpPyramid, addId, -1 );
4153 createMenu( SMESHOp::OpHexagonalPrism, addId, -1 );
4154 createMenu( SMESHOp::OpPolyhedron, addId, -1 );
4155 createMenu( separator(), addId, -1 );
4156 createMenu( SMESHOp::OpQuadraticEdge, addId, -1 );
4157 createMenu( SMESHOp::OpQuadraticTriangle, addId, -1 );
4158 createMenu( SMESHOp::OpBiQuadraticTriangle , addId, -1 );
4159 createMenu( SMESHOp::OpQuadraticQuadrangle, addId, -1 );
4160 createMenu( SMESHOp::OpBiQuadraticQuadrangle, addId, -1 );
4161 createMenu( SMESHOp::OpQuadraticPolygon, addId, -1 );
4162 createMenu( SMESHOp::OpQuadraticTetrahedron, addId, -1 );
4163 createMenu( SMESHOp::OpQuadraticPyramid, addId, -1 );
4164 createMenu( SMESHOp::OpQuadraticPentahedron, addId, -1 );
4165 createMenu( SMESHOp::OpQuadraticHexahedron, addId, -1 );
4166 createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4168 createMenu( SMESHOp::OpRemoveNodes, removeId, -1 );
4169 createMenu( SMESHOp::OpRemoveElements, removeId, -1 );
4170 createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4171 createMenu( separator(), removeId, -1 );
4172 createMenu( SMESHOp::OpDeleteGroup, removeId, -1 );
4173 createMenu( separator(), removeId, -1 );
4174 createMenu( SMESHOp::OpClearMesh, removeId, -1 );
4176 //createMenu( SMESHOp::OpRenumberingNodes, renumId, -1 );
4177 //createMenu( SMESHOp::OpRenumberingElements, renumId, -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::OpSewing, transfId, -1 );
4184 createMenu( SMESHOp::OpMergeNodes, transfId, -1 );
4185 createMenu( SMESHOp::OpMergeElements, transfId, -1 );
4186 createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4188 createMenu( SMESHOp::OpMoveNode, modifyId, -1 );
4189 createMenu( SMESHOp::OpDiagonalInversion, modifyId, -1 );
4190 createMenu( SMESHOp::OpUnionOfTwoTriangle, modifyId, -1 );
4191 createMenu( SMESHOp::OpOrientation, modifyId, -1 );
4192 createMenu( SMESHOp::OpReorientFaces, modifyId, -1 );
4193 createMenu( SMESHOp::OpUnionOfTriangles, modifyId, -1 );
4194 createMenu( SMESHOp::OpCuttingOfQuadrangles, modifyId, -1 );
4195 createMenu( SMESHOp::OpSplitVolumes, modifyId, -1 );
4196 createMenu( SMESHOp::OpSplitBiQuadratic, modifyId, -1 );
4197 createMenu( SMESHOp::OpSmoothing, modifyId, -1 );
4198 createMenu( SMESHOp::OpExtrusion, modifyId, -1 );
4199 createMenu( SMESHOp::OpExtrusionAlongAPath , modifyId, -1 );
4200 createMenu( SMESHOp::OpRevolution, modifyId, -1 );
4201 createMenu( SMESHOp::OpPatternMapping, modifyId, -1 );
4202 createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4203 createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4205 createMenu( SMESHOp::OpMinimumDistance, measureId, -1 );
4206 createMenu( SMESHOp::OpBoundingBox, measureId, -1 );
4207 createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4208 createMenu( SMESHOp::OpPropertiesArea, basicPropId, -1 );
4209 createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4210 createMenu( SMESHOp::OpUpdate, viewId, -1 );
4212 connect( nodeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4213 connect( edgeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4214 connect( faceMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4215 connect( volumeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4217 // ----- create toolbars --------------
4218 int meshTb = createTool( tr( "TB_MESH" ), QString( "SMESHMeshToolbar" ) ),
4219 info = createTool( tr( "TB_INFO" ), QString( "SMESHInformationToolbar" ) ),
4220 groupTb = createTool( tr( "TB_GROUP" ), QString( "SMESHGroupToolbar" ) ),
4221 ctrl0dTb = createTool( tr( "TB_CTRL0D" ), QString( "SMESHNodeControlsToolbar" ) ),
4222 ctrl1dTb = createTool( tr( "TB_CTRL1D" ), QString( "SMESHEdgeControlsToolbar" ) ),
4223 ctrl2dTb = createTool( tr( "TB_CTRL2D" ), QString( "SMESHFaceControlsToolbar" ) ),
4224 ctrl3dTb = createTool( tr( "TB_CTRL3D" ), QString( "SMESHVolumeControlsToolbar" ) ),
4225 addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ),
4226 addNonElemTb = createTool( tr( "TB_ADDNON" ), QString( "SMESHAddElementToolbar" ) ),
4227 remTb = createTool( tr( "TB_REM" ), QString( "SMESHRemoveToolbar" ) ),
4228 //renumbTb = createTool( tr( "TB_RENUMBER" ), QString( "SMESHRenumberingToolbar" ) ),
4229 transformTb = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ),
4230 modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ),
4231 measuremTb = createTool( tr( "TB_MEASUREM" ), QString( "SMESHMeasurementsToolbar" ) ),
4232 dispModeTb = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4234 createTool( SMESHOp::OpCreateMesh, meshTb );
4235 createTool( SMESHOp::OpCreateSubMesh, meshTb );
4236 createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4237 createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4238 createTool( SMESHOp::OpCopyMesh, meshTb );
4239 createTool( separator(), meshTb );
4240 createTool( SMESHOp::OpCompute, meshTb );
4241 createTool( SMESHOp::OpPreCompute, meshTb );
4242 createTool( SMESHOp::OpEvaluate, meshTb );
4243 createTool( SMESHOp::OpMeshOrder, meshTb );
4245 createTool( SMESHOp::OpCreateGroup, groupTb );
4246 createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4247 createTool( SMESHOp::OpConstructGroup, groupTb );
4248 createTool( SMESHOp::OpEditGroup, groupTb );
4250 createTool( SMESHOp::OpMeshInformation, info );
4251 //createTool( SMESHOp::OpStdInfo, meshTb );
4252 //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4253 createTool( SMESHOp::OpFindElementByPoint, info );
4255 createTool( SMESHOp::OpFreeNode, ctrl0dTb );
4256 createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4257 //createTool( SMESHOp::OpNodeConnectivityNb, ctrl0dTb );
4259 createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4260 createTool( SMESHOp::OpLength, ctrl1dTb );
4261 createTool( SMESHOp::OpConnection, ctrl1dTb );
4262 createTool( SMESHOp::OpEqualEdge, ctrl1dTb );
4264 createTool( SMESHOp::OpFreeEdge, ctrl2dTb );
4265 createTool( SMESHOp::OpFreeFace, ctrl2dTb );
4266 createTool( SMESHOp::OpBareBorderFace, ctrl2dTb );
4267 createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4268 createTool( SMESHOp::OpLength2D, ctrl2dTb );
4269 createTool( SMESHOp::OpConnection2D, ctrl2dTb );
4270 createTool( SMESHOp::OpArea, ctrl2dTb );
4271 createTool( SMESHOp::OpTaper, ctrl2dTb );
4272 createTool( SMESHOp::OpAspectRatio, ctrl2dTb );
4273 createTool( SMESHOp::OpMinimumAngle, ctrl2dTb );
4274 createTool( SMESHOp::OpWarpingAngle, ctrl2dTb );
4275 createTool( SMESHOp::OpSkew, ctrl2dTb );
4276 createTool( SMESHOp::OpMaxElementLength2D, ctrl2dTb );
4277 createTool( SMESHOp::OpEqualFace, 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::OpQuadraticHexahedron, addNonElemTb );
4311 createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4313 createTool( SMESHOp::OpRemoveNodes, remTb );
4314 createTool( SMESHOp::OpRemoveElements, remTb );
4315 createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4316 createTool( SMESHOp::OpClearMesh, remTb );
4318 //createTool( SMESHOp::OpRenumberingNodes, renumbTb );
4319 //createTool( SMESHOp::OpRenumberingElements, renumbTb );
4321 createTool( SMESHOp::OpTranslation, transformTb );
4322 createTool( SMESHOp::OpRotation, transformTb );
4323 createTool( SMESHOp::OpSymmetry, transformTb );
4324 createTool( SMESHOp::OpScale, transformTb );
4325 createTool( SMESHOp::OpSewing, transformTb );
4326 createTool( SMESHOp::OpMergeNodes, transformTb );
4327 createTool( SMESHOp::OpMergeElements, transformTb );
4328 createTool( SMESHOp::OpDuplicateNodes, transformTb );
4330 createTool( SMESHOp::OpMoveNode, modifyTb );
4331 createTool( SMESHOp::OpDiagonalInversion, modifyTb );
4332 createTool( SMESHOp::OpUnionOfTwoTriangle, modifyTb );
4333 createTool( SMESHOp::OpOrientation, modifyTb );
4334 createTool( SMESHOp::OpReorientFaces, modifyTb );
4335 createTool( SMESHOp::OpUnionOfTriangles, modifyTb );
4336 createTool( SMESHOp::OpCuttingOfQuadrangles, modifyTb );
4337 createTool( SMESHOp::OpSplitVolumes, modifyTb );
4338 createTool( SMESHOp::OpSplitBiQuadratic, modifyTb );
4339 createTool( SMESHOp::OpSmoothing, modifyTb );
4340 createTool( SMESHOp::OpExtrusion, modifyTb );
4341 createTool( SMESHOp::OpExtrusionAlongAPath, modifyTb );
4342 createTool( SMESHOp::OpRevolution, modifyTb );
4343 createTool( SMESHOp::OpPatternMapping, modifyTb );
4344 createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4345 createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4347 createTool( SMESHOp::OpMinimumDistance, measuremTb );
4349 createTool( SMESHOp::OpUpdate, dispModeTb );
4351 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4352 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4356 OB = "'ObjectBrowser'",
4357 View = "'" + SVTK_Viewer::Type() + "'",
4359 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4360 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4361 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4362 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4363 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4364 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4365 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4366 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4367 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4368 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4369 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4371 mesh_part = mesh + " " + subMesh + " " + group,
4372 mesh_group = mesh + " " + group,
4373 mesh_submesh = mesh + " " + subMesh,
4374 hyp_alg = hypo + " " + algo;
4376 // popup for object browser
4378 isInvisible("not( isVisible )"),
4379 isEmpty("numberOfNodes = 0"),
4380 isNotEmpty("numberOfNodes <> 0"),
4382 // has nodes, edges, etc in VISIBLE! actor
4383 hasNodes("(numberOfNodes > 0 ) && hasActor"),
4384 hasElems("(count( elemTypes ) > 0)"),
4385 hasDifferentElems("(count( elemTypes ) > 1)"),
4386 hasBalls("({'BallElem'} in elemTypes)"),
4387 hasElems0d("({'Elem0d'} in elemTypes)"),
4388 hasEdges("({'Edge'} in elemTypes)"),
4389 hasFaces("({'Face'} in elemTypes)"),
4390 hasVolumes("({'Volume'} in elemTypes)"),
4391 hasFacesOrVolumes("(({'Face'} in elemTypes) || ({'Volume'} in elemTypes)) ");
4393 createPopupItem( SMESHOp::OpFileInformation, OB, mesh, "&& selcount=1 && isImported" );
4394 createPopupItem( SMESHOp::OpCreateSubMesh, OB, mesh, "&& hasGeomReference");
4395 createPopupItem( SMESHOp::OpEditMesh, OB, mesh, "&& selcount=1" );
4396 createPopupItem( SMESHOp::OpEditSubMesh, OB, subMesh, "&& selcount=1 && hasGeomReference" );
4397 createPopupItem( SMESHOp::OpEditGroup, OB, group );
4398 createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4400 popupMgr()->insert( separator(), -1, 0 );
4401 createPopupItem( SMESHOp::OpCompute, OB, mesh, "&& selcount=1 && isComputable" );
4402 createPopupItem( SMESHOp::OpComputeSubMesh, OB, subMesh, "&& selcount=1 && isComputable" );
4403 createPopupItem( SMESHOp::OpPreCompute, OB, mesh, "&& selcount=1 && isPreComputable" );
4404 createPopupItem( SMESHOp::OpEvaluate, OB, mesh, "&& selcount=1 && isComputable" );
4405 createPopupItem( SMESHOp::OpMeshOrder, OB, mesh, "&& selcount=1 && isComputable && hasGeomReference" );
4406 createPopupItem( SMESHOp::OpUpdate, OB, mesh_part );
4407 createPopupItem( SMESHOp::OpMeshInformation, OB, mesh_part );
4408 createPopupItem( SMESHOp::OpFindElementByPoint,OB, mesh_group, "&& selcount=1" );
4409 createPopupItem( SMESHOp::OpOverallMeshQuality,OB, mesh_part );
4410 popupMgr()->insert( separator(), -1, 0 );
4411 createPopupItem( SMESHOp::OpCreateGroup, OB, mesh, "&& selcount=1" );
4412 createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh, "&& selcount=1 && hasGeomReference" );
4413 createPopupItem( SMESHOp::OpConstructGroup, OB, subMesh );
4414 popupMgr()->insert( separator(), -1, 0 );
4415 createPopupItem( SMESHOp::OpEditHypothesis, OB, hypo, "&& isEditableHyp");
4416 createPopupItem( SMESHOp::OpUnassign, OB, hyp_alg );
4417 popupMgr()->insert( separator(), -1, 0 );
4418 createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh_submesh );
4419 createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh_group, "&& selcount=1 && dim>=2");
4420 popupMgr()->insert( separator(), -1, 0 );
4421 createPopupItem( SMESHOp::OpClearMesh, OB, mesh );
4422 //popupMgr()->insert( separator(), -1, 0 );
4424 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4425 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4426 QString only_one_2D = only_one_non_empty + " && dim>1";
4428 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4429 createPopupItem( SMESHOp::OpPopupExportMED, OB, mesh_group, multiple_non_empty, anId );
4430 createPopupItem( SMESHOp::OpPopupExportUNV, OB, mesh_group, only_one_non_empty, anId );
4431 createPopupItem( SMESHOp::OpPopupExportSTL, OB, mesh_group, only_one_2D, anId );
4433 createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4435 createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, only_one_non_empty, anId );
4436 createPopupItem( SMESHOp::OpPopupExportGMF, OB, mesh_group, only_one_non_empty, anId );
4437 createPopupItem( SMESHOp::OpPopupExportDAT, OB, mesh_group, only_one_non_empty, anId );
4438 createPopupItem( SMESHOp::OpDelete, OB, mesh_part + " " + hyp_alg );
4439 createPopupItem( SMESHOp::OpDeleteGroup, OB, group );
4440 popupMgr()->insert( separator(), -1, 0 );
4443 createPopupItem( SMESHOp::OpEditGroup, View, group );
4444 createPopupItem( SMESHOp::OpAddElemGroupPopup, View, elems );
4445 createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems );
4447 popupMgr()->insert( separator(), -1, 0 );
4448 createPopupItem( SMESHOp::OpUpdate, View, mesh_part );
4449 createPopupItem( SMESHOp::OpMeshInformation, View, mesh_part );
4450 createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4451 createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh );
4452 popupMgr()->insert( separator(), -1, 0 );
4454 createPopupItem( SMESHOp::OpAutoColor, OB + " " + View, mesh, "&& (not isAutoColor)" );
4455 createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4456 popupMgr()->insert( separator(), -1, 0 );
4458 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4459 QString aType = QString( "%1type in {%2}" ).arg( lc );
4460 aType = aType.arg( mesh_part );
4461 QString aMeshInVTK = aClient + "&&" + aType;
4463 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4464 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4465 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4467 //-------------------------------------------------
4469 //-------------------------------------------------
4470 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4472 popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4473 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4474 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4476 popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4477 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4478 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4480 popupMgr()->insert( separator(), -1, -1 );
4482 //-------------------------------------------------
4484 //-------------------------------------------------
4485 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4487 popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4488 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4489 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4491 popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4492 popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4493 popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4495 popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4496 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes, QtxPopupMgr::VisibleRule );
4497 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4499 popupMgr()->insert( separator(), anId, -1 );
4501 popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4502 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4503 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4505 //-------------------------------------------------
4507 //-------------------------------------------------
4508 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4510 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4512 popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4513 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4514 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4516 popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4517 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4518 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4520 popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4521 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4522 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4524 popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4525 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4526 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4528 popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4529 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4530 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4532 popupMgr()->insert( separator(), anId, -1 );
4534 popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4535 popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&& $type in {" + mesh + "} &&" + isNotEmpty, QtxPopupMgr::VisibleRule );
4537 popupMgr()->insert( separator(), anId, -1 );
4539 popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4540 popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4543 //-------------------------------------------------
4544 // Representation of the 2D Quadratic elements
4545 //-------------------------------------------------
4546 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4547 popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4548 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "&& isVisible && isQuadratic",QtxPopupMgr::VisibleRule );
4549 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4551 popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4552 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "&& isVisible && isQuadratic", QtxPopupMgr::VisibleRule );
4553 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4555 //-------------------------------------------------
4556 // Orientation of faces
4557 //-------------------------------------------------
4558 popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4559 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4560 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4562 //-------------------------------------------------
4564 //-------------------------------------------------
4565 popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4566 popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4568 //-------------------------------------------------
4570 //-------------------------------------------------
4571 popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4572 popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4574 //-------------------------------------------------
4576 //-------------------------------------------------
4578 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4579 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4580 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4581 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4583 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4585 popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4586 popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4588 popupMgr()->insert( separator(), anId, -1 );
4590 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4592 popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4593 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4594 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4596 popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4597 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4598 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4600 // popupMgr()->insert( action( SMESHOp::OpNodeConnectivityNb ), aSubId, -1 );
4601 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4602 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), "controlMode = 'eNodeConnectivityNb'", QtxPopupMgr::ToggleRule );
4604 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4606 popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4607 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVTK + "&&" + hasEdges + "&&" + hasFacesOrVolumes, QtxPopupMgr::VisibleRule );
4608 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4610 popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4611 popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4612 popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4614 popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4615 popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4616 popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4617 popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4618 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4619 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4621 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4623 popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4624 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4625 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4627 popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4628 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4629 QtxPopupMgr::VisibleRule );
4630 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4632 popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4633 popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4634 popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4636 popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4637 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4638 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4640 popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
4641 popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4642 popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4644 popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
4645 popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4646 popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4648 popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
4649 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4650 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4652 popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
4653 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4654 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4656 popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
4657 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4658 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4660 popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
4661 popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4662 popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4664 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
4665 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4666 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4668 popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
4669 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4670 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4672 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
4673 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4674 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4675 popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
4676 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4677 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4679 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4681 popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D ), aSubId, -1 );
4682 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4683 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4685 popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
4686 popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4687 popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4689 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
4690 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4691 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4693 popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
4694 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4695 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4697 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
4698 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4699 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4701 popupMgr()->insert ( action( SMESHOp::OpEqualVolume ), aSubId, -1 );
4702 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4703 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4705 popupMgr()->insert( separator(), anId, -1 );
4707 popupMgr()->insert( action( SMESHOp::OpShowScalarBar ), anId, -1 );
4708 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4709 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone' && isScalarBarVisible", QtxPopupMgr::ToggleRule );
4710 popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
4711 popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4713 popupMgr()->insert( separator(), anId, -1 );
4715 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4717 popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
4718 popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4720 popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
4721 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4722 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isScalarBarVisible && isDistributionVisible", QtxPopupMgr::ToggleRule);
4724 #ifndef DISABLE_PLOT2DVIEWER
4725 popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
4726 popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4729 //-------------------------------------------------
4731 //-------------------------------------------------
4732 popupMgr()->insert( separator(), -1, -1 );
4733 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4734 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4735 popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
4736 popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4738 popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
4739 popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4741 popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
4742 popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4744 popupMgr()->insert( separator(), -1, -1 );
4746 //-------------------------------------------------
4748 //-------------------------------------------------
4749 popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
4750 popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4752 popupMgr()->insert( separator(), -1, -1 );
4754 popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
4755 popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
4756 popupMgr()->insert( separator(), -1, -1 );
4758 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4759 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4761 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4762 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4765 //================================================================================
4767 * \brief Return true if SMESH or GEOM objects are selected.
4768 * Is called form LightApp_Module::activateModule() which clear selection if
4769 * not isSelectionCompatible()
4771 //================================================================================
4773 bool SMESHGUI::isSelectionCompatible()
4775 bool isCompatible = true;
4776 SALOME_ListIO selected;
4777 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4778 Sel->selectedObjects( selected );
4780 SALOME_ListIteratorOfListIO It( selected );
4781 for ( ; isCompatible && It.More(); It.Next())
4783 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4784 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4786 return isCompatible;
4790 bool SMESHGUI::reusableOperation( const int id )
4792 // compute, evaluate and precompute are not reusable operations
4793 return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate ) ? false : SalomeApp_Module::reusableOperation( id );
4796 bool SMESHGUI::activateModule( SUIT_Study* study )
4798 bool res = SalomeApp_Module::activateModule( study );
4800 setMenuShown( true );
4801 setToolShown( true );
4803 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4804 PyGILState_STATE gstate = PyGILState_Ensure();
4805 PyObject* pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4806 if ( !pluginsmanager ) {
4810 PyObject* result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toUtf8().data(),tr("SMESH_PLUGINS_OTHER").toUtf8().data());
4815 PyGILState_Release(gstate);
4816 // end of SMESH plugins loading
4818 // Reset actions accelerator keys
4819 action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
4821 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4822 GetSMESHGen()->SetCurrentStudy(SALOMEDS::Study::_nil());
4823 if ( SalomeApp_Study* s = dynamic_cast<SalomeApp_Study*>( study )) {
4824 if ( _PTR(Study) aStudy = s->studyDS() )
4825 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
4828 // get all view currently opened in the study and connect their signals to
4829 // the corresponding slots of the class.
4830 SUIT_Desktop* aDesk = study->application()->desktop();
4832 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4833 SUIT_ViewWindow* wnd;
4834 foreach ( wnd, wndList )
4838 Py_XDECREF(pluginsmanager);
4842 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4844 setMenuShown( false );
4845 setToolShown( false );
4847 EmitSignalCloseAllDialogs();
4849 // Unset actions accelerator keys
4850 action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
4852 return SalomeApp_Module::deactivateModule( study );
4855 void SMESHGUI::studyClosed( SUIT_Study* s )
4859 SMESH::RemoveVisuData( s->id() );
4860 SalomeApp_Module::studyClosed( s );
4863 void SMESHGUI::OnGUIEvent()
4865 const QObject* obj = sender();
4866 if ( !obj || !obj->inherits( "QAction" ) )
4868 int id = actionId((QAction*)obj);
4873 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4875 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
4876 if ( CORBA::is_nil( myComponentSMESH ) )
4878 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4880 aGUI.myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4881 return aGUI.myComponentSMESH;
4884 myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4885 return myComponentSMESH;
4888 QString SMESHGUI::engineIOR() const
4890 CORBA::ORB_var anORB = getApp()->orb();
4891 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4892 return QString( anIOR.in() );
4895 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4897 SalomeApp_Module::contextMenuPopup( client, menu, title );
4899 selectionMgr()->selectedObjects( lst );
4900 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4901 Handle(SALOME_InteractiveObject) io = lst.First();
4902 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4903 _PTR(Study) study = appStudy->studyDS();
4904 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4906 QString aName = QString( SMESH::fromUtf8(obj->GetName()) );
4907 while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4908 aName.remove( (aName.length() - 1), 1 );
4914 LightApp_Selection* SMESHGUI::createSelection() const
4916 return new SMESHGUI_Selection();
4919 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4921 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4922 aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
4923 #ifndef DISABLE_PYCONSOLE
4924 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4928 void SMESHGUI::viewManagers( QStringList& list ) const
4930 list.append( SVTK_Viewer::Type() );
4933 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4935 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4936 SMESH::UpdateSelectionProp( this );
4938 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
4939 for(int i = 0; i < aViews.count() ; i++){
4940 SUIT_ViewWindow *sf = aViews[i];
4943 EmitSignalActivatedViewManager();
4947 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
4949 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
4950 myClippingPlaneInfoMap.erase( theViewManager );
4953 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
4955 theActor->AddObserver( SMESH::DeleteActorEvent,
4956 myEventCallbackCommand.GetPointer(),
4960 void SMESHGUI::ProcessEvents( vtkObject* theObject,
4961 unsigned long theEvent,
4962 void* theClientData,
4965 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
4966 if( theObject && (int) theEvent == SMESH::DeleteActorEvent ) {
4967 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
4968 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
4969 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
4970 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
4971 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
4972 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
4973 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
4974 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
4975 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
4976 SMESH::TActorList::iterator anIter3 = anActorList.begin();
4977 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
4978 if( anActor == *anIter3 ) {
4979 anActorList.erase( anIter3 );
4990 void SMESHGUI::createPreferences()
4992 // General tab ------------------------------------------------------------------------
4993 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
4995 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
4996 setPreferenceProperty( autoUpdate, "columns", 2 );
4997 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
4998 setPreferenceProperty( lim, "min", 0 );
4999 setPreferenceProperty( lim, "max", 100000000 );
5000 setPreferenceProperty( lim, "step", 1000 );
5001 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5002 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
5004 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
5005 setPreferenceProperty( dispgroup, "columns", 2 );
5006 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
5008 modes.append( tr("MEN_WIRE") );
5009 modes.append( tr("MEN_SHADE") );
5010 modes.append( tr("MEN_NODES") );
5011 modes.append( tr("MEN_SHRINK") );
5012 QList<QVariant> indices;
5013 indices.append( 0 );
5014 indices.append( 1 );
5015 indices.append( 2 );
5016 indices.append( 3 );
5017 setPreferenceProperty( dispmode, "strings", modes );
5018 setPreferenceProperty( dispmode, "indexes", indices );
5020 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
5021 setPreferenceProperty( arcgroup, "columns", 2 );
5022 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
5023 QStringList quadraticModes;
5024 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
5025 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
5027 indices.append( 0 );
5028 indices.append( 1 );
5029 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
5030 setPreferenceProperty( quadraticmode, "indexes", indices );
5032 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
5033 "SMESH", "max_angle" );
5034 setPreferenceProperty( maxAngle, "min", 1 );
5035 setPreferenceProperty( maxAngle, "max", 90 );
5037 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
5038 setPreferenceProperty( qaGroup, "columns", 2 );
5039 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
5040 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
5041 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
5042 setPreferenceProperty( prec, "min", 0 );
5043 setPreferenceProperty( prec, "max", 100 );
5044 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
5045 setPreferenceProperty( doubleNodesTol, "precision", 10 );
5046 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
5047 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
5048 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
5051 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
5052 setPreferenceProperty( exportgroup, "columns", 2 );
5053 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
5054 addPreference( tr( "PREF_SHOW_WARN" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "show_warning" );
5055 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
5057 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
5058 setPreferenceProperty( computeGroup, "columns", 2 );
5059 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
5061 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5062 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5063 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5065 indices.append( 0 );
5066 indices.append( 1 );
5067 indices.append( 2 );
5068 setPreferenceProperty( notifyMode, "strings", modes );
5069 setPreferenceProperty( notifyMode, "indexes", indices );
5071 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5072 setPreferenceProperty( infoGroup, "columns", 2 );
5073 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5075 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5076 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5078 indices.append( 0 );
5079 indices.append( 1 );
5080 setPreferenceProperty( elemInfo, "strings", modes );
5081 setPreferenceProperty( elemInfo, "indexes", indices );
5082 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5083 setPreferenceProperty( nodesLim, "min", 0 );
5084 setPreferenceProperty( nodesLim, "max", 10000000 );
5085 setPreferenceProperty( nodesLim, "step", 10000 );
5086 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5087 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5088 setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5089 setPreferenceProperty( ctrlLim, "min", 0 );
5090 setPreferenceProperty( ctrlLim, "max", 10000000 );
5091 setPreferenceProperty( ctrlLim, "step", 1000 );
5092 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5093 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5094 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5095 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5096 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5098 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5099 setPreferenceProperty( segGroup, "columns", 2 );
5100 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5101 "SMESH", "segmentation" );
5102 setPreferenceProperty( segLen, "min", 1 );
5103 setPreferenceProperty( segLen, "max", 10000000 );
5104 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5105 "SMESH", "nb_segments_per_edge" );
5106 setPreferenceProperty( nbSeg, "min", 1 );
5107 setPreferenceProperty( nbSeg, "max", 10000000 );
5109 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5110 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5111 "SMESH", "forget_mesh_on_hyp_modif" );
5114 // Quantities with individual precision settings
5115 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5116 setPreferenceProperty( precGroup, "columns", 2 );
5118 const int nbQuantities = 6;
5119 int precs[nbQuantities], ii = 0;
5120 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5121 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5122 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5123 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5124 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5125 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5126 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5127 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5128 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5129 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5130 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5131 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5133 // Set property for precision value for spinboxes
5134 for ( ii = 0; ii < nbQuantities; ii++ ){
5135 setPreferenceProperty( precs[ii], "min", -14 );
5136 setPreferenceProperty( precs[ii], "max", 14 );
5137 setPreferenceProperty( precs[ii], "precision", 2 );
5140 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5141 setPreferenceProperty( previewGroup, "columns", 2 );
5142 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5143 setPreferenceProperty( chunkSize, "min", 1 );
5144 setPreferenceProperty( chunkSize, "max", 1000 );
5145 setPreferenceProperty( chunkSize, "step", 50 );
5147 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5148 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5150 // Mesh tab ------------------------------------------------------------------------
5151 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5152 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5153 setPreferenceProperty( nodeGroup, "columns", 3 );
5155 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5157 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5159 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5160 QList<QVariant> aMarkerTypeIndicesList;
5161 QList<QVariant> aMarkerTypeIconsList;
5162 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5163 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5164 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5165 aMarkerTypeIndicesList << i;
5166 aMarkerTypeIconsList << pixmap;
5168 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5169 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
5171 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5173 QList<QVariant> aMarkerScaleIndicesList;
5174 QStringList aMarkerScaleValuesList;
5175 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5176 aMarkerScaleIndicesList << i;
5177 //aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5178 aMarkerScaleValuesList << QString::number( i );
5180 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5181 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5183 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5184 //setPreferenceProperty( elemGroup, "columns", 2 );
5186 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5187 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5188 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5189 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5190 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5191 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5192 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5193 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5194 addPreference( tr( "PREF_PREVIEW_COLOR" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5197 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5198 setPreferenceProperty( grpGroup, "columns", 2 );
5200 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5201 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5203 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5204 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5205 /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5206 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5207 double ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5208 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5209 double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5210 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5211 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
5212 LightApp_Preferences::IntSpin, "SMESH", "element_width");
5213 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5214 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5215 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5216 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5218 setPreferenceProperty( size0d, "min", 1 );
5219 setPreferenceProperty( size0d, "max", 10 );
5221 // setPreferenceProperty( ballSize, "min", 1 );
5222 // setPreferenceProperty( ballSize, "max", 10 );
5224 setPreferenceProperty( ballDiameter, "min", 1e-7 );
5225 setPreferenceProperty( ballDiameter, "max", 1e9 );
5226 setPreferenceProperty( ballDiameter, "step", 0.1 );
5228 setPreferenceProperty( ballScale, "min", 1e-2 );
5229 setPreferenceProperty( ballScale, "max", 1e7 );
5230 setPreferenceProperty( ballScale, "step", 0.5 );
5232 setPreferenceProperty( elemW, "min", 1 );
5233 setPreferenceProperty( elemW, "max", 5 );
5235 setPreferenceProperty( outW, "min", 1 );
5236 setPreferenceProperty( outW, "max", 5 );
5238 setPreferenceProperty( shrink, "min", 0 );
5239 setPreferenceProperty( shrink, "max", 100 );
5241 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5242 setPreferenceProperty( numGroup, "columns", 2 );
5244 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5245 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5247 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5248 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5250 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5251 setPreferenceProperty( orientGroup, "columns", 1 );
5253 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5254 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5256 setPreferenceProperty( orientScale, "min", 0.05 );
5257 setPreferenceProperty( orientScale, "max", 0.5 );
5258 setPreferenceProperty( orientScale, "step", 0.05 );
5260 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5262 // Selection tab ------------------------------------------------------------------------
5263 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5265 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5266 setPreferenceProperty( selGroup, "columns", 2 );
5268 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5269 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5271 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5272 setPreferenceProperty( preGroup, "columns", 2 );
5274 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5276 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5277 setPreferenceProperty( precSelGroup, "columns", 2 );
5279 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5280 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5281 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5283 // Scalar Bar tab ------------------------------------------------------------------------
5284 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5285 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5286 setPreferenceProperty( fontGr, "columns", 2 );
5288 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5289 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5291 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5292 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5294 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5295 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5297 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5298 setPreferenceProperty( numcol, "min", 2 );
5299 setPreferenceProperty( numcol, "max", 256 );
5301 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5302 setPreferenceProperty( numlab, "min", 2 );
5303 setPreferenceProperty( numlab, "max", 65 );
5305 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5306 setPreferenceProperty( orientGr, "columns", 2 );
5307 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5308 QStringList orients;
5309 orients.append( tr( "SMESH_VERTICAL" ) );
5310 orients.append( tr( "SMESH_HORIZONTAL" ) );
5311 indices.clear(); indices.append( 0 ); indices.append( 1 );
5312 setPreferenceProperty( orient, "strings", orients );
5313 setPreferenceProperty( orient, "indexes", indices );
5315 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5316 setPreferenceProperty( posVSizeGr, "columns", 2 );
5317 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5318 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5319 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5320 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5321 setPreferenceProperty( xv, "step", 0.1 );
5322 setPreferenceProperty( xv, "min", 0.0 );
5323 setPreferenceProperty( xv, "max", 1.0 );
5324 setPreferenceProperty( yv, "step", 0.1 );
5325 setPreferenceProperty( yv, "min", 0.0 );
5326 setPreferenceProperty( yv, "max", 1.0 );
5327 setPreferenceProperty( wv, "step", 0.1 );
5328 setPreferenceProperty( wv, "min", 0.0 );
5329 setPreferenceProperty( wv, "max", 1.0 );
5330 setPreferenceProperty( hv, "min", 0.0 );
5331 setPreferenceProperty( hv, "max", 1.0 );
5332 setPreferenceProperty( hv, "step", 0.1 );
5334 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5335 setPreferenceProperty( posHSizeGr, "columns", 2 );
5336 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5337 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5338 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5339 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5340 setPreferenceProperty( xv, "min", 0.0 );
5341 setPreferenceProperty( xv, "max", 1.0 );
5342 setPreferenceProperty( xv, "step", 0.1 );
5343 setPreferenceProperty( xh, "min", 0.0 );
5344 setPreferenceProperty( xh, "max", 1.0 );
5345 setPreferenceProperty( xh, "step", 0.1 );
5346 setPreferenceProperty( yh, "min", 0.0 );
5347 setPreferenceProperty( yh, "max", 1.0 );
5348 setPreferenceProperty( yh, "step", 0.1 );
5349 setPreferenceProperty( wh, "min", 0.0 );
5350 setPreferenceProperty( wh, "max", 1.0 );
5351 setPreferenceProperty( wh, "step", 0.1 );
5352 setPreferenceProperty( hh, "min", 0.0 );
5353 setPreferenceProperty( hh, "max", 1.0 );
5354 setPreferenceProperty( hh, "step", 0.1 );
5356 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5357 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5358 setPreferenceProperty( distributionGr, "columns", 3 );
5360 types.append( tr( "SMESH_MONOCOLOR" ) );
5361 types.append( tr( "SMESH_MULTICOLOR" ) );
5362 indices.clear(); indices.append( 0 ); indices.append( 1 );
5363 setPreferenceProperty( coloringType, "strings", types );
5364 setPreferenceProperty( coloringType, "indexes", indices );
5365 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5369 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5371 if ( sect=="SMESH" ) {
5372 float sbX1 = 0.01, sbY1 = 0.01, sbW = 0.08, sbH = 0.08;
5373 float aTol = 1.00000009999999;
5374 std::string aWarning;
5375 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5377 if ( name== "selection_object_color" ||
5378 name=="selection_element_color" ||
5379 name== "highlight_color" ||
5380 name=="selection_precision_node" ||
5381 name=="selection_precision_element" ||
5382 name=="selection_precision_object" )
5384 SMESH::UpdateSelectionProp( this );
5386 else if (name == "scalar_bar_vertical_x" || name == "scalar_bar_vertical_width")
5388 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5389 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5390 if ( sbX1+sbW > aTol ) {
5391 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5394 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5395 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5398 else if (name == "scalar_bar_vertical_y" || name == "scalar_bar_vertical_height" )
5400 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5401 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5402 if ( sbY1 + sbH > aTol ) {
5403 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5404 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5405 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5408 else if (name == "scalar_bar_horizontal_x" || name == "scalar_bar_horizontal_width")
5410 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5411 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5412 if ( sbX1 + sbW > aTol ) {
5413 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5416 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5417 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5420 else if (name == "scalar_bar_horizontal_y" || name == "scalar_bar_horizontal_height")
5422 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5423 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5424 if ( sbY1 + sbH > aTol ) {
5425 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5428 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5429 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5432 else if ( name == "segmentation" )
5434 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5435 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5437 else if ( name == "nb_segments_per_edge" )
5439 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5440 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5442 else if ( name == "historical_python_dump" || name == "forget_mesh_on_hyp_modif" || name == "default_grp_color" )
5444 QString val = aResourceMgr->stringValue( "SMESH", name );
5445 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5447 else if ( name == "numbering_node_color" || name == "numbering_node_font" )
5449 SMESH::UpdateFontProp( this );
5451 else if ( name == "numbering_elem_color" || name == "numbering_elem_font" )
5453 SMESH::UpdateFontProp( this );
5456 if ( aWarning.size() != 0 ) {
5457 aWarning += "The default values are applied instead.";
5458 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5459 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5460 QObject::tr(aWarning.c_str()));
5465 //================================================================================
5467 * \brief Update something in accordance with update flags
5468 * \param theFlags - update flags
5470 * Update viewer or/and object browser etc. in accordance with update flags ( see
5471 * LightApp_UpdateFlags enumeration ).
5473 //================================================================================
5474 void SMESHGUI::update( const int flags )
5476 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5477 SMESH::UpdateView();
5479 SalomeApp_Module::update( flags );
5482 //================================================================================
5484 * \brief Set default selection mode
5486 * SLOT called when operation commited. Sets default selection mode
5488 //================================================================================
5489 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5491 SVTK_ViewWindow* vtkWnd =
5492 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5494 vtkWnd->SetSelectionMode( ActorSelection );
5497 //================================================================================
5499 * \brief Set default selection mode
5501 * SLOT called when operation aborted. Sets default selection mode
5503 //================================================================================
5504 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5506 SVTK_ViewWindow* vtkWnd =
5507 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5509 vtkWnd->SetSelectionMode( ActorSelection );
5512 //================================================================================
5514 * \brief Creates operation with given identifier
5515 * \param id - identifier of operation to be started
5516 * \return Pointer on created operation or NULL if operation is not created
5518 * Virtual method redefined from the base class creates operation with given id.
5519 * It is called called automatically from startOperation method of base class.
5521 //================================================================================
5522 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5524 LightApp_Operation* op = 0;
5525 // to do : create operation here
5528 case SMESHOp::OpSplitBiQuadratic:
5529 op = new SMESHGUI_SplitBiQuadOp();
5531 case SMESHOp::OpConvertMeshToQuadratic:
5532 op = new SMESHGUI_ConvToQuadOp();
5534 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5535 op = new SMESHGUI_Make2DFrom3DOp();
5537 case SMESHOp::OpReorientFaces:
5538 op = new SMESHGUI_ReorientFacesOp();
5540 case SMESHOp::OpCreateMesh:
5541 op = new SMESHGUI_MeshOp( true, true );
5543 case SMESHOp::OpCreateSubMesh:
5544 op = new SMESHGUI_MeshOp( true, false );
5546 case SMESHOp::OpEditMeshOrSubMesh:
5547 case SMESHOp::OpEditMesh:
5548 case SMESHOp::OpEditSubMesh:
5549 op = new SMESHGUI_MeshOp( false );
5551 case SMESHOp::OpCompute:
5552 case SMESHOp::OpComputeSubMesh:
5553 op = new SMESHGUI_ComputeOp();
5555 case SMESHOp::OpPreCompute:
5556 op = new SMESHGUI_PrecomputeOp();
5558 case SMESHOp::OpEvaluate:
5559 op = new SMESHGUI_EvaluateOp();
5561 case SMESHOp::OpMeshOrder:
5562 op = new SMESHGUI_MeshOrderOp();
5564 case SMESHOp::OpCreateGeometryGroup:
5565 op = new SMESHGUI_GroupOnShapeOp();
5567 case SMESHOp::OpFindElementByPoint:
5568 op = new SMESHGUI_FindElemByPointOp();
5570 case SMESHOp::OpMoveNode: // Make mesh pass through point
5571 op = new SMESHGUI_MakeNodeAtPointOp();
5573 case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
5574 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5581 op = SalomeApp_Module::createOperation( id );
5585 //================================================================================
5587 * \brief Stops current operations and starts a given one
5588 * \param id - The id of the operation to start
5590 //================================================================================
5592 void SMESHGUI::switchToOperation(int id)
5594 if ( _PTR(Study) aStudy = SMESH::GetActiveStudyDocument() )
5595 activeStudy()->abortAllOperations();
5596 startOperation( id );
5599 LightApp_Displayer* SMESHGUI::displayer()
5602 myDisplayer = new SMESHGUI_Displayer( getApp() );
5606 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5609 int aTolerance = 64;
5610 int anIterations = 0;
5616 if( anIterations % aPeriod == 0 )
5619 if( aTolerance < 1 )
5623 aHue = (int)( 360.0 * rand() / RAND_MAX );
5626 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5627 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5628 for( ; it != itEnd; ++it )
5630 SALOMEDS::Color anAutoColor = *it;
5631 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5634 aQColor.getHsv( &h, &s, &v );
5635 if( abs( h - aHue ) < aTolerance )
5647 aColor.setHsv( aHue, 255, 255 );
5649 SALOMEDS::Color aSColor;
5650 aSColor.R = aColor.redF();
5651 aSColor.G = aColor.greenF();
5652 aSColor.B = aColor.blueF();
5657 const char* gSeparator = "_"; // character used to separate parameter names
5658 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5659 const char* gPathSep = "|"; // character used to separate paths
5662 * \brief Store visual parameters
5664 * This method is called just before the study document is saved.
5665 * Store visual parameters in AttributeParameter attribue(s)
5667 void SMESHGUI::storeVisualParameters (int savePoint)
5670 Kernel_Utils::Localizer loc;
5672 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5673 if (!appStudy || !appStudy->studyDS())
5675 _PTR(Study) studyDS = appStudy->studyDS();
5677 // componentName is used for encoding of entries when storing them in IParameters
5678 std::string componentName = myComponentSMESH->ComponentDataType();
5679 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5680 //if (!aSComponent) return;
5683 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5684 componentName.c_str(),
5686 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5688 // store map of custom markers
5689 const VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5690 if( !aMarkerMap.empty() )
5692 VTK::MarkerMap::const_iterator anIter = aMarkerMap.begin();
5693 for( ; anIter != aMarkerMap.end(); anIter++ )
5695 int anId = anIter->first;
5696 VTK::MarkerData aMarkerData = anIter->second;
5697 std::string aMarkerFileName = aMarkerData.first;
5698 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5699 if( aMarkerTexture.size() < 3 )
5700 continue; // should contain at least width, height and the first value
5702 QString aPropertyName( "texture" );
5703 aPropertyName += gSeparator;
5704 aPropertyName += QString::number( anId );
5706 QString aPropertyValue = aMarkerFileName.c_str();
5707 aPropertyValue += gPathSep;
5709 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5710 ushort aWidth = *aTextureIter++;
5711 ushort aHeight = *aTextureIter++;
5712 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5713 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5714 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5715 aPropertyValue += QString::number( *aTextureIter );
5717 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5721 // viewers counters are used for storing view_numbers in IParameters
5724 // main cycle to store parameters of displayed objects
5725 QList<SUIT_ViewManager*> lst;
5726 QList<SUIT_ViewManager*>::Iterator it;
5727 getApp()->viewManagers(lst);
5728 for (it = lst.begin(); it != lst.end(); it++)
5730 SUIT_ViewManager* vman = *it;
5731 QString vType = vman->getType();
5733 // saving VTK actors properties
5734 if (vType == SVTK_Viewer::Type())
5736 // store the clipping planes attached to the view manager
5737 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5738 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5739 if( anIter != myClippingPlaneInfoMap.end() )
5740 aClippingPlaneInfoList = anIter->second;
5742 if( !aClippingPlaneInfoList.empty() ) {
5743 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5744 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5746 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5747 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5749 QString aPropertyName( "ClippingPlane" );
5750 aPropertyName += gSeparator;
5751 aPropertyName += QString::number( vtkViewers );
5752 aPropertyName += gSeparator;
5753 aPropertyName += QString::number( anId );
5755 QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
5756 aPropertyValue += gDigitsSep;
5757 aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
5758 aPropertyValue += gDigitsSep;
5759 if ( aPlane->PlaneMode == SMESH::Absolute ) {
5760 aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
5761 aPropertyValue += gDigitsSep;
5762 aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
5763 aPropertyValue += gDigitsSep;
5764 aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
5765 aPropertyValue += gDigitsSep;
5766 aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
5767 aPropertyValue += gDigitsSep;
5768 aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
5769 aPropertyValue += gDigitsSep;
5770 aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
5771 aPropertyValue += gDigitsSep;
5772 aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
5774 else if ( aPlane->PlaneMode == SMESH::Relative ) {
5775 aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
5776 aPropertyValue += gDigitsSep;
5777 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5778 aPropertyValue += gDigitsSep;
5779 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5780 aPropertyValue += gDigitsSep;
5781 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5784 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5788 QVector<SUIT_ViewWindow*> views = vman->getViews();
5789 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5791 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5793 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5794 vtkActorCollection* allActors = aCopy.GetActors();
5795 allActors->InitTraversal();
5796 while (vtkActor* actor = allActors->GetNextActor())
5798 if (actor->GetVisibility()) // store only visible actors
5800 SMESH_Actor* aSmeshActor = 0;
5801 if (actor->IsA("SMESH_Actor"))
5802 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5803 if (aSmeshActor && aSmeshActor->hasIO())
5805 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5808 // entry is "encoded" = it does NOT contain component adress,
5809 // since it is a subject to change on next component loading
5810 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5812 std::string param, vtkParam = vType.toLatin1().data();
5813 vtkParam += gSeparator;
5814 vtkParam += QString::number(vtkViewers).toLatin1().data();
5815 vtkParam += gSeparator;
5818 param = vtkParam + "Visibility";
5819 ip->setParameter(entry, param, "On");
5822 param = vtkParam + "Representation";
5823 ip->setParameter(entry, param, QString::number
5824 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5827 param = vtkParam + "IsShrunk";
5828 ip->setParameter(entry, param, QString::number
5829 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5831 // Displayed entities
5832 unsigned int aMode = aSmeshActor->GetEntityMode();
5833 bool isE = aMode & SMESH_Actor::eEdges;
5834 bool isF = aMode & SMESH_Actor::eFaces;
5835 bool isV = aMode & SMESH_Actor::eVolumes;
5836 bool is0d = aMode & SMESH_Actor::e0DElements;
5837 bool isB = aMode & SMESH_Actor::eBallElem;
5839 QString modeStr ("e");
5840 modeStr += gDigitsSep; modeStr += QString::number(isE);
5841 modeStr += gDigitsSep; modeStr += "f";
5842 modeStr += gDigitsSep; modeStr += QString::number(isF);
5843 modeStr += gDigitsSep; modeStr += "v";
5844 modeStr += gDigitsSep; modeStr += QString::number(isV);
5845 modeStr += gDigitsSep; modeStr += "0d";
5846 modeStr += gDigitsSep; modeStr += QString::number(is0d);
5847 modeStr += gDigitsSep; modeStr += "b";
5848 modeStr += gDigitsSep; modeStr += QString::number(isB);
5850 param = vtkParam + "Entities";
5851 ip->setParameter(entry, param, modeStr.toLatin1().data());
5857 aSmeshActor->GetSufaceColor(r, g, b, delta);
5858 QStringList colorStr;
5859 colorStr << "surface";
5860 colorStr << QString::number(r);
5861 colorStr << QString::number(g);
5862 colorStr << QString::number(b);
5864 colorStr << "backsurface";
5865 colorStr << QString::number(delta);
5867 aSmeshActor->GetVolumeColor(r, g, b, delta);
5868 colorStr << "volume";
5869 colorStr << QString::number(r);
5870 colorStr << QString::number(g);
5871 colorStr << QString::number(b);
5872 colorStr << QString::number(delta);
5874 aSmeshActor->GetEdgeColor(r, g, b);
5876 colorStr << QString::number(r);
5877 colorStr << QString::number(g);
5878 colorStr << QString::number(b);
5880 aSmeshActor->GetNodeColor(r, g, b);
5882 colorStr << QString::number(r);
5883 colorStr << QString::number(g);
5884 colorStr << QString::number(b);
5886 aSmeshActor->GetOutlineColor(r, g, b);
5887 colorStr << "outline";
5888 colorStr << QString::number(r);
5889 colorStr << QString::number(g);
5890 colorStr << QString::number(b);
5892 aSmeshActor->Get0DColor(r, g, b);
5893 colorStr << "elem0d";
5894 colorStr << QString::number(r);
5895 colorStr << QString::number(g);
5896 colorStr << QString::number(b);
5898 aSmeshActor->GetBallColor(r, g, b);
5900 colorStr << QString::number(r);
5901 colorStr << QString::number(g);
5902 colorStr << QString::number(b);
5904 aSmeshActor->GetFacesOrientationColor(r, g, b);
5905 colorStr << "orientation";
5906 colorStr << QString::number(r);
5907 colorStr << QString::number(g);
5908 colorStr << QString::number(b);
5910 param = vtkParam + "Colors";
5911 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
5914 QStringList sizeStr;
5916 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
5917 sizeStr << "outline";
5918 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
5919 sizeStr << "elem0d";
5920 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
5922 //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
5923 sizeStr << QString::number((double)aSmeshActor->GetBallSize());
5924 sizeStr << QString::number((double)aSmeshActor->GetBallScale());
5925 sizeStr << "shrink";
5926 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
5927 sizeStr << "orientation";
5928 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
5929 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
5931 param = vtkParam + "Sizes";
5932 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
5937 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5938 if( aMarkerType == VTK::MT_USER ) {
5939 markerStr += "custom";
5940 markerStr += gDigitsSep;
5941 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
5945 markerStr += gDigitsSep;
5946 markerStr += QString::number( (int)aMarkerType );
5947 markerStr += gDigitsSep;
5948 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
5951 param = vtkParam + "PointMarker";
5952 ip->setParameter(entry, param, markerStr.toLatin1().data());
5955 param = vtkParam + "Opacity";
5956 ip->setParameter(entry, param,
5957 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
5960 param = vtkParam + "ClippingPlane";
5962 if( !aClippingPlaneInfoList.empty() ) {
5963 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
5964 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
5966 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
5967 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
5968 SMESH::TActorList::iterator anIter2 = anActorList.begin();
5969 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
5970 if( aSmeshActor == *anIter2 ) {
5971 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
5972 QString::number( anId ).toLatin1().constData() );
5979 ip->setParameter( entry, param, "Off" );
5980 } // if (io->hasEntry())
5981 } // SMESH_Actor && hasIO
5983 } // while.. actors traversal
5987 } // if (SVTK view model)
5988 } // for (viewManagers)
5991 // data structures for clipping planes processing
5995 bool isOpenGLClipping;
5996 vtkIdType RelativeOrientation;
5999 int AbsoluteOrientation;
6000 double X, Y, Z, Dx, Dy, Dz;
6002 typedef std::list<TPlaneData> TPlaneDataList;
6003 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
6005 typedef std::list<vtkActor*> TActorList;
6008 TActorList ActorList;
6009 SUIT_ViewManager* ViewManager;
6011 typedef std::list<TPlaneInfo> TPlaneInfoList;
6012 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
6015 * \brief Restore visual parameters
6017 * This method is called after the study document is opened.
6018 * Restore visual parameters from AttributeParameter attribue(s)
6020 void SMESHGUI::restoreVisualParameters (int savePoint)
6023 Kernel_Utils::Localizer loc;
6025 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6026 if (!appStudy || !appStudy->studyDS())
6028 _PTR(Study) studyDS = appStudy->studyDS();
6030 // componentName is used for encoding of entries when storing them in IParameters
6031 std::string componentName = myComponentSMESH->ComponentDataType();
6032 //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
6033 //if (!aSComponent) return;
6036 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6037 componentName.c_str(),
6039 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6041 // restore map of custom markers and map of clipping planes
6042 VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
6043 TPlaneDataMap aPlaneDataMap;
6045 std::vector<std::string> properties = ip->getProperties();
6046 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
6048 std::string property = *propIt;
6049 QString aPropertyName( property.c_str() );
6050 QString aPropertyValue( ip->getProperty( property ).c_str() );
6052 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
6053 if( aPropertyNameList.isEmpty() )
6056 QString aPropertyType = aPropertyNameList[0];
6057 if( aPropertyType == "texture" )
6059 if( aPropertyNameList.size() != 2 )
6063 int anId = aPropertyNameList[1].toInt( &ok );
6064 if( !ok || anId < 1 )
6067 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
6068 if( aPropertyValueList.size() != 2 )
6071 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
6072 QString aMarkerTextureString = aPropertyValueList[1];
6073 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
6074 if( aMarkerTextureStringList.size() != 3 )
6078 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6083 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6087 VTK::MarkerTexture aMarkerTexture;
6088 aMarkerTexture.push_back( aWidth );
6089 aMarkerTexture.push_back( aHeight );
6091 QString aMarkerTextureData = aMarkerTextureStringList[2];
6092 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6094 QChar aChar = aMarkerTextureData.at( i );
6095 if( aChar.isDigit() )
6096 aMarkerTexture.push_back( aChar.digitValue() );
6099 aMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6101 else if( aPropertyType == "ClippingPlane" )
6103 if( aPropertyNameList.size() != 3 )
6107 int aViewId = aPropertyNameList[1].toInt( &ok );
6108 if( !ok || aViewId < 0 )
6112 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6113 if( !ok || aClippingPlaneId < 0 )
6116 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6117 if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6120 TPlaneData aPlaneData;
6121 aPlaneData.AbsoluteOrientation = false;
6122 aPlaneData.RelativeOrientation = 0;
6123 aPlaneData.Distance = aPlaneData.Angle[0] = aPlaneData.Angle[1] = 0;
6124 aPlaneData.X = aPlaneData.Y = aPlaneData.Z = 0;
6125 aPlaneData.Dx = aPlaneData.Dy = aPlaneData.Dz = 0;
6127 aPlaneData.Id = aClippingPlaneId;
6130 aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6135 aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6139 if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6142 aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6147 aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6152 aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6157 aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6162 aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6167 aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6172 aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6176 else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6178 aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6183 aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6188 aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6193 aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6198 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6199 aPlaneDataList.push_back( aPlaneData );
6203 TPlaneInfoMap aPlaneInfoMap;
6205 std::vector<std::string> entries = ip->getEntries();
6207 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6209 // entry is a normal entry - it should be "decoded" (setting base adress of component)
6210 QString entry (ip->decodeEntry(*entIt).c_str());
6212 // Check that the entry corresponds to a real object in the Study
6213 // as the object may be deleted or modified after the visual state is saved.
6214 _PTR(SObject) so = studyDS->FindObjectID(entry.toLatin1().data());
6215 if (!so) continue; //Skip the not existent entry
6217 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6218 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6220 std::vector<std::string>::iterator namesIt = paramNames.begin();
6221 std::vector<std::string>::iterator valuesIt = paramValues.begin();
6223 // actors are stored in a map after displaying of them for
6224 // quicker access in the future: map < viewID to actor >
6225 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6227 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6229 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6230 // '_' is used as separator and should not be used in viewer type or parameter names.
6231 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6232 if (lst.size() != 3)
6235 QString viewerTypStr = lst[0];
6236 QString viewIndexStr = lst[1];
6237 QString paramNameStr = lst[2];
6240 int viewIndex = viewIndexStr.toUInt(&ok);
6241 if (!ok) // bad conversion of view index to integer
6245 if (viewerTypStr == SVTK_Viewer::Type())
6247 SMESH_Actor* aSmeshActor = 0;
6248 if (vtkActors.IsBound(viewIndex))
6249 aSmeshActor = vtkActors.Find(viewIndex);
6251 QList<SUIT_ViewManager*> lst;
6252 getApp()->viewManagers(viewerTypStr, lst);
6254 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6255 SUIT_ViewManager* vman = NULL;
6256 if (viewIndex >= 0 && viewIndex < lst.count())
6257 vman = lst.at(viewIndex);
6259 if (paramNameStr == "Visibility")
6261 if (!aSmeshActor && displayer() && vman)
6263 SUIT_ViewModel* vmodel = vman->getViewModel();
6264 // SVTK view model can be casted to SALOME_View
6265 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6267 // store displayed actor in a temporary map for quicker
6268 // access later when restoring other parameters
6269 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6270 vtkRenderer* Renderer = vtkView->getRenderer();
6271 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6272 vtkActorCollection* theActors = aCopy.GetActors();
6273 theActors->InitTraversal();
6274 bool isFound = false;
6275 vtkActor *ac = theActors->GetNextActor();
6276 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6277 if (ac->IsA("SMESH_Actor")) {
6278 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6279 if (aGeomAc->hasIO()) {
6280 Handle(SALOME_InteractiveObject) io = aGeomAc->getIO();
6281 if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) {
6283 vtkActors.Bind(viewIndex, aGeomAc);
6289 } // if (paramNameStr == "Visibility")
6292 // the rest properties "work" with SMESH_Actor
6295 QString val ((*valuesIt).c_str());
6298 if (paramNameStr == "Representation") {
6299 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6302 else if (paramNameStr == "IsShrunk") {
6304 if (!aSmeshActor->IsShrunk())
6305 aSmeshActor->SetShrink();
6308 if (aSmeshActor->IsShrunk())
6309 aSmeshActor->UnShrink();
6312 // Displayed entities
6313 else if (paramNameStr == "Entities") {
6314 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6315 int aEntityMode = SMESH_Actor::eAllEntity;
6316 for ( int i = 0; i < mode.count(); i+=2 ) {
6317 if ( i < mode.count()-1 ) {
6318 QString type = mode[i];
6319 bool val = mode[i+1].toInt();
6320 if ( type == "e" && !val )
6321 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6322 else if ( type == "f" && !val )
6323 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6324 else if ( type == "v" && !val )
6325 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6326 else if ( type == "0d" && !val )
6327 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6328 else if ( type == "b" && !val )
6329 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6332 aSmeshActor->SetEntityMode( aEntityMode );
6335 else if (paramNameStr == "Colors") {
6336 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6343 QColor outlineColor;
6344 QColor orientationColor;
6350 // below lines are required to get default values for delta coefficients
6351 // of backface color for faces and color of reversed volumes
6352 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
6353 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6354 for ( int i = 0; i < colors.count(); i++ ) {
6355 QString type = colors[i];
6356 if ( type == "surface" ) {
6357 // face color is set by 3 values r:g:b, where
6358 // - r,g,b - is rgb color components
6359 if ( i+1 >= colors.count() ) break; // format error
6360 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6361 if ( i+2 >= colors.count() ) break; // format error
6362 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6363 if ( i+3 >= colors.count() ) break; // format error
6364 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6365 faceColor.setRgbF( r, g, b );
6368 else if ( type == "backsurface" ) {
6369 // backface color can be defined in several ways
6370 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6371 // - in latest versions, it is set as delta coefficient
6372 bool rgbOk = false, deltaOk;
6373 if ( i+1 >= colors.count() ) break; // format error
6374 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6375 int delta = colors[i+1].toInt( &deltaOk );
6377 if ( i+1 < colors.count() ) // index is shifted to 1
6378 g = colors[i+1].toDouble( &rgbOk );
6379 if ( rgbOk ) i++; // shift index
6380 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6381 b = colors[i+1].toDouble( &rgbOk );
6383 // - as currently there's no way to set directly backsurface color as it was before,
6384 // we ignore old dump where r,g,b triple was set
6385 // - also we check that delta parameter is set properly
6386 if ( !rgbOk && deltaOk )
6389 else if ( type == "volume" ) {
6390 // volume color is set by 4 values r:g:b:delta, where
6391 // - r,g,b - is a normal volume rgb color components
6392 // - delta - is a reversed volume color delta coefficient
6393 if ( i+1 >= colors.count() ) break; // format error
6394 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6395 if ( i+2 >= colors.count() ) break; // format error
6396 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6397 if ( i+3 >= colors.count() ) break; // format error
6398 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6399 if ( i+4 >= colors.count() ) break; // format error
6400 int delta = colors[i+4].toInt( &bOk );
6401 if ( !bOk ) break; // format error
6402 volumeColor.setRgbF( r, g, b );
6406 else if ( type == "edge" ) {
6407 // edge color is set by 3 values r:g:b, where
6408 // - r,g,b - is rgb color components
6409 if ( i+1 >= colors.count() ) break; // format error
6410 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6411 if ( i+2 >= colors.count() ) break; // format error
6412 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6413 if ( i+3 >= colors.count() ) break; // format error
6414 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6415 edgeColor.setRgbF( r, g, b );
6418 else if ( type == "node" ) {
6419 // node color is set by 3 values r:g:b, where
6420 // - r,g,b - is rgb color components
6421 if ( i+1 >= colors.count() ) break; // format error
6422 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6423 if ( i+2 >= colors.count() ) break; // format error
6424 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6425 if ( i+3 >= colors.count() ) break; // format error
6426 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6427 nodeColor.setRgbF( r, g, b );
6430 else if ( type == "elem0d" ) {
6431 // 0d element color is set by 3 values r:g:b, where
6432 // - r,g,b - is rgb color components
6433 if ( i+1 >= colors.count() ) break; // format error
6434 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6435 if ( i+2 >= colors.count() ) break; // format error
6436 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6437 if ( i+3 >= colors.count() ) break; // format error
6438 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6439 elem0dColor.setRgbF( r, g, b );
6442 else if ( type == "ball" ) {
6443 // ball color is set by 3 values r:g:b, where
6444 // - r,g,b - is rgb color components
6445 if ( i+1 >= colors.count() ) break; // format error
6446 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6447 if ( i+2 >= colors.count() ) break; // format error
6448 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6449 if ( i+3 >= colors.count() ) break; // format error
6450 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6451 ballColor.setRgbF( r, g, b );
6454 else if ( type == "outline" ) {
6455 // outline color is set by 3 values r:g:b, where
6456 // - r,g,b - is rgb color components
6457 if ( i+1 >= colors.count() ) break; // format error
6458 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6459 if ( i+2 >= colors.count() ) break; // format error
6460 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6461 if ( i+3 >= colors.count() ) break; // format error
6462 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6463 outlineColor.setRgbF( r, g, b );
6466 else if ( type == "orientation" ) {
6467 // orientation color is set by 3 values r:g:b, where
6468 // - r,g,b - is rgb color components
6469 if ( i+1 >= colors.count() ) break; // format error
6470 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6471 if ( i+2 >= colors.count() ) break; // format error
6472 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6473 if ( i+3 >= colors.count() ) break; // format error
6474 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6475 orientationColor.setRgbF( r, g, b );
6480 if ( nodeColor.isValid() )
6481 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6483 if ( edgeColor.isValid() )
6484 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6486 if ( faceColor.isValid() )
6487 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6489 if ( volumeColor.isValid() )
6490 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6491 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6492 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6494 if ( elem0dColor.isValid() )
6495 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6497 if ( ballColor.isValid() )
6498 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6500 if ( outlineColor.isValid() )
6501 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6502 // orientation color
6503 if ( orientationColor.isValid() )
6504 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6507 else if (paramNameStr == "Sizes") {
6508 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6511 int outlineWidth = -1;
6512 int elem0dSize = -1;
6513 //int ballSize = -1;
6514 double ballDiameter = -1.0;
6515 double ballScale = -1.0;
6516 double shrinkSize = -1;
6517 double orientationSize = -1;
6518 bool orientation3d = false;
6519 for ( int i = 0; i < sizes.count(); i++ ) {
6520 QString type = sizes[i];
6521 if ( type == "line" ) {
6522 // line (wireframe) width is given as single integer value
6523 if ( i+1 >= sizes.count() ) break; // format error
6524 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6528 if ( type == "outline" ) {
6529 // outline width is given as single integer value
6530 if ( i+1 >= sizes.count() ) break; // format error
6531 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6535 else if ( type == "elem0d" ) {
6536 // 0d element size is given as single integer value
6537 if ( i+1 >= sizes.count() ) break; // format error
6538 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6542 else if ( type == "ball" ) {
6543 // balls are specified by two values: size:scale, where
6544 // - size - is a integer value specifying size
6545 // - scale - is a double value specifying scale factor
6546 if ( i+1 >= sizes.count() ) break; // format error
6547 //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6548 double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6549 if ( i+2 >= sizes.count() ) break; // format error
6550 double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6556 else if ( type == "shrink" ) {
6557 // shrink factor is given as single floating point value
6558 if ( i+1 >= sizes.count() ) break; // format error
6559 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6563 else if ( type == "orientation" ) {
6564 // orientation vectors are specified by two values size:3d, where
6565 // - size - is a floating point value specifying scale factor
6566 // - 3d - is a boolean
6567 if ( i+1 >= sizes.count() ) break; // format error
6568 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6569 if ( i+2 >= sizes.count() ) break; // format error
6570 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6571 orientationSize = v1;
6572 orientation3d = (bool)v2;
6576 // line (wireframe) width
6577 if ( lineWidth > 0 )
6578 aSmeshActor->SetLineWidth( lineWidth );
6580 if ( outlineWidth > 0 )
6581 aSmeshActor->SetOutlineWidth( outlineWidth );
6582 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6583 aSmeshActor->SetOutlineWidth( lineWidth );
6585 if ( elem0dSize > 0 )
6586 aSmeshActor->Set0DSize( elem0dSize );
6588 /*if ( ballSize > 0 )
6589 aSmeshActor->SetBallSize( ballSize );*/
6591 if ( ballDiameter > 0 )
6592 aSmeshActor->SetBallSize( ballDiameter );
6594 if ( ballScale > 0.0 )
6595 aSmeshActor->SetBallScale( ballScale );
6597 if ( shrinkSize > 0 )
6598 aSmeshActor->SetShrinkFactor( shrinkSize );
6599 // orientation vectors
6600 if ( orientationSize > 0 ) {
6601 aSmeshActor->SetFacesOrientationScale( orientationSize );
6602 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6606 else if (paramNameStr == "PointMarker") {
6607 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6608 if( data.count() >= 2 ) {
6610 int aParam1 = data[1].toInt( &ok );
6612 if( data[0] == "std" && data.count() == 3 ) {
6613 int aParam2 = data[2].toInt( &ok );
6614 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6616 else if( data[0] == "custom" ) {
6617 VTK::MarkerMap::const_iterator markerIt = aMarkerMap.find( aParam1 );
6618 if( markerIt != aMarkerMap.end() ) {
6619 VTK::MarkerData aMarkerData = markerIt->second;
6620 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6627 else if (paramNameStr == "Opacity") {
6628 aSmeshActor->SetOpacity(val.toFloat());
6631 else if (paramNameStr.startsWith("ClippingPlane")) {
6632 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6633 // old format - val looks like "Off" or "1:0:0:0.5:0:0"
6634 // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
6635 // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
6636 // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
6637 // new format - val looks like "Off" or "0" (plane id)
6638 // (note: in new format "Off" value is used only for consistency,
6639 // so it is processed together with values in old format)
6640 bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
6641 if( anIsOldFormat ) {
6642 if (paramNameStr == "ClippingPlane1" || val == "Off")
6643 aSmeshActor->RemoveAllClippingPlanes();
6645 QList<SUIT_ViewManager*> lst;
6646 getApp()->viewManagers(viewerTypStr, lst);
6647 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6648 if (viewIndex >= 0 && viewIndex < lst.count()) {
6649 SUIT_ViewManager* vman = lst.at(viewIndex);
6650 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6652 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6654 SMESH::TActorList anActorList;
6655 anActorList.push_back( aSmeshActor );
6656 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
6657 aPlane->myViewWindow = vtkView;
6658 SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
6659 aPlane->PlaneMode = aMode;
6660 bool isOpenGLClipping = ( bool )vals[1].toInt();
6661 aPlane->IsOpenGLClipping = isOpenGLClipping;
6662 if ( aMode == SMESH::Absolute ) {
6663 aPlane->myAbsoluteOrientation = vals[2].toInt();
6664 aPlane->X = vals[3].toFloat();
6665 aPlane->Y = vals[4].toFloat();
6666 aPlane->Z = vals[5].toFloat();
6667 aPlane->Dx = vals[6].toFloat();
6668 aPlane->Dy = vals[7].toFloat();
6669 aPlane->Dz = vals[8].toFloat();
6671 else if ( aMode == SMESH::Relative ) {
6672 aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
6673 aPlane->myDistance = vals[3].toFloat();
6674 aPlane->myAngle[0] = vals[4].toFloat();
6675 aPlane->myAngle[1] = vals[5].toFloat();
6679 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6680 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6681 aClippingPlaneInfo.Plane = aPlane;
6682 aClippingPlaneInfo.ActorList = anActorList;
6683 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6691 int aPlaneId = val.toInt( &ok );
6692 if( ok && aPlaneId >= 0 ) {
6693 bool anIsDefinedPlane = false;
6694 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6695 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6696 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6697 TPlaneInfo& aPlaneInfo = *anIter;
6698 if( aPlaneInfo.PlaneId == aPlaneId ) {
6699 aPlaneInfo.ActorList.push_back( aSmeshActor );
6700 anIsDefinedPlane = true;
6704 if( !anIsDefinedPlane ) {
6705 TPlaneInfo aPlaneInfo;
6706 aPlaneInfo.PlaneId = aPlaneId;
6707 aPlaneInfo.ActorList.push_back( aSmeshActor );
6708 aPlaneInfo.ViewManager = vman;
6710 // to make the list sorted by plane id
6711 anIter = aPlaneInfoList.begin();
6712 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6713 const TPlaneInfo& aPlaneInfoRef = *anIter;
6714 if( aPlaneInfoRef.PlaneId > aPlaneId )
6717 aPlaneInfoList.insert( anIter, aPlaneInfo );
6722 } // if (aSmeshActor)
6723 } // other parameters than Visibility
6725 } // for names/parameters iterator
6726 } // for entries iterator
6728 // take into account planes with empty list of actors referred to them
6729 QList<SUIT_ViewManager*> aVMList;
6730 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6732 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6733 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6734 int aViewId = aPlaneDataIter->first;
6735 if( aViewId >= 0 && aViewId < aVMList.count() ) {
6736 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6738 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6740 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6741 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6742 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6743 const TPlaneData& aPlaneData = *anIter2;
6744 int aPlaneId = aPlaneData.Id;
6746 bool anIsFound = false;
6747 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6748 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6749 const TPlaneInfo& aPlaneInfo = *anIter3;
6750 if( aPlaneInfo.PlaneId == aPlaneId ) {
6757 TPlaneInfo aPlaneInfo; // ActorList field is empty
6758 aPlaneInfo.PlaneId = aPlaneId;
6759 aPlaneInfo.ViewManager = aViewManager;
6761 // to make the list sorted by plane id
6762 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6763 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6764 const TPlaneInfo& aPlaneInfoRef = *anIter4;
6765 if( aPlaneInfoRef.PlaneId > aPlaneId )
6768 aPlaneInfoList.insert( anIter4, aPlaneInfo );
6774 // add clipping planes to actors according to the restored parameters
6775 // and update the clipping plane map
6776 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6777 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6778 int aViewId = anIter1->first;
6779 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6781 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6782 if( anIter2 == aPlaneDataMap.end() )
6784 const TPlaneDataList& aPlaneDataList = anIter2->second;
6786 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6787 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6788 const TPlaneInfo& aPlaneInfo = *anIter3;
6789 int aPlaneId = aPlaneInfo.PlaneId;
6790 const TActorList& anActorList = aPlaneInfo.ActorList;
6791 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6795 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6799 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6801 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6802 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6803 const TPlaneData& aPlaneData = *anIter4;
6804 if( aPlaneData.Id == aPlaneId ) {
6805 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
6806 aPlane->myViewWindow = aViewWindow;
6807 aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
6808 aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
6809 if ( aPlane->PlaneMode == SMESH::Absolute ) {
6810 aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
6811 aPlane->X = aPlaneData.X;
6812 aPlane->Y = aPlaneData.Y;
6813 aPlane->Z = aPlaneData.Z;
6814 aPlane->Dx = aPlaneData.Dx;
6815 aPlane->Dy = aPlaneData.Dy;
6816 aPlane->Dz = aPlaneData.Dz;
6818 else if ( aPlane->PlaneMode == SMESH::Relative ) {
6819 aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
6820 aPlane->myDistance = aPlaneData.Distance;
6821 aPlane->myAngle[0] = aPlaneData.Angle[0];
6822 aPlane->myAngle[1] = aPlaneData.Angle[1];
6825 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6826 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6827 aClippingPlaneInfo.Plane = aPlane;
6828 aClippingPlaneInfo.ActorList = anActorList;
6829 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6840 // update all VTK views
6841 QList<SUIT_ViewManager*> lst;
6842 getApp()->viewManagers(lst);
6843 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6844 SUIT_ViewModel* vmodel = (*it)->getViewModel();
6845 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6846 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6847 // set OpenGL clipping planes
6848 VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
6849 vtkActorCollection* anAllActors = aCopy.GetActors();
6850 anAllActors->InitTraversal();
6851 while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
6852 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
6853 anActor->SetOpenGLClippingPlane();
6855 vtkView->getRenderer()->ResetCameraClippingRange();
6862 \brief Adds preferences for dfont of VTK viewer
6864 \param pIf group identifier
6865 \param param parameter
6866 \return identifier of preferences
6868 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
6870 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6872 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6875 fam.append( tr( "SMESH_FONT_ARIAL" ) );
6876 fam.append( tr( "SMESH_FONT_COURIER" ) );
6877 fam.append( tr( "SMESH_FONT_TIMES" ) );
6879 setPreferenceProperty( tfont, "fonts", fam );
6881 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6882 if ( needSize ) f = f | QtxFontEdit::Size;
6883 setPreferenceProperty( tfont, "features", f );
6889 \brief Actions after hypothesis edition
6890 Updates object browser after hypothesis edition
6892 void SMESHGUI::onHypothesisEdit( int result )
6895 SMESHGUI::Modified();
6896 updateObjBrowser( true );
6900 \brief Actions after choosing menu of control modes
6901 Updates control mode actions according to current selection
6903 void SMESHGUI::onUpdateControlActions()
6905 SALOME_ListIO selected;
6906 if ( LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr() )
6907 aSel->selectedObjects( selected );
6909 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
6910 if ( selected.Extent() ) {
6911 if ( selected.First()->hasEntry() ) {
6912 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( selected.First()->getEntry() )) {
6913 aControl = anActor->GetControlMode();
6914 SALOME_ListIteratorOfListIO it(selected);
6915 for ( it.Next(); it.More(); it.Next() ) {
6916 Handle(SALOME_InteractiveObject) anIO = it.Value();
6917 if ( anIO->hasEntry() ) {
6918 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
6919 if ( aControl != anActor->GetControlMode() ) {
6920 aControl = SMESH_Actor::eNone;
6930 int anAction = ActionToControl( aControl, true );
6932 action( anAction )->setChecked( true );
6934 QMenu* send = (QMenu*)sender();
6935 QList<QAction*> actions = send->actions();
6936 for ( int i = 0; i < actions.size(); i++ )
6937 actions[i]->setChecked( false );
6943 \brief Signal handler closing(SUIT_ViewWindow*) of a view
6944 \param pview view being closed
6946 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
6947 #ifndef DISABLE_PLOT2DVIEWER
6948 //Crear all Plot2d Viewers if need.
6949 SMESH::ClearPlot2Viewers(pview);
6951 EmitSignalCloseView();
6954 void SMESHGUI::message( const QString& msg )
6957 QStringList data = msg.split("/");
6958 if ( data.count() > 0 ) {
6959 if ( data.first() == "mesh_loading" ) {
6961 QString entry = data.count() > 1 ? data[1] : QString();
6962 if ( entry.isEmpty() )
6965 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
6967 _PTR(SObject) obj = study->FindObjectID( entry.toLatin1().constData() );
6970 name = SMESH::fromUtf8(obj->GetName());
6971 if ( name.isEmpty() )
6974 if ( data.last() == "stop" )
6975 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
6977 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
6978 QApplication::processEvents();
6984 \brief Connects or disconnects signals about activating and cloning view on the module slots
6985 \param pview view which is connected/disconnected
6987 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
6991 SUIT_ViewManager* viewMgr = pview->getViewManager();
6993 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6994 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6996 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6997 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7002 \brief Return \c true if object can be renamed
7004 bool SMESHGUI::renameAllowed( const QString& entry) const {
7005 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7009 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7013 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
7018 if(appStudy->isComponent(entry) || obj->isReference())
7021 // check type to prevent renaming of inappropriate objects
7022 int aType = SMESHGUI_Selection::type(qPrintable(entry), SMESH::GetActiveStudyDocument());
7023 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7024 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7025 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7026 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7027 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
7034 Rename object by entry.
7035 \param entry entry of the object
7036 \param name new name of the object
7037 \brief Return \c true if rename operation finished successfully, \c false otherwise.
7039 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
7041 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7045 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7050 _PTR(Study) aStudy = appStudy->studyDS();
7055 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
7057 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
7062 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
7063 _PTR(GenericAttribute) anAttr;
7064 _PTR(AttributeName) aName;
7066 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
7068 // check type to prevent renaming of inappropriate objects
7069 int aType = SMESHGUI_Selection::type( qPrintable(entry), SMESH::GetActiveStudyDocument() );
7070 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7071 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7072 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7073 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7074 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
7075 if ( !name.isEmpty() ) {
7076 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
7078 // update name of group object and its actor
7079 Handle(SALOME_InteractiveObject) IObject =
7080 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
7082 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
7083 if( !aGroupObject->_is_nil() ) {
7084 aGroupObject->SetName( qPrintable(name) );
7085 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
7086 anActor->setName( qPrintable(name) );
7096 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
7098 static QList<QColor> colors;
7100 if ( colors.isEmpty() ) {
7102 for (int s = 0; s < 2 ; s++)
7104 for (int v = 100; v >= 40; v = v - 20)
7106 for (int h = 0; h < 359 ; h = h + 60)
7108 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
7113 static int currentColor = randomize( colors.size() );
7115 SALOMEDS::Color color;
7116 color.R = (double)colors[currentColor].red() / 255.0;
7117 color.G = (double)colors[currentColor].green() / 255.0;
7118 color.B = (double)colors[currentColor].blue() / 255.0;
7120 currentColor = (currentColor+1) % colors.count();