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 SALOME_ListIteratorOfListIO It( selected );
979 for( ; It.More(); It.Next()){
980 Handle(SALOME_InteractiveObject) IObject = It.Value();
981 if(IObject->hasEntry()){
982 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
983 unsigned int aMode = anActor->GetEntityMode();
984 switch(theCommandID){
985 case SMESHOp::OpDE0DElements: InverseEntityMode(aMode,SMESH_Actor::e0DElements); break;
986 case SMESHOp::OpDEEdges: InverseEntityMode(aMode,SMESH_Actor::eEdges); break;
987 case SMESHOp::OpDEFaces: InverseEntityMode(aMode,SMESH_Actor::eFaces); break;
988 case SMESHOp::OpDEVolumes: InverseEntityMode(aMode,SMESH_Actor::eVolumes); break;
989 case SMESHOp::OpDEBalls: InverseEntityMode(aMode,SMESH_Actor::eBallElem); break;
990 case SMESHOp::OpDEAllEntity: aMode = SMESH_Actor::eAllEntity; break;
993 anActor->SetEntityMode(aMode);
1002 SalomeApp_Application* app =
1003 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1007 LightApp_SelectionMgr* aSel = app->selectionMgr();
1008 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1009 if ( !aSel || !appStudy )
1012 SALOME_ListIO selected;
1013 aSel->selectedObjects( selected );
1014 if ( selected.IsEmpty() )
1017 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1019 _PTR(Study) aStudy = appStudy->studyDS();
1020 _PTR(SObject) aMainSObject = aStudy->FindObjectID( anIObject->getEntry() );
1021 SMESH::SMESH_Mesh_var aMainObject = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1022 if ( aMainObject->_is_nil() )
1025 SUIT_OverrideCursor wc;
1027 aMainObject->SetAutoColor( true ); // mesh groups are re-colored here
1029 QList<SALOMEDS::Color> aReservedColors;
1031 SMESH::ListOfGroups aListOfGroups = *aMainObject->GetGroups();
1032 for ( int i = 0, n = aListOfGroups.length(); i < n; i++ )
1034 SMESH::SMESH_GroupBase_var aGroupObject = aListOfGroups[i];
1036 #ifdef SIMPLE_AUTOCOLOR // simplified algorithm for auto-colors
1037 SALOMEDS::Color aColor = SMESHGUI::getPredefinedUniqueColor();
1038 #else // old algorithm for auto-colors
1039 SALOMEDS::Color aColor = SMESHGUI::getUniqueColor( aReservedColors );
1040 aReservedColors.append( aColor );
1041 #endif // SIMPLE_AUTOCOLOR
1042 aGroupObject->SetColor( aColor );
1044 _PTR(SObject) aGroupSObject = SMESH::FindSObject(aGroupObject);
1045 if ( aGroupSObject ) {
1048 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry(aGroupSObject->GetID().c_str())) {
1049 switch ( aGroupObject->GetType ()) {
1051 anActor->SetNodeColor( aColor.R, aColor.G, aColor.B ); break;
1053 anActor->SetEdgeColor( aColor.R, aColor.G, aColor.B ); break;
1055 anActor->Set0DColor( aColor.R, aColor.G, aColor.B ); break;
1057 anActor->SetBallColor( aColor.R, aColor.G, aColor.B ); break;
1059 SMESH::GetColor("SMESH", "volume_color", c, delta, "255,0,170|-100");
1060 anActor->SetVolumeColor( aColor.R, aColor.G, aColor.B, delta ); break;
1063 SMESH::GetColor("SMESH", "fill_color", c, delta, "0,170,255|-100");
1064 anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B, delta );
1070 SMESH::RepaintCurrentView();
1073 void OverallMeshQuality()
1075 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1076 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1077 SALOME_ListIO selected;
1079 aSel->selectedObjects( selected );
1081 if ( selected.IsEmpty() ) return;
1082 SALOME_ListIteratorOfListIO It( selected );
1083 for ( ; It.More(); It.Next() ) {
1084 SMESHGUI_CtrlInfoDlg* ctrlDlg = new SMESHGUI_CtrlInfoDlg( SMESHGUI::desktop() );
1085 ctrlDlg->showInfo( It.Value() );
1090 QString functorToString( SMESH::Controls::FunctorPtr f )
1092 QString type = QObject::tr( "UNKNOWN_CONTROL" );
1093 if ( dynamic_cast< SMESH::Controls::Volume* >( f.get() ) )
1094 type = QObject::tr( "VOLUME_3D_ELEMENTS" );
1095 else if ( dynamic_cast< SMESH::Controls::MaxElementLength2D* >( f.get() ) )
1096 type = QObject::tr( "MAX_ELEMENT_LENGTH_2D" );
1097 else if ( dynamic_cast< SMESH::Controls::MaxElementLength3D* >( f.get() ) )
1098 type = QObject::tr( "MAX_ELEMENT_LENGTH_3D" );
1099 else if ( dynamic_cast< SMESH::Controls::MinimumAngle* >( f.get() ) )
1100 type = QObject::tr( "MINIMUMANGLE_ELEMENTS" );
1101 else if ( dynamic_cast< SMESH::Controls::AspectRatio* >( f.get() ) )
1102 type = QObject::tr( "ASPECTRATIO_ELEMENTS" );
1103 else if ( dynamic_cast< SMESH::Controls::AspectRatio3D* >( f.get() ) )
1104 type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" );
1105 else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) )
1106 type = QObject::tr( "WARP_ELEMENTS" );
1107 else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) )
1108 type = QObject::tr( "TAPER_ELEMENTS" );
1109 else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) )
1110 type = QObject::tr( "SKEW_ELEMENTS" );
1111 else if ( dynamic_cast< SMESH::Controls::Area* >( f.get() ) )
1112 type = QObject::tr( "AREA_ELEMENTS" );
1113 else if ( dynamic_cast< SMESH::Controls::Length* >( f.get() ) )
1114 type = QObject::tr( "LENGTH_EDGES" );
1115 else if ( dynamic_cast< SMESH::Controls::Length2D* >( f.get() ) )
1116 type = QObject::tr( "LENGTH2D_EDGES" );
1117 else if ( dynamic_cast< SMESH::Controls::MultiConnection* >( f.get() ) )
1118 type = QObject::tr( "MULTI_BORDERS" );
1119 else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) )
1120 type = QObject::tr( "MULTI2D_BORDERS" );
1121 else if ( dynamic_cast< SMESH::Controls::FreeNodes* >( f.get() ) )
1122 type = QObject::tr( "FREE_NODES" );
1123 else if ( dynamic_cast< SMESH::Controls::FreeEdges* >( f.get() ) )
1124 type = QObject::tr( "FREE_EDGES" );
1125 else if ( dynamic_cast< SMESH::Controls::FreeBorders* >( f.get() ) )
1126 type = QObject::tr( "FREE_BORDERS" );
1127 else if ( dynamic_cast< SMESH::Controls::FreeFaces* >( f.get() ) )
1128 type = QObject::tr( "FREE_FACES" );
1129 else if ( dynamic_cast< SMESH::Controls::BareBorderVolume* >( f.get() ) )
1130 type = QObject::tr( "BARE_BORDER_VOLUME" );
1131 else if ( dynamic_cast< SMESH::Controls::BareBorderFace* >( f.get() ) )
1132 type = QObject::tr( "BARE_BORDER_FACE" );
1133 else if ( dynamic_cast< SMESH::Controls::OverConstrainedVolume* >( f.get() ) )
1134 type = QObject::tr( "OVER_CONSTRAINED_VOLUME" );
1135 else if ( dynamic_cast< SMESH::Controls::OverConstrainedFace* >( f.get() ) )
1136 type = QObject::tr( "OVER_CONSTRAINED_FACE" );
1137 else if ( dynamic_cast< SMESH::Controls::CoincidentNodes* >( f.get() ) )
1138 type = QObject::tr( "EQUAL_NODE" );
1139 else if ( dynamic_cast< SMESH::Controls::CoincidentElements1D* >( f.get() ) )
1140 type = QObject::tr( "EQUAL_EDGE" );
1141 else if ( dynamic_cast< SMESH::Controls::CoincidentElements2D* >( f.get() ) )
1142 type = QObject::tr( "EQUAL_FACE" );
1143 else if ( dynamic_cast< SMESH::Controls::CoincidentElements3D* >( f.get() ) )
1144 type = QObject::tr( "EQUAL_VOLUME" );
1145 else if ( dynamic_cast< SMESH::Controls::NodeConnectivityNumber* >( f.get() ) )
1146 type = QObject::tr( "NODE_CONNECTIVITY_NB" );
1150 void SaveDistribution()
1152 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1153 SALOME_ListIO selected;
1155 aSel->selectedObjects( selected );
1157 if ( selected.Extent() == 1 ) {
1158 Handle(SALOME_InteractiveObject) anIO = selected.First();
1159 if ( anIO->hasEntry() ) {
1160 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1162 anActor->GetScalarBarActor() &&
1163 anActor->GetControlMode() != SMESH_Actor::eNone )
1165 SMESH_ScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor();
1166 SMESH::Controls::FunctorPtr aFunctor = anActor->GetFunctor();
1167 if ( aScalarBarActor && aFunctor ) {
1168 SMESH::Controls::NumericalFunctor* aNumFun =
1169 dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
1171 std::vector<int> elements;
1172 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
1173 if ( mesh->_is_nil() ) {
1174 SMESH::SMESH_IDSource_var idSource =
1175 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
1176 if ( !idSource->_is_nil() )
1178 SMESH::long_array_var ids = idSource->GetIDs();
1179 elements.resize( ids->length() );
1180 for ( unsigned i = 0; i < elements.size(); ++i )
1181 elements[i] = ids[i];
1184 int nbIntervals = aScalarBarActor->GetMaximumNumberOfColors();
1185 vtkLookupTable* lookupTable =
1186 static_cast<vtkLookupTable*>(aScalarBarActor->GetLookupTable());
1187 double * minmax = lookupTable->GetRange();
1188 bool isLogarithmic = lookupTable->GetScale() == VTK_SCALE_LOG10;
1189 std::vector<int> nbEvents;
1190 std::vector<double> funValues;
1191 aNumFun->GetHistogram( nbIntervals, nbEvents, funValues,
1192 elements, minmax, isLogarithmic );
1193 QString anInitialPath = "";
1194 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
1195 anInitialPath = QDir::currentPath();
1196 QString aMeshName = anIO->getName();
1198 filter.append( QObject::tr( "TEXT_FILES_FILTER" ) + " (*.txt)" );
1199 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
1200 QString aFilename = anInitialPath + "/" + aMeshName + "_" +
1201 functorToString( aFunctor ).toLower().simplified().replace( QRegExp( " |-" ), "_" ) + ".txt";
1202 aFilename = SUIT_FileDlg::getFileName( SMESHGUI::desktop(),
1205 QObject::tr( "SMESH_SAVE_DISTRIBUTION" ),
1207 if ( !aFilename.isEmpty() ) {
1208 QFile f( aFilename );
1209 if ( f.open( QFile::WriteOnly | QFile::Truncate ) ) {
1210 QTextStream out( &f );
1211 out << "# Mesh: " << aMeshName << endl;
1212 out << "# Control: " << functorToString( aFunctor ) << endl;
1214 out.setFieldWidth( 10 );
1215 for ( int i = 0; i < (int)qMin( nbEvents.size(), funValues.size()-1 ); i++ )
1216 out << funValues[i] << "\t" << funValues[i+1] << "\t" << nbEvents[i] << endl;
1227 void ShowElement( int theCommandID )
1229 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1230 SALOME_ListIO selected;
1232 aSel->selectedObjects( selected );
1234 if ( selected.Extent() == 1 ) {
1235 Handle(SALOME_InteractiveObject) anIO = selected.First();
1236 if ( anIO->hasEntry() ) {
1237 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1239 anActor->GetScalarBarActor() &&
1240 anActor->GetControlMode() != SMESH_Actor::eNone )
1242 SMESH_ScalarBarActor *aScalarBarActor = anActor->GetScalarBarActor();
1243 if ( theCommandID == SMESHOp::OpShowDistribution ) {
1244 aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility());
1246 else if ( theCommandID == SMESHOp::OpShowScalarBar ) {
1247 aScalarBarActor->SetVisibility( !aScalarBarActor->GetVisibility());
1254 #ifndef DISABLE_PLOT2DVIEWER
1255 void PlotDistribution()
1257 SalomeApp_Application* app =
1258 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1262 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1263 SALOME_ListIO selected;
1265 aSel->selectedObjects( selected );
1267 if ( selected.Extent() == 1 ) {
1268 Handle(SALOME_InteractiveObject) anIO = selected.First();
1269 if ( anIO->hasEntry() ) {
1270 //Find Actor by entry before getting Plot2d viewer,
1271 //because after call getViewManager( Plot2d_Viewer::Type(), true ) active window is Plot2d Viewer
1272 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1274 SUIT_ViewManager* aViewManager =
1275 app->getViewManager( Plot2d_Viewer::Type(), true ); // create if necessary
1279 SPlot2d_Viewer* aView = dynamic_cast<SPlot2d_Viewer*>(aViewManager->getViewModel());
1283 Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
1287 if ( anActor && anActor->GetControlMode() != SMESH_Actor::eNone )
1289 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1290 QString functorName = functorToString( anActor->GetFunctor());
1291 QString aHistogramName("%1 : %2");
1292 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1293 aHistogram->setName(aHistogramName);
1294 aHistogram->setHorTitle(functorName);
1295 aHistogram->setVerTitle(QObject::tr("DISTRIBUTION_NB_ENT"));
1296 aPlot->displayObject(aHistogram, true);
1301 #endif //DISABLE_PLOT2DVIEWER
1303 void DisableAutoColor()
1305 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1306 SALOME_ListIO selected;
1308 aSel->selectedObjects( selected );
1310 if ( selected.Extent() ) {
1311 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1312 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1313 if ( !aMesh->_is_nil() ) {
1314 aMesh->SetAutoColor( false );
1321 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1322 SALOME_ListIO selected;
1324 aSel->selectedObjects( selected );
1325 if ( selected.Extent() )
1327 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1328 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1329 _PTR(SObject) aSObj = aStudy->FindObjectID(anIObject->getEntry());
1331 if ( aStudy->GetUseCaseBuilder()->SortChildren( aSObj, true/*AscendingOrder*/ ) ) {
1332 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1339 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap)
1341 SALOME_ListIO selected;
1342 SalomeApp_Application* app =
1343 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1347 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1348 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1349 if ( !aSel || !appStudy )
1352 if ( theCommandID == SMESHOp::OpClipping ) { // Clipping dialog can be activated without selection
1353 if ( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
1354 aModule->EmitSignalDeactivateDialog();
1355 if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
1356 (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
1361 _PTR(Study) aStudy = appStudy->studyDS();
1363 aSel->selectedObjects( selected );
1365 if ( selected.Extent() >= 1 )
1367 switch ( theCommandID ) {
1368 case SMESHOp::OpTransparency:
1370 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1371 (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
1374 case SMESHOp::OpProperties:
1377 QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
1378 QColor orientationColor, outlineColor, volumeColor;
1379 int deltaF = 0, deltaV = 0;
1382 double ballScale = 1.0;
1384 int outlineWidth = 1;
1385 double shrinkCoef = 0.0;
1386 double orientationScale = 0.0;
1387 bool orientation3d = false;
1388 VTK::MarkerType markerType = VTK::MT_NONE;
1389 VTK::MarkerScale markerScale = VTK::MS_NONE;
1391 bool hasNodes = false;
1392 int presentEntities = 0;
1393 bool firstTime = true;
1395 SALOME_ListIteratorOfListIO It( selected );
1396 for ( ; It.More(); It.Next() ) {
1397 Handle(SALOME_InteractiveObject) IObject = It.Value();
1398 if ( !IObject->hasEntry() ) continue;
1399 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1400 if ( !anActor || !anActor->GetObject() ) continue;
1403 // nodes: color, marker
1404 anActor->GetNodeColor( color[0], color[1], color[2] );
1405 nodeColor.setRgbF( color[0], color[1], color[2] );
1406 markerType = anActor->GetMarkerType();
1407 markerScale = anActor->GetMarkerScale();
1408 markerId = anActor->GetMarkerTexture();
1409 // edges: color, width
1410 anActor->GetEdgeColor( color[0], color[1], color[2] );
1411 edgeColor.setRgbF( color[0], color[1], color[2] );
1412 edgeWidth = qMax( (int)anActor->GetLineWidth(), 1 ); // minimum allowed width is 1
1413 // faces: front color, back color (delta)
1414 anActor->GetSufaceColor( color[0], color[1], color[2], deltaF );
1415 faceColor.setRgbF( color[0], color[1], color[2] );
1416 // faces: front color, back color (delta)
1417 anActor->GetVolumeColor( color[0], color[1], color[2], deltaV );
1418 volumeColor.setRgbF( color[0], color[1], color[2] );
1419 // 0d elements: color, size
1420 anActor->Get0DColor( color[0], color[1], color[2] );
1421 elem0dColor.setRgbF( color[0], color[1], color[2] );
1422 elem0dSize = qMax( (int)anActor->Get0DSize(), 1 ); // minimum allowed size is 1
1423 // balls: color, size
1424 anActor->GetBallColor( color[0], color[1], color[2] );
1425 ballColor.setRgbF( color[0], color[1], color[2] );
1426 //ballSize = qMax( (int)anActor->GetBallSize(), 1 ); // minimum allowed size is 1
1427 ballScale = qMax( (double)anActor->GetBallScale(), 1e-2 ); // minimum allowed scale is 1e-2
1429 anActor->GetOutlineColor( color[0], color[1], color[2] );
1430 outlineColor.setRgbF( color[0], color[1], color[2] );
1431 outlineWidth = qMax( (int)anActor->GetOutlineWidth(), 1 ); // minimum allowed width is 1
1432 // orientation vectors: color, scale, 3d flag
1433 anActor->GetFacesOrientationColor( color[0], color[1], color[2] );
1434 orientationColor.setRgbF( color[0], color[1], color[2] );
1435 orientationScale = anActor->GetFacesOrientationScale();
1436 orientation3d = anActor->GetFacesOrientation3DVectors();
1438 shrinkCoef = anActor->GetShrinkFactor();
1441 firstTime = false; // we only take properties from first object (for performance reasons)
1444 hasNodes = anActor->GetObject()->GetNbEntities( SMDSAbs_Node );
1445 if ( !(presentEntities & SMESH_Actor::eEdges) && anActor->GetObject()->GetNbEntities( SMDSAbs_Edge ) )
1446 presentEntities = presentEntities | SMESH_Actor::eEdges;
1447 if ( !(presentEntities & SMESH_Actor::eFaces) && anActor->GetObject()->GetNbEntities( SMDSAbs_Face ) )
1448 presentEntities = presentEntities | SMESH_Actor::eFaces;
1449 if ( !(presentEntities & SMESH_Actor::eVolumes) && anActor->GetObject()->GetNbEntities( SMDSAbs_Volume ) )
1450 presentEntities = presentEntities | SMESH_Actor::eVolumes;
1451 if ( !(presentEntities & SMESH_Actor::e0DElements) && anActor->GetObject()->GetNbEntities( SMDSAbs_0DElement ) )
1452 presentEntities = presentEntities | SMESH_Actor::e0DElements;
1453 if ( !(presentEntities & SMESH_Actor::eBallElem) && anActor->GetObject()->GetNbEntities( SMDSAbs_Ball ) )
1454 presentEntities = presentEntities | SMESH_Actor::eBallElem;
1456 // as we know that all types of elements are present, we can exit the loop
1457 if ( presentEntities == SMESH_Actor::eAllEntity )
1461 SMESHGUI_PropertiesDlg dlg( theMarkerMap[ aStudy->StudyId() ], SMESHGUI::desktop() );
1462 // nodes: color, marker
1463 dlg.setNodeColor( nodeColor );
1464 if( markerType != VTK::MT_USER )
1465 dlg.setNodeMarker( markerType, markerScale );
1467 dlg.setNodeCustomMarker( markerId );
1468 // edges: color, line width
1469 dlg.setEdgeColor( edgeColor );
1470 dlg.setEdgeWidth( edgeWidth );
1471 // faces: front color, back color
1472 dlg.setFaceColor( faceColor, deltaF );
1473 // volumes: normal color, reversed color
1474 dlg.setVolumeColor( volumeColor, deltaV );
1475 // outlines: color, line width
1476 dlg.setOutlineColor( outlineColor );
1477 dlg.setOutlineWidth( outlineWidth );
1478 // 0d elements: color, size
1479 dlg.setElem0dColor( elem0dColor );
1480 dlg.setElem0dSize( elem0dSize );
1481 // balls: color, size
1482 dlg.setBallColor( ballColor );
1483 //dlg.setBallSize( ballSize );
1484 dlg.setBallScale( ballScale );
1485 // orientation: color, scale, 3d flag
1486 dlg.setOrientationColor( orientationColor );
1487 dlg.setOrientationSize( int( orientationScale * 100. ) );
1488 dlg.setOrientation3d( orientation3d );
1489 // shrink: scale factor
1490 dlg.setShrinkCoef( int( shrinkCoef * 100. ) );
1491 // hide unused controls
1492 dlg.showControls( presentEntities, hasNodes );
1495 nodeColor = dlg.nodeColor();
1496 markerType = dlg.nodeMarkerType();
1497 markerScale = dlg.nodeMarkerScale();
1498 markerId = dlg.nodeMarkerId();
1499 edgeColor = dlg.edgeColor();
1500 edgeWidth = dlg.edgeWidth();
1501 faceColor = dlg.faceColor();
1502 deltaF = dlg.faceColorDelta();
1503 volumeColor = dlg.volumeColor();
1504 deltaV = dlg.volumeColorDelta();
1505 outlineColor = dlg.outlineColor();
1506 outlineWidth = dlg.outlineWidth();
1507 elem0dColor = dlg.elem0dColor();
1508 elem0dSize = dlg.elem0dSize();
1509 ballColor = dlg.ballColor();
1510 // ballSize = dlg.ballSize();
1511 ballScale = dlg.ballScale();
1512 orientationColor = dlg.orientationColor();
1513 orientationScale = dlg.orientationSize() / 100.;
1514 orientation3d = dlg.orientation3d();
1515 shrinkCoef = dlg.shrinkCoef() / 100.;
1517 // store point markers map that might be changed by the user
1518 theMarkerMap[ aStudy->StudyId() ] = dlg.customMarkers();
1520 // set properties from dialog box to the presentations
1521 SALOME_ListIteratorOfListIO It( selected );
1522 for ( ; It.More(); It.Next() ) {
1523 Handle(SALOME_InteractiveObject) IObject = It.Value();
1524 if ( !IObject->hasEntry() ) continue;
1525 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1526 if ( !anActor ) continue;
1528 // nodes: color, marker
1529 anActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
1530 if ( markerType != VTK::MT_USER ) {
1531 anActor->SetMarkerStd( markerType, markerScale );
1534 const VTK::MarkerMap& markerMap = theMarkerMap[ aStudy->StudyId() ];
1535 VTK::MarkerMap::const_iterator iter = markerMap.find( markerId );
1536 if ( iter != markerMap.end() )
1537 anActor->SetMarkerTexture( markerId, iter->second.second );
1539 // volumes: normal color, reversed color (delta)
1540 anActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
1541 // faces: front color, back color (delta)
1542 anActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
1543 // edges: color, width
1544 anActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
1545 anActor->SetLineWidth( edgeWidth );
1547 anActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
1548 anActor->SetOutlineWidth( outlineWidth );
1549 // 0D elements: color, size
1550 anActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
1551 anActor->Set0DSize( elem0dSize );
1552 // balls: color, size
1553 anActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
1554 // anActor->SetBallSize( ballSize );
1555 anActor->SetBallScale( ballScale );
1556 // orientation: color, scale, 3d flag
1557 anActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
1558 anActor->SetFacesOrientationScale( orientationScale );
1559 anActor->SetFacesOrientation3DVectors( orientation3d );
1561 anActor->SetShrinkFactor( shrinkCoef );
1563 // for groups, set also proper color
1564 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1565 if ( !aGroupObject->_is_nil() ) {
1566 SMESH::ElementType anElementType = aGroupObject->GetType();
1568 switch( anElementType ) {
1570 aColor = nodeColor; break;
1572 aColor = edgeColor; break;
1574 aColor = faceColor; break;
1576 aColor = volumeColor; break;
1578 aColor = elem0dColor; break;
1580 aColor = ballColor; break;
1584 if ( aColor.isValid() ) {
1585 SALOMEDS::Color aGroupColor;
1586 aGroupColor.R = aColor.redF();
1587 aGroupColor.G = aColor.greenF();
1588 aGroupColor.B = aColor.blueF();
1589 aGroupObject->SetColor( aGroupColor );
1591 } // if ( !aGroupObject->_is_nil() )
1592 } // for ( ; It.More(); It.Next() )
1593 SMESH::RepaintCurrentView();
1594 } // if ( dlg.exec() )
1596 } // case SMESHOp::OpProperties:
1597 } // switch(theCommandID)
1598 SALOME_ListIteratorOfListIO It( selected );
1599 for( ; It.More(); It.Next()){
1600 Handle(SALOME_InteractiveObject) IObject = It.Value();
1601 if(IObject->hasEntry()){
1602 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1603 switch(theCommandID){
1604 case SMESHOp::OpDMWireframe:
1605 anActor->SetRepresentation(SMESH_Actor::eEdge);
1607 case SMESHOp::OpDMShading:
1608 anActor->SetRepresentation(SMESH_Actor::eSurface);
1610 case SMESHOp::OpDMShrink:
1611 if(anActor->IsShrunk())
1612 anActor->UnShrink();
1614 anActor->SetShrink();
1616 case SMESHOp::OpDMNodes:
1617 anActor->SetRepresentation(SMESH_Actor::ePoint);
1619 case SMESHOp::OpRepresentationLines:
1620 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1621 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1623 case SMESHOp::OpRepresentationArcs:
1624 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1625 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1631 SMESH::RepaintCurrentView();
1635 int ActionToControl( int theID, bool theReversed )
1637 NCollection_DoubleMap<int,int> ActionControl;
1638 ActionControl.Bind( 0, SMESH_Actor::eNone );
1639 ActionControl.Bind( SMESHOp::OpFreeNode, SMESH_Actor::eFreeNodes );
1640 ActionControl.Bind( SMESHOp::OpEqualNode, SMESH_Actor::eCoincidentNodes );
1641 ActionControl.Bind( SMESHOp::OpNodeConnectivityNb, SMESH_Actor::eNodeConnectivityNb );
1642 ActionControl.Bind( SMESHOp::OpFreeEdge, SMESH_Actor::eFreeEdges );
1643 ActionControl.Bind( SMESHOp::OpFreeBorder, SMESH_Actor::eFreeBorders );
1644 ActionControl.Bind( SMESHOp::OpLength, SMESH_Actor::eLength );
1645 ActionControl.Bind( SMESHOp::OpConnection, SMESH_Actor::eMultiConnection );
1646 ActionControl.Bind( SMESHOp::OpEqualEdge, SMESH_Actor::eCoincidentElems1D );
1647 ActionControl.Bind( SMESHOp::OpFreeFace, SMESH_Actor::eFreeFaces );
1648 ActionControl.Bind( SMESHOp::OpBareBorderFace, SMESH_Actor::eBareBorderFace );
1649 ActionControl.Bind( SMESHOp::OpOverConstrainedFace, SMESH_Actor::eOverConstrainedFace );
1650 ActionControl.Bind( SMESHOp::OpLength2D, SMESH_Actor::eLength2D );
1651 ActionControl.Bind( SMESHOp::OpConnection2D, SMESH_Actor::eMultiConnection2D );
1652 ActionControl.Bind( SMESHOp::OpArea, SMESH_Actor::eArea );
1653 ActionControl.Bind( SMESHOp::OpTaper, SMESH_Actor::eTaper );
1654 ActionControl.Bind( SMESHOp::OpAspectRatio, SMESH_Actor::eAspectRatio );
1655 ActionControl.Bind( SMESHOp::OpMinimumAngle, SMESH_Actor::eMinimumAngle );
1656 ActionControl.Bind( SMESHOp::OpWarpingAngle, SMESH_Actor::eWarping );
1657 ActionControl.Bind( SMESHOp::OpSkew, SMESH_Actor::eSkew );
1658 ActionControl.Bind( SMESHOp::OpMaxElementLength2D, SMESH_Actor::eMaxElementLength2D );
1659 ActionControl.Bind( SMESHOp::OpEqualFace, SMESH_Actor::eCoincidentElems2D );
1660 ActionControl.Bind( SMESHOp::OpAspectRatio3D, SMESH_Actor::eAspectRatio3D );
1661 ActionControl.Bind( SMESHOp::OpVolume, SMESH_Actor::eVolume3D );
1662 ActionControl.Bind( SMESHOp::OpMaxElementLength3D, SMESH_Actor::eMaxElementLength3D );
1663 ActionControl.Bind( SMESHOp::OpBareBorderVolume, SMESH_Actor::eBareBorderVolume );
1664 ActionControl.Bind( SMESHOp::OpOverConstrainedVolume, SMESH_Actor::eOverConstrainedVolume );
1665 ActionControl.Bind( SMESHOp::OpEqualVolume, SMESH_Actor::eCoincidentElems3D );
1667 return theReversed ? ActionControl.Find2( theID ) : ActionControl.Find1( theID );
1670 void Control( int theCommandID )
1672 SMESH_Actor::eControl aControl = SMESH_Actor::eControl( ActionToControl( theCommandID ));
1673 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1675 SALOME_ListIO selected;
1676 if ( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
1677 aSel->selectedObjects( selected );
1679 if ( !selected.IsEmpty() ) {
1680 SALOME_ListIteratorOfListIO It(selected);
1681 for ( ; It.More(); It.Next())
1683 Handle(SALOME_InteractiveObject) anIO = It.Value();
1684 if ( !anIO.IsNull() ) {
1685 _PTR(SObject) SO = aStudy->FindObjectID( It.Value()->getEntry() );
1687 CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
1688 SMESH::SMESH_IDSource_var anIDSrc = SMESH::SMESH_IDSource::_narrow( aObject );
1689 if ( !anIDSrc->_is_nil() ) {
1690 SMESH_Actor *anActor = SMESH::FindActorByEntry( anIO->getEntry());
1691 if (( !anActor && selected.Extent() == 1 ) &&
1692 ( anActor = SMESH::CreateActor( aStudy, anIO->getEntry() )))
1694 anActor->SetControlMode( aControl );
1695 SMESH::DisplayActor( SMESH::GetCurrentVtkView(), anActor );
1696 SMESH::UpdateView ( SMESH::eDisplay, anIO->getEntry() );
1700 if ( anActor->GetControlMode() != aControl )
1701 anActor->SetControlMode( aControl );
1702 QString functorName = functorToString( anActor->GetFunctor() );
1703 int anEntitiesCount = anActor->GetNumberControlEntities();
1704 if (anEntitiesCount >= 0)
1705 functorName = functorName + ": " + QString::number(anEntitiesCount);
1706 anActor->GetScalarBarActor()->SetTitle( functorName.toLatin1().constData() );
1707 SMESH::RepaintCurrentView();
1708 #ifndef DISABLE_PLOT2DVIEWER
1709 if ( anActor->GetPlot2Histogram() ) {
1710 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1711 QString aHistogramName("%1 : %2");
1712 aHistogramName = aHistogramName.arg( anIO->getName() ).arg( functorName );
1713 aHistogram->setName( aHistogramName );
1714 aHistogram->setHorTitle( functorName );
1715 SMESH::ProcessIn2DViewers( anActor );
1727 bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1728 SMESH::MeshObjectType theType,
1729 const QString theInTypeName,
1730 QString & theOutTypeName)
1732 SMESH_TypeFilter aTypeFilter( theType );
1734 if ( !theIO.IsNull() )
1736 entry = theIO->getEntry();
1737 LightApp_DataOwner owner( entry );
1738 if ( aTypeFilter.isOk( &owner )) {
1739 theOutTypeName = theInTypeName;
1747 QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1749 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1750 _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1752 _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1753 CORBA::String_var anID = aSComp->GetID().c_str();
1754 if ( !strcmp(anID.in(),theIO->getEntry()) )
1760 CheckOIType ( theIO, SMESH::HYPOTHESIS, "Hypothesis", aTypeName ) ||
1761 CheckOIType ( theIO, SMESH::ALGORITHM, "Algorithm", aTypeName ) ||
1762 CheckOIType ( theIO, SMESH::MESH, "Mesh", aTypeName ) ||
1763 CheckOIType ( theIO, SMESH::SUBMESH, "SubMesh", aTypeName ) ||
1764 CheckOIType ( theIO, SMESH::GROUP, "Group", aTypeName )
1772 // QString CheckHomogeneousSelection()
1774 // LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1775 // SALOME_ListIO selected;
1777 // aSel->selectedObjects( selected );
1779 // QString RefType = CheckTypeObject(selected.First());
1780 // SALOME_ListIteratorOfListIO It(selected);
1781 // for ( ; It.More(); It.Next())
1783 // Handle(SALOME_InteractiveObject) IObject = It.Value();
1784 // QString Type = CheckTypeObject(IObject);
1785 // if ( Type.compare(RefType) != 0 )
1786 // return "Heterogeneous Selection";
1792 uint randomize( uint size )
1794 static bool initialized = false;
1795 if ( !initialized ) {
1796 qsrand( QDateTime::currentDateTime().toTime_t() );
1800 v = uint( (double)( v ) / RAND_MAX * size );
1801 v = qMax( uint(0), qMin ( v, size-1 ) );
1807 void SMESHGUI::OnEditDelete()
1809 // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1810 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1811 SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1813 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1814 _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1815 _PTR(GenericAttribute) anAttr;
1816 _PTR(AttributeIOR) anIOR;
1818 int objectCount = 0;
1820 QString aParentComponent = QString::null;
1821 Handle(SALOME_InteractiveObject) anIO;
1822 for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1824 anIO = anIt.Value();
1825 QString cur = anIO->getComponentDataType();
1826 _PTR(SObject) aSO = aStudy->FindObjectID(anIO->getEntry());
1828 // check if object is reference
1829 _PTR(SObject) aRefSObj;
1830 aNameList.append("\n - ");
1831 if ( aSO->ReferencedObject( aRefSObj ) ) {
1832 QString aRefName = QString::fromStdString ( aRefSObj->GetName() );
1833 aNameList.append( aRefName );
1834 cur = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1837 aNameList.append(anIO->getName());
1841 if( aParentComponent.isNull() )
1842 aParentComponent = cur;
1843 else if( !aParentComponent.isEmpty() && aParentComponent!=cur )
1844 aParentComponent = "";
1847 if ( objectCount == 0 )
1848 return; // No Valid Objects Selected
1850 if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
1851 SUIT_MessageBox::warning( SMESHGUI::desktop(),
1852 QObject::tr("ERR_ERROR"),
1853 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
1856 // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
1857 if (SUIT_MessageBox::warning
1858 (SMESHGUI::desktop(),
1859 QObject::tr("SMESH_WRN_WARNING"),
1860 QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
1861 SUIT_MessageBox::Yes | SUIT_MessageBox::No,
1862 SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
1865 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1867 // Put the whole hierarchy of sub-objects of the selected SO's into a list and
1868 // then treat them all starting from the deepest objects (at list back)
1869 std::list< _PTR(SObject) > listSO;
1870 SALOME_ListIteratorOfListIO It(selected);
1871 for( ; It.More(); It.Next()) // loop on selected IO's
1873 Handle(SALOME_InteractiveObject) IObject = It.Value();
1874 if(IObject->hasEntry()) {
1875 _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
1877 // disable removal of "SMESH" component object
1878 if(aSO->FindAttribute(anAttr, "AttributeIOR")){
1880 if ( engineIOR() == anIOR->Value().c_str() )
1883 //Check the referenced object
1884 _PTR(SObject) aRefSObject;
1885 if ( aSO && aSO->ReferencedObject( aRefSObject ) )
1886 aSO = aRefSObject; // Delete main Object instead of reference
1888 listSO.push_back( aSO );
1889 std::list< _PTR(SObject) >::iterator itSO = --listSO.end();
1890 for ( ; itSO != listSO.end(); ++itSO ) {
1891 _PTR(ChildIterator) it = aStudy->NewChildIterator( *itSO );
1892 for (it->InitEx(false); it->More(); it->Next())
1893 listSO.push_back( it->Value() );
1897 // Check if none of objects to delete is referred from outside
1898 std::list< _PTR(SObject) >::reverse_iterator ritSO;
1899 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1901 _PTR(SObject) SO = *ritSO;
1902 if ( !SO ) continue;
1903 std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( *ritSO );
1904 for (size_t i = 0; i < aReferences.size(); i++) {
1905 _PTR(SComponent) aComponent = aReferences[i]->GetFatherComponent();
1906 std::string type = aComponent->ComponentDataType();
1907 if ( type != "SMESH" )
1909 SUIT_MessageBox::warning( anApp->desktop(),
1910 QObject::tr("WRN_WARNING"),
1911 QObject::tr("DEP_OBJECT") );
1912 return; // outside SMESH, there is an object depending on a SMESH object
1917 // Call mesh->Clear() to prevent loading mesh from file caused by hypotheses removal
1918 for( It.Initialize( selected ); It.More(); It.Next()) // loop on selected IO's
1920 Handle(SALOME_InteractiveObject) IObject = It.Value();
1921 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface< SMESH::SMESH_Mesh >( IObject );
1922 if ( !mesh->_is_nil() )
1926 // Treat SO's in the list starting from the back
1927 aStudyBuilder->NewCommand(); // There is a transaction
1928 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1930 _PTR(SObject) SO = *ritSO;
1931 if ( !SO ) continue;
1932 std::string anEntry = SO->GetID();
1934 /** Erase graphical object and remove all its data **/
1935 if(SO->FindAttribute(anAttr, "AttributeIOR")) {
1936 SMESH::RemoveVisualObjectWithActors( anEntry.c_str(), true);
1938 /** Remove an object from data structures **/
1939 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
1940 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
1941 if ( !aGroup->_is_nil() ) { // DELETE GROUP
1942 SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
1943 aMesh->RemoveGroup( aGroup );
1945 else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
1946 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
1947 aMesh->RemoveSubMesh( aSubMesh );
1949 _PTR(SObject) aMeshSO = SMESH::FindSObject(aMesh);
1951 SMESH::ModifiedMesh(aMeshSO, false, aMesh->NbNodes()==0);
1954 Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
1955 ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
1956 QString objType = CheckTypeObject(IObject);
1957 if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
1958 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
1959 aStudyBuilder->RemoveObjectWithChildren( SO );
1961 else {// default action: remove SObject from the study
1962 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
1963 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
1965 aStudyBuilder->RemoveObjectWithChildren( SO );
1969 } /* listSO back loop */
1971 aStudyBuilder->CommitCommand();
1973 /* Clear any previous selection */
1975 aSel->setSelectedObjects( l1 );
1977 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1981 SMESHGUI_EXPORT CAM_Module* createModule()
1983 return new SMESHGUI();
1986 SMESHGUI_EXPORT char* getModuleVersion() {
1987 return (char*)SMESH_VERSION_STR;
1991 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
1993 //=============================================================================
1997 //=============================================================================
1998 SMESHGUI::SMESHGUI() :
1999 SalomeApp_Module( "SMESH" )
2001 if ( CORBA::is_nil( myComponentSMESH ) )
2003 CORBA::Boolean anIsEmbeddedMode;
2004 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
2005 //MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
2007 // 0019923: EDF 765 SMESH : default values of hypothesis
2008 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
2009 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
2010 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
2011 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
2012 myComponentSMESH->SetDefaultNbSegments( nbSeg );
2014 const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif", "default_grp_color" };
2015 for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
2016 if ( aResourceMgr->hasValue( "SMESH", options[i] ))
2018 QString val = aResourceMgr->stringValue( "SMESH", options[i] );
2019 myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
2023 myActiveDialogBox = 0;
2024 myFilterLibraryDlg = 0;
2028 myEventCallbackCommand = vtkCallbackCommand::New();
2029 myEventCallbackCommand->Delete();
2030 myEventCallbackCommand->SetClientData( this );
2031 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
2034 /* load resources for all available meshers */
2035 SMESH::InitAvailableHypotheses();
2038 //=============================================================================
2042 //=============================================================================
2043 SMESHGUI::~SMESHGUI()
2047 //=============================================================================
2051 //=============================================================================
2052 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
2054 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2056 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
2061 //=============================================================================
2065 //=============================================================================
2066 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
2068 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2072 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2073 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2074 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2075 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2076 return autoUpdate && !exceeded;
2079 //=============================================================================
2083 //=============================================================================
2084 bool SMESHGUI::automaticUpdate( SMESH::SMESH_IDSource_ptr theMesh,
2085 int* entities, bool* limitExceeded, int* hidden, long* nbElements )
2087 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2091 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2092 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2093 bool incrementalLimit = resMgr->booleanValue( "SMESH", "incremental_limit", false );
2095 SMESH::long_array_var info = theMesh->GetMeshInfo();
2096 long nbOdElems = info[SMDSEntity_0D];
2097 long nbEdges = info[SMDSEntity_Edge] + info[SMDSEntity_Quad_Edge];
2098 long nbFaces = info[SMDSEntity_Triangle] + info[SMDSEntity_Quad_Triangle] + info[SMDSEntity_BiQuad_Triangle] +
2099 info[SMDSEntity_Quadrangle] + info[SMDSEntity_Quad_Quadrangle] + info[SMDSEntity_BiQuad_Quadrangle] +
2100 info[SMDSEntity_Polygon] + info[SMDSEntity_Quad_Polygon];
2101 long nbVolumes = info[SMDSEntity_Tetra] + info[SMDSEntity_Quad_Tetra] +
2102 info[SMDSEntity_Hexa] + info[SMDSEntity_Quad_Hexa] + info[SMDSEntity_TriQuad_Hexa] +
2103 info[SMDSEntity_Pyramid] + info[SMDSEntity_Quad_Pyramid] +
2104 info[SMDSEntity_Penta] + info[SMDSEntity_Quad_Penta] +
2105 info[SMDSEntity_Polyhedra] +
2106 info[SMDSEntity_Hexagonal_Prism];
2107 long nbBalls = info[SMDSEntity_Ball];
2109 long requestedSize = nbOdElems + nbBalls + nbEdges + nbFaces + nbVolumes;
2110 *nbElements = requestedSize;
2112 *entities = SMESH_Actor::eAllEntity;
2115 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2117 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2119 if ( incrementalLimit ) {
2122 if ( nbOdElems > 0 ) {
2123 if ( total + nbOdElems > updateLimit ) {
2124 *entities = *entities & ~SMESH_Actor::e0DElements;
2125 *hidden = *hidden | SMESH_Actor::e0DElements;
2132 if ( nbEdges > 0 ) {
2133 if ( total + nbEdges > updateLimit ) {
2134 *entities = *entities & ~SMESH_Actor::eEdges;
2135 *hidden = *hidden | SMESH_Actor::eEdges;
2142 if ( nbFaces > 0 ) {
2143 if ( total + nbFaces > updateLimit ) {
2144 *entities = *entities & ~SMESH_Actor::eFaces;
2145 *hidden = *hidden | SMESH_Actor::eFaces;
2152 if ( nbVolumes > 0 ) {
2153 if ( total + nbVolumes > updateLimit ) {
2154 *entities = *entities & ~SMESH_Actor::eVolumes;
2155 *hidden = *hidden | SMESH_Actor::eVolumes;
2162 if ( nbBalls > 0 ) {
2163 if ( total + nbBalls > updateLimit ) {
2164 *entities = *entities & ~SMESH_Actor::eBallElem;
2165 *hidden = *hidden | SMESH_Actor::eBallElem;
2173 return autoUpdate && !exceeded;
2176 //=============================================================================
2180 //=============================================================================
2181 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
2183 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
2186 //=============================================================================
2190 //=============================================================================
2191 SMESHGUI* SMESHGUI::GetSMESHGUI()
2193 SMESHGUI* smeshMod = 0;
2194 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
2197 CAM_Module* module = app->module( "Mesh" );
2198 smeshMod = dynamic_cast<SMESHGUI*>( module );
2201 if ( smeshMod && smeshMod->application() && smeshMod->application()->activeStudy() )
2203 SalomeApp_Study* study = dynamic_cast<SalomeApp_Study*>( smeshMod->application()->activeStudy() );
2206 _PTR(Study) aStudy = study->studyDS();
2208 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
2217 Standard_EXPORT SMESHGUI* GetComponentGUI()
2219 return SMESHGUI::GetSMESHGUI();
2223 //=============================================================================
2227 //=============================================================================
2228 void SMESHGUI::SetState(int aState)
2233 //=============================================================================
2237 //=============================================================================
2238 void SMESHGUI::ResetState()
2243 //=============================================================================
2247 //=============================================================================
2248 void SMESHGUI::EmitSignalDeactivateDialog()
2250 emit SignalDeactivateActiveDialog();
2253 //=============================================================================
2257 //=============================================================================
2258 void SMESHGUI::EmitSignalStudyFrameChanged()
2260 emit SignalStudyFrameChanged();
2263 //=============================================================================
2267 //=============================================================================
2268 void SMESHGUI::EmitSignalCloseAllDialogs()
2270 emit SignalCloseAllDialogs();
2273 //=============================================================================
2277 //=============================================================================
2278 void SMESHGUI::EmitSignalVisibilityChanged()
2280 emit SignalVisibilityChanged();
2283 //=============================================================================
2287 //=============================================================================
2288 void SMESHGUI::EmitSignalCloseView()
2290 emit SignalCloseView();
2293 //=============================================================================
2297 //=============================================================================
2298 void SMESHGUI::EmitSignalActivatedViewManager()
2300 emit SignalActivatedViewManager();
2303 //=============================================================================
2307 //=============================================================================
2308 QDialog *SMESHGUI::GetActiveDialogBox()
2310 return myActiveDialogBox;
2313 //=============================================================================
2317 //=============================================================================
2318 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2320 myActiveDialogBox = (QDialog *) aDlg;
2324 //=============================================================================
2328 //=============================================================================
2329 SUIT_Desktop* SMESHGUI::desktop()
2331 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2333 return app->desktop();
2338 //=============================================================================
2342 //=============================================================================
2343 SalomeApp_Study* SMESHGUI::activeStudy()
2345 SUIT_Application* app = SUIT_Session::session()->activeApplication();
2347 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2352 //=============================================================================
2356 //=============================================================================
2357 void SMESHGUI::Modified( bool theIsUpdateActions )
2359 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2360 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2361 appStudy->Modified();
2362 if( theIsUpdateActions )
2363 app->updateActions();
2368 //=============================================================================
2372 //=============================================================================
2373 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2375 /* Here the position is on the bottom right corner - 10 */
2376 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2378 SUIT_Desktop *PP = desktop();
2379 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2380 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2384 //=============================================================================
2388 //=============================================================================
2389 static int isStudyLocked(_PTR(Study) theStudy){
2390 return theStudy->GetProperties()->IsLocked();
2393 static bool checkLock(_PTR(Study) theStudy) {
2394 if (isStudyLocked(theStudy)) {
2395 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2396 QObject::tr("WRN_WARNING"),
2397 QObject::tr("WRN_STUDY_LOCKED") );
2403 //=======================================================================
2404 //function : CheckActiveStudyLocked
2406 //=======================================================================
2408 bool SMESHGUI::isActiveStudyLocked()
2410 _PTR(Study) aStudy = activeStudy()->studyDS();
2411 return checkLock( aStudy );
2414 //=============================================================================
2418 //=============================================================================
2419 bool SMESHGUI::OnGUIEvent( int theCommandID )
2421 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2425 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
2426 SUIT_ResourceMgr* mgr = resourceMgr();
2430 if (CORBA::is_nil(GetSMESHGen()->GetCurrentStudy())) {
2431 GetSMESHGen()->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
2434 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2435 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2437 //QAction* act = action( theCommandID );
2439 switch (theCommandID) {
2440 case SMESHOp::OpDelete:
2441 if(checkLock(aStudy)) break;
2444 case SMESHOp::OpImportDAT:
2445 case SMESHOp::OpImportUNV:
2446 case SMESHOp::OpImportMED:
2447 case SMESHOp::OpImportSTL:
2449 case SMESHOp::OpImportCGNS:
2451 case SMESHOp::OpImportSAUV:
2452 case SMESHOp::OpImportGMF:
2454 if(checkLock(aStudy)) break;
2455 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2459 case SMESHOp::OpFileInformation:
2461 SALOME_ListIO selected;
2462 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2464 aSel->selectedObjects( selected );
2465 if( selected.Extent() )
2467 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2468 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2469 if ( !aMesh->_is_nil() )
2471 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2477 case SMESHOp::OpExportDAT:
2478 case SMESHOp::OpExportMED:
2479 case SMESHOp::OpExportUNV:
2480 case SMESHOp::OpExportSTL:
2482 case SMESHOp::OpExportCGNS:
2484 case SMESHOp::OpExportSAUV:
2485 case SMESHOp::OpExportGMF:
2486 case SMESHOp::OpPopupExportDAT:
2487 case SMESHOp::OpPopupExportMED:
2488 case SMESHOp::OpPopupExportUNV:
2489 case SMESHOp::OpPopupExportSTL:
2491 case SMESHOp::OpPopupExportCGNS:
2493 case SMESHOp::OpPopupExportSAUV:
2494 case SMESHOp::OpPopupExportGMF:
2496 ::ExportMeshToFile(theCommandID);
2500 case SMESHOp::OpReset: // SCALAR BAR
2502 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2503 SALOME_ListIO selected;
2505 aSel->selectedObjects( selected );
2507 SALOME_ListIteratorOfListIO it(selected);
2508 for( ; it.More(); it.Next()) {
2509 Handle(SALOME_InteractiveObject) anIO = it.Value();
2510 if( anIO->hasEntry() ) {
2511 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2512 anActor->SetControlMode( SMESH_Actor::eNone );
2513 #ifndef DISABLE_PLOT2DVIEWER
2514 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2519 SMESH::UpdateView();
2522 case SMESHOp::OpScalarBarProperties:
2524 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2527 case SMESHOp::OpShowScalarBar:
2529 // show/hide scalar bar
2530 ::ShowElement(theCommandID);
2533 case SMESHOp::OpSaveDistribution:
2535 // dump control distribution data to the text file
2536 ::SaveDistribution();
2540 case SMESHOp::OpShowDistribution:
2542 // show/hide distribution
2543 ::ShowElement(theCommandID);
2547 #ifndef DISABLE_PLOT2DVIEWER
2548 case SMESHOp::OpPlotDistribution:
2550 // plot distribution
2551 ::PlotDistribution();
2557 case SMESHOp::OpAutoColor:
2561 case SMESHOp::OpDisableAutoColor:
2562 ::DisableAutoColor();
2565 case SMESHOp::OpClipping:
2566 case SMESHOp::OpTransparency:
2567 case SMESHOp::OpProperties: // Display preferences (colors, shrink size, line width, ...)
2570 case SMESHOp::OpDMWireframe:
2571 case SMESHOp::OpDMShading:
2572 case SMESHOp::OpDMNodes:
2573 case SMESHOp::OpDMShrink:
2574 ::SetDisplayMode(theCommandID, myMarkerMap);
2577 //2D quadratic representation
2578 case SMESHOp::OpRepresentationLines:
2579 case SMESHOp::OpRepresentationArcs:
2580 ::SetDisplayMode(theCommandID, myMarkerMap);
2584 case SMESHOp::OpDE0DElements:
2585 case SMESHOp::OpDEEdges:
2586 case SMESHOp::OpDEFaces:
2587 case SMESHOp::OpDEVolumes:
2588 case SMESHOp::OpDEBalls:
2589 case SMESHOp::OpDEAllEntity:
2590 ::SetDisplayEntity(theCommandID);
2593 // Choose entities to be displayed
2594 case SMESHOp::OpDEChoose:
2596 ( new SMESHGUI_DisplayEntitiesDlg( SMESHGUI::desktop() ) )->exec();
2600 case SMESHOp::OpOrientationOnFaces:
2602 LightApp_SelectionMgr* mgr = selectionMgr();
2603 SALOME_ListIO selected; mgr->selectedObjects( selected );
2605 SALOME_ListIteratorOfListIO it(selected);
2606 for( ; it.More(); it.Next()) {
2607 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2608 if(anIObject->hasEntry()) {
2609 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2610 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2617 case SMESHOp::OpUpdate:
2619 if(checkLock(aStudy)) break;
2620 SUIT_OverrideCursor wc;
2622 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2625 SMESH::UpdateView();
2627 catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2628 SMESH::OnVisuException();
2630 catch (...) { // PAL16774 (Crash after display of many groups)
2631 SMESH::OnVisuException();
2635 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2636 aSel->selectedObjects( l );
2637 aSel->setSelectedObjects( l );
2641 case SMESHOp::OpHide:
2642 case SMESHOp::OpShow:
2643 case SMESHOp::OpShowOnly:
2645 SUIT_OverrideCursor wc;
2646 SMESH::EDisplaing anAction;
2647 switch (theCommandID) {
2648 case SMESHOp::OpHide: anAction = SMESH::eErase; break;
2649 case SMESHOp::OpShow: anAction = SMESH::eDisplay; break;
2650 case SMESHOp::OpShowOnly: anAction = SMESH::eDisplayOnly; break;
2653 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2654 SALOME_ListIO sel_objects, to_process;
2656 aSel->selectedObjects( sel_objects );
2658 if ( theCommandID==SMESHOp::OpShowOnly )
2660 //MESSAGE("anAction = SMESH::eDisplayOnly");
2661 startOperation( myEraseAll );
2664 extractContainers( sel_objects, to_process );
2667 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2671 SALOME_ListIteratorOfListIO It( to_process );
2672 for ( ; It.More(); It.Next())
2674 Handle(SALOME_InteractiveObject) IOS = It.Value();
2675 if ( IOS->hasEntry() )
2677 if ( !SMESH::UpdateView( anAction, IOS->getEntry() )) {
2678 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2679 break; // PAL16774 (Crash after display of many groups)
2681 if (anAction == SMESH::eDisplayOnly)
2682 anAction = SMESH::eDisplay;
2687 // PAL13338 + PAL15161 -->
2688 if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !checkLock(aStudy)) {
2689 SMESH::UpdateView();
2690 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2692 // PAL13338 + PAL15161 <--
2694 catch (...) { // PAL16774 (Crash after display of many groups)
2695 SMESH::OnVisuException();
2698 if (anAction == SMESH::eErase) {
2700 aSel->setSelectedObjects( l1 );
2703 aSel->setSelectedObjects( to_process );
2708 case SMESHOp::OpNode:
2710 if(checkLock(aStudy)) break;
2713 EmitSignalDeactivateDialog();
2715 ( new SMESHGUI_NodesDlg( this ) )->show();
2718 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"),tr("SMESH_WRN_VIEWER_VTK"));
2723 case SMESHOp::OpCreateMesh:
2724 case SMESHOp::OpCreateSubMesh:
2725 case SMESHOp::OpEditMeshOrSubMesh:
2726 case SMESHOp::OpEditMesh:
2727 case SMESHOp::OpEditSubMesh:
2728 case SMESHOp::OpCompute:
2729 case SMESHOp::OpComputeSubMesh:
2730 case SMESHOp::OpPreCompute:
2731 case SMESHOp::OpEvaluate:
2732 case SMESHOp::OpMeshOrder:
2733 startOperation( theCommandID );
2735 case SMESHOp::OpCopyMesh:
2737 if (checkLock(aStudy)) break;
2738 EmitSignalDeactivateDialog();
2739 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2742 case SMESHOp::OpBuildCompoundMesh:
2744 if (checkLock(aStudy)) break;
2745 EmitSignalDeactivateDialog();
2746 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2750 case SMESHOp::OpDiagonalInversion:
2751 case SMESHOp::OpUnionOfTwoTriangle:
2755 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2759 if ( checkLock( aStudy ) )
2762 /*Standard_Boolean aRes;
2763 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2764 if ( aMesh->_is_nil() )
2766 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2767 tr( "SMESH_BAD_SELECTION" ) );
2771 EmitSignalDeactivateDialog();
2772 if ( theCommandID == SMESHOp::OpDiagonalInversion )
2773 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2775 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2778 case SMESHOp::OpOrientation:
2779 case SMESHOp::OpUnionOfTriangles:
2780 case SMESHOp::OpCuttingOfQuadrangles:
2781 case SMESHOp::OpSplitVolumes:
2785 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2789 if ( checkLock( aStudy ) )
2792 EmitSignalDeactivateDialog();
2793 SMESHGUI_MultiEditDlg* aDlg = NULL;
2794 if ( theCommandID == SMESHOp::OpOrientation )
2795 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2796 else if ( theCommandID == SMESHOp::OpUnionOfTriangles )
2797 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2798 else if ( theCommandID == SMESHOp::OpSplitVolumes )
2799 aDlg = new SMESHGUI_SplitVolumesDlg(this);
2801 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2806 case SMESHOp::OpSmoothing:
2808 if(checkLock(aStudy)) break;
2810 EmitSignalDeactivateDialog();
2811 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2814 SUIT_MessageBox::warning(desktop(), tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2818 case SMESHOp::OpExtrusion:
2820 if (checkLock(aStudy)) break;
2822 EmitSignalDeactivateDialog();
2823 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2825 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2829 case SMESHOp::OpExtrusionAlongAPath:
2831 if (checkLock(aStudy)) break;
2833 EmitSignalDeactivateDialog();
2834 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2836 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2840 case SMESHOp::OpRevolution:
2842 if(checkLock(aStudy)) break;
2844 EmitSignalDeactivateDialog();
2845 ( new SMESHGUI_RevolutionDlg( this ) )->show();
2848 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2852 case SMESHOp::OpPatternMapping:
2854 if ( checkLock( aStudy ) )
2858 EmitSignalDeactivateDialog();
2859 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2862 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2866 case SMESHOp::OpSplitBiQuadratic:
2867 case SMESHOp::OpConvertMeshToQuadratic:
2868 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
2869 case SMESHOp::OpReorientFaces:
2870 case SMESHOp::OpCreateGeometryGroup:
2872 startOperation( theCommandID );
2875 case SMESHOp::OpCreateGroup:
2879 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2883 if(checkLock(aStudy)) break;
2884 EmitSignalDeactivateDialog();
2885 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2887 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2888 SALOME_ListIO selected;
2890 aSel->selectedObjects( selected );
2892 int nbSel = selected.Extent();
2894 // check if mesh is selected
2895 aMesh = SMESH::GetMeshByIO( selected.First() );
2897 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2902 case SMESHOp::OpConstructGroup:
2906 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2910 if(checkLock(aStudy)) break;
2911 EmitSignalDeactivateDialog();
2913 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2914 SALOME_ListIO selected;
2916 aSel->selectedObjects( selected );
2918 int nbSel = selected.Extent();
2920 // check if submesh is selected
2921 Handle(SALOME_InteractiveObject) IObject = selected.First();
2922 if (IObject->hasEntry()) {
2923 _PTR(SObject) aSObj = aStudy->FindObjectID(IObject->getEntry());
2925 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2926 if (!aSubMesh->_is_nil()) {
2928 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2929 // get submesh elements list by types
2930 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2931 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2932 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2933 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2934 // create group for each type o elements
2935 QString aName = IObject->getName();
2936 QStringList anEntryList;
2937 if (aNodes->length() > 0) {
2938 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2939 aGroup->Add(aNodes.inout());
2940 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2941 anEntryList.append( aSObject->GetID().c_str() );
2943 if (aEdges->length() > 0) {
2944 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2945 aGroup->Add(aEdges.inout());
2946 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2947 anEntryList.append( aSObject->GetID().c_str() );
2949 if (aFaces->length() > 0) {
2950 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2951 aGroup->Add(aFaces.inout());
2952 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2953 anEntryList.append( aSObject->GetID().c_str() );
2955 if (aVolumes->length() > 0) {
2956 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2957 aGroup->Add(aVolumes.inout());
2958 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2959 anEntryList.append( aSObject->GetID().c_str() );
2962 anApp->browseObjects( anEntryList );
2964 catch(const SALOME::SALOME_Exception & S_ex){
2965 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2972 SUIT_MessageBox::warning(desktop(),
2973 tr("SMESH_WRN_WARNING"),
2974 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
2979 case SMESHOp::OpEditGroup:
2983 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2987 if(checkLock(aStudy)) break;
2988 EmitSignalDeactivateDialog();
2990 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2991 SALOME_ListIO selected;
2993 aSel->selectedObjects( selected );
2995 SALOME_ListIteratorOfListIO It (selected);
2996 int nbSelectedGroups = 0;
2997 for ( ; It.More(); It.Next() )
2999 SMESH::SMESH_GroupBase_var aGroup =
3000 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
3001 if (!aGroup->_is_nil()) {
3003 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
3007 if (nbSelectedGroups == 0)
3009 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
3015 case SMESHOp::OpAddElemGroupPopup: // Add elements to group
3017 if(checkLock(aStudy)) break;
3018 if (myState == 800) {
3019 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3020 if (aDlg) aDlg->onAdd();
3025 case SMESHOp::OpRemoveElemGroupPopup: // Remove elements from group
3027 if(checkLock(aStudy)) break;
3028 if (myState == 800) {
3029 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3030 if (aDlg) aDlg->onRemove();
3035 case SMESHOp::OpEditGeomGroupAsGroup:
3039 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3043 if(checkLock(aStudy)) break;
3044 EmitSignalDeactivateDialog();
3046 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3047 SALOME_ListIO selected;
3049 aSel->selectedObjects( selected );
3051 SALOME_ListIteratorOfListIO It (selected);
3052 for ( ; It.More(); It.Next() )
3054 SMESH::SMESH_GroupOnGeom_var aGroup =
3055 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
3056 if (!aGroup->_is_nil()) {
3057 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3062 SMESH::SMESH_GroupOnFilter_var aGroup =
3063 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
3064 if (!aGroup->_is_nil()) {
3065 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3073 case SMESHOp::OpUnionGroups:
3074 case SMESHOp::OpIntersectGroups:
3075 case SMESHOp::OpCutGroups:
3079 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3083 if ( checkLock( aStudy ) )
3086 EmitSignalDeactivateDialog();
3088 SMESHGUI_GroupOpDlg* aDlg = 0;
3089 if ( theCommandID == SMESHOp::OpUnionGroups )
3090 aDlg = new SMESHGUI_UnionGroupsDlg( this );
3091 else if ( theCommandID == SMESHOp::OpIntersectGroups )
3092 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3094 aDlg = new SMESHGUI_CutGroupsDlg( this );
3101 case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
3103 if ( checkLock( aStudy ) )
3106 EmitSignalDeactivateDialog();
3107 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3113 case SMESHOp::OpDeleteGroup: // Delete groups with their contents
3117 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3121 if ( checkLock( aStudy ) )
3124 EmitSignalDeactivateDialog();
3126 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3130 case SMESHOp::OpMeshInformation:
3131 case SMESHOp::OpWhatIs:
3133 int page = theCommandID == SMESHOp::OpMeshInformation ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3134 EmitSignalDeactivateDialog();
3135 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3136 SALOME_ListIO selected;
3138 aSel->selectedObjects( selected );
3140 if ( selected.Extent() > 1 ) { // a dlg for each IO
3141 SALOME_ListIteratorOfListIO It( selected );
3142 for ( ; It.More(); It.Next() ) {
3143 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3144 dlg->showInfo( It.Value() );
3149 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3155 case SMESHOp::OpFindElementByPoint:
3157 startOperation( theCommandID );
3161 case SMESHOp::OpEditHypothesis:
3163 if(checkLock(aStudy)) break;
3165 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3166 SALOME_ListIO selected;
3168 aSel->selectedObjects( selected );
3170 int nbSel = selected.Extent();
3173 Handle(SALOME_InteractiveObject) anIObject = selected.First();
3174 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3176 if ( !aHypothesis->_is_nil() )
3178 SMESHGUI_GenericHypothesisCreator* aCreator =
3179 SMESH::GetHypothesisCreator( SMESH::toQStr( aHypothesis->GetName() ));
3182 // set geometry of mesh and sub-mesh to aCreator
3183 aSel->selectedObjects( selected, "", /*convertReferences=*/false);
3184 if ( selected.Extent() == 1 )
3186 QString subGeomID, meshGeomID;
3187 Handle(SALOME_InteractiveObject) hypIO = selected.First();
3188 if ( SMESH::GetGeomEntries( hypIO, subGeomID, meshGeomID ))
3190 if ( subGeomID.isEmpty() ) subGeomID = meshGeomID;
3191 aCreator->setShapeEntry( subGeomID );
3192 aCreator->setMainShapeEntry( meshGeomID );
3196 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3206 case SMESHOp::OpUnassign: // REMOVE HYPOTHESIS / ALGORITHMS
3208 if(checkLock(aStudy)) break;
3209 SUIT_OverrideCursor wc;
3211 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3212 SALOME_ListIO selected;
3214 aSel->selectedObjects( selected, QString::null, false );
3216 SALOME_ListIteratorOfListIO It(selected);
3217 for (int i = 0; It.More(); It.Next(), i++) {
3218 Handle(SALOME_InteractiveObject) IObject = It.Value();
3219 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3222 aSel->setSelectedObjects( l1 );
3227 case SMESHOp::OpElem0D:
3228 case SMESHOp::OpBall:
3229 case SMESHOp::OpEdge:
3230 case SMESHOp::OpTriangle:
3231 case SMESHOp::OpQuadrangle:
3232 case SMESHOp::OpPolygon:
3233 case SMESHOp::OpTetrahedron:
3234 case SMESHOp::OpHexahedron:
3235 case SMESHOp::OpPentahedron:
3236 case SMESHOp::OpPyramid:
3237 case SMESHOp::OpHexagonalPrism:
3239 if(checkLock(aStudy)) break;
3241 EmitSignalDeactivateDialog();
3242 SMDSAbs_EntityType type = SMDSEntity_Edge;
3243 switch (theCommandID) {
3244 case SMESHOp::OpElem0D: type = SMDSEntity_0D; break;
3245 case SMESHOp::OpBall: type = SMDSEntity_Ball; break;
3246 case SMESHOp::OpTriangle: type = SMDSEntity_Triangle; break;
3247 case SMESHOp::OpQuadrangle: type = SMDSEntity_Quadrangle; break;
3248 case SMESHOp::OpTetrahedron: type = SMDSEntity_Tetra; break;
3249 case SMESHOp::OpPolygon: type = SMDSEntity_Polygon; break;
3250 case SMESHOp::OpHexahedron: type = SMDSEntity_Hexa; break;
3251 case SMESHOp::OpPentahedron: type = SMDSEntity_Penta; break;
3252 case SMESHOp::OpPyramid: type = SMDSEntity_Pyramid; break;
3253 case SMESHOp::OpHexagonalPrism: type = SMDSEntity_Hexagonal_Prism; break;
3256 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3259 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3263 case SMESHOp::OpPolyhedron:
3265 if(checkLock(aStudy)) break;
3267 EmitSignalDeactivateDialog();
3268 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3271 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3275 case SMESHOp::OpQuadraticEdge:
3276 case SMESHOp::OpQuadraticTriangle:
3277 case SMESHOp::OpBiQuadraticTriangle:
3278 case SMESHOp::OpQuadraticQuadrangle:
3279 case SMESHOp::OpBiQuadraticQuadrangle:
3280 case SMESHOp::OpQuadraticPolygon:
3281 case SMESHOp::OpQuadraticTetrahedron:
3282 case SMESHOp::OpQuadraticPyramid:
3283 case SMESHOp::OpQuadraticPentahedron:
3284 case SMESHOp::OpQuadraticHexahedron:
3285 case SMESHOp::OpTriQuadraticHexahedron:
3287 if(checkLock(aStudy)) break;
3289 EmitSignalDeactivateDialog();
3290 SMDSAbs_EntityType type = SMDSEntity_Last;
3292 switch (theCommandID) {
3293 case SMESHOp::OpQuadraticEdge: type = SMDSEntity_Quad_Edge; break;
3294 case SMESHOp::OpQuadraticTriangle: type = SMDSEntity_Quad_Triangle; break;
3295 case SMESHOp::OpBiQuadraticTriangle: type = SMDSEntity_BiQuad_Triangle; break;
3296 case SMESHOp::OpQuadraticQuadrangle: type = SMDSEntity_Quad_Quadrangle; break;
3297 case SMESHOp::OpBiQuadraticQuadrangle: type = SMDSEntity_BiQuad_Quadrangle; break;
3298 case SMESHOp::OpQuadraticPolygon: type = SMDSEntity_Quad_Polygon; break;
3299 case SMESHOp::OpQuadraticTetrahedron: type = SMDSEntity_Quad_Tetra; break;
3300 case SMESHOp::OpQuadraticPyramid: type = SMDSEntity_Quad_Pyramid; break;
3301 case SMESHOp::OpQuadraticPentahedron: type = SMDSEntity_Quad_Penta; break;
3302 case SMESHOp::OpQuadraticHexahedron: type = SMDSEntity_Quad_Hexa; break;
3303 case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
3306 if ( type != SMDSEntity_Last )
3307 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3310 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3311 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3315 case SMESHOp::OpRemoveNodes:
3317 if(checkLock(aStudy)) break;
3319 EmitSignalDeactivateDialog();
3320 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3323 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3324 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3328 case SMESHOp::OpRemoveElements: // REMOVES ELEMENTS
3330 if(checkLock(aStudy)) break;
3332 EmitSignalDeactivateDialog();
3333 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3337 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3338 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3342 case SMESHOp::OpClearMesh: {
3344 if(checkLock(aStudy)) break;
3346 SALOME_ListIO selected;
3347 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3348 aSel->selectedObjects( selected );
3350 SUIT_OverrideCursor wc;
3351 SALOME_ListIteratorOfListIO It (selected);
3352 for ( ; It.More(); It.Next() )
3354 Handle(SALOME_InteractiveObject) IOS = It.Value();
3355 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3356 if ( aMesh->_is_nil()) continue;
3359 if ( aMesh->NbNodes() == 0 ) // imported mesh is not empty
3360 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3361 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3362 SMESH::ModifiedMesh( aMeshSObj, false, true);
3363 // hide groups and submeshes
3364 _PTR(ChildIterator) anIter =
3365 SMESH::GetActiveStudyDocument()->NewChildIterator( aMeshSObj );
3366 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3368 _PTR(SObject) so = anIter->Value();
3369 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3372 catch (const SALOME::SALOME_Exception& S_ex){
3374 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3378 SMESH::UpdateView();
3382 case SMESHOp::OpRemoveOrphanNodes:
3384 if(checkLock(aStudy)) break;
3385 SALOME_ListIO selected;
3386 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3387 aSel->selectedObjects( selected );
3388 if ( selected.Extent() == 1 ) {
3389 Handle(SALOME_InteractiveObject) anIO = selected.First();
3390 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3391 if ( !aMesh->_is_nil() ) {
3392 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3393 tr( "SMESH_WARNING" ),
3394 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3395 SUIT_MessageBox::Yes |
3396 SUIT_MessageBox::No,
3397 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3400 SUIT_OverrideCursor wc;
3401 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3402 int removed = aMeshEditor->RemoveOrphanNodes();
3403 SUIT_MessageBox::information(SMESHGUI::desktop(),
3404 tr("SMESH_INFORMATION"),
3405 tr("NB_NODES_REMOVED").arg(removed));
3406 if ( removed > 0 ) {
3407 SMESH::UpdateView();
3408 SMESHGUI::Modified();
3411 catch (const SALOME::SALOME_Exception& S_ex) {
3412 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3421 case SMESHOp::OpRenumberingNodes:
3423 if(checkLock(aStudy)) break;
3425 EmitSignalDeactivateDialog();
3426 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3430 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3431 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3435 case SMESHOp::OpRenumberingElements:
3437 if(checkLock(aStudy)) break;
3439 EmitSignalDeactivateDialog();
3440 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3444 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3445 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3449 case SMESHOp::OpTranslation:
3451 if(checkLock(aStudy)) break;
3453 EmitSignalDeactivateDialog();
3454 ( new SMESHGUI_TranslationDlg( this ) )->show();
3457 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3458 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3462 case SMESHOp::OpRotation:
3464 if(checkLock(aStudy)) break;
3466 EmitSignalDeactivateDialog();
3467 ( new SMESHGUI_RotationDlg( this ) )->show();
3470 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3471 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3475 case SMESHOp::OpSymmetry:
3477 if(checkLock(aStudy)) break;
3479 EmitSignalDeactivateDialog();
3480 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3483 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3484 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3488 case SMESHOp::OpScale:
3490 if(checkLock(aStudy)) break;
3492 EmitSignalDeactivateDialog();
3493 ( new SMESHGUI_ScaleDlg( this ) )->show();
3496 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3497 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3502 case SMESHOp::OpSewing:
3504 if(checkLock(aStudy)) break;
3506 EmitSignalDeactivateDialog();
3507 ( new SMESHGUI_SewingDlg( this ) )->show();
3510 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3511 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3515 case SMESHOp::OpMergeNodes:
3517 if(checkLock(aStudy)) break;
3519 EmitSignalDeactivateDialog();
3520 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3523 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3524 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3528 case SMESHOp::OpMergeElements:
3530 if (checkLock(aStudy)) break;
3532 EmitSignalDeactivateDialog();
3533 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3535 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3536 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3541 case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
3542 startOperation( SMESHOp::OpMoveNode );
3545 case SMESHOp::OpDuplicateNodes:
3547 if(checkLock(aStudy)) break;
3549 EmitSignalDeactivateDialog();
3550 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3553 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3554 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3559 case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
3560 startOperation( SMESHOp::OpElem0DOnElemNodes );
3563 case SMESHOp::OpSelectFiltersLibrary: // Library of selection filters
3565 static QList<int> aTypes;
3566 if ( aTypes.isEmpty() )
3568 aTypes.append( SMESH::NODE );
3569 aTypes.append( SMESH::EDGE );
3570 aTypes.append( SMESH::FACE );
3571 aTypes.append( SMESH::VOLUME );
3573 if (!myFilterLibraryDlg)
3574 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3575 else if (myFilterLibraryDlg->isHidden())
3576 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3577 myFilterLibraryDlg->raise();
3581 case SMESHOp::OpFreeNode:
3582 case SMESHOp::OpEqualNode:
3583 case SMESHOp::OpNodeConnectivityNb:
3584 case SMESHOp::OpFreeEdge:
3585 case SMESHOp::OpFreeBorder:
3586 case SMESHOp::OpLength:
3587 case SMESHOp::OpConnection:
3588 case SMESHOp::OpEqualEdge:
3589 case SMESHOp::OpFreeFace:
3590 case SMESHOp::OpBareBorderFace:
3591 case SMESHOp::OpOverConstrainedFace:
3592 case SMESHOp::OpLength2D:
3593 case SMESHOp::OpConnection2D:
3594 case SMESHOp::OpArea:
3595 case SMESHOp::OpTaper:
3596 case SMESHOp::OpAspectRatio:
3597 case SMESHOp::OpMinimumAngle:
3598 case SMESHOp::OpWarpingAngle:
3599 case SMESHOp::OpSkew:
3600 case SMESHOp::OpMaxElementLength2D:
3601 case SMESHOp::OpEqualFace:
3602 case SMESHOp::OpAspectRatio3D:
3603 case SMESHOp::OpVolume:
3604 case SMESHOp::OpMaxElementLength3D:
3605 case SMESHOp::OpBareBorderVolume:
3606 case SMESHOp::OpOverConstrainedVolume:
3607 case SMESHOp::OpEqualVolume:
3610 LightApp_SelectionMgr* mgr = selectionMgr();
3611 SALOME_ListIO selected; mgr->selectedObjects( selected );
3613 if( !selected.IsEmpty() ) {
3614 SUIT_OverrideCursor wc;
3615 ::Control( theCommandID );
3618 SUIT_MessageBox::warning(desktop(),
3619 tr( "SMESH_WRN_WARNING" ),
3620 tr( "SMESH_BAD_SELECTION" ) );
3624 SUIT_MessageBox::warning(desktop(),
3625 tr( "SMESH_WRN_WARNING" ),
3626 tr( "NOT_A_VTK_VIEWER" ) );
3629 case SMESHOp::OpOverallMeshQuality:
3630 OverallMeshQuality();
3632 case SMESHOp::OpNumberingNodes:
3634 SUIT_OverrideCursor wc;
3635 LightApp_SelectionMgr* mgr = selectionMgr();
3636 SALOME_ListIO selected; mgr->selectedObjects( selected );
3638 SALOME_ListIteratorOfListIO it(selected);
3639 for( ; it.More(); it.Next()) {
3640 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3641 if(anIObject->hasEntry()) {
3642 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3643 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3649 case SMESHOp::OpNumberingElements:
3651 SUIT_OverrideCursor wc;
3652 LightApp_SelectionMgr* mgr = selectionMgr();
3653 SALOME_ListIO selected; mgr->selectedObjects( selected );
3655 SALOME_ListIteratorOfListIO it(selected);
3656 for( ; it.More(); it.Next()) {
3657 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3658 if(anIObject->hasEntry())
3659 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3660 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3665 case SMESHOp::OpPropertiesLength:
3666 case SMESHOp::OpPropertiesArea:
3667 case SMESHOp::OpPropertiesVolume:
3668 case SMESHOp::OpMinimumDistance:
3669 case SMESHOp::OpBoundingBox:
3671 int page = SMESHGUI_MeasureDlg::MinDistance;
3672 if ( theCommandID == SMESHOp::OpBoundingBox )
3673 page = SMESHGUI_MeasureDlg::BoundingBox;
3674 else if ( theCommandID == SMESHOp::OpPropertiesLength )
3675 page = SMESHGUI_MeasureDlg::Length;
3676 else if ( theCommandID == SMESHOp::OpPropertiesArea )
3677 page = SMESHGUI_MeasureDlg::Area;
3678 else if ( theCommandID == SMESHOp::OpPropertiesVolume )
3679 page = SMESHGUI_MeasureDlg::Volume;
3681 EmitSignalDeactivateDialog();
3682 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3686 case SMESHOp::OpSortChild:
3692 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3693 //updateObjBrowser();
3697 //=============================================================================
3701 //=============================================================================
3702 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3707 //=============================================================================
3711 //=============================================================================
3712 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3717 //=============================================================================
3721 //=============================================================================
3722 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3727 //=============================================================================
3728 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3729 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3731 //=============================================================================
3732 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3733 SUIT_ViewWindow* wnd )
3735 if(theIO->hasEntry()){
3736 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3737 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3741 //=======================================================================
3742 // function : createSMESHAction
3744 //=======================================================================
3745 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3746 const int key, const bool toggle, const QString& shortcutAction )
3749 QWidget* parent = application()->desktop();
3750 SUIT_ResourceMgr* resMgr = resourceMgr();
3752 if ( !icon_id.isEmpty() )
3753 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3755 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3756 if ( !pix.isNull() )
3757 icon = QIcon( pix );
3759 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3760 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3761 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3763 createAction( id, tooltip, icon, menu, status_bar, key, parent,
3764 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3767 //=======================================================================
3768 // function : createPopupItem
3770 //=======================================================================
3771 void SMESHGUI::createPopupItem( const int id,
3772 const QString& clients,
3773 const QString& types,
3774 const QString& theRule,
3777 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3778 popupMgr()->insert( action( id ), pId, 0 );
3780 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3781 QString dc = "selcount"; // VSR : insetad of QtxPopupSelection::defSelCountParam()
3782 QString rule = "(%1) and (%2) and (%3)";
3783 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3784 if( clients.isEmpty() )
3785 rule = rule.arg( QString( "true" ) );
3787 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3788 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3791 bool cont = myRules.contains( id );
3793 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3795 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3796 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3799 //=======================================================================
3800 // function : initialize
3802 //=======================================================================
3803 void SMESHGUI::initialize( CAM_Application* app )
3805 SalomeApp_Module::initialize( app );
3807 // SUIT_ResourceMgr* mgr = app->resourceMgr();
3809 /* Automatic Update flag */
3810 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3812 // ----- create actions --------------
3814 //createSMESHAction( SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
3815 createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_I) );
3816 createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
3817 //createSMESHAction( 114, "NUM" );
3818 createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL" );
3820 createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
3822 createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
3823 createSMESHAction( SMESHOp::OpImportGMF, "IMPORT_GMF" );
3824 createSMESHAction( SMESHOp::OpExportDAT, "DAT" );
3825 createSMESHAction( SMESHOp::OpExportMED, "MED" );
3826 createSMESHAction( SMESHOp::OpExportUNV, "UNV" );
3827 createSMESHAction( SMESHOp::OpExportSTL, "STL" );
3829 createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
3831 createSMESHAction( SMESHOp::OpExportSAUV, "SAUV");
3832 createSMESHAction( SMESHOp::OpExportGMF, "GMF" );
3833 createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
3834 createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
3835 createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
3836 createSMESHAction( SMESHOp::OpPopupExportSTL, "STL" );
3838 createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
3840 createSMESHAction( SMESHOp::OpPopupExportSAUV, "SAUV");
3841 createSMESHAction( SMESHOp::OpPopupExportGMF, "GMF" );
3842 createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
3843 createSMESHAction( SMESHOp::OpDelete, "DELETE", "ICON_DELETE", Qt::Key_Delete );
3844 createSMESHAction( SMESHOp::OpSelectFiltersLibrary, "SEL_FILTER_LIB" );
3845 createSMESHAction( SMESHOp::OpCreateMesh, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
3846 createSMESHAction( SMESHOp::OpCreateSubMesh, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
3847 createSMESHAction( SMESHOp::OpEditMeshOrSubMesh, "EDIT_MESHSUBMESH", "ICON_DLG_EDIT_MESH" );
3848 createSMESHAction( SMESHOp::OpEditMesh, "EDIT_MESH", "ICON_DLG_EDIT_MESH" );
3849 createSMESHAction( SMESHOp::OpEditSubMesh, "EDIT_SUBMESH", "ICON_DLG_EDIT_MESH" );
3850 createSMESHAction( SMESHOp::OpBuildCompoundMesh, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
3851 createSMESHAction( SMESHOp::OpCopyMesh, "COPY_MESH", "ICON_COPY_MESH" );
3852 createSMESHAction( SMESHOp::OpCompute, "COMPUTE", "ICON_COMPUTE" );
3853 createSMESHAction( SMESHOp::OpComputeSubMesh, "COMPUTE_SUBMESH", "ICON_COMPUTE" );
3854 createSMESHAction( SMESHOp::OpPreCompute, "PRECOMPUTE", "ICON_PRECOMPUTE" );
3855 createSMESHAction( SMESHOp::OpEvaluate, "EVALUATE", "ICON_EVALUATE" );
3856 createSMESHAction( SMESHOp::OpMeshOrder, "MESH_ORDER", "ICON_MESH_ORDER");
3857 createSMESHAction( SMESHOp::OpCreateGroup, "CREATE_GROUP", "ICON_CREATE_GROUP" );
3858 createSMESHAction( SMESHOp::OpCreateGeometryGroup, "CREATE_GEO_GROUP", "ICON_CREATE_GEO_GROUP" );
3859 createSMESHAction( SMESHOp::OpConstructGroup, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
3860 createSMESHAction( SMESHOp::OpEditGroup, "EDIT_GROUP", "ICON_EDIT_GROUP" );
3861 createSMESHAction( SMESHOp::OpEditGeomGroupAsGroup, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3862 createSMESHAction( SMESHOp::OpUnionGroups, "UN_GROUP", "ICON_UNION" );
3863 createSMESHAction( SMESHOp::OpIntersectGroups, "INT_GROUP", "ICON_INTERSECT" );
3864 createSMESHAction( SMESHOp::OpCutGroups, "CUT_GROUP", "ICON_CUT" );
3865 createSMESHAction( SMESHOp::OpGroupUnderlyingElem, "UNDERLYING_ELEMS", "ICON_UNDERLYING_ELEMS" );
3866 createSMESHAction( SMESHOp::OpAddElemGroupPopup, "ADD" );
3867 createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE" );
3868 createSMESHAction( SMESHOp::OpDeleteGroup, "DEL_GROUP", "ICON_DEL_GROUP" );
3869 createSMESHAction( SMESHOp::OpMeshInformation , "ADV_INFO", "ICON_ADV_INFO" );
3870 //createSMESHAction( SMESHOp::OpStdInfo, "STD_INFO", "ICON_STD_INFO" );
3871 //createSMESHAction( SMESHOp::OpWhatIs, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3872 createSMESHAction( SMESHOp::OpFindElementByPoint, "FIND_ELEM", "ICON_FIND_ELEM" );
3874 createSMESHAction( SMESHOp::OpFreeNode, "FREE_NODE", "ICON_FREE_NODE", 0, true );
3875 createSMESHAction( SMESHOp::OpEqualNode, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
3876 createSMESHAction( SMESHOp::OpNodeConnectivityNb, "NODE_CONNECTIVITY_NB", "ICON_NODE_CONN_NB", 0, true );
3877 createSMESHAction( SMESHOp::OpFreeEdge, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
3878 createSMESHAction( SMESHOp::OpFreeBorder, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
3879 createSMESHAction( SMESHOp::OpLength, "LENGTH", "ICON_LENGTH", 0, true );
3880 createSMESHAction( SMESHOp::OpConnection, "CONNECTION", "ICON_CONNECTION", 0, true );
3881 createSMESHAction( SMESHOp::OpEqualEdge, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
3882 createSMESHAction( SMESHOp::OpFreeFace, "FREE_FACES", "ICON_FREE_FACES", 0, true );
3883 createSMESHAction( SMESHOp::OpBareBorderFace, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
3884 createSMESHAction( SMESHOp::OpOverConstrainedFace, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
3885 createSMESHAction( SMESHOp::OpLength2D, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
3886 createSMESHAction( SMESHOp::OpConnection2D, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
3887 createSMESHAction( SMESHOp::OpArea, "AREA", "ICON_AREA", 0, true );
3888 createSMESHAction( SMESHOp::OpTaper, "TAPER", "ICON_TAPER", 0, true );
3889 createSMESHAction( SMESHOp::OpAspectRatio, "ASPECT", "ICON_ASPECT", 0, true );
3890 createSMESHAction( SMESHOp::OpMinimumAngle, "MIN_ANG", "ICON_ANGLE", 0, true );
3891 createSMESHAction( SMESHOp::OpWarpingAngle, "WARP", "ICON_WARP", 0, true );
3892 createSMESHAction( SMESHOp::OpSkew, "SKEW", "ICON_SKEW", 0, true );
3893 createSMESHAction( SMESHOp::OpMaxElementLength2D, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
3894 createSMESHAction( SMESHOp::OpEqualFace, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
3895 createSMESHAction( SMESHOp::OpAspectRatio3D, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
3896 createSMESHAction( SMESHOp::OpVolume, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
3897 createSMESHAction( SMESHOp::OpMaxElementLength3D, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
3898 createSMESHAction( SMESHOp::OpBareBorderVolume, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
3899 createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
3900 createSMESHAction( SMESHOp::OpEqualVolume, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
3901 createSMESHAction( SMESHOp::OpOverallMeshQuality, "OVERALL_MESH_QUALITY" );
3903 createSMESHAction( SMESHOp::OpNode, "NODE", "ICON_DLG_NODE" );
3904 createSMESHAction( SMESHOp::OpElem0D, "ELEM0D", "ICON_DLG_ELEM0D" );
3905 createSMESHAction( SMESHOp::OpElem0DOnElemNodes, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
3906 createSMESHAction( SMESHOp::OpBall, "BALL", "ICON_DLG_BALL" );
3907 createSMESHAction( SMESHOp::OpEdge, "EDGE", "ICON_DLG_EDGE" );
3908 createSMESHAction( SMESHOp::OpTriangle, "TRIANGLE", "ICON_DLG_TRIANGLE" );
3909 createSMESHAction( SMESHOp::OpQuadrangle, "QUAD", "ICON_DLG_QUADRANGLE" );
3910 createSMESHAction( SMESHOp::OpPolygon, "POLYGON", "ICON_DLG_POLYGON" );
3911 createSMESHAction( SMESHOp::OpTetrahedron, "TETRA", "ICON_DLG_TETRAS" );
3912 createSMESHAction( SMESHOp::OpHexahedron, "HEXA", "ICON_DLG_HEXAS" );
3913 createSMESHAction( SMESHOp::OpPentahedron, "PENTA", "ICON_DLG_PENTA" );
3914 createSMESHAction( SMESHOp::OpPyramid , "PYRAMID", "ICON_DLG_PYRAMID" );
3915 createSMESHAction( SMESHOp::OpHexagonalPrism, "OCTA", "ICON_DLG_OCTA" );
3916 createSMESHAction( SMESHOp::OpPolyhedron, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
3917 createSMESHAction( SMESHOp::OpQuadraticEdge, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
3918 createSMESHAction( SMESHOp::OpQuadraticTriangle, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
3919 createSMESHAction( SMESHOp::OpBiQuadraticTriangle, "BIQUADRATIC_TRIANGLE", "ICON_DLG_BIQUADRATIC_TRIANGLE" );
3920 createSMESHAction( SMESHOp::OpQuadraticQuadrangle, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
3921 createSMESHAction( SMESHOp::OpBiQuadraticQuadrangle, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
3922 createSMESHAction( SMESHOp::OpQuadraticPolygon, "QUADRATIC_POLYGON", "ICON_DLG_QUADRATIC_POLYGON" );
3923 createSMESHAction( SMESHOp::OpQuadraticTetrahedron, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
3924 createSMESHAction( SMESHOp::OpQuadraticPyramid, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
3925 createSMESHAction( SMESHOp::OpQuadraticPentahedron, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
3926 createSMESHAction( SMESHOp::OpQuadraticHexahedron, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
3927 createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
3929 createSMESHAction( SMESHOp::OpRemoveNodes, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
3930 createSMESHAction( SMESHOp::OpRemoveElements, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
3931 createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
3932 createSMESHAction( SMESHOp::OpClearMesh, "CLEAR_MESH", "ICON_CLEAR_MESH" );
3934 //createSMESHAction( SMESHOp::OpRenumberingNodes, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
3935 //createSMESHAction( SMESHOp::OpRenumberingElements, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
3937 createSMESHAction( SMESHOp::OpTranslation, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
3938 createSMESHAction( SMESHOp::OpRotation, "ROT", "ICON_DLG_MESH_ROTATION" );
3939 createSMESHAction( SMESHOp::OpSymmetry, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
3940 createSMESHAction( SMESHOp::OpScale, "SCALE", "ICON_DLG_MESH_SCALE" );
3941 createSMESHAction( SMESHOp::OpSewing, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
3942 createSMESHAction( SMESHOp::OpMergeNodes, "MERGE", "ICON_SMESH_MERGE_NODES" );
3943 createSMESHAction( SMESHOp::OpMergeElements, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
3944 createSMESHAction( SMESHOp::OpMoveNode, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
3945 createSMESHAction( SMESHOp::OpDuplicateNodes, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
3946 createSMESHAction( SMESHOp::OpDiagonalInversion, "INV", "ICON_DLG_MESH_DIAGONAL" );
3947 createSMESHAction( SMESHOp::OpUnionOfTwoTriangle, "UNION2", "ICON_UNION2TRI" );
3948 createSMESHAction( SMESHOp::OpOrientation, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
3949 createSMESHAction( SMESHOp::OpReorientFaces, "REORIENT_2D", "ICON_REORIENT_2D" );
3950 createSMESHAction( SMESHOp::OpUnionOfTriangles, "UNION", "ICON_UNIONTRI" );
3951 createSMESHAction( SMESHOp::OpCuttingOfQuadrangles, "CUT", "ICON_CUTQUAD" );
3952 createSMESHAction( SMESHOp::OpSplitVolumes, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
3953 createSMESHAction( SMESHOp::OpSplitBiQuadratic, "SPLIT_BIQUAD", "ICON_SPLIT_BIQUAD" );
3954 createSMESHAction( SMESHOp::OpSmoothing, "SMOOTH", "ICON_DLG_SMOOTHING" );
3955 createSMESHAction( SMESHOp::OpExtrusion, "EXTRUSION", "ICON_EXTRUSION" );
3956 createSMESHAction( SMESHOp::OpExtrusionAlongAPath, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
3957 createSMESHAction( SMESHOp::OpRevolution, "REVOLUTION", "ICON_REVOLUTION" );
3958 createSMESHAction( SMESHOp::OpPatternMapping, "MAP", "ICON_MAP" );
3959 createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
3960 createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D", "ICON_2D_FROM_3D" );
3962 createSMESHAction( SMESHOp::OpReset, "RESET" );
3963 createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
3964 createSMESHAction( SMESHOp::OpShowScalarBar, "SHOW_SCALAR_BAR","",0, true );
3965 createSMESHAction( SMESHOp::OpSaveDistribution, "SAVE_DISTRIBUTION" );
3966 createSMESHAction( SMESHOp::OpShowDistribution, "SHOW_DISTRIBUTION","",0, true );
3967 #ifndef DISABLE_PLOT2DVIEWER
3968 createSMESHAction( SMESHOp::OpPlotDistribution, "PLOT_DISTRIBUTION" );
3970 createSMESHAction( SMESHOp::OpDMWireframe, "WIRE", "ICON_WIRE", 0, true );
3971 createSMESHAction( SMESHOp::OpDMShading, "SHADE", "ICON_SHADE", 0, true );
3972 createSMESHAction( SMESHOp::OpDMNodes, "NODES", "ICON_POINTS", 0, true );
3973 createSMESHAction( SMESHOp::OpDMShrink, "SHRINK", "ICON_SHRINK", 0, true );
3974 createSMESHAction( SMESHOp::OpUpdate, "UPDATE", "ICON_UPDATE" );
3975 createSMESHAction( SMESHOp::OpDE0DElements, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
3976 createSMESHAction( SMESHOp::OpDEEdges, "EDGES", "ICON_DLG_EDGE", 0, true );
3977 createSMESHAction( SMESHOp::OpDEFaces, "FACES", "ICON_DLG_TRIANGLE", 0, true );
3978 createSMESHAction( SMESHOp::OpDEVolumes, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
3979 createSMESHAction( SMESHOp::OpDEBalls, "BALLS", "ICON_DLG_BALL", 0, true );
3980 createSMESHAction( SMESHOp::OpDEChoose, "CHOOSE", "ICON_DLG_CHOOSE", 0, false );
3981 createSMESHAction( SMESHOp::OpDEAllEntity, "ALL", "ICON_DLG_CHOOSE_ALL", 0, false );
3982 createSMESHAction( SMESHOp::OpOrientationOnFaces, "FACE_ORIENTATION", "", 0, true );
3984 createSMESHAction( SMESHOp::OpRepresentationLines, "LINE_REPRESENTATION", "", 0, true );
3985 createSMESHAction( SMESHOp::OpRepresentationArcs, "ARC_REPRESENTATION", "", 0, true );
3987 createSMESHAction( SMESHOp::OpEditHypothesis, "EDIT_HYPO" );
3988 createSMESHAction( SMESHOp::OpUnassign, "UNASSIGN" );
3989 createSMESHAction( SMESHOp::OpNumberingNodes, "NUM_NODES", "", 0, true );
3990 createSMESHAction( SMESHOp::OpNumberingElements, "NUM_ELEMENTS", "", 0, true );
3991 createSMESHAction( SMESHOp::OpProperties, "COLORS" );
3992 createSMESHAction( SMESHOp::OpTransparency, "TRANSP" );
3993 createSMESHAction( SMESHOp::OpClipping, "CLIP" );
3994 createSMESHAction( SMESHOp::OpAutoColor, "AUTO_COLOR" );
3995 createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
3997 createSMESHAction( SMESHOp::OpMinimumDistance, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
3998 createSMESHAction( SMESHOp::OpBoundingBox, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
3999 createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH", "ICON_MEASURE_LENGTH" );
4000 createSMESHAction( SMESHOp::OpPropertiesArea, "MEASURE_AREA", "ICON_MEASURE_AREA" );
4001 createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME", "ICON_MEASURE_VOLUME" );
4003 createSMESHAction( SMESHOp::OpHide, "HIDE" );
4004 createSMESHAction( SMESHOp::OpShow, "SHOW" );
4005 createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
4007 createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
4009 QList<int> aCtrlActions;
4010 aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode
4011 << SMESHOp::OpNodeConnectivityNb // node controls
4012 << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
4013 << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge // edge controls
4014 << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
4015 << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
4016 << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
4017 << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
4018 << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace // face controls
4019 << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
4020 << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
4021 << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume; // volume controls
4022 QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
4023 aCtrlGroup->setExclusive( true );
4024 for( int i = 0; i < aCtrlActions.size(); i++ )
4025 aCtrlGroup->addAction( action( aCtrlActions[i] ) );
4027 // ----- create menu --------------
4028 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
4029 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
4030 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
4031 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
4032 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
4033 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
4034 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
4035 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
4037 createMenu( separator(), fileId );
4039 QMenu* nodeMenu = new QMenu(); QMenu* edgeMenu = new QMenu();
4040 QMenu* faceMenu = new QMenu(); QMenu* volumeMenu = new QMenu();
4041 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
4042 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
4043 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10, -1, nodeMenu ),
4044 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10, -1, edgeMenu ),
4045 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10, -1, faceMenu ),
4046 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10, -1, volumeMenu ),
4047 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
4048 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
4049 //renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
4050 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
4051 basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
4053 //createMenu( SMESHOp::OpImportDAT, importId, -1 );
4054 createMenu( SMESHOp::OpImportUNV, importId, -1 );
4055 createMenu( SMESHOp::OpImportMED, importId, -1 );
4056 createMenu( SMESHOp::OpImportSTL, importId, -1 );
4058 createMenu( SMESHOp::OpImportCGNS, importId, -1 );
4060 createMenu( SMESHOp::OpImportSAUV, importId, -1 );
4061 createMenu( SMESHOp::OpImportGMF, importId, -1 );
4062 createMenu( SMESHOp::OpExportDAT, exportId, -1 );
4063 createMenu( SMESHOp::OpExportMED, exportId, -1 );
4064 createMenu( SMESHOp::OpExportUNV, exportId, -1 );
4065 createMenu( SMESHOp::OpExportSTL, exportId, -1 );
4067 createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
4069 createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
4070 createMenu( SMESHOp::OpExportGMF, exportId, -1 );
4071 createMenu( separator(), fileId, 10 );
4073 createMenu( SMESHOp::OpDelete, editId, -1 );
4075 createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
4077 createMenu( SMESHOp::OpCreateMesh, meshId, -1 ); // "Mesh" menu
4078 createMenu( SMESHOp::OpCreateSubMesh, meshId, -1 );
4079 createMenu( SMESHOp::OpEditMeshOrSubMesh, meshId, -1 );
4080 createMenu( SMESHOp::OpBuildCompoundMesh, meshId, -1 );
4081 createMenu( SMESHOp::OpCopyMesh, meshId, -1 );
4082 createMenu( separator(), meshId, -1 );
4083 createMenu( SMESHOp::OpCompute, meshId, -1 );
4084 createMenu( SMESHOp::OpPreCompute, meshId, -1 );
4085 createMenu( SMESHOp::OpEvaluate, meshId, -1 );
4086 createMenu( SMESHOp::OpMeshOrder, meshId, -1 );
4087 createMenu( separator(), meshId, -1 );
4088 createMenu( SMESHOp::OpCreateGroup, meshId, -1 );
4089 createMenu( SMESHOp::OpCreateGeometryGroup, meshId, -1 );
4090 createMenu( SMESHOp::OpConstructGroup, meshId, -1 );
4091 createMenu( SMESHOp::OpEditGroup, meshId, -1 );
4092 createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4093 createMenu( separator(), meshId, -1 );
4094 createMenu( SMESHOp::OpUnionGroups, meshId, -1 );
4095 createMenu( SMESHOp::OpIntersectGroups, meshId, -1 );
4096 createMenu( SMESHOp::OpCutGroups, meshId, -1 );
4097 createMenu( separator(), meshId, -1 );
4098 createMenu( SMESHOp::OpGroupUnderlyingElem, meshId, -1 );
4099 createMenu( separator(), meshId, -1 );
4100 createMenu( SMESHOp::OpMeshInformation, meshId, -1 );
4101 //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4102 //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4103 createMenu( SMESHOp::OpFindElementByPoint, meshId, -1 );
4104 createMenu( separator(), meshId, -1 );
4106 createMenu( SMESHOp::OpFreeNode, nodeId, -1 );
4107 createMenu( SMESHOp::OpEqualNode, nodeId, -1 );
4108 //createMenu( SMESHOp::OpNodeConnectivityNb, nodeId, -1 );
4109 createMenu( SMESHOp::OpFreeBorder, edgeId, -1 );
4110 createMenu( SMESHOp::OpLength, edgeId, -1 );
4111 createMenu( SMESHOp::OpConnection, edgeId, -1 );
4112 createMenu( SMESHOp::OpEqualEdge, edgeId, -1 );
4113 createMenu( SMESHOp::OpFreeEdge, faceId, -1 );
4114 createMenu( SMESHOp::OpFreeFace, faceId, -1 );
4115 createMenu( SMESHOp::OpBareBorderFace, faceId, -1 );
4116 createMenu( SMESHOp::OpOverConstrainedFace, faceId, -1 );
4117 createMenu( SMESHOp::OpLength2D, faceId, -1 );
4118 createMenu( SMESHOp::OpConnection2D, faceId, -1 );
4119 createMenu( SMESHOp::OpArea, faceId, -1 );
4120 createMenu( SMESHOp::OpTaper, faceId, -1 );
4121 createMenu( SMESHOp::OpAspectRatio, faceId, -1 );
4122 createMenu( SMESHOp::OpMinimumAngle, faceId, -1 );
4123 createMenu( SMESHOp::OpWarpingAngle, faceId, -1 );
4124 createMenu( SMESHOp::OpSkew, faceId, -1 );
4125 createMenu( SMESHOp::OpMaxElementLength2D, faceId, -1 );
4126 createMenu( SMESHOp::OpEqualFace, faceId, -1 );
4127 createMenu( SMESHOp::OpAspectRatio3D, volumeId, -1 );
4128 createMenu( SMESHOp::OpVolume, volumeId, -1 );
4129 createMenu( SMESHOp::OpMaxElementLength3D, volumeId, -1 );
4130 createMenu( SMESHOp::OpBareBorderVolume, volumeId, -1 );
4131 createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4132 createMenu( SMESHOp::OpEqualVolume, volumeId, -1 );
4133 createMenu( separator(), ctrlId, -1 );
4134 createMenu( SMESHOp::OpReset, ctrlId, -1 );
4135 createMenu( separator(), ctrlId, -1 );
4136 createMenu( SMESHOp::OpOverallMeshQuality, ctrlId, -1 );
4138 createMenu( SMESHOp::OpNode, addId, -1 );
4139 createMenu( SMESHOp::OpElem0D, addId, -1 );
4140 createMenu( SMESHOp::OpElem0DOnElemNodes, addId, -1 );
4141 createMenu( SMESHOp::OpBall, addId, -1 );
4142 createMenu( SMESHOp::OpEdge, addId, -1 );
4143 createMenu( SMESHOp::OpTriangle, addId, -1 );
4144 createMenu( SMESHOp::OpQuadrangle, addId, -1 );
4145 createMenu( SMESHOp::OpPolygon, addId, -1 );
4146 createMenu( SMESHOp::OpTetrahedron, addId, -1 );
4147 createMenu( SMESHOp::OpHexahedron, addId, -1 );
4148 createMenu( SMESHOp::OpPentahedron, addId, -1 );
4149 createMenu( SMESHOp::OpPyramid, addId, -1 );
4150 createMenu( SMESHOp::OpHexagonalPrism, addId, -1 );
4151 createMenu( SMESHOp::OpPolyhedron, addId, -1 );
4152 createMenu( separator(), addId, -1 );
4153 createMenu( SMESHOp::OpQuadraticEdge, addId, -1 );
4154 createMenu( SMESHOp::OpQuadraticTriangle, addId, -1 );
4155 createMenu( SMESHOp::OpBiQuadraticTriangle , addId, -1 );
4156 createMenu( SMESHOp::OpQuadraticQuadrangle, addId, -1 );
4157 createMenu( SMESHOp::OpBiQuadraticQuadrangle, addId, -1 );
4158 createMenu( SMESHOp::OpQuadraticPolygon, addId, -1 );
4159 createMenu( SMESHOp::OpQuadraticTetrahedron, addId, -1 );
4160 createMenu( SMESHOp::OpQuadraticPyramid, addId, -1 );
4161 createMenu( SMESHOp::OpQuadraticPentahedron, addId, -1 );
4162 createMenu( SMESHOp::OpQuadraticHexahedron, addId, -1 );
4163 createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4165 createMenu( SMESHOp::OpRemoveNodes, removeId, -1 );
4166 createMenu( SMESHOp::OpRemoveElements, removeId, -1 );
4167 createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4168 createMenu( separator(), removeId, -1 );
4169 createMenu( SMESHOp::OpDeleteGroup, removeId, -1 );
4170 createMenu( separator(), removeId, -1 );
4171 createMenu( SMESHOp::OpClearMesh, removeId, -1 );
4173 //createMenu( SMESHOp::OpRenumberingNodes, renumId, -1 );
4174 //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4176 createMenu( SMESHOp::OpTranslation, transfId, -1 );
4177 createMenu( SMESHOp::OpRotation, transfId, -1 );
4178 createMenu( SMESHOp::OpSymmetry, transfId, -1 );
4179 createMenu( SMESHOp::OpScale, transfId, -1 );
4180 createMenu( SMESHOp::OpSewing, transfId, -1 );
4181 createMenu( SMESHOp::OpMergeNodes, transfId, -1 );
4182 createMenu( SMESHOp::OpMergeElements, transfId, -1 );
4183 createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4185 createMenu( SMESHOp::OpMoveNode, modifyId, -1 );
4186 createMenu( SMESHOp::OpDiagonalInversion, modifyId, -1 );
4187 createMenu( SMESHOp::OpUnionOfTwoTriangle, modifyId, -1 );
4188 createMenu( SMESHOp::OpOrientation, modifyId, -1 );
4189 createMenu( SMESHOp::OpReorientFaces, modifyId, -1 );
4190 createMenu( SMESHOp::OpUnionOfTriangles, modifyId, -1 );
4191 createMenu( SMESHOp::OpCuttingOfQuadrangles, modifyId, -1 );
4192 createMenu( SMESHOp::OpSplitVolumes, modifyId, -1 );
4193 createMenu( SMESHOp::OpSplitBiQuadratic, modifyId, -1 );
4194 createMenu( SMESHOp::OpSmoothing, modifyId, -1 );
4195 createMenu( SMESHOp::OpExtrusion, modifyId, -1 );
4196 createMenu( SMESHOp::OpExtrusionAlongAPath , modifyId, -1 );
4197 createMenu( SMESHOp::OpRevolution, modifyId, -1 );
4198 createMenu( SMESHOp::OpPatternMapping, modifyId, -1 );
4199 createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4200 createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4202 createMenu( SMESHOp::OpMinimumDistance, measureId, -1 );
4203 createMenu( SMESHOp::OpBoundingBox, measureId, -1 );
4204 createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4205 createMenu( SMESHOp::OpPropertiesArea, basicPropId, -1 );
4206 createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4207 createMenu( SMESHOp::OpUpdate, viewId, -1 );
4209 connect( nodeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4210 connect( edgeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4211 connect( faceMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4212 connect( volumeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4214 // ----- create toolbars --------------
4215 int meshTb = createTool( tr( "TB_MESH" ), QString( "SMESHMeshToolbar" ) ),
4216 info = createTool( tr( "TB_INFO" ), QString( "SMESHInformationToolbar" ) ),
4217 groupTb = createTool( tr( "TB_GROUP" ), QString( "SMESHGroupToolbar" ) ),
4218 ctrl0dTb = createTool( tr( "TB_CTRL0D" ), QString( "SMESHNodeControlsToolbar" ) ),
4219 ctrl1dTb = createTool( tr( "TB_CTRL1D" ), QString( "SMESHEdgeControlsToolbar" ) ),
4220 ctrl2dTb = createTool( tr( "TB_CTRL2D" ), QString( "SMESHFaceControlsToolbar" ) ),
4221 ctrl3dTb = createTool( tr( "TB_CTRL3D" ), QString( "SMESHVolumeControlsToolbar" ) ),
4222 addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ),
4223 addNonElemTb = createTool( tr( "TB_ADDNON" ), QString( "SMESHAddElementToolbar" ) ),
4224 remTb = createTool( tr( "TB_REM" ), QString( "SMESHRemoveToolbar" ) ),
4225 //renumbTb = createTool( tr( "TB_RENUMBER" ), QString( "SMESHRenumberingToolbar" ) ),
4226 transformTb = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ),
4227 modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ),
4228 measuremTb = createTool( tr( "TB_MEASUREM" ), QString( "SMESHMeasurementsToolbar" ) ),
4229 dispModeTb = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4231 createTool( SMESHOp::OpCreateMesh, meshTb );
4232 createTool( SMESHOp::OpCreateSubMesh, meshTb );
4233 createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4234 createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4235 createTool( SMESHOp::OpCopyMesh, meshTb );
4236 createTool( separator(), meshTb );
4237 createTool( SMESHOp::OpCompute, meshTb );
4238 createTool( SMESHOp::OpPreCompute, meshTb );
4239 createTool( SMESHOp::OpEvaluate, meshTb );
4240 createTool( SMESHOp::OpMeshOrder, meshTb );
4242 createTool( SMESHOp::OpCreateGroup, groupTb );
4243 createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4244 createTool( SMESHOp::OpConstructGroup, groupTb );
4245 createTool( SMESHOp::OpEditGroup, groupTb );
4247 createTool( SMESHOp::OpMeshInformation, info );
4248 //createTool( SMESHOp::OpStdInfo, meshTb );
4249 //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4250 createTool( SMESHOp::OpFindElementByPoint, info );
4252 createTool( SMESHOp::OpFreeNode, ctrl0dTb );
4253 createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4254 //createTool( SMESHOp::OpNodeConnectivityNb, ctrl0dTb );
4256 createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4257 createTool( SMESHOp::OpLength, ctrl1dTb );
4258 createTool( SMESHOp::OpConnection, ctrl1dTb );
4259 createTool( SMESHOp::OpEqualEdge, ctrl1dTb );
4261 createTool( SMESHOp::OpFreeEdge, ctrl2dTb );
4262 createTool( SMESHOp::OpFreeFace, ctrl2dTb );
4263 createTool( SMESHOp::OpBareBorderFace, ctrl2dTb );
4264 createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4265 createTool( SMESHOp::OpLength2D, ctrl2dTb );
4266 createTool( SMESHOp::OpConnection2D, ctrl2dTb );
4267 createTool( SMESHOp::OpArea, ctrl2dTb );
4268 createTool( SMESHOp::OpTaper, ctrl2dTb );
4269 createTool( SMESHOp::OpAspectRatio, ctrl2dTb );
4270 createTool( SMESHOp::OpMinimumAngle, ctrl2dTb );
4271 createTool( SMESHOp::OpWarpingAngle, ctrl2dTb );
4272 createTool( SMESHOp::OpSkew, ctrl2dTb );
4273 createTool( SMESHOp::OpMaxElementLength2D, ctrl2dTb );
4274 createTool( SMESHOp::OpEqualFace, ctrl2dTb );
4276 createTool( SMESHOp::OpAspectRatio3D, ctrl3dTb );
4277 createTool( SMESHOp::OpVolume, ctrl3dTb );
4278 createTool( SMESHOp::OpMaxElementLength3D, ctrl3dTb );
4279 createTool( SMESHOp::OpBareBorderVolume, ctrl3dTb );
4280 createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
4281 createTool( SMESHOp::OpEqualVolume, ctrl3dTb );
4283 createTool( SMESHOp::OpNode, addElemTb );
4284 createTool( SMESHOp::OpElem0D, addElemTb );
4285 createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4286 createTool( SMESHOp::OpBall, addElemTb );
4287 createTool( SMESHOp::OpEdge, addElemTb );
4288 createTool( SMESHOp::OpTriangle, addElemTb );
4289 createTool( SMESHOp::OpQuadrangle, addElemTb );
4290 createTool( SMESHOp::OpPolygon, addElemTb );
4291 createTool( SMESHOp::OpTetrahedron, addElemTb );
4292 createTool( SMESHOp::OpHexahedron, addElemTb );
4293 createTool( SMESHOp::OpPentahedron, addElemTb );
4294 createTool( SMESHOp::OpPyramid, addElemTb );
4295 createTool( SMESHOp::OpHexagonalPrism, addElemTb );
4296 createTool( SMESHOp::OpPolyhedron, addElemTb );
4298 createTool( SMESHOp::OpQuadraticEdge, addNonElemTb );
4299 createTool( SMESHOp::OpQuadraticTriangle, addNonElemTb );
4300 createTool( SMESHOp::OpBiQuadraticTriangle, addNonElemTb );
4301 createTool( SMESHOp::OpQuadraticQuadrangle, addNonElemTb );
4302 createTool( SMESHOp::OpBiQuadraticQuadrangle, addNonElemTb );
4303 createTool( SMESHOp::OpQuadraticPolygon, addNonElemTb );
4304 createTool( SMESHOp::OpQuadraticTetrahedron, addNonElemTb );
4305 createTool( SMESHOp::OpQuadraticPyramid, addNonElemTb );
4306 createTool( SMESHOp::OpQuadraticPentahedron, addNonElemTb );
4307 createTool( SMESHOp::OpQuadraticHexahedron, addNonElemTb );
4308 createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4310 createTool( SMESHOp::OpRemoveNodes, remTb );
4311 createTool( SMESHOp::OpRemoveElements, remTb );
4312 createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4313 createTool( SMESHOp::OpClearMesh, remTb );
4315 //createTool( SMESHOp::OpRenumberingNodes, renumbTb );
4316 //createTool( SMESHOp::OpRenumberingElements, renumbTb );
4318 createTool( SMESHOp::OpTranslation, transformTb );
4319 createTool( SMESHOp::OpRotation, transformTb );
4320 createTool( SMESHOp::OpSymmetry, transformTb );
4321 createTool( SMESHOp::OpScale, transformTb );
4322 createTool( SMESHOp::OpSewing, transformTb );
4323 createTool( SMESHOp::OpMergeNodes, transformTb );
4324 createTool( SMESHOp::OpMergeElements, transformTb );
4325 createTool( SMESHOp::OpDuplicateNodes, transformTb );
4327 createTool( SMESHOp::OpMoveNode, modifyTb );
4328 createTool( SMESHOp::OpDiagonalInversion, modifyTb );
4329 createTool( SMESHOp::OpUnionOfTwoTriangle, modifyTb );
4330 createTool( SMESHOp::OpOrientation, modifyTb );
4331 createTool( SMESHOp::OpReorientFaces, modifyTb );
4332 createTool( SMESHOp::OpUnionOfTriangles, modifyTb );
4333 createTool( SMESHOp::OpCuttingOfQuadrangles, modifyTb );
4334 createTool( SMESHOp::OpSplitVolumes, modifyTb );
4335 createTool( SMESHOp::OpSplitBiQuadratic, modifyTb );
4336 createTool( SMESHOp::OpSmoothing, modifyTb );
4337 createTool( SMESHOp::OpExtrusion, modifyTb );
4338 createTool( SMESHOp::OpExtrusionAlongAPath, modifyTb );
4339 createTool( SMESHOp::OpRevolution, modifyTb );
4340 createTool( SMESHOp::OpPatternMapping, modifyTb );
4341 createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4342 createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4344 createTool( SMESHOp::OpMinimumDistance, measuremTb );
4346 createTool( SMESHOp::OpUpdate, dispModeTb );
4348 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4349 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4353 OB = "'ObjectBrowser'",
4354 View = "'" + SVTK_Viewer::Type() + "'",
4356 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4357 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4358 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4359 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4360 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4361 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4362 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4363 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4364 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4365 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4366 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4368 mesh_part = mesh + " " + subMesh + " " + group,
4369 mesh_group = mesh + " " + group,
4370 mesh_submesh = mesh + " " + subMesh,
4371 hyp_alg = hypo + " " + algo;
4373 // popup for object browser
4375 isInvisible("not( isVisible )"),
4376 isEmpty("numberOfNodes = 0"),
4377 isNotEmpty("numberOfNodes <> 0"),
4379 // has nodes, edges, etc in VISIBLE! actor
4380 hasNodes("(numberOfNodes > 0 )"),//&& isVisible)"),
4381 hasElems("(count( elemTypes ) > 0)"),
4382 hasDifferentElems("(count( elemTypes ) > 1)"),
4383 hasBalls("({'BallElem'} in elemTypes)"),
4384 hasElems0d("({'Elem0d'} in elemTypes)"),
4385 hasEdges("({'Edge'} in elemTypes)"),
4386 hasFaces("({'Face'} in elemTypes)"),
4387 hasVolumes("({'Volume'} in elemTypes)"),
4388 hasFacesOrVolumes("(({'Face'} in elemTypes) || ({'Volume'} in elemTypes)) ");
4390 createPopupItem( SMESHOp::OpFileInformation, OB, mesh, "&& selcount=1 && isImported" );
4391 createPopupItem( SMESHOp::OpCreateSubMesh, OB, mesh, "&& hasGeomReference");
4392 createPopupItem( SMESHOp::OpEditMesh, OB, mesh, "&& selcount=1" );
4393 createPopupItem( SMESHOp::OpEditSubMesh, OB, subMesh, "&& selcount=1 && hasGeomReference" );
4394 createPopupItem( SMESHOp::OpEditGroup, OB, group );
4395 createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4397 popupMgr()->insert( separator(), -1, 0 );
4398 createPopupItem( SMESHOp::OpCompute, OB, mesh, "&& selcount=1 && isComputable" );
4399 createPopupItem( SMESHOp::OpComputeSubMesh, OB, subMesh, "&& selcount=1 && isComputable" );
4400 createPopupItem( SMESHOp::OpPreCompute, OB, mesh, "&& selcount=1 && isPreComputable" );
4401 createPopupItem( SMESHOp::OpEvaluate, OB, mesh, "&& selcount=1 && isComputable" );
4402 createPopupItem( SMESHOp::OpMeshOrder, OB, mesh, "&& selcount=1 && isComputable && hasGeomReference" );
4403 createPopupItem( SMESHOp::OpUpdate, OB, mesh_part );
4404 createPopupItem( SMESHOp::OpMeshInformation, OB, mesh_part );
4405 createPopupItem( SMESHOp::OpFindElementByPoint,OB, mesh_group, "&& selcount=1" );
4406 createPopupItem( SMESHOp::OpOverallMeshQuality,OB, mesh_part );
4407 popupMgr()->insert( separator(), -1, 0 );
4408 createPopupItem( SMESHOp::OpCreateGroup, OB, mesh, "&& selcount=1" );
4409 createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh, "&& selcount=1 && hasGeomReference" );
4410 createPopupItem( SMESHOp::OpConstructGroup, OB, subMesh );
4411 popupMgr()->insert( separator(), -1, 0 );
4412 createPopupItem( SMESHOp::OpEditHypothesis, OB, hypo, "&& isEditableHyp");
4413 createPopupItem( SMESHOp::OpUnassign, OB, hyp_alg );
4414 popupMgr()->insert( separator(), -1, 0 );
4415 createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh_submesh );
4416 createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh_group, "&& selcount=1 && dim>=2");
4417 popupMgr()->insert( separator(), -1, 0 );
4418 createPopupItem( SMESHOp::OpClearMesh, OB, mesh );
4419 //popupMgr()->insert( separator(), -1, 0 );
4421 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4422 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4423 QString only_one_2D = only_one_non_empty + " && dim>1";
4425 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4426 createPopupItem( SMESHOp::OpPopupExportMED, OB, mesh_group, multiple_non_empty, anId );
4427 createPopupItem( SMESHOp::OpPopupExportUNV, OB, mesh_group, only_one_non_empty, anId );
4428 createPopupItem( SMESHOp::OpPopupExportSTL, OB, mesh_group, only_one_2D, anId );
4430 createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4432 createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, only_one_non_empty, anId );
4433 createPopupItem( SMESHOp::OpPopupExportGMF, OB, mesh_group, only_one_non_empty, anId );
4434 createPopupItem( SMESHOp::OpPopupExportDAT, OB, mesh_group, only_one_non_empty, anId );
4435 createPopupItem( SMESHOp::OpDelete, OB, mesh_part + " " + hyp_alg );
4436 createPopupItem( SMESHOp::OpDeleteGroup, OB, group );
4437 popupMgr()->insert( separator(), -1, 0 );
4440 createPopupItem( SMESHOp::OpEditGroup, View, group );
4441 createPopupItem( SMESHOp::OpAddElemGroupPopup, View, elems );
4442 createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems );
4444 popupMgr()->insert( separator(), -1, 0 );
4445 createPopupItem( SMESHOp::OpUpdate, View, mesh_part );
4446 createPopupItem( SMESHOp::OpMeshInformation, View, mesh_part );
4447 createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4448 createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh );
4449 popupMgr()->insert( separator(), -1, 0 );
4451 createPopupItem( SMESHOp::OpAutoColor, OB + " " + View, mesh, "&& (not isAutoColor)" );
4452 createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4453 popupMgr()->insert( separator(), -1, 0 );
4455 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4456 QString aType = QString( "%1type in {%2}" ).arg( lc );
4457 aType = aType.arg( mesh_part );
4458 QString aMeshInVTK = aClient + "&&" + aType;
4460 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4461 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4462 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4464 //-------------------------------------------------
4466 //-------------------------------------------------
4467 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4469 popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4470 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4471 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4473 popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4474 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4475 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4477 popupMgr()->insert( separator(), -1, -1 );
4479 //-------------------------------------------------
4481 //-------------------------------------------------
4482 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4484 popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4485 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4486 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4488 popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4489 popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4490 popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4492 popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4493 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes, QtxPopupMgr::VisibleRule );
4494 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4496 popupMgr()->insert( separator(), anId, -1 );
4498 popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4499 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4500 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4502 //-------------------------------------------------
4504 //-------------------------------------------------
4505 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4507 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4509 popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4510 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4511 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4513 popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4514 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4515 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4517 popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4518 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4519 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4521 popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4522 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4523 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4525 popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4526 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4527 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4529 popupMgr()->insert( separator(), anId, -1 );
4531 popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4532 popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&&" + aType + "&&" + isNotEmpty, QtxPopupMgr::VisibleRule );
4534 popupMgr()->insert( separator(), anId, -1 );
4536 popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4537 popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4540 //-------------------------------------------------
4541 // Representation of the 2D Quadratic elements
4542 //-------------------------------------------------
4543 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4544 popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4545 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "&& isVisible && isQuadratic",QtxPopupMgr::VisibleRule );
4546 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4548 popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4549 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "&& isVisible && isQuadratic", QtxPopupMgr::VisibleRule );
4550 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4552 //-------------------------------------------------
4553 // Orientation of faces
4554 //-------------------------------------------------
4555 popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4556 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4557 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4559 //-------------------------------------------------
4561 //-------------------------------------------------
4562 popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4563 popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4565 //-------------------------------------------------
4567 //-------------------------------------------------
4568 popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4569 popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4571 //-------------------------------------------------
4573 //-------------------------------------------------
4575 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4576 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4577 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4578 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4580 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4582 popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4583 popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4585 popupMgr()->insert( separator(), anId, -1 );
4587 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4589 popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4590 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4591 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4593 popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4594 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4595 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4597 // popupMgr()->insert( action( SMESHOp::OpNodeConnectivityNb ), aSubId, -1 );
4598 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4599 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), "controlMode = 'eNodeConnectivityNb'", QtxPopupMgr::ToggleRule );
4601 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4603 popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4604 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVTK + "&&" + hasEdges + "&&" + hasFacesOrVolumes, QtxPopupMgr::VisibleRule );
4605 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4607 popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4608 popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4609 popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4611 popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4612 popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4613 popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4614 popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4615 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4616 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4618 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4620 popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4621 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4622 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4624 popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4625 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4626 QtxPopupMgr::VisibleRule );
4627 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4629 popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4630 popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4631 popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4633 popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4634 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4635 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4637 popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
4638 popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4639 popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4641 popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
4642 popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4643 popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4645 popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
4646 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4647 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4649 popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
4650 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4651 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4653 popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
4654 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4655 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4657 popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
4658 popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4659 popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4661 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
4662 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4663 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4665 popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
4666 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4667 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4669 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
4670 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4671 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4672 popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
4673 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4674 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4676 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4678 popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D ), aSubId, -1 );
4679 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4680 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4682 popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
4683 popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4684 popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4686 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
4687 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4688 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4690 popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
4691 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4692 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4694 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
4695 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4696 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4698 popupMgr()->insert ( action( SMESHOp::OpEqualVolume ), aSubId, -1 );
4699 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4700 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4702 popupMgr()->insert( separator(), anId, -1 );
4704 popupMgr()->insert( action( SMESHOp::OpShowScalarBar ), anId, -1 );
4705 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4706 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone' && isScalarBarVisible", QtxPopupMgr::ToggleRule );
4707 popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
4708 popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4710 popupMgr()->insert( separator(), anId, -1 );
4712 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4714 popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
4715 popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4717 popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
4718 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4719 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isScalarBarVisible && isDistributionVisible", QtxPopupMgr::ToggleRule);
4721 #ifndef DISABLE_PLOT2DVIEWER
4722 popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
4723 popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4726 //-------------------------------------------------
4728 //-------------------------------------------------
4729 popupMgr()->insert( separator(), -1, -1 );
4730 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4731 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4732 popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
4733 popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4735 popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
4736 popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4738 popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
4739 popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4741 popupMgr()->insert( separator(), -1, -1 );
4743 //-------------------------------------------------
4745 //-------------------------------------------------
4746 popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
4747 popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4749 popupMgr()->insert( separator(), -1, -1 );
4751 popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
4752 popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
4753 popupMgr()->insert( separator(), -1, -1 );
4755 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4756 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4758 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4759 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4762 //================================================================================
4764 * \brief Return true if SMESH or GEOM objects are selected.
4765 * Is called form LightApp_Module::activateModule() which clear selection if
4766 * not isSelectionCompatible()
4768 //================================================================================
4770 bool SMESHGUI::isSelectionCompatible()
4772 bool isCompatible = true;
4773 SALOME_ListIO selected;
4774 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4775 Sel->selectedObjects( selected );
4777 SALOME_ListIteratorOfListIO It( selected );
4778 for ( ; isCompatible && It.More(); It.Next())
4780 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4781 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4783 return isCompatible;
4787 bool SMESHGUI::reusableOperation( const int id )
4789 // compute, evaluate and precompute are not reusable operations
4790 return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate ) ? false : SalomeApp_Module::reusableOperation( id );
4793 bool SMESHGUI::activateModule( SUIT_Study* study )
4795 bool res = SalomeApp_Module::activateModule( study );
4797 setMenuShown( true );
4798 setToolShown( true );
4800 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4801 PyGILState_STATE gstate = PyGILState_Ensure();
4802 PyObject* pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4803 if ( !pluginsmanager ) {
4807 PyObject* result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toUtf8().data(),tr("SMESH_PLUGINS_OTHER").toUtf8().data());
4812 PyGILState_Release(gstate);
4813 // end of SMESH plugins loading
4815 // Reset actions accelerator keys
4816 action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
4818 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4819 GetSMESHGen()->SetCurrentStudy(SALOMEDS::Study::_nil());
4820 if ( SalomeApp_Study* s = dynamic_cast<SalomeApp_Study*>( study )) {
4821 if ( _PTR(Study) aStudy = s->studyDS() )
4822 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
4825 // get all view currently opened in the study and connect their signals to
4826 // the corresponding slots of the class.
4827 SUIT_Desktop* aDesk = study->application()->desktop();
4829 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4830 SUIT_ViewWindow* wnd;
4831 foreach ( wnd, wndList )
4835 Py_XDECREF(pluginsmanager);
4839 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4841 setMenuShown( false );
4842 setToolShown( false );
4844 EmitSignalCloseAllDialogs();
4846 // Unset actions accelerator keys
4847 action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
4849 return SalomeApp_Module::deactivateModule( study );
4852 void SMESHGUI::studyClosed( SUIT_Study* s )
4856 SMESH::RemoveVisuData( s->id() );
4857 SalomeApp_Module::studyClosed( s );
4860 void SMESHGUI::OnGUIEvent()
4862 const QObject* obj = sender();
4863 if ( !obj || !obj->inherits( "QAction" ) )
4865 int id = actionId((QAction*)obj);
4870 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4872 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
4873 if ( CORBA::is_nil( myComponentSMESH ) )
4875 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4877 aGUI.myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4878 return aGUI.myComponentSMESH;
4881 myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4882 return myComponentSMESH;
4885 QString SMESHGUI::engineIOR() const
4887 CORBA::ORB_var anORB = getApp()->orb();
4888 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4889 return QString( anIOR.in() );
4892 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4894 SalomeApp_Module::contextMenuPopup( client, menu, title );
4896 selectionMgr()->selectedObjects( lst );
4897 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4898 Handle(SALOME_InteractiveObject) io = lst.First();
4899 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4900 _PTR(Study) study = appStudy->studyDS();
4901 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4903 QString aName = QString( SMESH::fromUtf8(obj->GetName()) );
4904 while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4905 aName.remove( (aName.length() - 1), 1 );
4911 LightApp_Selection* SMESHGUI::createSelection() const
4913 return new SMESHGUI_Selection();
4916 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4918 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4919 aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
4920 #ifndef DISABLE_PYCONSOLE
4921 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4925 void SMESHGUI::viewManagers( QStringList& list ) const
4927 list.append( SVTK_Viewer::Type() );
4930 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4932 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4933 SMESH::UpdateSelectionProp( this );
4935 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
4936 for(int i = 0; i < aViews.count() ; i++){
4937 SUIT_ViewWindow *sf = aViews[i];
4940 EmitSignalActivatedViewManager();
4944 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
4946 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
4947 myClippingPlaneInfoMap.erase( theViewManager );
4950 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
4952 theActor->AddObserver( SMESH::DeleteActorEvent,
4953 myEventCallbackCommand.GetPointer(),
4957 void SMESHGUI::ProcessEvents( vtkObject* theObject,
4958 unsigned long theEvent,
4959 void* theClientData,
4962 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
4963 if( theObject && (int) theEvent == SMESH::DeleteActorEvent ) {
4964 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
4965 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
4966 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
4967 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
4968 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
4969 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
4970 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
4971 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
4972 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
4973 SMESH::TActorList::iterator anIter3 = anActorList.begin();
4974 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
4975 if( anActor == *anIter3 ) {
4976 anActorList.erase( anIter3 );
4987 void SMESHGUI::createPreferences()
4989 // General tab ------------------------------------------------------------------------
4990 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
4992 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
4993 setPreferenceProperty( autoUpdate, "columns", 2 );
4994 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
4995 setPreferenceProperty( lim, "min", 0 );
4996 setPreferenceProperty( lim, "max", 100000000 );
4997 setPreferenceProperty( lim, "step", 1000 );
4998 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4999 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
5001 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
5002 setPreferenceProperty( qaGroup, "columns", 2 );
5003 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
5004 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
5005 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
5006 setPreferenceProperty( prec, "min", 0 );
5007 setPreferenceProperty( prec, "max", 100 );
5008 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
5009 setPreferenceProperty( doubleNodesTol, "precision", 10 );
5010 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
5011 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
5012 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
5014 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
5015 setPreferenceProperty( dispgroup, "columns", 2 );
5016 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
5018 modes.append( tr("MEN_WIRE") );
5019 modes.append( tr("MEN_SHADE") );
5020 modes.append( tr("MEN_NODES") );
5021 modes.append( tr("MEN_SHRINK") );
5022 QList<QVariant> indices;
5023 indices.append( 0 );
5024 indices.append( 1 );
5025 indices.append( 2 );
5026 indices.append( 3 );
5027 setPreferenceProperty( dispmode, "strings", modes );
5028 setPreferenceProperty( dispmode, "indexes", indices );
5030 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
5031 setPreferenceProperty( arcgroup, "columns", 2 );
5032 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
5033 QStringList quadraticModes;
5034 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
5035 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
5037 indices.append( 0 );
5038 indices.append( 1 );
5039 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
5040 setPreferenceProperty( quadraticmode, "indexes", indices );
5042 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
5043 "SMESH", "max_angle" );
5044 setPreferenceProperty( maxAngle, "min", 1 );
5045 setPreferenceProperty( maxAngle, "max", 90 );
5049 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
5050 setPreferenceProperty( exportgroup, "columns", 2 );
5051 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
5052 addPreference( tr( "PREF_SHOW_WARN" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "show_warning" );
5053 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
5055 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
5056 setPreferenceProperty( computeGroup, "columns", 2 );
5057 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
5059 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5060 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5061 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5063 indices.append( 0 );
5064 indices.append( 1 );
5065 indices.append( 2 );
5066 setPreferenceProperty( notifyMode, "strings", modes );
5067 setPreferenceProperty( notifyMode, "indexes", indices );
5069 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5070 setPreferenceProperty( infoGroup, "columns", 2 );
5071 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5073 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5074 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5076 indices.append( 0 );
5077 indices.append( 1 );
5078 setPreferenceProperty( elemInfo, "strings", modes );
5079 setPreferenceProperty( elemInfo, "indexes", indices );
5080 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5081 setPreferenceProperty( nodesLim, "min", 0 );
5082 setPreferenceProperty( nodesLim, "max", 10000000 );
5083 setPreferenceProperty( nodesLim, "step", 10000 );
5084 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5085 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5086 setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5087 setPreferenceProperty( ctrlLim, "min", 0 );
5088 setPreferenceProperty( ctrlLim, "max", 10000000 );
5089 setPreferenceProperty( ctrlLim, "step", 1000 );
5090 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5091 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5092 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5093 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5094 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5096 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5097 setPreferenceProperty( segGroup, "columns", 2 );
5098 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5099 "SMESH", "segmentation" );
5100 setPreferenceProperty( segLen, "min", 1 );
5101 setPreferenceProperty( segLen, "max", 10000000 );
5102 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5103 "SMESH", "nb_segments_per_edge" );
5104 setPreferenceProperty( nbSeg, "min", 1 );
5105 setPreferenceProperty( nbSeg, "max", 10000000 );
5107 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5108 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5109 "SMESH", "forget_mesh_on_hyp_modif" );
5112 // Quantities with individual precision settings
5113 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5114 setPreferenceProperty( precGroup, "columns", 2 );
5116 const int nbQuantities = 6;
5117 int precs[nbQuantities], ii = 0;
5118 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5119 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5120 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5121 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5122 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5123 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5124 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5125 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5126 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5127 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5128 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5129 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5131 // Set property for precision value for spinboxes
5132 for ( ii = 0; ii < nbQuantities; ii++ ){
5133 setPreferenceProperty( precs[ii], "min", -14 );
5134 setPreferenceProperty( precs[ii], "max", 14 );
5135 setPreferenceProperty( precs[ii], "precision", 2 );
5138 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5139 setPreferenceProperty( previewGroup, "columns", 2 );
5140 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5141 setPreferenceProperty( chunkSize, "min", 1 );
5142 setPreferenceProperty( chunkSize, "max", 1000 );
5143 setPreferenceProperty( chunkSize, "step", 50 );
5145 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5146 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5148 // Mesh tab ------------------------------------------------------------------------
5149 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5150 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5151 setPreferenceProperty( nodeGroup, "columns", 3 );
5153 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5155 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5157 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5158 QList<QVariant> aMarkerTypeIndicesList;
5159 QList<QVariant> aMarkerTypeIconsList;
5160 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5161 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5162 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5163 aMarkerTypeIndicesList << i;
5164 aMarkerTypeIconsList << pixmap;
5166 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5167 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
5169 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5171 QList<QVariant> aMarkerScaleIndicesList;
5172 QStringList aMarkerScaleValuesList;
5173 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5174 aMarkerScaleIndicesList << i;
5175 //aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5176 aMarkerScaleValuesList << QString::number( i );
5178 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5179 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5181 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5182 //setPreferenceProperty( elemGroup, "columns", 2 );
5184 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5185 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5186 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5187 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5188 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5189 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5190 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5191 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5192 addPreference( tr( "PREF_PREVIEW_COLOR" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5195 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5196 setPreferenceProperty( grpGroup, "columns", 2 );
5198 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5199 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5201 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5202 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5203 /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5204 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5205 double ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5206 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5207 double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5208 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5209 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
5210 LightApp_Preferences::IntSpin, "SMESH", "element_width");
5211 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5212 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5213 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5214 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5216 setPreferenceProperty( size0d, "min", 1 );
5217 setPreferenceProperty( size0d, "max", 10 );
5219 // setPreferenceProperty( ballSize, "min", 1 );
5220 // setPreferenceProperty( ballSize, "max", 10 );
5222 setPreferenceProperty( ballDiameter, "min", 1e-7 );
5223 setPreferenceProperty( ballDiameter, "max", 1e9 );
5224 setPreferenceProperty( ballDiameter, "step", 0.1 );
5226 setPreferenceProperty( ballScale, "min", 1e-2 );
5227 setPreferenceProperty( ballScale, "max", 1e7 );
5228 setPreferenceProperty( ballScale, "step", 0.5 );
5230 setPreferenceProperty( elemW, "min", 1 );
5231 setPreferenceProperty( elemW, "max", 5 );
5233 setPreferenceProperty( outW, "min", 1 );
5234 setPreferenceProperty( outW, "max", 5 );
5236 setPreferenceProperty( shrink, "min", 0 );
5237 setPreferenceProperty( shrink, "max", 100 );
5239 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5240 setPreferenceProperty( numGroup, "columns", 2 );
5242 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5243 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5245 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5246 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5248 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5249 setPreferenceProperty( orientGroup, "columns", 1 );
5251 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5252 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5254 setPreferenceProperty( orientScale, "min", 0.05 );
5255 setPreferenceProperty( orientScale, "max", 0.5 );
5256 setPreferenceProperty( orientScale, "step", 0.05 );
5258 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5260 // Selection tab ------------------------------------------------------------------------
5261 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5263 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5264 setPreferenceProperty( selGroup, "columns", 2 );
5266 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5267 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5269 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5270 setPreferenceProperty( preGroup, "columns", 2 );
5272 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5274 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5275 setPreferenceProperty( precSelGroup, "columns", 2 );
5277 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5278 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5279 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5281 // Scalar Bar tab ------------------------------------------------------------------------
5282 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5283 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5284 setPreferenceProperty( fontGr, "columns", 2 );
5286 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5287 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5289 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5290 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5292 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5293 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5295 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5296 setPreferenceProperty( numcol, "min", 2 );
5297 setPreferenceProperty( numcol, "max", 256 );
5299 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5300 setPreferenceProperty( numlab, "min", 2 );
5301 setPreferenceProperty( numlab, "max", 65 );
5303 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5304 setPreferenceProperty( orientGr, "columns", 2 );
5305 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5306 QStringList orients;
5307 orients.append( tr( "SMESH_VERTICAL" ) );
5308 orients.append( tr( "SMESH_HORIZONTAL" ) );
5309 indices.clear(); indices.append( 0 ); indices.append( 1 );
5310 setPreferenceProperty( orient, "strings", orients );
5311 setPreferenceProperty( orient, "indexes", indices );
5313 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5314 setPreferenceProperty( posVSizeGr, "columns", 2 );
5315 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5316 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5317 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5318 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5319 setPreferenceProperty( xv, "step", 0.1 );
5320 setPreferenceProperty( xv, "min", 0.0 );
5321 setPreferenceProperty( xv, "max", 1.0 );
5322 setPreferenceProperty( yv, "step", 0.1 );
5323 setPreferenceProperty( yv, "min", 0.0 );
5324 setPreferenceProperty( yv, "max", 1.0 );
5325 setPreferenceProperty( wv, "step", 0.1 );
5326 setPreferenceProperty( wv, "min", 0.0 );
5327 setPreferenceProperty( wv, "max", 1.0 );
5328 setPreferenceProperty( hv, "min", 0.0 );
5329 setPreferenceProperty( hv, "max", 1.0 );
5330 setPreferenceProperty( hv, "step", 0.1 );
5332 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5333 setPreferenceProperty( posHSizeGr, "columns", 2 );
5334 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5335 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5336 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5337 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5338 setPreferenceProperty( xv, "min", 0.0 );
5339 setPreferenceProperty( xv, "max", 1.0 );
5340 setPreferenceProperty( xv, "step", 0.1 );
5341 setPreferenceProperty( xh, "min", 0.0 );
5342 setPreferenceProperty( xh, "max", 1.0 );
5343 setPreferenceProperty( xh, "step", 0.1 );
5344 setPreferenceProperty( yh, "min", 0.0 );
5345 setPreferenceProperty( yh, "max", 1.0 );
5346 setPreferenceProperty( yh, "step", 0.1 );
5347 setPreferenceProperty( wh, "min", 0.0 );
5348 setPreferenceProperty( wh, "max", 1.0 );
5349 setPreferenceProperty( wh, "step", 0.1 );
5350 setPreferenceProperty( hh, "min", 0.0 );
5351 setPreferenceProperty( hh, "max", 1.0 );
5352 setPreferenceProperty( hh, "step", 0.1 );
5354 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5355 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5356 setPreferenceProperty( distributionGr, "columns", 3 );
5358 types.append( tr( "SMESH_MONOCOLOR" ) );
5359 types.append( tr( "SMESH_MULTICOLOR" ) );
5360 indices.clear(); indices.append( 0 ); indices.append( 1 );
5361 setPreferenceProperty( coloringType, "strings", types );
5362 setPreferenceProperty( coloringType, "indexes", indices );
5363 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5367 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5369 if ( sect=="SMESH" ) {
5370 float sbX1 = 0.01, sbY1 = 0.01, sbW = 0.08, sbH = 0.08;
5371 float aTol = 1.00000009999999;
5372 std::string aWarning;
5373 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5375 if ( name== "selection_object_color" ||
5376 name=="selection_element_color" ||
5377 name== "highlight_color" ||
5378 name=="selection_precision_node" ||
5379 name=="selection_precision_element" ||
5380 name=="selection_precision_object" )
5382 SMESH::UpdateSelectionProp( this );
5384 else if (name == "scalar_bar_vertical_x" || name == "scalar_bar_vertical_width")
5386 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5387 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5388 if ( sbX1+sbW > aTol ) {
5389 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5392 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5393 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5396 else if (name == "scalar_bar_vertical_y" || name == "scalar_bar_vertical_height" )
5398 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5399 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5400 if ( sbY1 + sbH > aTol ) {
5401 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5402 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5403 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5406 else if (name == "scalar_bar_horizontal_x" || name == "scalar_bar_horizontal_width")
5408 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5409 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5410 if ( sbX1 + sbW > aTol ) {
5411 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5414 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5415 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5418 else if (name == "scalar_bar_horizontal_y" || name == "scalar_bar_horizontal_height")
5420 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5421 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5422 if ( sbY1 + sbH > aTol ) {
5423 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5426 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5427 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5430 else if ( name == "segmentation" )
5432 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5433 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5435 else if ( name == "nb_segments_per_edge" )
5437 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5438 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5440 else if ( name == "historical_python_dump" || name == "forget_mesh_on_hyp_modif" || name == "default_grp_color" )
5442 QString val = aResourceMgr->stringValue( "SMESH", name );
5443 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5445 else if ( name == "numbering_node_color" || name == "numbering_node_font" )
5447 SMESH::UpdateFontProp( this );
5449 else if ( name == "numbering_elem_color" || name == "numbering_elem_font" )
5451 SMESH::UpdateFontProp( this );
5454 if ( aWarning.size() != 0 ) {
5455 aWarning += "The default values are applied instead.";
5456 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5457 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5458 QObject::tr(aWarning.c_str()));
5463 //================================================================================
5465 * \brief Update something in accordance with update flags
5466 * \param theFlags - update flags
5468 * Update viewer or/and object browser etc. in accordance with update flags ( see
5469 * LightApp_UpdateFlags enumeration ).
5471 //================================================================================
5472 void SMESHGUI::update( const int flags )
5474 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5475 SMESH::UpdateView();
5477 SalomeApp_Module::update( flags );
5480 //================================================================================
5482 * \brief Set default selection mode
5484 * SLOT called when operation commited. Sets default selection mode
5486 //================================================================================
5487 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5489 SVTK_ViewWindow* vtkWnd =
5490 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5492 vtkWnd->SetSelectionMode( ActorSelection );
5495 //================================================================================
5497 * \brief Set default selection mode
5499 * SLOT called when operation aborted. Sets default selection mode
5501 //================================================================================
5502 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5504 SVTK_ViewWindow* vtkWnd =
5505 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5507 vtkWnd->SetSelectionMode( ActorSelection );
5510 //================================================================================
5512 * \brief Creates operation with given identifier
5513 * \param id - identifier of operation to be started
5514 * \return Pointer on created operation or NULL if operation is not created
5516 * Virtual method redefined from the base class creates operation with given id.
5517 * It is called called automatically from startOperation method of base class.
5519 //================================================================================
5520 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5522 LightApp_Operation* op = 0;
5523 // to do : create operation here
5526 case SMESHOp::OpSplitBiQuadratic:
5527 op = new SMESHGUI_SplitBiQuadOp();
5529 case SMESHOp::OpConvertMeshToQuadratic:
5530 op = new SMESHGUI_ConvToQuadOp();
5532 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5533 op = new SMESHGUI_Make2DFrom3DOp();
5535 case SMESHOp::OpReorientFaces:
5536 op = new SMESHGUI_ReorientFacesOp();
5538 case SMESHOp::OpCreateMesh:
5539 op = new SMESHGUI_MeshOp( true, true );
5541 case SMESHOp::OpCreateSubMesh:
5542 op = new SMESHGUI_MeshOp( true, false );
5544 case SMESHOp::OpEditMeshOrSubMesh:
5545 case SMESHOp::OpEditMesh:
5546 case SMESHOp::OpEditSubMesh:
5547 op = new SMESHGUI_MeshOp( false );
5549 case SMESHOp::OpCompute:
5550 case SMESHOp::OpComputeSubMesh:
5551 op = new SMESHGUI_ComputeOp();
5553 case SMESHOp::OpPreCompute:
5554 op = new SMESHGUI_PrecomputeOp();
5556 case SMESHOp::OpEvaluate:
5557 op = new SMESHGUI_EvaluateOp();
5559 case SMESHOp::OpMeshOrder:
5560 op = new SMESHGUI_MeshOrderOp();
5562 case SMESHOp::OpCreateGeometryGroup:
5563 op = new SMESHGUI_GroupOnShapeOp();
5565 case SMESHOp::OpFindElementByPoint:
5566 op = new SMESHGUI_FindElemByPointOp();
5568 case SMESHOp::OpMoveNode: // Make mesh pass through point
5569 op = new SMESHGUI_MakeNodeAtPointOp();
5571 case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
5572 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5579 op = SalomeApp_Module::createOperation( id );
5583 //================================================================================
5585 * \brief Stops current operations and starts a given one
5586 * \param id - The id of the operation to start
5588 //================================================================================
5590 void SMESHGUI::switchToOperation(int id)
5592 if ( _PTR(Study) aStudy = SMESH::GetActiveStudyDocument() )
5593 activeStudy()->abortAllOperations();
5594 startOperation( id );
5597 LightApp_Displayer* SMESHGUI::displayer()
5600 myDisplayer = new SMESHGUI_Displayer( getApp() );
5604 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5607 int aTolerance = 64;
5608 int anIterations = 0;
5614 if( anIterations % aPeriod == 0 )
5617 if( aTolerance < 1 )
5621 aHue = (int)( 360.0 * rand() / RAND_MAX );
5624 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5625 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5626 for( ; it != itEnd; ++it )
5628 SALOMEDS::Color anAutoColor = *it;
5629 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5632 aQColor.getHsv( &h, &s, &v );
5633 if( abs( h - aHue ) < aTolerance )
5645 aColor.setHsv( aHue, 255, 255 );
5647 SALOMEDS::Color aSColor;
5648 aSColor.R = aColor.redF();
5649 aSColor.G = aColor.greenF();
5650 aSColor.B = aColor.blueF();
5655 const char* gSeparator = "_"; // character used to separate parameter names
5656 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5657 const char* gPathSep = "|"; // character used to separate paths
5660 * \brief Store visual parameters
5662 * This method is called just before the study document is saved.
5663 * Store visual parameters in AttributeParameter attribue(s)
5665 void SMESHGUI::storeVisualParameters (int savePoint)
5668 Kernel_Utils::Localizer loc;
5670 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5671 if (!appStudy || !appStudy->studyDS())
5673 _PTR(Study) studyDS = appStudy->studyDS();
5675 // componentName is used for encoding of entries when storing them in IParameters
5676 std::string componentName = myComponentSMESH->ComponentDataType();
5677 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5678 //if (!aSComponent) return;
5681 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5682 componentName.c_str(),
5684 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5686 // store map of custom markers
5687 const VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5688 if( !aMarkerMap.empty() )
5690 VTK::MarkerMap::const_iterator anIter = aMarkerMap.begin();
5691 for( ; anIter != aMarkerMap.end(); anIter++ )
5693 int anId = anIter->first;
5694 VTK::MarkerData aMarkerData = anIter->second;
5695 std::string aMarkerFileName = aMarkerData.first;
5696 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5697 if( aMarkerTexture.size() < 3 )
5698 continue; // should contain at least width, height and the first value
5700 QString aPropertyName( "texture" );
5701 aPropertyName += gSeparator;
5702 aPropertyName += QString::number( anId );
5704 QString aPropertyValue = aMarkerFileName.c_str();
5705 aPropertyValue += gPathSep;
5707 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5708 ushort aWidth = *aTextureIter++;
5709 ushort aHeight = *aTextureIter++;
5710 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5711 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5712 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5713 aPropertyValue += QString::number( *aTextureIter );
5715 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5719 // viewers counters are used for storing view_numbers in IParameters
5722 // main cycle to store parameters of displayed objects
5723 QList<SUIT_ViewManager*> lst;
5724 QList<SUIT_ViewManager*>::Iterator it;
5725 getApp()->viewManagers(lst);
5726 for (it = lst.begin(); it != lst.end(); it++)
5728 SUIT_ViewManager* vman = *it;
5729 QString vType = vman->getType();
5731 // saving VTK actors properties
5732 if (vType == SVTK_Viewer::Type())
5734 // store the clipping planes attached to the view manager
5735 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5736 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5737 if( anIter != myClippingPlaneInfoMap.end() )
5738 aClippingPlaneInfoList = anIter->second;
5740 if( !aClippingPlaneInfoList.empty() ) {
5741 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5742 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5744 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5745 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5747 QString aPropertyName( "ClippingPlane" );
5748 aPropertyName += gSeparator;
5749 aPropertyName += QString::number( vtkViewers );
5750 aPropertyName += gSeparator;
5751 aPropertyName += QString::number( anId );
5753 QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
5754 aPropertyValue += gDigitsSep;
5755 aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
5756 aPropertyValue += gDigitsSep;
5757 if ( aPlane->PlaneMode == SMESH::Absolute ) {
5758 aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
5759 aPropertyValue += gDigitsSep;
5760 aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
5761 aPropertyValue += gDigitsSep;
5762 aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
5763 aPropertyValue += gDigitsSep;
5764 aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
5765 aPropertyValue += gDigitsSep;
5766 aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
5767 aPropertyValue += gDigitsSep;
5768 aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
5769 aPropertyValue += gDigitsSep;
5770 aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
5772 else if ( aPlane->PlaneMode == SMESH::Relative ) {
5773 aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
5774 aPropertyValue += gDigitsSep;
5775 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5776 aPropertyValue += gDigitsSep;
5777 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5778 aPropertyValue += gDigitsSep;
5779 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5782 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5786 QVector<SUIT_ViewWindow*> views = vman->getViews();
5787 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5789 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5791 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5792 vtkActorCollection* allActors = aCopy.GetActors();
5793 allActors->InitTraversal();
5794 while (vtkActor* actor = allActors->GetNextActor())
5796 if (actor->GetVisibility()) // store only visible actors
5798 SMESH_Actor* aSmeshActor = 0;
5799 if (actor->IsA("SMESH_Actor"))
5800 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5801 if (aSmeshActor && aSmeshActor->hasIO())
5803 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5806 // entry is "encoded" = it does NOT contain component adress,
5807 // since it is a subject to change on next component loading
5808 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5810 std::string param, vtkParam = vType.toLatin1().data();
5811 vtkParam += gSeparator;
5812 vtkParam += QString::number(vtkViewers).toLatin1().data();
5813 vtkParam += gSeparator;
5816 param = vtkParam + "Visibility";
5817 ip->setParameter(entry, param, "On");
5820 param = vtkParam + "Representation";
5821 ip->setParameter(entry, param, QString::number
5822 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5825 param = vtkParam + "IsShrunk";
5826 ip->setParameter(entry, param, QString::number
5827 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5829 // Displayed entities
5830 unsigned int aMode = aSmeshActor->GetEntityMode();
5831 bool isE = aMode & SMESH_Actor::eEdges;
5832 bool isF = aMode & SMESH_Actor::eFaces;
5833 bool isV = aMode & SMESH_Actor::eVolumes;
5834 bool is0d = aMode & SMESH_Actor::e0DElements;
5835 bool isB = aMode & SMESH_Actor::eBallElem;
5837 QString modeStr ("e");
5838 modeStr += gDigitsSep; modeStr += QString::number(isE);
5839 modeStr += gDigitsSep; modeStr += "f";
5840 modeStr += gDigitsSep; modeStr += QString::number(isF);
5841 modeStr += gDigitsSep; modeStr += "v";
5842 modeStr += gDigitsSep; modeStr += QString::number(isV);
5843 modeStr += gDigitsSep; modeStr += "0d";
5844 modeStr += gDigitsSep; modeStr += QString::number(is0d);
5845 modeStr += gDigitsSep; modeStr += "b";
5846 modeStr += gDigitsSep; modeStr += QString::number(isB);
5848 param = vtkParam + "Entities";
5849 ip->setParameter(entry, param, modeStr.toLatin1().data());
5855 aSmeshActor->GetSufaceColor(r, g, b, delta);
5856 QStringList colorStr;
5857 colorStr << "surface";
5858 colorStr << QString::number(r);
5859 colorStr << QString::number(g);
5860 colorStr << QString::number(b);
5862 colorStr << "backsurface";
5863 colorStr << QString::number(delta);
5865 aSmeshActor->GetVolumeColor(r, g, b, delta);
5866 colorStr << "volume";
5867 colorStr << QString::number(r);
5868 colorStr << QString::number(g);
5869 colorStr << QString::number(b);
5870 colorStr << QString::number(delta);
5872 aSmeshActor->GetEdgeColor(r, g, b);
5874 colorStr << QString::number(r);
5875 colorStr << QString::number(g);
5876 colorStr << QString::number(b);
5878 aSmeshActor->GetNodeColor(r, g, b);
5880 colorStr << QString::number(r);
5881 colorStr << QString::number(g);
5882 colorStr << QString::number(b);
5884 aSmeshActor->GetOutlineColor(r, g, b);
5885 colorStr << "outline";
5886 colorStr << QString::number(r);
5887 colorStr << QString::number(g);
5888 colorStr << QString::number(b);
5890 aSmeshActor->Get0DColor(r, g, b);
5891 colorStr << "elem0d";
5892 colorStr << QString::number(r);
5893 colorStr << QString::number(g);
5894 colorStr << QString::number(b);
5896 aSmeshActor->GetBallColor(r, g, b);
5898 colorStr << QString::number(r);
5899 colorStr << QString::number(g);
5900 colorStr << QString::number(b);
5902 aSmeshActor->GetFacesOrientationColor(r, g, b);
5903 colorStr << "orientation";
5904 colorStr << QString::number(r);
5905 colorStr << QString::number(g);
5906 colorStr << QString::number(b);
5908 param = vtkParam + "Colors";
5909 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
5912 QStringList sizeStr;
5914 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
5915 sizeStr << "outline";
5916 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
5917 sizeStr << "elem0d";
5918 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
5920 //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
5921 sizeStr << QString::number((double)aSmeshActor->GetBallSize());
5922 sizeStr << QString::number((double)aSmeshActor->GetBallScale());
5923 sizeStr << "shrink";
5924 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
5925 sizeStr << "orientation";
5926 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
5927 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
5929 param = vtkParam + "Sizes";
5930 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
5935 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5936 if( aMarkerType == VTK::MT_USER ) {
5937 markerStr += "custom";
5938 markerStr += gDigitsSep;
5939 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
5943 markerStr += gDigitsSep;
5944 markerStr += QString::number( (int)aMarkerType );
5945 markerStr += gDigitsSep;
5946 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
5949 param = vtkParam + "PointMarker";
5950 ip->setParameter(entry, param, markerStr.toLatin1().data());
5953 param = vtkParam + "Opacity";
5954 ip->setParameter(entry, param,
5955 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
5958 param = vtkParam + "ClippingPlane";
5960 if( !aClippingPlaneInfoList.empty() ) {
5961 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
5962 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
5964 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
5965 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
5966 SMESH::TActorList::iterator anIter2 = anActorList.begin();
5967 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
5968 if( aSmeshActor == *anIter2 ) {
5969 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
5970 QString::number( anId ).toLatin1().constData() );
5977 ip->setParameter( entry, param, "Off" );
5978 } // if (io->hasEntry())
5979 } // SMESH_Actor && hasIO
5981 } // while.. actors traversal
5985 } // if (SVTK view model)
5986 } // for (viewManagers)
5989 // data structures for clipping planes processing
5993 bool isOpenGLClipping;
5994 vtkIdType RelativeOrientation;
5997 int AbsoluteOrientation;
5998 double X, Y, Z, Dx, Dy, Dz;
6000 typedef std::list<TPlaneData> TPlaneDataList;
6001 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
6003 typedef std::list<vtkActor*> TActorList;
6006 TActorList ActorList;
6007 SUIT_ViewManager* ViewManager;
6009 typedef std::list<TPlaneInfo> TPlaneInfoList;
6010 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
6013 * \brief Restore visual parameters
6015 * This method is called after the study document is opened.
6016 * Restore visual parameters from AttributeParameter attribue(s)
6018 void SMESHGUI::restoreVisualParameters (int savePoint)
6021 Kernel_Utils::Localizer loc;
6023 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6024 if (!appStudy || !appStudy->studyDS())
6026 _PTR(Study) studyDS = appStudy->studyDS();
6028 // componentName is used for encoding of entries when storing them in IParameters
6029 std::string componentName = myComponentSMESH->ComponentDataType();
6030 //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
6031 //if (!aSComponent) return;
6034 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6035 componentName.c_str(),
6037 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6039 // restore map of custom markers and map of clipping planes
6040 VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
6041 TPlaneDataMap aPlaneDataMap;
6043 std::vector<std::string> properties = ip->getProperties();
6044 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
6046 std::string property = *propIt;
6047 QString aPropertyName( property.c_str() );
6048 QString aPropertyValue( ip->getProperty( property ).c_str() );
6050 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
6051 if( aPropertyNameList.isEmpty() )
6054 QString aPropertyType = aPropertyNameList[0];
6055 if( aPropertyType == "texture" )
6057 if( aPropertyNameList.size() != 2 )
6061 int anId = aPropertyNameList[1].toInt( &ok );
6062 if( !ok || anId < 1 )
6065 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
6066 if( aPropertyValueList.size() != 2 )
6069 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
6070 QString aMarkerTextureString = aPropertyValueList[1];
6071 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
6072 if( aMarkerTextureStringList.size() != 3 )
6076 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6081 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6085 VTK::MarkerTexture aMarkerTexture;
6086 aMarkerTexture.push_back( aWidth );
6087 aMarkerTexture.push_back( aHeight );
6089 QString aMarkerTextureData = aMarkerTextureStringList[2];
6090 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6092 QChar aChar = aMarkerTextureData.at( i );
6093 if( aChar.isDigit() )
6094 aMarkerTexture.push_back( aChar.digitValue() );
6097 aMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6099 else if( aPropertyType == "ClippingPlane" )
6101 if( aPropertyNameList.size() != 3 )
6105 int aViewId = aPropertyNameList[1].toInt( &ok );
6106 if( !ok || aViewId < 0 )
6110 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6111 if( !ok || aClippingPlaneId < 0 )
6114 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6115 if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6118 TPlaneData aPlaneData;
6119 aPlaneData.AbsoluteOrientation = false;
6120 aPlaneData.RelativeOrientation = 0;
6121 aPlaneData.Distance = aPlaneData.Angle[0] = aPlaneData.Angle[1] = 0;
6122 aPlaneData.X = aPlaneData.Y = aPlaneData.Z = 0;
6123 aPlaneData.Dx = aPlaneData.Dy = aPlaneData.Dz = 0;
6125 aPlaneData.Id = aClippingPlaneId;
6128 aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6133 aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6137 if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6140 aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6145 aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6150 aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6155 aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6160 aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6165 aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6170 aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6174 else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6176 aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6181 aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6186 aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6191 aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6196 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6197 aPlaneDataList.push_back( aPlaneData );
6201 TPlaneInfoMap aPlaneInfoMap;
6203 std::vector<std::string> entries = ip->getEntries();
6205 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6207 // entry is a normal entry - it should be "decoded" (setting base adress of component)
6208 QString entry (ip->decodeEntry(*entIt).c_str());
6210 // Check that the entry corresponds to a real object in the Study
6211 // as the object may be deleted or modified after the visual state is saved.
6212 _PTR(SObject) so = studyDS->FindObjectID(entry.toLatin1().data());
6213 if (!so) continue; //Skip the not existent entry
6215 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6216 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6218 std::vector<std::string>::iterator namesIt = paramNames.begin();
6219 std::vector<std::string>::iterator valuesIt = paramValues.begin();
6221 // actors are stored in a map after displaying of them for
6222 // quicker access in the future: map < viewID to actor >
6223 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6225 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6227 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6228 // '_' is used as separator and should not be used in viewer type or parameter names.
6229 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6230 if (lst.size() != 3)
6233 QString viewerTypStr = lst[0];
6234 QString viewIndexStr = lst[1];
6235 QString paramNameStr = lst[2];
6238 int viewIndex = viewIndexStr.toUInt(&ok);
6239 if (!ok) // bad conversion of view index to integer
6243 if (viewerTypStr == SVTK_Viewer::Type())
6245 SMESH_Actor* aSmeshActor = 0;
6246 if (vtkActors.IsBound(viewIndex))
6247 aSmeshActor = vtkActors.Find(viewIndex);
6249 QList<SUIT_ViewManager*> lst;
6250 getApp()->viewManagers(viewerTypStr, lst);
6252 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6253 SUIT_ViewManager* vman = NULL;
6254 if (viewIndex >= 0 && viewIndex < lst.count())
6255 vman = lst.at(viewIndex);
6257 if (paramNameStr == "Visibility")
6259 if (!aSmeshActor && displayer() && vman)
6261 SUIT_ViewModel* vmodel = vman->getViewModel();
6262 // SVTK view model can be casted to SALOME_View
6263 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6265 // store displayed actor in a temporary map for quicker
6266 // access later when restoring other parameters
6267 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6268 vtkRenderer* Renderer = vtkView->getRenderer();
6269 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6270 vtkActorCollection* theActors = aCopy.GetActors();
6271 theActors->InitTraversal();
6272 bool isFound = false;
6273 vtkActor *ac = theActors->GetNextActor();
6274 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6275 if (ac->IsA("SMESH_Actor")) {
6276 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6277 if (aGeomAc->hasIO()) {
6278 Handle(SALOME_InteractiveObject) io = aGeomAc->getIO();
6279 if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) {
6281 vtkActors.Bind(viewIndex, aGeomAc);
6287 } // if (paramNameStr == "Visibility")
6290 // the rest properties "work" with SMESH_Actor
6293 QString val ((*valuesIt).c_str());
6296 if (paramNameStr == "Representation") {
6297 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6300 else if (paramNameStr == "IsShrunk") {
6302 if (!aSmeshActor->IsShrunk())
6303 aSmeshActor->SetShrink();
6306 if (aSmeshActor->IsShrunk())
6307 aSmeshActor->UnShrink();
6310 // Displayed entities
6311 else if (paramNameStr == "Entities") {
6312 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6313 int aEntityMode = SMESH_Actor::eAllEntity;
6314 for ( int i = 0; i < mode.count(); i+=2 ) {
6315 if ( i < mode.count()-1 ) {
6316 QString type = mode[i];
6317 bool val = mode[i+1].toInt();
6318 if ( type == "e" && !val )
6319 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6320 else if ( type == "f" && !val )
6321 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6322 else if ( type == "v" && !val )
6323 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6324 else if ( type == "0d" && !val )
6325 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6326 else if ( type == "b" && !val )
6327 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6330 aSmeshActor->SetEntityMode( aEntityMode );
6333 else if (paramNameStr == "Colors") {
6334 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6341 QColor outlineColor;
6342 QColor orientationColor;
6348 // below lines are required to get default values for delta coefficients
6349 // of backface color for faces and color of reversed volumes
6350 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
6351 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6352 for ( int i = 0; i < colors.count(); i++ ) {
6353 QString type = colors[i];
6354 if ( type == "surface" ) {
6355 // face color is set by 3 values r:g:b, where
6356 // - r,g,b - is rgb color components
6357 if ( i+1 >= colors.count() ) break; // format error
6358 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6359 if ( i+2 >= colors.count() ) break; // format error
6360 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6361 if ( i+3 >= colors.count() ) break; // format error
6362 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6363 faceColor.setRgbF( r, g, b );
6366 else if ( type == "backsurface" ) {
6367 // backface color can be defined in several ways
6368 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6369 // - in latest versions, it is set as delta coefficient
6370 bool rgbOk = false, deltaOk;
6371 if ( i+1 >= colors.count() ) break; // format error
6372 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6373 int delta = colors[i+1].toInt( &deltaOk );
6375 if ( i+1 < colors.count() ) // index is shifted to 1
6376 g = colors[i+1].toDouble( &rgbOk );
6377 if ( rgbOk ) i++; // shift index
6378 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6379 b = colors[i+1].toDouble( &rgbOk );
6381 // - as currently there's no way to set directly backsurface color as it was before,
6382 // we ignore old dump where r,g,b triple was set
6383 // - also we check that delta parameter is set properly
6384 if ( !rgbOk && deltaOk )
6387 else if ( type == "volume" ) {
6388 // volume color is set by 4 values r:g:b:delta, where
6389 // - r,g,b - is a normal volume rgb color components
6390 // - delta - is a reversed volume color delta coefficient
6391 if ( i+1 >= colors.count() ) break; // format error
6392 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6393 if ( i+2 >= colors.count() ) break; // format error
6394 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6395 if ( i+3 >= colors.count() ) break; // format error
6396 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6397 if ( i+4 >= colors.count() ) break; // format error
6398 int delta = colors[i+4].toInt( &bOk );
6399 if ( !bOk ) break; // format error
6400 volumeColor.setRgbF( r, g, b );
6404 else if ( type == "edge" ) {
6405 // edge color is set by 3 values r:g:b, where
6406 // - r,g,b - is rgb color components
6407 if ( i+1 >= colors.count() ) break; // format error
6408 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6409 if ( i+2 >= colors.count() ) break; // format error
6410 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6411 if ( i+3 >= colors.count() ) break; // format error
6412 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6413 edgeColor.setRgbF( r, g, b );
6416 else if ( type == "node" ) {
6417 // node color is set by 3 values r:g:b, where
6418 // - r,g,b - is rgb color components
6419 if ( i+1 >= colors.count() ) break; // format error
6420 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6421 if ( i+2 >= colors.count() ) break; // format error
6422 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6423 if ( i+3 >= colors.count() ) break; // format error
6424 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6425 nodeColor.setRgbF( r, g, b );
6428 else if ( type == "elem0d" ) {
6429 // 0d element color is set by 3 values r:g:b, where
6430 // - r,g,b - is rgb color components
6431 if ( i+1 >= colors.count() ) break; // format error
6432 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6433 if ( i+2 >= colors.count() ) break; // format error
6434 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6435 if ( i+3 >= colors.count() ) break; // format error
6436 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6437 elem0dColor.setRgbF( r, g, b );
6440 else if ( type == "ball" ) {
6441 // ball color is set by 3 values r:g:b, where
6442 // - r,g,b - is rgb color components
6443 if ( i+1 >= colors.count() ) break; // format error
6444 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6445 if ( i+2 >= colors.count() ) break; // format error
6446 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6447 if ( i+3 >= colors.count() ) break; // format error
6448 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6449 ballColor.setRgbF( r, g, b );
6452 else if ( type == "outline" ) {
6453 // outline color is set by 3 values r:g:b, where
6454 // - r,g,b - is rgb color components
6455 if ( i+1 >= colors.count() ) break; // format error
6456 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6457 if ( i+2 >= colors.count() ) break; // format error
6458 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6459 if ( i+3 >= colors.count() ) break; // format error
6460 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6461 outlineColor.setRgbF( r, g, b );
6464 else if ( type == "orientation" ) {
6465 // orientation color is set by 3 values r:g:b, where
6466 // - r,g,b - is rgb color components
6467 if ( i+1 >= colors.count() ) break; // format error
6468 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6469 if ( i+2 >= colors.count() ) break; // format error
6470 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6471 if ( i+3 >= colors.count() ) break; // format error
6472 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6473 orientationColor.setRgbF( r, g, b );
6478 if ( nodeColor.isValid() )
6479 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6481 if ( edgeColor.isValid() )
6482 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6484 if ( faceColor.isValid() )
6485 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6487 if ( volumeColor.isValid() )
6488 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6489 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6490 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6492 if ( elem0dColor.isValid() )
6493 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6495 if ( ballColor.isValid() )
6496 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6498 if ( outlineColor.isValid() )
6499 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6500 // orientation color
6501 if ( orientationColor.isValid() )
6502 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6505 else if (paramNameStr == "Sizes") {
6506 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6509 int outlineWidth = -1;
6510 int elem0dSize = -1;
6511 //int ballSize = -1;
6512 double ballDiameter = -1.0;
6513 double ballScale = -1.0;
6514 double shrinkSize = -1;
6515 double orientationSize = -1;
6516 bool orientation3d = false;
6517 for ( int i = 0; i < sizes.count(); i++ ) {
6518 QString type = sizes[i];
6519 if ( type == "line" ) {
6520 // line (wireframe) width is given as single integer value
6521 if ( i+1 >= sizes.count() ) break; // format error
6522 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6526 if ( type == "outline" ) {
6527 // outline width is given as single integer value
6528 if ( i+1 >= sizes.count() ) break; // format error
6529 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6533 else if ( type == "elem0d" ) {
6534 // 0d element size is given as single integer value
6535 if ( i+1 >= sizes.count() ) break; // format error
6536 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6540 else if ( type == "ball" ) {
6541 // balls are specified by two values: size:scale, where
6542 // - size - is a integer value specifying size
6543 // - scale - is a double value specifying scale factor
6544 if ( i+1 >= sizes.count() ) break; // format error
6545 //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6546 double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6547 if ( i+2 >= sizes.count() ) break; // format error
6548 double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6554 else if ( type == "shrink" ) {
6555 // shrink factor is given as single floating point value
6556 if ( i+1 >= sizes.count() ) break; // format error
6557 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6561 else if ( type == "orientation" ) {
6562 // orientation vectors are specified by two values size:3d, where
6563 // - size - is a floating point value specifying scale factor
6564 // - 3d - is a boolean
6565 if ( i+1 >= sizes.count() ) break; // format error
6566 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6567 if ( i+2 >= sizes.count() ) break; // format error
6568 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6569 orientationSize = v1;
6570 orientation3d = (bool)v2;
6574 // line (wireframe) width
6575 if ( lineWidth > 0 )
6576 aSmeshActor->SetLineWidth( lineWidth );
6578 if ( outlineWidth > 0 )
6579 aSmeshActor->SetOutlineWidth( outlineWidth );
6580 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6581 aSmeshActor->SetOutlineWidth( lineWidth );
6583 if ( elem0dSize > 0 )
6584 aSmeshActor->Set0DSize( elem0dSize );
6586 /*if ( ballSize > 0 )
6587 aSmeshActor->SetBallSize( ballSize );*/
6589 if ( ballDiameter > 0 )
6590 aSmeshActor->SetBallSize( ballDiameter );
6592 if ( ballScale > 0.0 )
6593 aSmeshActor->SetBallScale( ballScale );
6595 if ( shrinkSize > 0 )
6596 aSmeshActor->SetShrinkFactor( shrinkSize );
6597 // orientation vectors
6598 if ( orientationSize > 0 ) {
6599 aSmeshActor->SetFacesOrientationScale( orientationSize );
6600 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6604 else if (paramNameStr == "PointMarker") {
6605 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6606 if( data.count() >= 2 ) {
6608 int aParam1 = data[1].toInt( &ok );
6610 if( data[0] == "std" && data.count() == 3 ) {
6611 int aParam2 = data[2].toInt( &ok );
6612 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6614 else if( data[0] == "custom" ) {
6615 VTK::MarkerMap::const_iterator markerIt = aMarkerMap.find( aParam1 );
6616 if( markerIt != aMarkerMap.end() ) {
6617 VTK::MarkerData aMarkerData = markerIt->second;
6618 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6625 else if (paramNameStr == "Opacity") {
6626 aSmeshActor->SetOpacity(val.toFloat());
6629 else if (paramNameStr.startsWith("ClippingPlane")) {
6630 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6631 // old format - val looks like "Off" or "1:0:0:0.5:0:0"
6632 // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
6633 // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
6634 // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
6635 // new format - val looks like "Off" or "0" (plane id)
6636 // (note: in new format "Off" value is used only for consistency,
6637 // so it is processed together with values in old format)
6638 bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
6639 if( anIsOldFormat ) {
6640 if (paramNameStr == "ClippingPlane1" || val == "Off")
6641 aSmeshActor->RemoveAllClippingPlanes();
6643 QList<SUIT_ViewManager*> lst;
6644 getApp()->viewManagers(viewerTypStr, lst);
6645 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6646 if (viewIndex >= 0 && viewIndex < lst.count()) {
6647 SUIT_ViewManager* vman = lst.at(viewIndex);
6648 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6650 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6652 SMESH::TActorList anActorList;
6653 anActorList.push_back( aSmeshActor );
6654 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
6655 aPlane->myViewWindow = vtkView;
6656 SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
6657 aPlane->PlaneMode = aMode;
6658 bool isOpenGLClipping = ( bool )vals[1].toInt();
6659 aPlane->IsOpenGLClipping = isOpenGLClipping;
6660 if ( aMode == SMESH::Absolute ) {
6661 aPlane->myAbsoluteOrientation = vals[2].toInt();
6662 aPlane->X = vals[3].toFloat();
6663 aPlane->Y = vals[4].toFloat();
6664 aPlane->Z = vals[5].toFloat();
6665 aPlane->Dx = vals[6].toFloat();
6666 aPlane->Dy = vals[7].toFloat();
6667 aPlane->Dz = vals[8].toFloat();
6669 else if ( aMode == SMESH::Relative ) {
6670 aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
6671 aPlane->myDistance = vals[3].toFloat();
6672 aPlane->myAngle[0] = vals[4].toFloat();
6673 aPlane->myAngle[1] = vals[5].toFloat();
6677 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6678 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6679 aClippingPlaneInfo.Plane = aPlane;
6680 aClippingPlaneInfo.ActorList = anActorList;
6681 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6689 int aPlaneId = val.toInt( &ok );
6690 if( ok && aPlaneId >= 0 ) {
6691 bool anIsDefinedPlane = false;
6692 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6693 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6694 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6695 TPlaneInfo& aPlaneInfo = *anIter;
6696 if( aPlaneInfo.PlaneId == aPlaneId ) {
6697 aPlaneInfo.ActorList.push_back( aSmeshActor );
6698 anIsDefinedPlane = true;
6702 if( !anIsDefinedPlane ) {
6703 TPlaneInfo aPlaneInfo;
6704 aPlaneInfo.PlaneId = aPlaneId;
6705 aPlaneInfo.ActorList.push_back( aSmeshActor );
6706 aPlaneInfo.ViewManager = vman;
6708 // to make the list sorted by plane id
6709 anIter = aPlaneInfoList.begin();
6710 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6711 const TPlaneInfo& aPlaneInfoRef = *anIter;
6712 if( aPlaneInfoRef.PlaneId > aPlaneId )
6715 aPlaneInfoList.insert( anIter, aPlaneInfo );
6720 } // if (aSmeshActor)
6721 } // other parameters than Visibility
6723 } // for names/parameters iterator
6724 } // for entries iterator
6726 // take into account planes with empty list of actors referred to them
6727 QList<SUIT_ViewManager*> aVMList;
6728 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6730 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6731 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6732 int aViewId = aPlaneDataIter->first;
6733 if( aViewId >= 0 && aViewId < aVMList.count() ) {
6734 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6736 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6738 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6739 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6740 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6741 const TPlaneData& aPlaneData = *anIter2;
6742 int aPlaneId = aPlaneData.Id;
6744 bool anIsFound = false;
6745 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6746 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6747 const TPlaneInfo& aPlaneInfo = *anIter3;
6748 if( aPlaneInfo.PlaneId == aPlaneId ) {
6755 TPlaneInfo aPlaneInfo; // ActorList field is empty
6756 aPlaneInfo.PlaneId = aPlaneId;
6757 aPlaneInfo.ViewManager = aViewManager;
6759 // to make the list sorted by plane id
6760 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6761 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6762 const TPlaneInfo& aPlaneInfoRef = *anIter4;
6763 if( aPlaneInfoRef.PlaneId > aPlaneId )
6766 aPlaneInfoList.insert( anIter4, aPlaneInfo );
6772 // add clipping planes to actors according to the restored parameters
6773 // and update the clipping plane map
6774 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6775 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6776 int aViewId = anIter1->first;
6777 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6779 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6780 if( anIter2 == aPlaneDataMap.end() )
6782 const TPlaneDataList& aPlaneDataList = anIter2->second;
6784 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6785 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6786 const TPlaneInfo& aPlaneInfo = *anIter3;
6787 int aPlaneId = aPlaneInfo.PlaneId;
6788 const TActorList& anActorList = aPlaneInfo.ActorList;
6789 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6793 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6797 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6799 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6800 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6801 const TPlaneData& aPlaneData = *anIter4;
6802 if( aPlaneData.Id == aPlaneId ) {
6803 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
6804 aPlane->myViewWindow = aViewWindow;
6805 aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
6806 aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
6807 if ( aPlane->PlaneMode == SMESH::Absolute ) {
6808 aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
6809 aPlane->X = aPlaneData.X;
6810 aPlane->Y = aPlaneData.Y;
6811 aPlane->Z = aPlaneData.Z;
6812 aPlane->Dx = aPlaneData.Dx;
6813 aPlane->Dy = aPlaneData.Dy;
6814 aPlane->Dz = aPlaneData.Dz;
6816 else if ( aPlane->PlaneMode == SMESH::Relative ) {
6817 aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
6818 aPlane->myDistance = aPlaneData.Distance;
6819 aPlane->myAngle[0] = aPlaneData.Angle[0];
6820 aPlane->myAngle[1] = aPlaneData.Angle[1];
6823 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6824 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6825 aClippingPlaneInfo.Plane = aPlane;
6826 aClippingPlaneInfo.ActorList = anActorList;
6827 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6838 // update all VTK views
6839 QList<SUIT_ViewManager*> lst;
6840 getApp()->viewManagers(lst);
6841 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6842 SUIT_ViewModel* vmodel = (*it)->getViewModel();
6843 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6844 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6845 // set OpenGL clipping planes
6846 VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
6847 vtkActorCollection* anAllActors = aCopy.GetActors();
6848 anAllActors->InitTraversal();
6849 while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
6850 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
6851 anActor->SetOpenGLClippingPlane();
6853 vtkView->getRenderer()->ResetCameraClippingRange();
6860 \brief Adds preferences for dfont of VTK viewer
6862 \param pIf group identifier
6863 \param param parameter
6864 \return identifier of preferences
6866 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
6868 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6870 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6873 fam.append( tr( "SMESH_FONT_ARIAL" ) );
6874 fam.append( tr( "SMESH_FONT_COURIER" ) );
6875 fam.append( tr( "SMESH_FONT_TIMES" ) );
6877 setPreferenceProperty( tfont, "fonts", fam );
6879 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6880 if ( needSize ) f = f | QtxFontEdit::Size;
6881 setPreferenceProperty( tfont, "features", f );
6887 \brief Actions after hypothesis edition
6888 Updates object browser after hypothesis edition
6890 void SMESHGUI::onHypothesisEdit( int result )
6893 SMESHGUI::Modified();
6894 updateObjBrowser( true );
6898 \brief Actions after choosing menu of control modes
6899 Updates control mode actions according to current selection
6901 void SMESHGUI::onUpdateControlActions()
6903 SALOME_ListIO selected;
6904 if ( LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr() )
6905 aSel->selectedObjects( selected );
6907 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
6908 if ( selected.Extent() ) {
6909 if ( selected.First()->hasEntry() ) {
6910 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( selected.First()->getEntry() )) {
6911 aControl = anActor->GetControlMode();
6912 SALOME_ListIteratorOfListIO it(selected);
6913 for ( it.Next(); it.More(); it.Next() ) {
6914 Handle(SALOME_InteractiveObject) anIO = it.Value();
6915 if ( anIO->hasEntry() ) {
6916 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
6917 if ( aControl != anActor->GetControlMode() ) {
6918 aControl = SMESH_Actor::eNone;
6928 int anAction = ActionToControl( aControl, true );
6930 action( anAction )->setChecked( true );
6932 QMenu* send = (QMenu*)sender();
6933 QList<QAction*> actions = send->actions();
6934 for ( int i = 0; i < actions.size(); i++ )
6935 actions[i]->setChecked( false );
6941 \brief Signal handler closing(SUIT_ViewWindow*) of a view
6942 \param pview view being closed
6944 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
6945 #ifndef DISABLE_PLOT2DVIEWER
6946 //Crear all Plot2d Viewers if need.
6947 SMESH::ClearPlot2Viewers(pview);
6949 EmitSignalCloseView();
6952 void SMESHGUI::message( const QString& msg )
6955 QStringList data = msg.split("/");
6956 if ( data.count() > 0 ) {
6957 if ( data.first() == "mesh_loading" ) {
6959 QString entry = data.count() > 1 ? data[1] : QString();
6960 if ( entry.isEmpty() )
6963 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
6965 _PTR(SObject) obj = study->FindObjectID( entry.toLatin1().constData() );
6968 name = SMESH::fromUtf8(obj->GetName());
6969 if ( name.isEmpty() )
6972 if ( data.last() == "stop" )
6973 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
6975 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
6976 QApplication::processEvents();
6982 \brief Connects or disconnects signals about activating and cloning view on the module slots
6983 \param pview view which is connected/disconnected
6985 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
6989 SUIT_ViewManager* viewMgr = pview->getViewManager();
6991 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6992 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6994 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6995 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7000 \brief Return \c true if object can be renamed
7002 bool SMESHGUI::renameAllowed( const QString& entry) const {
7003 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7007 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7011 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
7016 if(appStudy->isComponent(entry) || obj->isReference())
7019 // check type to prevent renaming of inappropriate objects
7020 int aType = SMESHGUI_Selection::type(qPrintable(entry), SMESH::GetActiveStudyDocument());
7021 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7022 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7023 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7024 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7025 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
7032 Rename object by entry.
7033 \param entry entry of the object
7034 \param name new name of the object
7035 \brief Return \c true if rename operation finished successfully, \c false otherwise.
7037 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
7039 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7043 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7048 _PTR(Study) aStudy = appStudy->studyDS();
7053 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
7055 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
7060 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
7061 _PTR(GenericAttribute) anAttr;
7062 _PTR(AttributeName) aName;
7064 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
7066 // check type to prevent renaming of inappropriate objects
7067 int aType = SMESHGUI_Selection::type( qPrintable(entry), SMESH::GetActiveStudyDocument() );
7068 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7069 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7070 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7071 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7072 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
7073 if ( !name.isEmpty() ) {
7074 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
7076 // update name of group object and its actor
7077 Handle(SALOME_InteractiveObject) IObject =
7078 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
7080 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
7081 if( !aGroupObject->_is_nil() ) {
7082 aGroupObject->SetName( qPrintable(name) );
7083 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
7084 anActor->setName( qPrintable(name) );
7094 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
7096 static QList<QColor> colors;
7098 if ( colors.isEmpty() ) {
7100 for (int s = 0; s < 2 ; s++)
7102 for (int v = 100; v >= 40; v = v - 20)
7104 for (int h = 0; h < 359 ; h = h + 60)
7106 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
7111 static int currentColor = randomize( colors.size() );
7113 SALOMEDS::Color color;
7114 color.R = (double)colors[currentColor].red() / 255.0;
7115 color.G = (double)colors[currentColor].green() / 255.0;
7116 color.B = (double)colors[currentColor].blue() / 255.0;
7118 currentColor = (currentColor+1) % colors.count();