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" );
1148 void SaveDistribution()
1150 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1151 SALOME_ListIO selected;
1153 aSel->selectedObjects( selected );
1155 if ( selected.Extent() == 1 ) {
1156 Handle(SALOME_InteractiveObject) anIO = selected.First();
1157 if ( anIO->hasEntry() ) {
1158 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1160 anActor->GetScalarBarActor() &&
1161 anActor->GetControlMode() != SMESH_Actor::eNone )
1163 SMESH_ScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor();
1164 SMESH::Controls::FunctorPtr aFunctor = anActor->GetFunctor();
1165 if ( aScalarBarActor && aFunctor ) {
1166 SMESH::Controls::NumericalFunctor* aNumFun =
1167 dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
1169 std::vector<int> elements;
1170 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
1171 if ( mesh->_is_nil() ) {
1172 SMESH::SMESH_IDSource_var idSource =
1173 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
1174 if ( !idSource->_is_nil() )
1176 SMESH::long_array_var ids = idSource->GetIDs();
1177 elements.resize( ids->length() );
1178 for ( unsigned i = 0; i < elements.size(); ++i )
1179 elements[i] = ids[i];
1182 int nbIntervals = aScalarBarActor->GetMaximumNumberOfColors();
1183 vtkLookupTable* lookupTable =
1184 static_cast<vtkLookupTable*>(aScalarBarActor->GetLookupTable());
1185 double * minmax = lookupTable->GetRange();
1186 bool isLogarithmic = lookupTable->GetScale() == VTK_SCALE_LOG10;
1187 std::vector<int> nbEvents;
1188 std::vector<double> funValues;
1189 aNumFun->GetHistogram( nbIntervals, nbEvents, funValues,
1190 elements, minmax, isLogarithmic );
1191 QString anInitialPath = "";
1192 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
1193 anInitialPath = QDir::currentPath();
1194 QString aMeshName = anIO->getName();
1196 filter.append( QObject::tr( "TEXT_FILES_FILTER" ) + " (*.txt)" );
1197 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
1198 QString aFilename = anInitialPath + "/" + aMeshName + "_" +
1199 functorToString( aFunctor ).toLower().simplified().replace( QRegExp( " |-" ), "_" ) + ".txt";
1200 aFilename = SUIT_FileDlg::getFileName( SMESHGUI::desktop(),
1203 QObject::tr( "SMESH_SAVE_DISTRIBUTION" ),
1205 if ( !aFilename.isEmpty() ) {
1206 QFile f( aFilename );
1207 if ( f.open( QFile::WriteOnly | QFile::Truncate ) ) {
1208 QTextStream out( &f );
1209 out << "# Mesh: " << aMeshName << endl;
1210 out << "# Control: " << functorToString( aFunctor ) << endl;
1212 out.setFieldWidth( 10 );
1213 for ( int i = 0; i < (int)qMin( nbEvents.size(), funValues.size()-1 ); i++ )
1214 out << funValues[i] << "\t" << funValues[i+1] << "\t" << nbEvents[i] << endl;
1225 void ShowElement( int theCommandID )
1227 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1228 SALOME_ListIO selected;
1230 aSel->selectedObjects( selected );
1232 if ( selected.Extent() == 1 ) {
1233 Handle(SALOME_InteractiveObject) anIO = selected.First();
1234 if ( anIO->hasEntry() ) {
1235 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1237 anActor->GetScalarBarActor() &&
1238 anActor->GetControlMode() != SMESH_Actor::eNone )
1240 SMESH_ScalarBarActor *aScalarBarActor = anActor->GetScalarBarActor();
1241 if ( theCommandID == SMESHOp::OpShowDistribution ) {
1242 aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility());
1244 else if ( theCommandID == SMESHOp::OpShowScalarBar ) {
1245 aScalarBarActor->SetVisibility( !aScalarBarActor->GetVisibility());
1252 #ifndef DISABLE_PLOT2DVIEWER
1253 void PlotDistribution()
1255 SalomeApp_Application* app =
1256 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1260 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1261 SALOME_ListIO selected;
1263 aSel->selectedObjects( selected );
1265 if ( selected.Extent() == 1 ) {
1266 Handle(SALOME_InteractiveObject) anIO = selected.First();
1267 if ( anIO->hasEntry() ) {
1268 //Find Actor by entry before getting Plot2d viewer,
1269 //because after call getViewManager( Plot2d_Viewer::Type(), true ) active window is Plot2d Viewer
1270 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1272 SUIT_ViewManager* aViewManager =
1273 app->getViewManager( Plot2d_Viewer::Type(), true ); // create if necessary
1277 SPlot2d_Viewer* aView = dynamic_cast<SPlot2d_Viewer*>(aViewManager->getViewModel());
1281 Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
1285 if ( anActor && anActor->GetControlMode() != SMESH_Actor::eNone )
1287 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1288 QString functorName = functorToString( anActor->GetFunctor());
1289 QString aHistogramName("%1 : %2");
1290 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1291 aHistogram->setName(aHistogramName);
1292 aHistogram->setHorTitle(functorName);
1293 aHistogram->setVerTitle(QObject::tr("DISTRIBUTION_NB_ENT"));
1294 aPlot->displayObject(aHistogram, true);
1299 #endif //DISABLE_PLOT2DVIEWER
1301 void DisableAutoColor()
1303 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1304 SALOME_ListIO selected;
1306 aSel->selectedObjects( selected );
1308 if ( selected.Extent() ) {
1309 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1310 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1311 if ( !aMesh->_is_nil() ) {
1312 aMesh->SetAutoColor( false );
1319 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1320 SALOME_ListIO selected;
1322 aSel->selectedObjects( selected );
1323 if ( selected.Extent() )
1325 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1326 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1327 _PTR(SObject) aSObj = aStudy->FindObjectID(anIObject->getEntry());
1329 if ( aStudy->GetUseCaseBuilder()->SortChildren( aSObj, true/*AscendingOrder*/ ) ) {
1330 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1337 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap)
1339 SALOME_ListIO selected;
1340 SalomeApp_Application* app =
1341 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1345 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1346 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1347 if ( !aSel || !appStudy )
1350 if ( theCommandID == SMESHOp::OpClipping ) { // Clipping dialog can be activated without selection
1351 if ( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
1352 aModule->EmitSignalDeactivateDialog();
1353 if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
1354 (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
1359 _PTR(Study) aStudy = appStudy->studyDS();
1361 aSel->selectedObjects( selected );
1363 if ( selected.Extent() >= 1 )
1365 switch ( theCommandID ) {
1366 case SMESHOp::OpTransparency:
1368 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1369 (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
1372 case SMESHOp::OpProperties:
1375 QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
1376 QColor orientationColor, outlineColor, volumeColor;
1377 int deltaF = 0, deltaV = 0;
1380 double ballScale = 1.0;
1382 int outlineWidth = 1;
1383 double shrinkCoef = 0.0;
1384 double orientationScale = 0.0;
1385 bool orientation3d = false;
1386 VTK::MarkerType markerType = VTK::MT_NONE;
1387 VTK::MarkerScale markerScale = VTK::MS_NONE;
1389 bool hasNodes = false;
1390 int presentEntities = 0;
1391 bool firstTime = true;
1393 SALOME_ListIteratorOfListIO It( selected );
1394 for ( ; It.More(); It.Next() ) {
1395 Handle(SALOME_InteractiveObject) IObject = It.Value();
1396 if ( !IObject->hasEntry() ) continue;
1397 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1398 if ( !anActor || !anActor->GetObject() ) continue;
1401 // nodes: color, marker
1402 anActor->GetNodeColor( color[0], color[1], color[2] );
1403 nodeColor.setRgbF( color[0], color[1], color[2] );
1404 markerType = anActor->GetMarkerType();
1405 markerScale = anActor->GetMarkerScale();
1406 markerId = anActor->GetMarkerTexture();
1407 // edges: color, width
1408 anActor->GetEdgeColor( color[0], color[1], color[2] );
1409 edgeColor.setRgbF( color[0], color[1], color[2] );
1410 edgeWidth = qMax( (int)anActor->GetLineWidth(), 1 ); // minimum allowed width is 1
1411 // faces: front color, back color (delta)
1412 anActor->GetSufaceColor( color[0], color[1], color[2], deltaF );
1413 faceColor.setRgbF( color[0], color[1], color[2] );
1414 // faces: front color, back color (delta)
1415 anActor->GetVolumeColor( color[0], color[1], color[2], deltaV );
1416 volumeColor.setRgbF( color[0], color[1], color[2] );
1417 // 0d elements: color, size
1418 anActor->Get0DColor( color[0], color[1], color[2] );
1419 elem0dColor.setRgbF( color[0], color[1], color[2] );
1420 elem0dSize = qMax( (int)anActor->Get0DSize(), 1 ); // minimum allowed size is 1
1421 // balls: color, size
1422 anActor->GetBallColor( color[0], color[1], color[2] );
1423 ballColor.setRgbF( color[0], color[1], color[2] );
1424 //ballSize = qMax( (int)anActor->GetBallSize(), 1 ); // minimum allowed size is 1
1425 ballScale = qMax( (double)anActor->GetBallScale(), 1e-2 ); // minimum allowed scale is 1e-2
1427 anActor->GetOutlineColor( color[0], color[1], color[2] );
1428 outlineColor.setRgbF( color[0], color[1], color[2] );
1429 outlineWidth = qMax( (int)anActor->GetOutlineWidth(), 1 ); // minimum allowed width is 1
1430 // orientation vectors: color, scale, 3d flag
1431 anActor->GetFacesOrientationColor( color[0], color[1], color[2] );
1432 orientationColor.setRgbF( color[0], color[1], color[2] );
1433 orientationScale = anActor->GetFacesOrientationScale();
1434 orientation3d = anActor->GetFacesOrientation3DVectors();
1436 shrinkCoef = anActor->GetShrinkFactor();
1439 firstTime = false; // we only take properties from first object (for performance reasons)
1442 hasNodes = anActor->GetObject()->GetNbEntities( SMDSAbs_Node );
1443 if ( !(presentEntities & SMESH_Actor::eEdges) && anActor->GetObject()->GetNbEntities( SMDSAbs_Edge ) )
1444 presentEntities = presentEntities | SMESH_Actor::eEdges;
1445 if ( !(presentEntities & SMESH_Actor::eFaces) && anActor->GetObject()->GetNbEntities( SMDSAbs_Face ) )
1446 presentEntities = presentEntities | SMESH_Actor::eFaces;
1447 if ( !(presentEntities & SMESH_Actor::eVolumes) && anActor->GetObject()->GetNbEntities( SMDSAbs_Volume ) )
1448 presentEntities = presentEntities | SMESH_Actor::eVolumes;
1449 if ( !(presentEntities & SMESH_Actor::e0DElements) && anActor->GetObject()->GetNbEntities( SMDSAbs_0DElement ) )
1450 presentEntities = presentEntities | SMESH_Actor::e0DElements;
1451 if ( !(presentEntities & SMESH_Actor::eBallElem) && anActor->GetObject()->GetNbEntities( SMDSAbs_Ball ) )
1452 presentEntities = presentEntities | SMESH_Actor::eBallElem;
1454 // as we know that all types of elements are present, we can exit the loop
1455 if ( presentEntities == SMESH_Actor::eAllEntity )
1459 SMESHGUI_PropertiesDlg dlg( theMarkerMap[ aStudy->StudyId() ], SMESHGUI::desktop() );
1460 // nodes: color, marker
1461 dlg.setNodeColor( nodeColor );
1462 if( markerType != VTK::MT_USER )
1463 dlg.setNodeMarker( markerType, markerScale );
1465 dlg.setNodeCustomMarker( markerId );
1466 // edges: color, line width
1467 dlg.setEdgeColor( edgeColor );
1468 dlg.setEdgeWidth( edgeWidth );
1469 // faces: front color, back color
1470 dlg.setFaceColor( faceColor, deltaF );
1471 // volumes: normal color, reversed color
1472 dlg.setVolumeColor( volumeColor, deltaV );
1473 // outlines: color, line width
1474 dlg.setOutlineColor( outlineColor );
1475 dlg.setOutlineWidth( outlineWidth );
1476 // 0d elements: color, size
1477 dlg.setElem0dColor( elem0dColor );
1478 dlg.setElem0dSize( elem0dSize );
1479 // balls: color, size
1480 dlg.setBallColor( ballColor );
1481 //dlg.setBallSize( ballSize );
1482 dlg.setBallScale( ballScale );
1483 // orientation: color, scale, 3d flag
1484 dlg.setOrientationColor( orientationColor );
1485 dlg.setOrientationSize( int( orientationScale * 100. ) );
1486 dlg.setOrientation3d( orientation3d );
1487 // shrink: scale factor
1488 dlg.setShrinkCoef( int( shrinkCoef * 100. ) );
1489 // hide unused controls
1490 dlg.showControls( presentEntities, hasNodes );
1493 nodeColor = dlg.nodeColor();
1494 markerType = dlg.nodeMarkerType();
1495 markerScale = dlg.nodeMarkerScale();
1496 markerId = dlg.nodeMarkerId();
1497 edgeColor = dlg.edgeColor();
1498 edgeWidth = dlg.edgeWidth();
1499 faceColor = dlg.faceColor();
1500 deltaF = dlg.faceColorDelta();
1501 volumeColor = dlg.volumeColor();
1502 deltaV = dlg.volumeColorDelta();
1503 outlineColor = dlg.outlineColor();
1504 outlineWidth = dlg.outlineWidth();
1505 elem0dColor = dlg.elem0dColor();
1506 elem0dSize = dlg.elem0dSize();
1507 ballColor = dlg.ballColor();
1508 // ballSize = dlg.ballSize();
1509 ballScale = dlg.ballScale();
1510 orientationColor = dlg.orientationColor();
1511 orientationScale = dlg.orientationSize() / 100.;
1512 orientation3d = dlg.orientation3d();
1513 shrinkCoef = dlg.shrinkCoef() / 100.;
1515 // store point markers map that might be changed by the user
1516 theMarkerMap[ aStudy->StudyId() ] = dlg.customMarkers();
1518 // set properties from dialog box to the presentations
1519 SALOME_ListIteratorOfListIO It( selected );
1520 for ( ; It.More(); It.Next() ) {
1521 Handle(SALOME_InteractiveObject) IObject = It.Value();
1522 if ( !IObject->hasEntry() ) continue;
1523 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1524 if ( !anActor ) continue;
1526 // nodes: color, marker
1527 anActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
1528 if ( markerType != VTK::MT_USER ) {
1529 anActor->SetMarkerStd( markerType, markerScale );
1532 const VTK::MarkerMap& markerMap = theMarkerMap[ aStudy->StudyId() ];
1533 VTK::MarkerMap::const_iterator iter = markerMap.find( markerId );
1534 if ( iter != markerMap.end() )
1535 anActor->SetMarkerTexture( markerId, iter->second.second );
1537 // volumes: normal color, reversed color (delta)
1538 anActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
1539 // faces: front color, back color (delta)
1540 anActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
1541 // edges: color, width
1542 anActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
1543 anActor->SetLineWidth( edgeWidth );
1545 anActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
1546 anActor->SetOutlineWidth( outlineWidth );
1547 // 0D elements: color, size
1548 anActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
1549 anActor->Set0DSize( elem0dSize );
1550 // balls: color, size
1551 anActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
1552 // anActor->SetBallSize( ballSize );
1553 anActor->SetBallScale( ballScale );
1554 // orientation: color, scale, 3d flag
1555 anActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
1556 anActor->SetFacesOrientationScale( orientationScale );
1557 anActor->SetFacesOrientation3DVectors( orientation3d );
1559 anActor->SetShrinkFactor( shrinkCoef );
1561 // for groups, set also proper color
1562 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1563 if ( !aGroupObject->_is_nil() ) {
1564 SMESH::ElementType anElementType = aGroupObject->GetType();
1566 switch( anElementType ) {
1568 aColor = nodeColor; break;
1570 aColor = edgeColor; break;
1572 aColor = faceColor; break;
1574 aColor = volumeColor; break;
1576 aColor = elem0dColor; break;
1578 aColor = ballColor; break;
1582 if ( aColor.isValid() ) {
1583 SALOMEDS::Color aGroupColor;
1584 aGroupColor.R = aColor.redF();
1585 aGroupColor.G = aColor.greenF();
1586 aGroupColor.B = aColor.blueF();
1587 aGroupObject->SetColor( aGroupColor );
1589 } // if ( !aGroupObject->_is_nil() )
1590 } // for ( ; It.More(); It.Next() )
1591 SMESH::RepaintCurrentView();
1592 } // if ( dlg.exec() )
1594 } // case SMESHOp::OpProperties:
1595 } // switch(theCommandID)
1596 SALOME_ListIteratorOfListIO It( selected );
1597 for( ; It.More(); It.Next()){
1598 Handle(SALOME_InteractiveObject) IObject = It.Value();
1599 if(IObject->hasEntry()){
1600 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1601 switch(theCommandID){
1602 case SMESHOp::OpDMWireframe:
1603 anActor->SetRepresentation(SMESH_Actor::eEdge);
1605 case SMESHOp::OpDMShading:
1606 anActor->SetRepresentation(SMESH_Actor::eSurface);
1608 case SMESHOp::OpDMShrink:
1609 if(anActor->IsShrunk())
1610 anActor->UnShrink();
1612 anActor->SetShrink();
1614 case SMESHOp::OpDMNodes:
1615 anActor->SetRepresentation(SMESH_Actor::ePoint);
1617 case SMESHOp::OpRepresentationLines:
1618 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1619 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1621 case SMESHOp::OpRepresentationArcs:
1622 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1623 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1629 SMESH::RepaintCurrentView();
1633 int ActionToControl( int theID, bool theReversed )
1635 NCollection_DoubleMap<int,int> ActionControl;
1636 ActionControl.Bind( 0, SMESH_Actor::eNone );
1637 ActionControl.Bind( SMESHOp::OpFreeNode, SMESH_Actor::eFreeNodes );
1638 ActionControl.Bind( SMESHOp::OpEqualNode, SMESH_Actor::eCoincidentNodes );
1639 ActionControl.Bind( SMESHOp::OpFreeEdge, SMESH_Actor::eFreeEdges );
1640 ActionControl.Bind( SMESHOp::OpFreeBorder, SMESH_Actor::eFreeBorders );
1641 ActionControl.Bind( SMESHOp::OpLength, SMESH_Actor::eLength );
1642 ActionControl.Bind( SMESHOp::OpConnection, SMESH_Actor::eMultiConnection );
1643 ActionControl.Bind( SMESHOp::OpEqualEdge, SMESH_Actor::eCoincidentElems1D );
1644 ActionControl.Bind( SMESHOp::OpFreeFace, SMESH_Actor::eFreeFaces );
1645 ActionControl.Bind( SMESHOp::OpBareBorderFace, SMESH_Actor::eBareBorderFace );
1646 ActionControl.Bind( SMESHOp::OpOverConstrainedFace, SMESH_Actor::eOverConstrainedFace );
1647 ActionControl.Bind( SMESHOp::OpLength2D, SMESH_Actor::eLength2D );
1648 ActionControl.Bind( SMESHOp::OpConnection2D, SMESH_Actor::eMultiConnection2D );
1649 ActionControl.Bind( SMESHOp::OpArea, SMESH_Actor::eArea );
1650 ActionControl.Bind( SMESHOp::OpTaper, SMESH_Actor::eTaper );
1651 ActionControl.Bind( SMESHOp::OpAspectRatio, SMESH_Actor::eAspectRatio );
1652 ActionControl.Bind( SMESHOp::OpMinimumAngle, SMESH_Actor::eMinimumAngle );
1653 ActionControl.Bind( SMESHOp::OpWarpingAngle, SMESH_Actor::eWarping );
1654 ActionControl.Bind( SMESHOp::OpSkew, SMESH_Actor::eSkew );
1655 ActionControl.Bind( SMESHOp::OpMaxElementLength2D, SMESH_Actor::eMaxElementLength2D );
1656 ActionControl.Bind( SMESHOp::OpEqualFace, SMESH_Actor::eCoincidentElems2D );
1657 ActionControl.Bind( SMESHOp::OpAspectRatio3D, SMESH_Actor::eAspectRatio3D );
1658 ActionControl.Bind( SMESHOp::OpVolume, SMESH_Actor::eVolume3D );
1659 ActionControl.Bind( SMESHOp::OpMaxElementLength3D, SMESH_Actor::eMaxElementLength3D );
1660 ActionControl.Bind( SMESHOp::OpBareBorderVolume, SMESH_Actor::eBareBorderVolume );
1661 ActionControl.Bind( SMESHOp::OpOverConstrainedVolume, SMESH_Actor::eOverConstrainedVolume );
1662 ActionControl.Bind( SMESHOp::OpEqualVolume, SMESH_Actor::eCoincidentElems3D );
1664 return theReversed ? ActionControl.Find2( theID ) : ActionControl.Find1( theID );
1667 void Control( int theCommandID )
1669 SMESH_Actor::eControl aControl = SMESH_Actor::eControl( ActionToControl( theCommandID ));
1670 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1672 SALOME_ListIO selected;
1673 if ( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
1674 aSel->selectedObjects( selected );
1676 if ( !selected.IsEmpty() ) {
1677 SALOME_ListIteratorOfListIO It(selected);
1678 for ( ; It.More(); It.Next())
1680 Handle(SALOME_InteractiveObject) anIO = It.Value();
1681 if ( !anIO.IsNull() ) {
1682 _PTR(SObject) SO = aStudy->FindObjectID( It.Value()->getEntry() );
1684 CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
1685 SMESH::SMESH_IDSource_var anIDSrc = SMESH::SMESH_IDSource::_narrow( aObject );
1686 if ( !anIDSrc->_is_nil() ) {
1687 SMESH_Actor *anActor = SMESH::FindActorByEntry( anIO->getEntry());
1688 if (( !anActor && selected.Extent() == 1 ) &&
1689 ( anActor = SMESH::CreateActor( aStudy, anIO->getEntry() )))
1691 anActor->SetControlMode( aControl );
1692 SMESH::DisplayActor( SMESH::GetCurrentVtkView(), anActor );
1693 SMESH::UpdateView ( SMESH::eDisplay, anIO->getEntry() );
1697 if ( anActor->GetControlMode() != aControl )
1698 anActor->SetControlMode( aControl );
1699 QString functorName = functorToString( anActor->GetFunctor() );
1700 int anEntitiesCount = anActor->GetNumberControlEntities();
1701 if (anEntitiesCount >= 0)
1702 functorName = functorName + ": " + QString::number(anEntitiesCount);
1703 anActor->GetScalarBarActor()->SetTitle( functorName.toLatin1().constData() );
1704 SMESH::RepaintCurrentView();
1705 #ifndef DISABLE_PLOT2DVIEWER
1706 if ( anActor->GetPlot2Histogram() ) {
1707 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1708 QString aHistogramName("%1 : %2");
1709 aHistogramName = aHistogramName.arg( anIO->getName() ).arg( functorName );
1710 aHistogram->setName( aHistogramName );
1711 aHistogram->setHorTitle( functorName );
1712 SMESH::ProcessIn2DViewers( anActor );
1724 bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1725 SMESH::MeshObjectType theType,
1726 const QString theInTypeName,
1727 QString & theOutTypeName)
1729 SMESH_TypeFilter aTypeFilter( theType );
1731 if ( !theIO.IsNull() )
1733 entry = theIO->getEntry();
1734 LightApp_DataOwner owner( entry );
1735 if ( aTypeFilter.isOk( &owner )) {
1736 theOutTypeName = theInTypeName;
1744 QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1746 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1747 _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1749 _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1750 CORBA::String_var anID = aSComp->GetID().c_str();
1751 if ( !strcmp(anID.in(),theIO->getEntry()) )
1757 CheckOIType ( theIO, SMESH::HYPOTHESIS, "Hypothesis", aTypeName ) ||
1758 CheckOIType ( theIO, SMESH::ALGORITHM, "Algorithm", aTypeName ) ||
1759 CheckOIType ( theIO, SMESH::MESH, "Mesh", aTypeName ) ||
1760 CheckOIType ( theIO, SMESH::SUBMESH, "SubMesh", aTypeName ) ||
1761 CheckOIType ( theIO, SMESH::GROUP, "Group", aTypeName )
1769 // QString CheckHomogeneousSelection()
1771 // LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1772 // SALOME_ListIO selected;
1774 // aSel->selectedObjects( selected );
1776 // QString RefType = CheckTypeObject(selected.First());
1777 // SALOME_ListIteratorOfListIO It(selected);
1778 // for ( ; It.More(); It.Next())
1780 // Handle(SALOME_InteractiveObject) IObject = It.Value();
1781 // QString Type = CheckTypeObject(IObject);
1782 // if ( Type.compare(RefType) != 0 )
1783 // return "Heterogeneous Selection";
1789 uint randomize( uint size )
1791 static bool initialized = false;
1792 if ( !initialized ) {
1793 qsrand( QDateTime::currentDateTime().toTime_t() );
1797 v = uint( (double)( v ) / RAND_MAX * size );
1798 v = qMax( uint(0), qMin ( v, size-1 ) );
1804 void SMESHGUI::OnEditDelete()
1806 // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1807 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1808 SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1810 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1811 _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1812 _PTR(GenericAttribute) anAttr;
1813 _PTR(AttributeIOR) anIOR;
1815 int objectCount = 0;
1817 QString aParentComponent = QString::null;
1818 Handle(SALOME_InteractiveObject) anIO;
1819 for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1821 anIO = anIt.Value();
1822 QString cur = anIO->getComponentDataType();
1823 _PTR(SObject) aSO = aStudy->FindObjectID(anIO->getEntry());
1825 // check if object is reference
1826 _PTR(SObject) aRefSObj;
1827 aNameList.append("\n - ");
1828 if ( aSO->ReferencedObject( aRefSObj ) ) {
1829 QString aRefName = QString::fromStdString ( aRefSObj->GetName() );
1830 aNameList.append( aRefName );
1831 cur = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1834 aNameList.append(anIO->getName());
1838 if( aParentComponent.isNull() )
1839 aParentComponent = cur;
1840 else if( !aParentComponent.isEmpty() && aParentComponent!=cur )
1841 aParentComponent = "";
1844 if ( objectCount == 0 )
1845 return; // No Valid Objects Selected
1847 if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
1848 SUIT_MessageBox::warning( SMESHGUI::desktop(),
1849 QObject::tr("ERR_ERROR"),
1850 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
1853 // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
1854 if (SUIT_MessageBox::warning
1855 (SMESHGUI::desktop(),
1856 QObject::tr("SMESH_WRN_WARNING"),
1857 QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
1858 SUIT_MessageBox::Yes | SUIT_MessageBox::No,
1859 SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
1862 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1864 // Put the whole hierarchy of sub-objects of the selected SO's into a list and
1865 // then treat them all starting from the deepest objects (at list back)
1866 std::list< _PTR(SObject) > listSO;
1867 SALOME_ListIteratorOfListIO It(selected);
1868 for( ; It.More(); It.Next()) // loop on selected IO's
1870 Handle(SALOME_InteractiveObject) IObject = It.Value();
1871 if(IObject->hasEntry()) {
1872 _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
1874 // disable removal of "SMESH" component object
1875 if(aSO->FindAttribute(anAttr, "AttributeIOR")){
1877 if ( engineIOR() == anIOR->Value().c_str() )
1880 //Check the referenced object
1881 _PTR(SObject) aRefSObject;
1882 if ( aSO && aSO->ReferencedObject( aRefSObject ) )
1883 aSO = aRefSObject; // Delete main Object instead of reference
1885 listSO.push_back( aSO );
1886 std::list< _PTR(SObject) >::iterator itSO = --listSO.end();
1887 for ( ; itSO != listSO.end(); ++itSO ) {
1888 _PTR(ChildIterator) it = aStudy->NewChildIterator( *itSO );
1889 for (it->InitEx(false); it->More(); it->Next())
1890 listSO.push_back( it->Value() );
1894 // Check if none of objects to delete is referred from outside
1895 std::list< _PTR(SObject) >::reverse_iterator ritSO;
1896 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1898 _PTR(SObject) SO = *ritSO;
1899 if ( !SO ) continue;
1900 std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( *ritSO );
1901 for (size_t i = 0; i < aReferences.size(); i++) {
1902 _PTR(SComponent) aComponent = aReferences[i]->GetFatherComponent();
1903 std::string type = aComponent->ComponentDataType();
1904 if ( type != "SMESH" )
1906 SUIT_MessageBox::warning( anApp->desktop(),
1907 QObject::tr("WRN_WARNING"),
1908 QObject::tr("DEP_OBJECT") );
1909 return; // outside SMESH, there is an object depending on a SMESH object
1914 // Call mesh->Clear() to prevent loading mesh from file caused by hypotheses removal
1915 for( It.Initialize( selected ); It.More(); It.Next()) // loop on selected IO's
1917 Handle(SALOME_InteractiveObject) IObject = It.Value();
1918 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface< SMESH::SMESH_Mesh >( IObject );
1919 if ( !mesh->_is_nil() )
1923 // Treat SO's in the list starting from the back
1924 aStudyBuilder->NewCommand(); // There is a transaction
1925 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1927 _PTR(SObject) SO = *ritSO;
1928 if ( !SO ) continue;
1929 std::string anEntry = SO->GetID();
1931 /** Erase graphical object and remove all its data **/
1932 if(SO->FindAttribute(anAttr, "AttributeIOR")) {
1933 SMESH::RemoveVisualObjectWithActors( anEntry.c_str(), true);
1935 /** Remove an object from data structures **/
1936 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
1937 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
1938 if ( !aGroup->_is_nil() ) { // DELETE GROUP
1939 SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
1940 aMesh->RemoveGroup( aGroup );
1942 else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
1943 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
1944 aMesh->RemoveSubMesh( aSubMesh );
1946 _PTR(SObject) aMeshSO = SMESH::FindSObject(aMesh);
1948 SMESH::ModifiedMesh(aMeshSO, false, aMesh->NbNodes()==0);
1951 Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
1952 ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
1953 QString objType = CheckTypeObject(IObject);
1954 if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
1955 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
1956 aStudyBuilder->RemoveObjectWithChildren( SO );
1958 else {// default action: remove SObject from the study
1959 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
1960 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
1962 aStudyBuilder->RemoveObjectWithChildren( SO );
1966 } /* listSO back loop */
1968 aStudyBuilder->CommitCommand();
1970 /* Clear any previous selection */
1972 aSel->setSelectedObjects( l1 );
1974 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1978 SMESHGUI_EXPORT CAM_Module* createModule()
1980 return new SMESHGUI();
1983 SMESHGUI_EXPORT char* getModuleVersion() {
1984 return (char*)SMESH_VERSION_STR;
1988 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
1990 //=============================================================================
1994 //=============================================================================
1995 SMESHGUI::SMESHGUI() :
1996 SalomeApp_Module( "SMESH" )
1998 if ( CORBA::is_nil( myComponentSMESH ) )
2000 CORBA::Boolean anIsEmbeddedMode;
2001 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
2002 //MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
2004 // 0019923: EDF 765 SMESH : default values of hypothesis
2005 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
2006 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
2007 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
2008 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
2009 myComponentSMESH->SetDefaultNbSegments( nbSeg );
2011 const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif", "default_grp_color" };
2012 for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
2013 if ( aResourceMgr->hasValue( "SMESH", options[i] ))
2015 QString val = aResourceMgr->stringValue( "SMESH", options[i] );
2016 myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
2020 myActiveDialogBox = 0;
2021 myFilterLibraryDlg = 0;
2025 myEventCallbackCommand = vtkCallbackCommand::New();
2026 myEventCallbackCommand->Delete();
2027 myEventCallbackCommand->SetClientData( this );
2028 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
2031 /* load resources for all available meshers */
2032 SMESH::InitAvailableHypotheses();
2035 //=============================================================================
2039 //=============================================================================
2040 SMESHGUI::~SMESHGUI()
2044 //=============================================================================
2048 //=============================================================================
2049 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
2051 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2053 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
2058 //=============================================================================
2062 //=============================================================================
2063 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
2065 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2069 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2070 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2071 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2072 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2073 return autoUpdate && !exceeded;
2076 //=============================================================================
2080 //=============================================================================
2081 bool SMESHGUI::automaticUpdate( SMESH::SMESH_IDSource_ptr theMesh,
2082 int* entities, bool* limitExceeded, int* hidden, long* nbElements )
2084 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2088 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2089 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2090 bool incrementalLimit = resMgr->booleanValue( "SMESH", "incremental_limit", false );
2092 SMESH::long_array_var info = theMesh->GetMeshInfo();
2093 long nbOdElems = info[SMDSEntity_0D];
2094 long nbEdges = info[SMDSEntity_Edge] + info[SMDSEntity_Quad_Edge];
2095 long nbFaces = info[SMDSEntity_Triangle] + info[SMDSEntity_Quad_Triangle] + info[SMDSEntity_BiQuad_Triangle] +
2096 info[SMDSEntity_Quadrangle] + info[SMDSEntity_Quad_Quadrangle] + info[SMDSEntity_BiQuad_Quadrangle] +
2097 info[SMDSEntity_Polygon] + info[SMDSEntity_Quad_Polygon];
2098 long nbVolumes = info[SMDSEntity_Tetra] + info[SMDSEntity_Quad_Tetra] +
2099 info[SMDSEntity_Hexa] + info[SMDSEntity_Quad_Hexa] + info[SMDSEntity_TriQuad_Hexa] +
2100 info[SMDSEntity_Pyramid] + info[SMDSEntity_Quad_Pyramid] +
2101 info[SMDSEntity_Penta] + info[SMDSEntity_Quad_Penta] +
2102 info[SMDSEntity_Polyhedra] +
2103 info[SMDSEntity_Hexagonal_Prism];
2104 long nbBalls = info[SMDSEntity_Ball];
2106 long requestedSize = nbOdElems + nbBalls + nbEdges + nbFaces + nbVolumes;
2107 *nbElements = requestedSize;
2109 *entities = SMESH_Actor::eAllEntity;
2112 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2114 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2116 if ( incrementalLimit ) {
2119 if ( nbOdElems > 0 ) {
2120 if ( total + nbOdElems > updateLimit ) {
2121 *entities = *entities & ~SMESH_Actor::e0DElements;
2122 *hidden = *hidden | SMESH_Actor::e0DElements;
2129 if ( nbEdges > 0 ) {
2130 if ( total + nbEdges > updateLimit ) {
2131 *entities = *entities & ~SMESH_Actor::eEdges;
2132 *hidden = *hidden | SMESH_Actor::eEdges;
2139 if ( nbFaces > 0 ) {
2140 if ( total + nbFaces > updateLimit ) {
2141 *entities = *entities & ~SMESH_Actor::eFaces;
2142 *hidden = *hidden | SMESH_Actor::eFaces;
2149 if ( nbVolumes > 0 ) {
2150 if ( total + nbVolumes > updateLimit ) {
2151 *entities = *entities & ~SMESH_Actor::eVolumes;
2152 *hidden = *hidden | SMESH_Actor::eVolumes;
2159 if ( nbBalls > 0 ) {
2160 if ( total + nbBalls > updateLimit ) {
2161 *entities = *entities & ~SMESH_Actor::eBallElem;
2162 *hidden = *hidden | SMESH_Actor::eBallElem;
2170 return autoUpdate && !exceeded;
2173 //=============================================================================
2177 //=============================================================================
2178 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
2180 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
2183 //=============================================================================
2187 //=============================================================================
2188 SMESHGUI* SMESHGUI::GetSMESHGUI()
2190 SMESHGUI* smeshMod = 0;
2191 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
2194 CAM_Module* module = app->module( "Mesh" );
2195 smeshMod = dynamic_cast<SMESHGUI*>( module );
2198 if ( smeshMod && smeshMod->application() && smeshMod->application()->activeStudy() )
2200 SalomeApp_Study* study = dynamic_cast<SalomeApp_Study*>( smeshMod->application()->activeStudy() );
2203 _PTR(Study) aStudy = study->studyDS();
2205 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
2214 Standard_EXPORT SMESHGUI* GetComponentGUI()
2216 return SMESHGUI::GetSMESHGUI();
2220 //=============================================================================
2224 //=============================================================================
2225 void SMESHGUI::SetState(int aState)
2230 //=============================================================================
2234 //=============================================================================
2235 void SMESHGUI::ResetState()
2240 //=============================================================================
2244 //=============================================================================
2245 void SMESHGUI::EmitSignalDeactivateDialog()
2247 emit SignalDeactivateActiveDialog();
2250 //=============================================================================
2254 //=============================================================================
2255 void SMESHGUI::EmitSignalStudyFrameChanged()
2257 emit SignalStudyFrameChanged();
2260 //=============================================================================
2264 //=============================================================================
2265 void SMESHGUI::EmitSignalCloseAllDialogs()
2267 emit SignalCloseAllDialogs();
2270 //=============================================================================
2274 //=============================================================================
2275 void SMESHGUI::EmitSignalVisibilityChanged()
2277 emit SignalVisibilityChanged();
2280 //=============================================================================
2284 //=============================================================================
2285 void SMESHGUI::EmitSignalCloseView()
2287 emit SignalCloseView();
2290 //=============================================================================
2294 //=============================================================================
2295 void SMESHGUI::EmitSignalActivatedViewManager()
2297 emit SignalActivatedViewManager();
2300 //=============================================================================
2304 //=============================================================================
2305 QDialog *SMESHGUI::GetActiveDialogBox()
2307 return myActiveDialogBox;
2310 //=============================================================================
2314 //=============================================================================
2315 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2317 myActiveDialogBox = (QDialog *) aDlg;
2321 //=============================================================================
2325 //=============================================================================
2326 SUIT_Desktop* SMESHGUI::desktop()
2328 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2330 return app->desktop();
2335 //=============================================================================
2339 //=============================================================================
2340 SalomeApp_Study* SMESHGUI::activeStudy()
2342 SUIT_Application* app = SUIT_Session::session()->activeApplication();
2344 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2349 //=============================================================================
2353 //=============================================================================
2354 void SMESHGUI::Modified( bool theIsUpdateActions )
2356 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2357 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2358 appStudy->Modified();
2359 if( theIsUpdateActions )
2360 app->updateActions();
2365 //=============================================================================
2369 //=============================================================================
2370 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2372 /* Here the position is on the bottom right corner - 10 */
2373 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2375 SUIT_Desktop *PP = desktop();
2376 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2377 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2381 //=============================================================================
2385 //=============================================================================
2386 static int isStudyLocked(_PTR(Study) theStudy){
2387 return theStudy->GetProperties()->IsLocked();
2390 static bool checkLock(_PTR(Study) theStudy) {
2391 if (isStudyLocked(theStudy)) {
2392 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2393 QObject::tr("WRN_WARNING"),
2394 QObject::tr("WRN_STUDY_LOCKED") );
2400 //=======================================================================
2401 //function : CheckActiveStudyLocked
2403 //=======================================================================
2405 bool SMESHGUI::isActiveStudyLocked()
2407 _PTR(Study) aStudy = activeStudy()->studyDS();
2408 return checkLock( aStudy );
2411 //=============================================================================
2415 //=============================================================================
2416 bool SMESHGUI::OnGUIEvent( int theCommandID )
2418 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2422 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
2423 SUIT_ResourceMgr* mgr = resourceMgr();
2427 if (CORBA::is_nil(GetSMESHGen()->GetCurrentStudy())) {
2428 GetSMESHGen()->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
2431 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2432 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2434 //QAction* act = action( theCommandID );
2436 switch (theCommandID) {
2437 case SMESHOp::OpDelete:
2438 if(checkLock(aStudy)) break;
2441 case SMESHOp::OpImportDAT:
2442 case SMESHOp::OpImportUNV:
2443 case SMESHOp::OpImportMED:
2444 case SMESHOp::OpImportSTL:
2446 case SMESHOp::OpImportCGNS:
2448 case SMESHOp::OpImportSAUV:
2449 case SMESHOp::OpImportGMF:
2451 if(checkLock(aStudy)) break;
2452 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2456 case SMESHOp::OpFileInformation:
2458 SALOME_ListIO selected;
2459 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2461 aSel->selectedObjects( selected );
2462 if( selected.Extent() )
2464 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2465 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2466 if ( !aMesh->_is_nil() )
2468 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2474 case SMESHOp::OpExportDAT:
2475 case SMESHOp::OpExportMED:
2476 case SMESHOp::OpExportUNV:
2477 case SMESHOp::OpExportSTL:
2479 case SMESHOp::OpExportCGNS:
2481 case SMESHOp::OpExportSAUV:
2482 case SMESHOp::OpExportGMF:
2483 case SMESHOp::OpPopupExportDAT:
2484 case SMESHOp::OpPopupExportMED:
2485 case SMESHOp::OpPopupExportUNV:
2486 case SMESHOp::OpPopupExportSTL:
2488 case SMESHOp::OpPopupExportCGNS:
2490 case SMESHOp::OpPopupExportSAUV:
2491 case SMESHOp::OpPopupExportGMF:
2493 ::ExportMeshToFile(theCommandID);
2497 case SMESHOp::OpReset: // SCALAR BAR
2499 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2500 SALOME_ListIO selected;
2502 aSel->selectedObjects( selected );
2504 SALOME_ListIteratorOfListIO it(selected);
2505 for( ; it.More(); it.Next()) {
2506 Handle(SALOME_InteractiveObject) anIO = it.Value();
2507 if( anIO->hasEntry() ) {
2508 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2509 anActor->SetControlMode( SMESH_Actor::eNone );
2510 #ifndef DISABLE_PLOT2DVIEWER
2511 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2516 SMESH::UpdateView();
2519 case SMESHOp::OpScalarBarProperties:
2521 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2524 case SMESHOp::OpShowScalarBar:
2526 // show/hide scalar bar
2527 ::ShowElement(theCommandID);
2530 case SMESHOp::OpSaveDistribution:
2532 // dump control distribution data to the text file
2533 ::SaveDistribution();
2537 case SMESHOp::OpShowDistribution:
2539 // show/hide distribution
2540 ::ShowElement(theCommandID);
2544 #ifndef DISABLE_PLOT2DVIEWER
2545 case SMESHOp::OpPlotDistribution:
2547 // plot distribution
2548 ::PlotDistribution();
2554 case SMESHOp::OpAutoColor:
2558 case SMESHOp::OpDisableAutoColor:
2559 ::DisableAutoColor();
2562 case SMESHOp::OpClipping:
2563 case SMESHOp::OpTransparency:
2564 case SMESHOp::OpProperties: // Display preferences (colors, shrink size, line width, ...)
2567 case SMESHOp::OpDMWireframe:
2568 case SMESHOp::OpDMShading:
2569 case SMESHOp::OpDMNodes:
2570 case SMESHOp::OpDMShrink:
2571 ::SetDisplayMode(theCommandID, myMarkerMap);
2574 //2D quadratic representation
2575 case SMESHOp::OpRepresentationLines:
2576 case SMESHOp::OpRepresentationArcs:
2577 ::SetDisplayMode(theCommandID, myMarkerMap);
2581 case SMESHOp::OpDE0DElements:
2582 case SMESHOp::OpDEEdges:
2583 case SMESHOp::OpDEFaces:
2584 case SMESHOp::OpDEVolumes:
2585 case SMESHOp::OpDEBalls:
2586 case SMESHOp::OpDEAllEntity:
2587 ::SetDisplayEntity(theCommandID);
2590 // Choose entities to be displayed
2591 case SMESHOp::OpDEChoose:
2593 ( new SMESHGUI_DisplayEntitiesDlg( SMESHGUI::desktop() ) )->exec();
2597 case SMESHOp::OpOrientationOnFaces:
2599 LightApp_SelectionMgr* mgr = selectionMgr();
2600 SALOME_ListIO selected; mgr->selectedObjects( selected );
2602 SALOME_ListIteratorOfListIO it(selected);
2603 for( ; it.More(); it.Next()) {
2604 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2605 if(anIObject->hasEntry()) {
2606 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2607 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2614 case SMESHOp::OpUpdate:
2616 if(checkLock(aStudy)) break;
2617 SUIT_OverrideCursor wc;
2619 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2622 SMESH::UpdateView();
2624 catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2625 SMESH::OnVisuException();
2627 catch (...) { // PAL16774 (Crash after display of many groups)
2628 SMESH::OnVisuException();
2632 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2633 aSel->selectedObjects( l );
2634 aSel->setSelectedObjects( l );
2638 case SMESHOp::OpHide:
2639 case SMESHOp::OpShow:
2640 case SMESHOp::OpShowOnly:
2642 SUIT_OverrideCursor wc;
2643 SMESH::EDisplaing anAction;
2644 switch (theCommandID) {
2645 case SMESHOp::OpHide: anAction = SMESH::eErase; break;
2646 case SMESHOp::OpShow: anAction = SMESH::eDisplay; break;
2647 case SMESHOp::OpShowOnly: anAction = SMESH::eDisplayOnly; break;
2650 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2651 SALOME_ListIO sel_objects, to_process;
2653 aSel->selectedObjects( sel_objects );
2655 if ( theCommandID==SMESHOp::OpShowOnly )
2657 //MESSAGE("anAction = SMESH::eDisplayOnly");
2658 startOperation( myEraseAll );
2661 extractContainers( sel_objects, to_process );
2664 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2668 SALOME_ListIteratorOfListIO It( to_process );
2669 for ( ; It.More(); It.Next())
2671 Handle(SALOME_InteractiveObject) IOS = It.Value();
2672 if ( IOS->hasEntry() )
2674 if ( !SMESH::UpdateView( anAction, IOS->getEntry() )) {
2675 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2676 break; // PAL16774 (Crash after display of many groups)
2678 if (anAction == SMESH::eDisplayOnly)
2679 anAction = SMESH::eDisplay;
2684 // PAL13338 + PAL15161 -->
2685 if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !checkLock(aStudy)) {
2686 SMESH::UpdateView();
2687 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2689 // PAL13338 + PAL15161 <--
2691 catch (...) { // PAL16774 (Crash after display of many groups)
2692 SMESH::OnVisuException();
2695 if (anAction == SMESH::eErase) {
2697 aSel->setSelectedObjects( l1 );
2700 aSel->setSelectedObjects( to_process );
2705 case SMESHOp::OpNode:
2707 if(checkLock(aStudy)) break;
2710 EmitSignalDeactivateDialog();
2712 ( new SMESHGUI_NodesDlg( this ) )->show();
2715 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"),tr("SMESH_WRN_VIEWER_VTK"));
2720 case SMESHOp::OpCreateMesh:
2721 case SMESHOp::OpCreateSubMesh:
2722 case SMESHOp::OpEditMeshOrSubMesh:
2723 case SMESHOp::OpEditMesh:
2724 case SMESHOp::OpEditSubMesh:
2725 case SMESHOp::OpCompute:
2726 case SMESHOp::OpComputeSubMesh:
2727 case SMESHOp::OpPreCompute:
2728 case SMESHOp::OpEvaluate:
2729 case SMESHOp::OpMeshOrder:
2730 startOperation( theCommandID );
2732 case SMESHOp::OpCopyMesh:
2734 if (checkLock(aStudy)) break;
2735 EmitSignalDeactivateDialog();
2736 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2739 case SMESHOp::OpBuildCompoundMesh:
2741 if (checkLock(aStudy)) break;
2742 EmitSignalDeactivateDialog();
2743 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2747 case SMESHOp::OpDiagonalInversion:
2748 case SMESHOp::OpUnionOfTwoTriangle:
2752 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2756 if ( checkLock( aStudy ) )
2759 /*Standard_Boolean aRes;
2760 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2761 if ( aMesh->_is_nil() )
2763 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2764 tr( "SMESH_BAD_SELECTION" ) );
2768 EmitSignalDeactivateDialog();
2769 if ( theCommandID == SMESHOp::OpDiagonalInversion )
2770 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2772 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2775 case SMESHOp::OpOrientation:
2776 case SMESHOp::OpUnionOfTriangles:
2777 case SMESHOp::OpCuttingOfQuadrangles:
2778 case SMESHOp::OpSplitVolumes:
2782 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2786 if ( checkLock( aStudy ) )
2789 EmitSignalDeactivateDialog();
2790 SMESHGUI_MultiEditDlg* aDlg = NULL;
2791 if ( theCommandID == SMESHOp::OpOrientation )
2792 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2793 else if ( theCommandID == SMESHOp::OpUnionOfTriangles )
2794 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2795 else if ( theCommandID == SMESHOp::OpSplitVolumes )
2796 aDlg = new SMESHGUI_SplitVolumesDlg(this);
2798 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2803 case SMESHOp::OpSmoothing:
2805 if(checkLock(aStudy)) break;
2807 EmitSignalDeactivateDialog();
2808 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2811 SUIT_MessageBox::warning(desktop(), tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2815 case SMESHOp::OpExtrusion:
2817 if (checkLock(aStudy)) break;
2819 EmitSignalDeactivateDialog();
2820 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2822 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2826 case SMESHOp::OpExtrusionAlongAPath:
2828 if (checkLock(aStudy)) break;
2830 EmitSignalDeactivateDialog();
2831 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2833 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2837 case SMESHOp::OpRevolution:
2839 if(checkLock(aStudy)) break;
2841 EmitSignalDeactivateDialog();
2842 ( new SMESHGUI_RevolutionDlg( this ) )->show();
2845 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2849 case SMESHOp::OpPatternMapping:
2851 if ( checkLock( aStudy ) )
2855 EmitSignalDeactivateDialog();
2856 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2859 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2863 case SMESHOp::OpSplitBiQuadratic:
2864 case SMESHOp::OpConvertMeshToQuadratic:
2865 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
2866 case SMESHOp::OpReorientFaces:
2867 case SMESHOp::OpCreateGeometryGroup:
2869 startOperation( theCommandID );
2872 case SMESHOp::OpCreateGroup:
2876 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2880 if(checkLock(aStudy)) break;
2881 EmitSignalDeactivateDialog();
2882 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2884 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2885 SALOME_ListIO selected;
2887 aSel->selectedObjects( selected );
2889 int nbSel = selected.Extent();
2891 // check if mesh is selected
2892 aMesh = SMESH::GetMeshByIO( selected.First() );
2894 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2899 case SMESHOp::OpConstructGroup:
2903 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2907 if(checkLock(aStudy)) break;
2908 EmitSignalDeactivateDialog();
2910 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2911 SALOME_ListIO selected;
2913 aSel->selectedObjects( selected );
2915 int nbSel = selected.Extent();
2917 // check if submesh is selected
2918 Handle(SALOME_InteractiveObject) IObject = selected.First();
2919 if (IObject->hasEntry()) {
2920 _PTR(SObject) aSObj = aStudy->FindObjectID(IObject->getEntry());
2922 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2923 if (!aSubMesh->_is_nil()) {
2925 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2926 // get submesh elements list by types
2927 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2928 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2929 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2930 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2931 // create group for each type o elements
2932 QString aName = IObject->getName();
2933 QStringList anEntryList;
2934 if (aNodes->length() > 0) {
2935 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2936 aGroup->Add(aNodes.inout());
2937 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2938 anEntryList.append( aSObject->GetID().c_str() );
2940 if (aEdges->length() > 0) {
2941 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2942 aGroup->Add(aEdges.inout());
2943 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2944 anEntryList.append( aSObject->GetID().c_str() );
2946 if (aFaces->length() > 0) {
2947 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2948 aGroup->Add(aFaces.inout());
2949 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2950 anEntryList.append( aSObject->GetID().c_str() );
2952 if (aVolumes->length() > 0) {
2953 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2954 aGroup->Add(aVolumes.inout());
2955 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2956 anEntryList.append( aSObject->GetID().c_str() );
2959 anApp->browseObjects( anEntryList );
2961 catch(const SALOME::SALOME_Exception & S_ex){
2962 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2969 SUIT_MessageBox::warning(desktop(),
2970 tr("SMESH_WRN_WARNING"),
2971 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
2976 case SMESHOp::OpEditGroup:
2980 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2984 if(checkLock(aStudy)) break;
2985 EmitSignalDeactivateDialog();
2987 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2988 SALOME_ListIO selected;
2990 aSel->selectedObjects( selected );
2992 SALOME_ListIteratorOfListIO It (selected);
2993 int nbSelectedGroups = 0;
2994 for ( ; It.More(); It.Next() )
2996 SMESH::SMESH_GroupBase_var aGroup =
2997 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
2998 if (!aGroup->_is_nil()) {
3000 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
3004 if (nbSelectedGroups == 0)
3006 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
3012 case SMESHOp::OpAddElemGroupPopup: // Add elements to group
3014 if(checkLock(aStudy)) break;
3015 if (myState == 800) {
3016 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3017 if (aDlg) aDlg->onAdd();
3022 case SMESHOp::OpRemoveElemGroupPopup: // Remove elements from group
3024 if(checkLock(aStudy)) break;
3025 if (myState == 800) {
3026 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3027 if (aDlg) aDlg->onRemove();
3032 case SMESHOp::OpEditGeomGroupAsGroup:
3036 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3040 if(checkLock(aStudy)) break;
3041 EmitSignalDeactivateDialog();
3043 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3044 SALOME_ListIO selected;
3046 aSel->selectedObjects( selected );
3048 SALOME_ListIteratorOfListIO It (selected);
3049 for ( ; It.More(); It.Next() )
3051 SMESH::SMESH_GroupOnGeom_var aGroup =
3052 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
3053 if (!aGroup->_is_nil()) {
3054 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3059 SMESH::SMESH_GroupOnFilter_var aGroup =
3060 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
3061 if (!aGroup->_is_nil()) {
3062 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3070 case SMESHOp::OpUnionGroups:
3071 case SMESHOp::OpIntersectGroups:
3072 case SMESHOp::OpCutGroups:
3076 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3080 if ( checkLock( aStudy ) )
3083 EmitSignalDeactivateDialog();
3085 SMESHGUI_GroupOpDlg* aDlg = 0;
3086 if ( theCommandID == SMESHOp::OpUnionGroups )
3087 aDlg = new SMESHGUI_UnionGroupsDlg( this );
3088 else if ( theCommandID == SMESHOp::OpIntersectGroups )
3089 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3091 aDlg = new SMESHGUI_CutGroupsDlg( this );
3098 case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
3100 if ( checkLock( aStudy ) )
3103 EmitSignalDeactivateDialog();
3104 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3110 case SMESHOp::OpDeleteGroup: // Delete groups with their contents
3114 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3118 if ( checkLock( aStudy ) )
3121 EmitSignalDeactivateDialog();
3123 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3127 case SMESHOp::OpMeshInformation:
3128 case SMESHOp::OpWhatIs:
3130 int page = theCommandID == SMESHOp::OpMeshInformation ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3131 EmitSignalDeactivateDialog();
3132 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3133 SALOME_ListIO selected;
3135 aSel->selectedObjects( selected );
3137 if ( selected.Extent() > 1 ) { // a dlg for each IO
3138 SALOME_ListIteratorOfListIO It( selected );
3139 for ( ; It.More(); It.Next() ) {
3140 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3141 dlg->showInfo( It.Value() );
3146 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3152 case SMESHOp::OpFindElementByPoint:
3154 startOperation( theCommandID );
3158 case SMESHOp::OpEditHypothesis:
3160 if(checkLock(aStudy)) break;
3162 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3163 SALOME_ListIO selected;
3165 aSel->selectedObjects( selected );
3167 int nbSel = selected.Extent();
3170 Handle(SALOME_InteractiveObject) anIObject = selected.First();
3171 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3173 if ( !aHypothesis->_is_nil() )
3175 SMESHGUI_GenericHypothesisCreator* aCreator =
3176 SMESH::GetHypothesisCreator( SMESH::toQStr( aHypothesis->GetName() ));
3179 // set geometry of mesh and sub-mesh to aCreator
3180 aSel->selectedObjects( selected, "", /*convertReferences=*/false);
3181 if ( selected.Extent() == 1 )
3183 QString subGeomID, meshGeomID;
3184 Handle(SALOME_InteractiveObject) hypIO = selected.First();
3185 if ( SMESH::GetGeomEntries( hypIO, subGeomID, meshGeomID ))
3187 if ( subGeomID.isEmpty() ) subGeomID = meshGeomID;
3188 aCreator->setShapeEntry( subGeomID );
3189 aCreator->setMainShapeEntry( meshGeomID );
3193 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3203 case SMESHOp::OpUnassign: // REMOVE HYPOTHESIS / ALGORITHMS
3205 if(checkLock(aStudy)) break;
3206 SUIT_OverrideCursor wc;
3208 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3209 SALOME_ListIO selected;
3211 aSel->selectedObjects( selected, QString::null, false );
3213 SALOME_ListIteratorOfListIO It(selected);
3214 for (int i = 0; It.More(); It.Next(), i++) {
3215 Handle(SALOME_InteractiveObject) IObject = It.Value();
3216 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3219 aSel->setSelectedObjects( l1 );
3224 case SMESHOp::OpElem0D:
3225 case SMESHOp::OpBall:
3226 case SMESHOp::OpEdge:
3227 case SMESHOp::OpTriangle:
3228 case SMESHOp::OpQuadrangle:
3229 case SMESHOp::OpPolygon:
3230 case SMESHOp::OpTetrahedron:
3231 case SMESHOp::OpHexahedron:
3232 case SMESHOp::OpPentahedron:
3233 case SMESHOp::OpPyramid:
3234 case SMESHOp::OpHexagonalPrism:
3236 if(checkLock(aStudy)) break;
3238 EmitSignalDeactivateDialog();
3239 SMDSAbs_EntityType type = SMDSEntity_Edge;
3240 switch (theCommandID) {
3241 case SMESHOp::OpElem0D: type = SMDSEntity_0D; break;
3242 case SMESHOp::OpBall: type = SMDSEntity_Ball; break;
3243 case SMESHOp::OpTriangle: type = SMDSEntity_Triangle; break;
3244 case SMESHOp::OpQuadrangle: type = SMDSEntity_Quadrangle; break;
3245 case SMESHOp::OpTetrahedron: type = SMDSEntity_Tetra; break;
3246 case SMESHOp::OpPolygon: type = SMDSEntity_Polygon; break;
3247 case SMESHOp::OpHexahedron: type = SMDSEntity_Hexa; break;
3248 case SMESHOp::OpPentahedron: type = SMDSEntity_Penta; break;
3249 case SMESHOp::OpPyramid: type = SMDSEntity_Pyramid; break;
3250 case SMESHOp::OpHexagonalPrism: type = SMDSEntity_Hexagonal_Prism; break;
3253 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3256 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3260 case SMESHOp::OpPolyhedron:
3262 if(checkLock(aStudy)) break;
3264 EmitSignalDeactivateDialog();
3265 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3268 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3272 case SMESHOp::OpQuadraticEdge:
3273 case SMESHOp::OpQuadraticTriangle:
3274 case SMESHOp::OpBiQuadraticTriangle:
3275 case SMESHOp::OpQuadraticQuadrangle:
3276 case SMESHOp::OpBiQuadraticQuadrangle:
3277 case SMESHOp::OpQuadraticPolygon:
3278 case SMESHOp::OpQuadraticTetrahedron:
3279 case SMESHOp::OpQuadraticPyramid:
3280 case SMESHOp::OpQuadraticPentahedron:
3281 case SMESHOp::OpQuadraticHexahedron:
3282 case SMESHOp::OpTriQuadraticHexahedron:
3284 if(checkLock(aStudy)) break;
3286 EmitSignalDeactivateDialog();
3287 SMDSAbs_EntityType type = SMDSEntity_Last;
3289 switch (theCommandID) {
3290 case SMESHOp::OpQuadraticEdge: type = SMDSEntity_Quad_Edge; break;
3291 case SMESHOp::OpQuadraticTriangle: type = SMDSEntity_Quad_Triangle; break;
3292 case SMESHOp::OpBiQuadraticTriangle: type = SMDSEntity_BiQuad_Triangle; break;
3293 case SMESHOp::OpQuadraticQuadrangle: type = SMDSEntity_Quad_Quadrangle; break;
3294 case SMESHOp::OpBiQuadraticQuadrangle: type = SMDSEntity_BiQuad_Quadrangle; break;
3295 case SMESHOp::OpQuadraticPolygon: type = SMDSEntity_Quad_Polygon; break;
3296 case SMESHOp::OpQuadraticTetrahedron: type = SMDSEntity_Quad_Tetra; break;
3297 case SMESHOp::OpQuadraticPyramid: type = SMDSEntity_Quad_Pyramid; break;
3298 case SMESHOp::OpQuadraticPentahedron: type = SMDSEntity_Quad_Penta; break;
3299 case SMESHOp::OpQuadraticHexahedron: type = SMDSEntity_Quad_Hexa; break;
3300 case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
3303 if ( type != SMDSEntity_Last )
3304 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3307 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3308 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3312 case SMESHOp::OpRemoveNodes:
3314 if(checkLock(aStudy)) break;
3316 EmitSignalDeactivateDialog();
3317 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3320 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3321 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3325 case SMESHOp::OpRemoveElements: // REMOVES ELEMENTS
3327 if(checkLock(aStudy)) break;
3329 EmitSignalDeactivateDialog();
3330 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3334 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3335 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3339 case SMESHOp::OpClearMesh: {
3341 if(checkLock(aStudy)) break;
3343 SALOME_ListIO selected;
3344 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3345 aSel->selectedObjects( selected );
3347 SUIT_OverrideCursor wc;
3348 SALOME_ListIteratorOfListIO It (selected);
3349 for ( ; It.More(); It.Next() )
3351 Handle(SALOME_InteractiveObject) IOS = It.Value();
3352 SMESH::SMESH_Mesh_var aMesh =
3353 SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3354 if ( aMesh->_is_nil()) continue;
3356 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3358 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3359 SMESH::ModifiedMesh( aMeshSObj, false, true);
3360 // hide groups and submeshes
3361 _PTR(ChildIterator) anIter =
3362 SMESH::GetActiveStudyDocument()->NewChildIterator( aMeshSObj );
3363 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3365 _PTR(SObject) so = anIter->Value();
3366 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3369 catch (const SALOME::SALOME_Exception& S_ex){
3371 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3375 SMESH::UpdateView();
3379 case SMESHOp::OpRemoveOrphanNodes:
3381 if(checkLock(aStudy)) break;
3382 SALOME_ListIO selected;
3383 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3384 aSel->selectedObjects( selected );
3385 if ( selected.Extent() == 1 ) {
3386 Handle(SALOME_InteractiveObject) anIO = selected.First();
3387 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3388 if ( !aMesh->_is_nil() ) {
3389 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3390 tr( "SMESH_WARNING" ),
3391 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3392 SUIT_MessageBox::Yes |
3393 SUIT_MessageBox::No,
3394 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3397 SUIT_OverrideCursor wc;
3398 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3399 int removed = aMeshEditor->RemoveOrphanNodes();
3400 SUIT_MessageBox::information(SMESHGUI::desktop(),
3401 tr("SMESH_INFORMATION"),
3402 tr("NB_NODES_REMOVED").arg(removed));
3403 if ( removed > 0 ) {
3404 SMESH::UpdateView();
3405 SMESHGUI::Modified();
3408 catch (const SALOME::SALOME_Exception& S_ex) {
3409 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3418 case SMESHOp::OpRenumberingNodes:
3420 if(checkLock(aStudy)) break;
3422 EmitSignalDeactivateDialog();
3423 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3427 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3428 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3432 case SMESHOp::OpRenumberingElements:
3434 if(checkLock(aStudy)) break;
3436 EmitSignalDeactivateDialog();
3437 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3441 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3442 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3446 case SMESHOp::OpTranslation:
3448 if(checkLock(aStudy)) break;
3450 EmitSignalDeactivateDialog();
3451 ( new SMESHGUI_TranslationDlg( this ) )->show();
3454 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3455 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3459 case SMESHOp::OpRotation:
3461 if(checkLock(aStudy)) break;
3463 EmitSignalDeactivateDialog();
3464 ( new SMESHGUI_RotationDlg( this ) )->show();
3467 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3468 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3472 case SMESHOp::OpSymmetry:
3474 if(checkLock(aStudy)) break;
3476 EmitSignalDeactivateDialog();
3477 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3480 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3481 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3485 case SMESHOp::OpScale:
3487 if(checkLock(aStudy)) break;
3489 EmitSignalDeactivateDialog();
3490 ( new SMESHGUI_ScaleDlg( this ) )->show();
3493 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3494 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3499 case SMESHOp::OpSewing:
3501 if(checkLock(aStudy)) break;
3503 EmitSignalDeactivateDialog();
3504 ( new SMESHGUI_SewingDlg( this ) )->show();
3507 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3508 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3512 case SMESHOp::OpMergeNodes:
3514 if(checkLock(aStudy)) break;
3516 EmitSignalDeactivateDialog();
3517 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3520 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3521 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3525 case SMESHOp::OpMergeElements:
3527 if (checkLock(aStudy)) break;
3529 EmitSignalDeactivateDialog();
3530 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3532 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3533 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3538 case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
3539 startOperation( SMESHOp::OpMoveNode );
3542 case SMESHOp::OpDuplicateNodes:
3544 if(checkLock(aStudy)) break;
3546 EmitSignalDeactivateDialog();
3547 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3550 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3551 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3556 case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
3557 startOperation( SMESHOp::OpElem0DOnElemNodes );
3560 case SMESHOp::OpSelectFiltersLibrary: // Library of selection filters
3562 static QList<int> aTypes;
3563 if ( aTypes.isEmpty() )
3565 aTypes.append( SMESH::NODE );
3566 aTypes.append( SMESH::EDGE );
3567 aTypes.append( SMESH::FACE );
3568 aTypes.append( SMESH::VOLUME );
3570 if (!myFilterLibraryDlg)
3571 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3572 else if (myFilterLibraryDlg->isHidden())
3573 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3574 myFilterLibraryDlg->raise();
3578 case SMESHOp::OpFreeNode:
3579 case SMESHOp::OpEqualNode:
3580 case SMESHOp::OpFreeEdge:
3581 case SMESHOp::OpFreeBorder:
3582 case SMESHOp::OpLength:
3583 case SMESHOp::OpConnection:
3584 case SMESHOp::OpEqualEdge:
3585 case SMESHOp::OpFreeFace:
3586 case SMESHOp::OpBareBorderFace:
3587 case SMESHOp::OpOverConstrainedFace:
3588 case SMESHOp::OpLength2D:
3589 case SMESHOp::OpConnection2D:
3590 case SMESHOp::OpArea:
3591 case SMESHOp::OpTaper:
3592 case SMESHOp::OpAspectRatio:
3593 case SMESHOp::OpMinimumAngle:
3594 case SMESHOp::OpWarpingAngle:
3595 case SMESHOp::OpSkew:
3596 case SMESHOp::OpMaxElementLength2D:
3597 case SMESHOp::OpEqualFace:
3598 case SMESHOp::OpAspectRatio3D:
3599 case SMESHOp::OpVolume:
3600 case SMESHOp::OpMaxElementLength3D:
3601 case SMESHOp::OpBareBorderVolume:
3602 case SMESHOp::OpOverConstrainedVolume:
3603 case SMESHOp::OpEqualVolume:
3606 LightApp_SelectionMgr* mgr = selectionMgr();
3607 SALOME_ListIO selected; mgr->selectedObjects( selected );
3609 if( !selected.IsEmpty() ) {
3610 SUIT_OverrideCursor wc;
3611 ::Control( theCommandID );
3614 SUIT_MessageBox::warning(desktop(),
3615 tr( "SMESH_WRN_WARNING" ),
3616 tr( "SMESH_BAD_SELECTION" ) );
3620 SUIT_MessageBox::warning(desktop(),
3621 tr( "SMESH_WRN_WARNING" ),
3622 tr( "NOT_A_VTK_VIEWER" ) );
3625 case SMESHOp::OpOverallMeshQuality:
3626 OverallMeshQuality();
3628 case SMESHOp::OpNumberingNodes:
3630 SUIT_OverrideCursor wc;
3631 LightApp_SelectionMgr* mgr = selectionMgr();
3632 SALOME_ListIO selected; mgr->selectedObjects( selected );
3634 SALOME_ListIteratorOfListIO it(selected);
3635 for( ; it.More(); it.Next()) {
3636 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3637 if(anIObject->hasEntry()) {
3638 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3639 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3645 case SMESHOp::OpNumberingElements:
3647 SUIT_OverrideCursor wc;
3648 LightApp_SelectionMgr* mgr = selectionMgr();
3649 SALOME_ListIO selected; mgr->selectedObjects( selected );
3651 SALOME_ListIteratorOfListIO it(selected);
3652 for( ; it.More(); it.Next()) {
3653 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3654 if(anIObject->hasEntry())
3655 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3656 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3661 case SMESHOp::OpPropertiesLength:
3662 case SMESHOp::OpPropertiesArea:
3663 case SMESHOp::OpPropertiesVolume:
3664 case SMESHOp::OpMinimumDistance:
3665 case SMESHOp::OpBoundingBox:
3667 int page = SMESHGUI_MeasureDlg::MinDistance;
3668 if ( theCommandID == SMESHOp::OpBoundingBox )
3669 page = SMESHGUI_MeasureDlg::BoundingBox;
3670 else if ( theCommandID == SMESHOp::OpPropertiesLength )
3671 page = SMESHGUI_MeasureDlg::Length;
3672 else if ( theCommandID == SMESHOp::OpPropertiesArea )
3673 page = SMESHGUI_MeasureDlg::Area;
3674 else if ( theCommandID == SMESHOp::OpPropertiesVolume )
3675 page = SMESHGUI_MeasureDlg::Volume;
3677 EmitSignalDeactivateDialog();
3678 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3682 case SMESHOp::OpSortChild:
3688 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3689 //updateObjBrowser();
3693 //=============================================================================
3697 //=============================================================================
3698 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3703 //=============================================================================
3707 //=============================================================================
3708 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3713 //=============================================================================
3717 //=============================================================================
3718 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3723 //=============================================================================
3724 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3725 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3727 //=============================================================================
3728 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3729 SUIT_ViewWindow* wnd )
3731 if(theIO->hasEntry()){
3732 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3733 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3737 //=======================================================================
3738 // function : createSMESHAction
3740 //=======================================================================
3741 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3742 const int key, const bool toggle, const QString& shortcutAction )
3745 QWidget* parent = application()->desktop();
3746 SUIT_ResourceMgr* resMgr = resourceMgr();
3748 if ( !icon_id.isEmpty() )
3749 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3751 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3752 if ( !pix.isNull() )
3753 icon = QIcon( pix );
3755 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3756 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3757 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3759 createAction( id, tooltip, icon, menu, status_bar, key, parent,
3760 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3763 //=======================================================================
3764 // function : createPopupItem
3766 //=======================================================================
3767 void SMESHGUI::createPopupItem( const int id,
3768 const QString& clients,
3769 const QString& types,
3770 const QString& theRule,
3773 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3774 popupMgr()->insert( action( id ), pId, 0 );
3776 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3777 QString dc = "selcount"; // VSR : insetad of QtxPopupSelection::defSelCountParam()
3778 QString rule = "(%1) and (%2) and (%3)";
3779 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3780 if( clients.isEmpty() )
3781 rule = rule.arg( QString( "true" ) );
3783 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3784 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3787 bool cont = myRules.contains( id );
3789 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3791 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3792 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3795 //=======================================================================
3796 // function : initialize
3798 //=======================================================================
3799 void SMESHGUI::initialize( CAM_Application* app )
3801 SalomeApp_Module::initialize( app );
3803 // SUIT_ResourceMgr* mgr = app->resourceMgr();
3805 /* Automatic Update flag */
3806 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3808 // ----- create actions --------------
3810 //createSMESHAction( SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
3811 createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_I) );
3812 createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
3813 //createSMESHAction( 114, "NUM" );
3814 createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL" );
3816 createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
3818 createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
3819 createSMESHAction( SMESHOp::OpImportGMF, "IMPORT_GMF" );
3820 createSMESHAction( SMESHOp::OpExportDAT, "DAT" );
3821 createSMESHAction( SMESHOp::OpExportMED, "MED" );
3822 createSMESHAction( SMESHOp::OpExportUNV, "UNV" );
3823 createSMESHAction( SMESHOp::OpExportSTL, "STL" );
3825 createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
3827 createSMESHAction( SMESHOp::OpExportSAUV, "SAUV");
3828 createSMESHAction( SMESHOp::OpExportGMF, "GMF" );
3829 createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
3830 createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
3831 createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
3832 createSMESHAction( SMESHOp::OpPopupExportSTL, "STL" );
3834 createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
3836 createSMESHAction( SMESHOp::OpPopupExportSAUV, "SAUV");
3837 createSMESHAction( SMESHOp::OpPopupExportGMF, "GMF" );
3838 createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
3839 createSMESHAction( SMESHOp::OpDelete, "DELETE", "ICON_DELETE", Qt::Key_Delete );
3840 createSMESHAction( SMESHOp::OpSelectFiltersLibrary, "SEL_FILTER_LIB" );
3841 createSMESHAction( SMESHOp::OpCreateMesh, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
3842 createSMESHAction( SMESHOp::OpCreateSubMesh, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
3843 createSMESHAction( SMESHOp::OpEditMeshOrSubMesh, "EDIT_MESHSUBMESH", "ICON_DLG_EDIT_MESH" );
3844 createSMESHAction( SMESHOp::OpEditMesh, "EDIT_MESH", "ICON_DLG_EDIT_MESH" );
3845 createSMESHAction( SMESHOp::OpEditSubMesh, "EDIT_SUBMESH", "ICON_DLG_EDIT_MESH" );
3846 createSMESHAction( SMESHOp::OpBuildCompoundMesh, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
3847 createSMESHAction( SMESHOp::OpCopyMesh, "COPY_MESH", "ICON_COPY_MESH" );
3848 createSMESHAction( SMESHOp::OpCompute, "COMPUTE", "ICON_COMPUTE" );
3849 createSMESHAction( SMESHOp::OpComputeSubMesh, "COMPUTE_SUBMESH", "ICON_COMPUTE" );
3850 createSMESHAction( SMESHOp::OpPreCompute, "PRECOMPUTE", "ICON_PRECOMPUTE" );
3851 createSMESHAction( SMESHOp::OpEvaluate, "EVALUATE", "ICON_EVALUATE" );
3852 createSMESHAction( SMESHOp::OpMeshOrder, "MESH_ORDER", "ICON_MESH_ORDER");
3853 createSMESHAction( SMESHOp::OpCreateGroup, "CREATE_GROUP", "ICON_CREATE_GROUP" );
3854 createSMESHAction( SMESHOp::OpCreateGeometryGroup, "CREATE_GEO_GROUP", "ICON_CREATE_GEO_GROUP" );
3855 createSMESHAction( SMESHOp::OpConstructGroup, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
3856 createSMESHAction( SMESHOp::OpEditGroup, "EDIT_GROUP", "ICON_EDIT_GROUP" );
3857 createSMESHAction( SMESHOp::OpEditGeomGroupAsGroup, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3858 createSMESHAction( SMESHOp::OpUnionGroups, "UN_GROUP", "ICON_UNION" );
3859 createSMESHAction( SMESHOp::OpIntersectGroups, "INT_GROUP", "ICON_INTERSECT" );
3860 createSMESHAction( SMESHOp::OpCutGroups, "CUT_GROUP", "ICON_CUT" );
3861 createSMESHAction( SMESHOp::OpGroupUnderlyingElem, "UNDERLYING_ELEMS", "ICON_UNDERLYING_ELEMS" );
3862 createSMESHAction( SMESHOp::OpAddElemGroupPopup, "ADD" );
3863 createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE" );
3864 createSMESHAction( SMESHOp::OpDeleteGroup, "DEL_GROUP", "ICON_DEL_GROUP" );
3865 createSMESHAction( SMESHOp::OpMeshInformation , "ADV_INFO", "ICON_ADV_INFO" );
3866 //createSMESHAction( SMESHOp::OpStdInfo, "STD_INFO", "ICON_STD_INFO" );
3867 //createSMESHAction( SMESHOp::OpWhatIs, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3868 createSMESHAction( SMESHOp::OpFindElementByPoint, "FIND_ELEM", "ICON_FIND_ELEM" );
3870 createSMESHAction( SMESHOp::OpFreeNode, "FREE_NODE", "ICON_FREE_NODE", 0, true );
3871 createSMESHAction( SMESHOp::OpEqualNode, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
3872 createSMESHAction( SMESHOp::OpFreeEdge, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
3873 createSMESHAction( SMESHOp::OpFreeBorder, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
3874 createSMESHAction( SMESHOp::OpLength, "LENGTH", "ICON_LENGTH", 0, true );
3875 createSMESHAction( SMESHOp::OpConnection, "CONNECTION", "ICON_CONNECTION", 0, true );
3876 createSMESHAction( SMESHOp::OpEqualEdge, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
3877 createSMESHAction( SMESHOp::OpFreeFace, "FREE_FACES", "ICON_FREE_FACES", 0, true );
3878 createSMESHAction( SMESHOp::OpBareBorderFace, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
3879 createSMESHAction( SMESHOp::OpOverConstrainedFace, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
3880 createSMESHAction( SMESHOp::OpLength2D, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
3881 createSMESHAction( SMESHOp::OpConnection2D, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
3882 createSMESHAction( SMESHOp::OpArea, "AREA", "ICON_AREA", 0, true );
3883 createSMESHAction( SMESHOp::OpTaper, "TAPER", "ICON_TAPER", 0, true );
3884 createSMESHAction( SMESHOp::OpAspectRatio, "ASPECT", "ICON_ASPECT", 0, true );
3885 createSMESHAction( SMESHOp::OpMinimumAngle, "MIN_ANG", "ICON_ANGLE", 0, true );
3886 createSMESHAction( SMESHOp::OpWarpingAngle, "WARP", "ICON_WARP", 0, true );
3887 createSMESHAction( SMESHOp::OpSkew, "SKEW", "ICON_SKEW", 0, true );
3888 createSMESHAction( SMESHOp::OpMaxElementLength2D, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
3889 createSMESHAction( SMESHOp::OpEqualFace, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
3890 createSMESHAction( SMESHOp::OpAspectRatio3D, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
3891 createSMESHAction( SMESHOp::OpVolume, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
3892 createSMESHAction( SMESHOp::OpMaxElementLength3D, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
3893 createSMESHAction( SMESHOp::OpBareBorderVolume, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
3894 createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
3895 createSMESHAction( SMESHOp::OpEqualVolume, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
3896 createSMESHAction( SMESHOp::OpOverallMeshQuality, "OVERALL_MESH_QUALITY" );
3898 createSMESHAction( SMESHOp::OpNode, "NODE", "ICON_DLG_NODE" );
3899 createSMESHAction( SMESHOp::OpElem0D, "ELEM0D", "ICON_DLG_ELEM0D" );
3900 createSMESHAction( SMESHOp::OpElem0DOnElemNodes, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
3901 createSMESHAction( SMESHOp::OpBall, "BALL", "ICON_DLG_BALL" );
3902 createSMESHAction( SMESHOp::OpEdge, "EDGE", "ICON_DLG_EDGE" );
3903 createSMESHAction( SMESHOp::OpTriangle, "TRIANGLE", "ICON_DLG_TRIANGLE" );
3904 createSMESHAction( SMESHOp::OpQuadrangle, "QUAD", "ICON_DLG_QUADRANGLE" );
3905 createSMESHAction( SMESHOp::OpPolygon, "POLYGON", "ICON_DLG_POLYGON" );
3906 createSMESHAction( SMESHOp::OpTetrahedron, "TETRA", "ICON_DLG_TETRAS" );
3907 createSMESHAction( SMESHOp::OpHexahedron, "HEXA", "ICON_DLG_HEXAS" );
3908 createSMESHAction( SMESHOp::OpPentahedron, "PENTA", "ICON_DLG_PENTA" );
3909 createSMESHAction( SMESHOp::OpPyramid , "PYRAMID", "ICON_DLG_PYRAMID" );
3910 createSMESHAction( SMESHOp::OpHexagonalPrism, "OCTA", "ICON_DLG_OCTA" );
3911 createSMESHAction( SMESHOp::OpPolyhedron, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
3912 createSMESHAction( SMESHOp::OpQuadraticEdge, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
3913 createSMESHAction( SMESHOp::OpQuadraticTriangle, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
3914 createSMESHAction( SMESHOp::OpBiQuadraticTriangle, "BIQUADRATIC_TRIANGLE", "ICON_DLG_BIQUADRATIC_TRIANGLE" );
3915 createSMESHAction( SMESHOp::OpQuadraticQuadrangle, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
3916 createSMESHAction( SMESHOp::OpBiQuadraticQuadrangle, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
3917 createSMESHAction( SMESHOp::OpQuadraticPolygon, "QUADRATIC_POLYGON", "ICON_DLG_QUADRATIC_POLYGON" );
3918 createSMESHAction( SMESHOp::OpQuadraticTetrahedron, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
3919 createSMESHAction( SMESHOp::OpQuadraticPyramid, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
3920 createSMESHAction( SMESHOp::OpQuadraticPentahedron, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
3921 createSMESHAction( SMESHOp::OpQuadraticHexahedron, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
3922 createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
3924 createSMESHAction( SMESHOp::OpRemoveNodes, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
3925 createSMESHAction( SMESHOp::OpRemoveElements, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
3926 createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
3927 createSMESHAction( SMESHOp::OpClearMesh, "CLEAR_MESH", "ICON_CLEAR_MESH" );
3929 //createSMESHAction( SMESHOp::OpRenumberingNodes, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
3930 //createSMESHAction( SMESHOp::OpRenumberingElements, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
3932 createSMESHAction( SMESHOp::OpTranslation, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
3933 createSMESHAction( SMESHOp::OpRotation, "ROT", "ICON_DLG_MESH_ROTATION" );
3934 createSMESHAction( SMESHOp::OpSymmetry, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
3935 createSMESHAction( SMESHOp::OpScale, "SCALE", "ICON_DLG_MESH_SCALE" );
3936 createSMESHAction( SMESHOp::OpSewing, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
3937 createSMESHAction( SMESHOp::OpMergeNodes, "MERGE", "ICON_SMESH_MERGE_NODES" );
3938 createSMESHAction( SMESHOp::OpMergeElements, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
3939 createSMESHAction( SMESHOp::OpMoveNode, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
3940 createSMESHAction( SMESHOp::OpDuplicateNodes, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
3941 createSMESHAction( SMESHOp::OpDiagonalInversion, "INV", "ICON_DLG_MESH_DIAGONAL" );
3942 createSMESHAction( SMESHOp::OpUnionOfTwoTriangle, "UNION2", "ICON_UNION2TRI" );
3943 createSMESHAction( SMESHOp::OpOrientation, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
3944 createSMESHAction( SMESHOp::OpReorientFaces, "REORIENT_2D", "ICON_REORIENT_2D" );
3945 createSMESHAction( SMESHOp::OpUnionOfTriangles, "UNION", "ICON_UNIONTRI" );
3946 createSMESHAction( SMESHOp::OpCuttingOfQuadrangles, "CUT", "ICON_CUTQUAD" );
3947 createSMESHAction( SMESHOp::OpSplitVolumes, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
3948 createSMESHAction( SMESHOp::OpSplitBiQuadratic, "SPLIT_BIQUAD", "ICON_SPLIT_BIQUAD" );
3949 createSMESHAction( SMESHOp::OpSmoothing, "SMOOTH", "ICON_DLG_SMOOTHING" );
3950 createSMESHAction( SMESHOp::OpExtrusion, "EXTRUSION", "ICON_EXTRUSION" );
3951 createSMESHAction( SMESHOp::OpExtrusionAlongAPath, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
3952 createSMESHAction( SMESHOp::OpRevolution, "REVOLUTION", "ICON_REVOLUTION" );
3953 createSMESHAction( SMESHOp::OpPatternMapping, "MAP", "ICON_MAP" );
3954 createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
3955 createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D", "ICON_2D_FROM_3D" );
3957 createSMESHAction( SMESHOp::OpReset, "RESET" );
3958 createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
3959 createSMESHAction( SMESHOp::OpShowScalarBar, "SHOW_SCALAR_BAR","",0, true );
3960 createSMESHAction( SMESHOp::OpSaveDistribution, "SAVE_DISTRIBUTION" );
3961 createSMESHAction( SMESHOp::OpShowDistribution, "SHOW_DISTRIBUTION","",0, true );
3962 #ifndef DISABLE_PLOT2DVIEWER
3963 createSMESHAction( SMESHOp::OpPlotDistribution, "PLOT_DISTRIBUTION" );
3965 createSMESHAction( SMESHOp::OpDMWireframe, "WIRE", "ICON_WIRE", 0, true );
3966 createSMESHAction( SMESHOp::OpDMShading, "SHADE", "ICON_SHADE", 0, true );
3967 createSMESHAction( SMESHOp::OpDMNodes, "NODES", "ICON_POINTS", 0, true );
3968 createSMESHAction( SMESHOp::OpDMShrink, "SHRINK", "ICON_SHRINK", 0, true );
3969 createSMESHAction( SMESHOp::OpUpdate, "UPDATE", "ICON_UPDATE" );
3970 createSMESHAction( SMESHOp::OpDE0DElements, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
3971 createSMESHAction( SMESHOp::OpDEEdges, "EDGES", "ICON_DLG_EDGE", 0, true );
3972 createSMESHAction( SMESHOp::OpDEFaces, "FACES", "ICON_DLG_TRIANGLE", 0, true );
3973 createSMESHAction( SMESHOp::OpDEVolumes, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
3974 createSMESHAction( SMESHOp::OpDEBalls, "BALLS", "ICON_DLG_BALL", 0, true );
3975 createSMESHAction( SMESHOp::OpDEChoose, "CHOOSE", "ICON_DLG_CHOOSE", 0, false );
3976 createSMESHAction( SMESHOp::OpDEAllEntity, "ALL", "ICON_DLG_CHOOSE_ALL", 0, false );
3977 createSMESHAction( SMESHOp::OpOrientationOnFaces, "FACE_ORIENTATION", "", 0, true );
3979 createSMESHAction( SMESHOp::OpRepresentationLines, "LINE_REPRESENTATION", "", 0, true );
3980 createSMESHAction( SMESHOp::OpRepresentationArcs, "ARC_REPRESENTATION", "", 0, true );
3982 createSMESHAction( SMESHOp::OpEditHypothesis, "EDIT_HYPO" );
3983 createSMESHAction( SMESHOp::OpUnassign, "UNASSIGN" );
3984 createSMESHAction( SMESHOp::OpNumberingNodes, "NUM_NODES", "", 0, true );
3985 createSMESHAction( SMESHOp::OpNumberingElements, "NUM_ELEMENTS", "", 0, true );
3986 createSMESHAction( SMESHOp::OpProperties, "COLORS" );
3987 createSMESHAction( SMESHOp::OpTransparency, "TRANSP" );
3988 createSMESHAction( SMESHOp::OpClipping, "CLIP" );
3989 createSMESHAction( SMESHOp::OpAutoColor, "AUTO_COLOR" );
3990 createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
3992 createSMESHAction( SMESHOp::OpMinimumDistance, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
3993 createSMESHAction( SMESHOp::OpBoundingBox, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
3994 createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH", "ICON_MEASURE_LENGTH" );
3995 createSMESHAction( SMESHOp::OpPropertiesArea, "MEASURE_AREA", "ICON_MEASURE_AREA" );
3996 createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME", "ICON_MEASURE_VOLUME" );
3998 createSMESHAction( SMESHOp::OpHide, "HIDE" );
3999 createSMESHAction( SMESHOp::OpShow, "SHOW" );
4000 createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
4002 createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
4004 QList<int> aCtrlActions;
4005 aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode // node controls
4006 << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
4007 << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge // edge controls
4008 << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
4009 << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
4010 << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
4011 << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
4012 << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace // face controls
4013 << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
4014 << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
4015 << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume; // volume controls
4016 QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
4017 aCtrlGroup->setExclusive( true );
4018 for( int i = 0; i < aCtrlActions.size(); i++ )
4019 aCtrlGroup->addAction( action( aCtrlActions[i] ) );
4021 // ----- create menu --------------
4022 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
4023 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
4024 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
4025 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
4026 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
4027 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
4028 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
4029 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
4031 createMenu( separator(), fileId );
4033 QMenu* nodeMenu = new QMenu(); QMenu* edgeMenu = new QMenu();
4034 QMenu* faceMenu = new QMenu(); QMenu* volumeMenu = new QMenu();
4035 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
4036 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
4037 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10, -1, nodeMenu ),
4038 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10, -1, edgeMenu ),
4039 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10, -1, faceMenu ),
4040 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10, -1, volumeMenu ),
4041 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
4042 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
4043 //renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
4044 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
4045 basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
4047 //createMenu( SMESHOp::OpImportDAT, importId, -1 );
4048 createMenu( SMESHOp::OpImportUNV, importId, -1 );
4049 createMenu( SMESHOp::OpImportMED, importId, -1 );
4050 createMenu( SMESHOp::OpImportSTL, importId, -1 );
4052 createMenu( SMESHOp::OpImportCGNS, importId, -1 );
4054 createMenu( SMESHOp::OpImportSAUV, importId, -1 );
4055 createMenu( SMESHOp::OpImportGMF, importId, -1 );
4056 createMenu( SMESHOp::OpExportDAT, exportId, -1 );
4057 createMenu( SMESHOp::OpExportMED, exportId, -1 );
4058 createMenu( SMESHOp::OpExportUNV, exportId, -1 );
4059 createMenu( SMESHOp::OpExportSTL, exportId, -1 );
4061 createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
4063 createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
4064 createMenu( SMESHOp::OpExportGMF, exportId, -1 );
4065 createMenu( separator(), fileId, 10 );
4067 createMenu( SMESHOp::OpDelete, editId, -1 );
4069 createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
4071 createMenu( SMESHOp::OpCreateMesh, meshId, -1 ); // "Mesh" menu
4072 createMenu( SMESHOp::OpCreateSubMesh, meshId, -1 );
4073 createMenu( SMESHOp::OpEditMeshOrSubMesh, meshId, -1 );
4074 createMenu( SMESHOp::OpBuildCompoundMesh, meshId, -1 );
4075 createMenu( SMESHOp::OpCopyMesh, meshId, -1 );
4076 createMenu( separator(), meshId, -1 );
4077 createMenu( SMESHOp::OpCompute, meshId, -1 );
4078 createMenu( SMESHOp::OpPreCompute, meshId, -1 );
4079 createMenu( SMESHOp::OpEvaluate, meshId, -1 );
4080 createMenu( SMESHOp::OpMeshOrder, meshId, -1 );
4081 createMenu( separator(), meshId, -1 );
4082 createMenu( SMESHOp::OpCreateGroup, meshId, -1 );
4083 createMenu( SMESHOp::OpCreateGeometryGroup, meshId, -1 );
4084 createMenu( SMESHOp::OpConstructGroup, meshId, -1 );
4085 createMenu( SMESHOp::OpEditGroup, meshId, -1 );
4086 createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4087 createMenu( separator(), meshId, -1 );
4088 createMenu( SMESHOp::OpUnionGroups, meshId, -1 );
4089 createMenu( SMESHOp::OpIntersectGroups, meshId, -1 );
4090 createMenu( SMESHOp::OpCutGroups, meshId, -1 );
4091 createMenu( separator(), meshId, -1 );
4092 createMenu( SMESHOp::OpGroupUnderlyingElem, meshId, -1 );
4093 createMenu( separator(), meshId, -1 );
4094 createMenu( SMESHOp::OpMeshInformation, meshId, -1 );
4095 //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4096 //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4097 createMenu( SMESHOp::OpFindElementByPoint, meshId, -1 );
4098 createMenu( separator(), meshId, -1 );
4100 createMenu( SMESHOp::OpFreeNode, nodeId, -1 );
4101 createMenu( SMESHOp::OpEqualNode, nodeId, -1 );
4102 createMenu( SMESHOp::OpFreeBorder, edgeId, -1 );
4103 createMenu( SMESHOp::OpLength, edgeId, -1 );
4104 createMenu( SMESHOp::OpConnection, edgeId, -1 );
4105 createMenu( SMESHOp::OpEqualEdge, edgeId, -1 );
4106 createMenu( SMESHOp::OpFreeEdge, faceId, -1 );
4107 createMenu( SMESHOp::OpFreeFace, faceId, -1 );
4108 createMenu( SMESHOp::OpBareBorderFace, faceId, -1 );
4109 createMenu( SMESHOp::OpOverConstrainedFace, faceId, -1 );
4110 createMenu( SMESHOp::OpLength2D, faceId, -1 );
4111 createMenu( SMESHOp::OpConnection2D, faceId, -1 );
4112 createMenu( SMESHOp::OpArea, faceId, -1 );
4113 createMenu( SMESHOp::OpTaper, faceId, -1 );
4114 createMenu( SMESHOp::OpAspectRatio, faceId, -1 );
4115 createMenu( SMESHOp::OpMinimumAngle, faceId, -1 );
4116 createMenu( SMESHOp::OpWarpingAngle, faceId, -1 );
4117 createMenu( SMESHOp::OpSkew, faceId, -1 );
4118 createMenu( SMESHOp::OpMaxElementLength2D, faceId, -1 );
4119 createMenu( SMESHOp::OpEqualFace, faceId, -1 );
4120 createMenu( SMESHOp::OpAspectRatio3D, volumeId, -1 );
4121 createMenu( SMESHOp::OpVolume, volumeId, -1 );
4122 createMenu( SMESHOp::OpMaxElementLength3D, volumeId, -1 );
4123 createMenu( SMESHOp::OpBareBorderVolume, volumeId, -1 );
4124 createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4125 createMenu( SMESHOp::OpEqualVolume, volumeId, -1 );
4126 createMenu( separator(), ctrlId, -1 );
4127 createMenu( SMESHOp::OpReset, ctrlId, -1 );
4128 createMenu( separator(), ctrlId, -1 );
4129 createMenu( SMESHOp::OpOverallMeshQuality, ctrlId, -1 );
4131 createMenu( SMESHOp::OpNode, addId, -1 );
4132 createMenu( SMESHOp::OpElem0D, addId, -1 );
4133 createMenu( SMESHOp::OpElem0DOnElemNodes, addId, -1 );
4134 createMenu( SMESHOp::OpBall, addId, -1 );
4135 createMenu( SMESHOp::OpEdge, addId, -1 );
4136 createMenu( SMESHOp::OpTriangle, addId, -1 );
4137 createMenu( SMESHOp::OpQuadrangle, addId, -1 );
4138 createMenu( SMESHOp::OpPolygon, addId, -1 );
4139 createMenu( SMESHOp::OpTetrahedron, addId, -1 );
4140 createMenu( SMESHOp::OpHexahedron, addId, -1 );
4141 createMenu( SMESHOp::OpPentahedron, addId, -1 );
4142 createMenu( SMESHOp::OpPyramid, addId, -1 );
4143 createMenu( SMESHOp::OpHexagonalPrism, addId, -1 );
4144 createMenu( SMESHOp::OpPolyhedron, addId, -1 );
4145 createMenu( separator(), addId, -1 );
4146 createMenu( SMESHOp::OpQuadraticEdge, addId, -1 );
4147 createMenu( SMESHOp::OpQuadraticTriangle, addId, -1 );
4148 createMenu( SMESHOp::OpBiQuadraticTriangle , addId, -1 );
4149 createMenu( SMESHOp::OpQuadraticQuadrangle, addId, -1 );
4150 createMenu( SMESHOp::OpBiQuadraticQuadrangle, addId, -1 );
4151 createMenu( SMESHOp::OpQuadraticPolygon, addId, -1 );
4152 createMenu( SMESHOp::OpQuadraticTetrahedron, addId, -1 );
4153 createMenu( SMESHOp::OpQuadraticPyramid, addId, -1 );
4154 createMenu( SMESHOp::OpQuadraticPentahedron, addId, -1 );
4155 createMenu( SMESHOp::OpQuadraticHexahedron, addId, -1 );
4156 createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4158 createMenu( SMESHOp::OpRemoveNodes, removeId, -1 );
4159 createMenu( SMESHOp::OpRemoveElements, removeId, -1 );
4160 createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4161 createMenu( separator(), removeId, -1 );
4162 createMenu( SMESHOp::OpDeleteGroup, removeId, -1 );
4163 createMenu( separator(), removeId, -1 );
4164 createMenu( SMESHOp::OpClearMesh, removeId, -1 );
4166 //createMenu( SMESHOp::OpRenumberingNodes, renumId, -1 );
4167 //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4169 createMenu( SMESHOp::OpTranslation, transfId, -1 );
4170 createMenu( SMESHOp::OpRotation, transfId, -1 );
4171 createMenu( SMESHOp::OpSymmetry, transfId, -1 );
4172 createMenu( SMESHOp::OpScale, transfId, -1 );
4173 createMenu( SMESHOp::OpSewing, transfId, -1 );
4174 createMenu( SMESHOp::OpMergeNodes, transfId, -1 );
4175 createMenu( SMESHOp::OpMergeElements, transfId, -1 );
4176 createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4178 createMenu( SMESHOp::OpMoveNode, modifyId, -1 );
4179 createMenu( SMESHOp::OpDiagonalInversion, modifyId, -1 );
4180 createMenu( SMESHOp::OpUnionOfTwoTriangle, modifyId, -1 );
4181 createMenu( SMESHOp::OpOrientation, modifyId, -1 );
4182 createMenu( SMESHOp::OpReorientFaces, modifyId, -1 );
4183 createMenu( SMESHOp::OpUnionOfTriangles, modifyId, -1 );
4184 createMenu( SMESHOp::OpCuttingOfQuadrangles, modifyId, -1 );
4185 createMenu( SMESHOp::OpSplitVolumes, modifyId, -1 );
4186 createMenu( SMESHOp::OpSplitBiQuadratic, modifyId, -1 );
4187 createMenu( SMESHOp::OpSmoothing, modifyId, -1 );
4188 createMenu( SMESHOp::OpExtrusion, modifyId, -1 );
4189 createMenu( SMESHOp::OpExtrusionAlongAPath , modifyId, -1 );
4190 createMenu( SMESHOp::OpRevolution, modifyId, -1 );
4191 createMenu( SMESHOp::OpPatternMapping, modifyId, -1 );
4192 createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4193 createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4195 createMenu( SMESHOp::OpMinimumDistance, measureId, -1 );
4196 createMenu( SMESHOp::OpBoundingBox, measureId, -1 );
4197 createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4198 createMenu( SMESHOp::OpPropertiesArea, basicPropId, -1 );
4199 createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4200 createMenu( SMESHOp::OpUpdate, viewId, -1 );
4202 connect( nodeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4203 connect( edgeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4204 connect( faceMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4205 connect( volumeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4207 // ----- create toolbars --------------
4208 int meshTb = createTool( tr( "TB_MESH" ), QString( "SMESHMeshToolbar" ) ),
4209 info = createTool( tr( "TB_INFO" ), QString( "SMESHInformationToolbar" ) ),
4210 groupTb = createTool( tr( "TB_GROUP" ), QString( "SMESHGroupToolbar" ) ),
4211 ctrl0dTb = createTool( tr( "TB_CTRL0D" ), QString( "SMESHNodeControlsToolbar" ) ),
4212 ctrl1dTb = createTool( tr( "TB_CTRL1D" ), QString( "SMESHEdgeControlsToolbar" ) ),
4213 ctrl2dTb = createTool( tr( "TB_CTRL2D" ), QString( "SMESHFaceControlsToolbar" ) ),
4214 ctrl3dTb = createTool( tr( "TB_CTRL3D" ), QString( "SMESHVolumeControlsToolbar" ) ),
4215 addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ),
4216 addNonElemTb = createTool( tr( "TB_ADDNON" ), QString( "SMESHAddElementToolbar" ) ),
4217 remTb = createTool( tr( "TB_REM" ), QString( "SMESHRemoveToolbar" ) ),
4218 //renumbTb = createTool( tr( "TB_RENUMBER" ), QString( "SMESHRenumberingToolbar" ) ),
4219 transformTb = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ),
4220 modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ),
4221 measuremTb = createTool( tr( "TB_MEASUREM" ), QString( "SMESHMeasurementsToolbar" ) ),
4222 dispModeTb = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4224 createTool( SMESHOp::OpCreateMesh, meshTb );
4225 createTool( SMESHOp::OpCreateSubMesh, meshTb );
4226 createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4227 createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4228 createTool( SMESHOp::OpCopyMesh, meshTb );
4229 createTool( separator(), meshTb );
4230 createTool( SMESHOp::OpCompute, meshTb );
4231 createTool( SMESHOp::OpPreCompute, meshTb );
4232 createTool( SMESHOp::OpEvaluate, meshTb );
4233 createTool( SMESHOp::OpMeshOrder, meshTb );
4235 createTool( SMESHOp::OpCreateGroup, groupTb );
4236 createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4237 createTool( SMESHOp::OpConstructGroup, groupTb );
4238 createTool( SMESHOp::OpEditGroup, groupTb );
4240 createTool( SMESHOp::OpMeshInformation, info );
4241 //createTool( SMESHOp::OpStdInfo, meshTb );
4242 //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4243 createTool( SMESHOp::OpFindElementByPoint, info );
4245 createTool( SMESHOp::OpFreeNode, ctrl0dTb );
4246 createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4248 createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4249 createTool( SMESHOp::OpLength, ctrl1dTb );
4250 createTool( SMESHOp::OpConnection, ctrl1dTb );
4251 createTool( SMESHOp::OpEqualEdge, ctrl1dTb );
4253 createTool( SMESHOp::OpFreeEdge, ctrl2dTb );
4254 createTool( SMESHOp::OpFreeFace, ctrl2dTb );
4255 createTool( SMESHOp::OpBareBorderFace, ctrl2dTb );
4256 createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4257 createTool( SMESHOp::OpLength2D, ctrl2dTb );
4258 createTool( SMESHOp::OpConnection2D, ctrl2dTb );
4259 createTool( SMESHOp::OpArea, ctrl2dTb );
4260 createTool( SMESHOp::OpTaper, ctrl2dTb );
4261 createTool( SMESHOp::OpAspectRatio, ctrl2dTb );
4262 createTool( SMESHOp::OpMinimumAngle, ctrl2dTb );
4263 createTool( SMESHOp::OpWarpingAngle, ctrl2dTb );
4264 createTool( SMESHOp::OpSkew, ctrl2dTb );
4265 createTool( SMESHOp::OpMaxElementLength2D, ctrl2dTb );
4266 createTool( SMESHOp::OpEqualFace, ctrl2dTb );
4268 createTool( SMESHOp::OpAspectRatio3D, ctrl3dTb );
4269 createTool( SMESHOp::OpVolume, ctrl3dTb );
4270 createTool( SMESHOp::OpMaxElementLength3D, ctrl3dTb );
4271 createTool( SMESHOp::OpBareBorderVolume, ctrl3dTb );
4272 createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
4273 createTool( SMESHOp::OpEqualVolume, ctrl3dTb );
4275 createTool( SMESHOp::OpNode, addElemTb );
4276 createTool( SMESHOp::OpElem0D, addElemTb );
4277 createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4278 createTool( SMESHOp::OpBall, addElemTb );
4279 createTool( SMESHOp::OpEdge, addElemTb );
4280 createTool( SMESHOp::OpTriangle, addElemTb );
4281 createTool( SMESHOp::OpQuadrangle, addElemTb );
4282 createTool( SMESHOp::OpPolygon, addElemTb );
4283 createTool( SMESHOp::OpTetrahedron, addElemTb );
4284 createTool( SMESHOp::OpHexahedron, addElemTb );
4285 createTool( SMESHOp::OpPentahedron, addElemTb );
4286 createTool( SMESHOp::OpPyramid, addElemTb );
4287 createTool( SMESHOp::OpHexagonalPrism, addElemTb );
4288 createTool( SMESHOp::OpPolyhedron, addElemTb );
4290 createTool( SMESHOp::OpQuadraticEdge, addNonElemTb );
4291 createTool( SMESHOp::OpQuadraticTriangle, addNonElemTb );
4292 createTool( SMESHOp::OpBiQuadraticTriangle, addNonElemTb );
4293 createTool( SMESHOp::OpQuadraticQuadrangle, addNonElemTb );
4294 createTool( SMESHOp::OpBiQuadraticQuadrangle, addNonElemTb );
4295 createTool( SMESHOp::OpQuadraticPolygon, addNonElemTb );
4296 createTool( SMESHOp::OpQuadraticTetrahedron, addNonElemTb );
4297 createTool( SMESHOp::OpQuadraticPyramid, addNonElemTb );
4298 createTool( SMESHOp::OpQuadraticPentahedron, addNonElemTb );
4299 createTool( SMESHOp::OpQuadraticHexahedron, addNonElemTb );
4300 createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4302 createTool( SMESHOp::OpRemoveNodes, remTb );
4303 createTool( SMESHOp::OpRemoveElements, remTb );
4304 createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4305 createTool( SMESHOp::OpClearMesh, remTb );
4307 //createTool( SMESHOp::OpRenumberingNodes, renumbTb );
4308 //createTool( SMESHOp::OpRenumberingElements, renumbTb );
4310 createTool( SMESHOp::OpTranslation, transformTb );
4311 createTool( SMESHOp::OpRotation, transformTb );
4312 createTool( SMESHOp::OpSymmetry, transformTb );
4313 createTool( SMESHOp::OpScale, transformTb );
4314 createTool( SMESHOp::OpSewing, transformTb );
4315 createTool( SMESHOp::OpMergeNodes, transformTb );
4316 createTool( SMESHOp::OpMergeElements, transformTb );
4317 createTool( SMESHOp::OpDuplicateNodes, transformTb );
4319 createTool( SMESHOp::OpMoveNode, modifyTb );
4320 createTool( SMESHOp::OpDiagonalInversion, modifyTb );
4321 createTool( SMESHOp::OpUnionOfTwoTriangle, modifyTb );
4322 createTool( SMESHOp::OpOrientation, modifyTb );
4323 createTool( SMESHOp::OpReorientFaces, modifyTb );
4324 createTool( SMESHOp::OpUnionOfTriangles, modifyTb );
4325 createTool( SMESHOp::OpCuttingOfQuadrangles, modifyTb );
4326 createTool( SMESHOp::OpSplitVolumes, modifyTb );
4327 createTool( SMESHOp::OpSplitBiQuadratic, modifyTb );
4328 createTool( SMESHOp::OpSmoothing, modifyTb );
4329 createTool( SMESHOp::OpExtrusion, modifyTb );
4330 createTool( SMESHOp::OpExtrusionAlongAPath, modifyTb );
4331 createTool( SMESHOp::OpRevolution, modifyTb );
4332 createTool( SMESHOp::OpPatternMapping, modifyTb );
4333 createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4334 createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4336 createTool( SMESHOp::OpMinimumDistance, measuremTb );
4338 createTool( SMESHOp::OpUpdate, dispModeTb );
4340 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4341 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4345 OB = "'ObjectBrowser'",
4346 View = "'" + SVTK_Viewer::Type() + "'",
4348 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4349 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4350 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4351 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4352 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4353 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4354 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4355 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4356 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4357 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4358 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4360 mesh_part = mesh + " " + subMesh + " " + group,
4361 mesh_group = mesh + " " + group,
4362 mesh_submesh = mesh + " " + subMesh,
4363 hyp_alg = hypo + " " + algo;
4365 // popup for object browser
4367 isInvisible("not( isVisible )"),
4368 isEmpty("numberOfNodes = 0"),
4369 isNotEmpty("numberOfNodes <> 0"),
4371 // has nodes, edges, etc in VISIBLE! actor
4372 hasNodes("(numberOfNodes > 0 )"),//&& isVisible)"),
4373 hasElems("(count( elemTypes ) > 0)"),
4374 hasDifferentElems("(count( elemTypes ) > 1)"),
4375 hasBalls("({'BallElem'} in elemTypes)"),
4376 hasElems0d("({'Elem0d'} in elemTypes)"),
4377 hasEdges("({'Edge'} in elemTypes)"),
4378 hasFaces("({'Face'} in elemTypes)"),
4379 hasVolumes("({'Volume'} in elemTypes)"),
4380 hasFacesOrVolumes("(({'Face'} in elemTypes) || ({'Volume'} in elemTypes)) ");
4382 createPopupItem( SMESHOp::OpFileInformation, OB, mesh, "&& selcount=1 && isImported" );
4383 createPopupItem( SMESHOp::OpCreateSubMesh, OB, mesh, "&& hasGeomReference");
4384 createPopupItem( SMESHOp::OpEditMesh, OB, mesh, "&& selcount=1" );
4385 createPopupItem( SMESHOp::OpEditSubMesh, OB, subMesh, "&& selcount=1 && hasGeomReference" );
4386 createPopupItem( SMESHOp::OpEditGroup, OB, group );
4387 createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4389 popupMgr()->insert( separator(), -1, 0 );
4390 createPopupItem( SMESHOp::OpCompute, OB, mesh, "&& selcount=1 && isComputable" );
4391 createPopupItem( SMESHOp::OpComputeSubMesh, OB, subMesh, "&& selcount=1 && isComputable" );
4392 createPopupItem( SMESHOp::OpPreCompute, OB, mesh, "&& selcount=1 && isPreComputable" );
4393 createPopupItem( SMESHOp::OpEvaluate, OB, mesh, "&& selcount=1 && isComputable" );
4394 createPopupItem( SMESHOp::OpMeshOrder, OB, mesh, "&& selcount=1 && isComputable && hasGeomReference" );
4395 createPopupItem( SMESHOp::OpUpdate, OB, mesh_part );
4396 createPopupItem( SMESHOp::OpMeshInformation, OB, mesh_part );
4397 createPopupItem( SMESHOp::OpFindElementByPoint,OB, mesh_group, "&& selcount=1" );
4398 createPopupItem( SMESHOp::OpOverallMeshQuality,OB, mesh_part );
4399 popupMgr()->insert( separator(), -1, 0 );
4400 createPopupItem( SMESHOp::OpCreateGroup, OB, mesh, "&& selcount=1" );
4401 createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh, "&& selcount=1 && hasGeomReference" );
4402 createPopupItem( SMESHOp::OpConstructGroup, OB, subMesh );
4403 popupMgr()->insert( separator(), -1, 0 );
4404 createPopupItem( SMESHOp::OpEditHypothesis, OB, hypo, "&& isEditableHyp");
4405 createPopupItem( SMESHOp::OpUnassign, OB, hyp_alg );
4406 popupMgr()->insert( separator(), -1, 0 );
4407 createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh_submesh );
4408 createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh_group, "&& selcount=1 && dim>=2");
4409 popupMgr()->insert( separator(), -1, 0 );
4410 createPopupItem( SMESHOp::OpClearMesh, OB, mesh );
4411 //popupMgr()->insert( separator(), -1, 0 );
4413 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4414 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4415 QString only_one_2D = only_one_non_empty + " && dim>1";
4417 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4418 createPopupItem( SMESHOp::OpPopupExportMED, OB, mesh_group, multiple_non_empty, anId );
4419 createPopupItem( SMESHOp::OpPopupExportUNV, OB, mesh_group, only_one_non_empty, anId );
4420 createPopupItem( SMESHOp::OpPopupExportSTL, OB, mesh_group, only_one_2D, anId );
4422 createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4424 createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, only_one_non_empty, anId );
4425 createPopupItem( SMESHOp::OpPopupExportGMF, OB, mesh_group, only_one_non_empty, anId );
4426 createPopupItem( SMESHOp::OpPopupExportDAT, OB, mesh_group, only_one_non_empty, anId );
4427 createPopupItem( SMESHOp::OpDelete, OB, mesh_part + " " + hyp_alg );
4428 createPopupItem( SMESHOp::OpDeleteGroup, OB, group );
4429 popupMgr()->insert( separator(), -1, 0 );
4432 createPopupItem( SMESHOp::OpEditGroup, View, group );
4433 createPopupItem( SMESHOp::OpAddElemGroupPopup, View, elems );
4434 createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems );
4436 popupMgr()->insert( separator(), -1, 0 );
4437 createPopupItem( SMESHOp::OpUpdate, View, mesh_part );
4438 createPopupItem( SMESHOp::OpMeshInformation, View, mesh_part );
4439 createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4440 createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh );
4441 popupMgr()->insert( separator(), -1, 0 );
4443 createPopupItem( SMESHOp::OpAutoColor, OB + " " + View, mesh, "&& (not isAutoColor)" );
4444 createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4445 popupMgr()->insert( separator(), -1, 0 );
4447 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4448 QString aType = QString( "%1type in {%2}" ).arg( lc );
4449 aType = aType.arg( mesh_part );
4450 QString aMeshInVTK = aClient + "&&" + aType;
4452 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4453 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4454 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4456 //-------------------------------------------------
4458 //-------------------------------------------------
4459 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4461 popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4462 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4463 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4465 popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4466 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4467 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4469 popupMgr()->insert( separator(), -1, -1 );
4471 //-------------------------------------------------
4473 //-------------------------------------------------
4474 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4476 popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4477 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4478 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4480 popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4481 popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4482 popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4484 popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4485 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes, QtxPopupMgr::VisibleRule );
4486 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4488 popupMgr()->insert( separator(), anId, -1 );
4490 popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4491 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4492 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4494 //-------------------------------------------------
4496 //-------------------------------------------------
4497 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4499 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4501 popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4502 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4503 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4505 popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4506 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4507 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4509 popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4510 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4511 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4513 popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4514 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4515 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4517 popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4518 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4519 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4521 popupMgr()->insert( separator(), anId, -1 );
4523 popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4524 popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&&" + aType + "&&" + isNotEmpty, QtxPopupMgr::VisibleRule );
4526 popupMgr()->insert( separator(), anId, -1 );
4528 popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4529 popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4532 //-------------------------------------------------
4533 // Representation of the 2D Quadratic elements
4534 //-------------------------------------------------
4535 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4536 popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4537 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "&& isVisible && isQuadratic",QtxPopupMgr::VisibleRule );
4538 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4540 popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4541 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "&& isVisible && isQuadratic", QtxPopupMgr::VisibleRule );
4542 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4544 //-------------------------------------------------
4545 // Orientation of faces
4546 //-------------------------------------------------
4547 popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4548 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4549 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4551 //-------------------------------------------------
4553 //-------------------------------------------------
4554 popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4555 popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4557 //-------------------------------------------------
4559 //-------------------------------------------------
4560 popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4561 popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4563 //-------------------------------------------------
4565 //-------------------------------------------------
4567 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4568 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4569 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4570 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4572 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4574 popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4575 popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4577 popupMgr()->insert( separator(), anId, -1 );
4579 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4581 popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4582 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4583 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4585 popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4586 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4587 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4589 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4591 popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4592 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVTK + "&&" + hasEdges + "&&" + hasFacesOrVolumes, QtxPopupMgr::VisibleRule );
4593 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4595 popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4596 popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4597 popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4599 popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4600 popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4601 popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4602 popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4603 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4604 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4606 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4608 popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4609 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4610 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4612 popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4613 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4614 QtxPopupMgr::VisibleRule );
4615 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4617 popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4618 popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4619 popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4621 popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4622 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4623 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4625 popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
4626 popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4627 popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4629 popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
4630 popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4631 popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4633 popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
4634 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4635 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4637 popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
4638 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4639 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4641 popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
4642 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4643 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4645 popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
4646 popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4647 popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4649 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
4650 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4651 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4653 popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
4654 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4655 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4657 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
4658 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4659 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4660 popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
4661 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4662 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4664 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4666 popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D ), aSubId, -1 );
4667 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4668 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4670 popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
4671 popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4672 popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4674 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
4675 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4676 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4678 popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
4679 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4680 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4682 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
4683 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4684 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4686 popupMgr()->insert ( action( SMESHOp::OpEqualVolume ), aSubId, -1 );
4687 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4688 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4690 popupMgr()->insert( separator(), anId, -1 );
4692 popupMgr()->insert( action( SMESHOp::OpShowScalarBar ), anId, -1 );
4693 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4694 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone' && isScalarBarVisible", QtxPopupMgr::ToggleRule );
4695 popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
4696 popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4698 popupMgr()->insert( separator(), anId, -1 );
4700 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4702 popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
4703 popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4705 popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
4706 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4707 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isScalarBarVisible && isDistributionVisible", QtxPopupMgr::ToggleRule);
4709 #ifndef DISABLE_PLOT2DVIEWER
4710 popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
4711 popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4714 //-------------------------------------------------
4716 //-------------------------------------------------
4717 popupMgr()->insert( separator(), -1, -1 );
4718 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4719 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4720 popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
4721 popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4723 popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
4724 popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4726 popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
4727 popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4729 popupMgr()->insert( separator(), -1, -1 );
4731 //-------------------------------------------------
4733 //-------------------------------------------------
4734 popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
4735 popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4737 popupMgr()->insert( separator(), -1, -1 );
4739 popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
4740 popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
4741 popupMgr()->insert( separator(), -1, -1 );
4743 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4744 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4746 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4747 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4750 //================================================================================
4752 * \brief Return true if SMESH or GEOM objects are selected.
4753 * Is called form LightApp_Module::activateModule() which clear selection if
4754 * not isSelectionCompatible()
4756 //================================================================================
4758 bool SMESHGUI::isSelectionCompatible()
4760 bool isCompatible = true;
4761 SALOME_ListIO selected;
4762 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4763 Sel->selectedObjects( selected );
4765 SALOME_ListIteratorOfListIO It( selected );
4766 for ( ; isCompatible && It.More(); It.Next())
4768 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4769 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4771 return isCompatible;
4775 bool SMESHGUI::reusableOperation( const int id )
4777 // compute, evaluate and precompute are not reusable operations
4778 return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate ) ? false : SalomeApp_Module::reusableOperation( id );
4781 bool SMESHGUI::activateModule( SUIT_Study* study )
4783 bool res = SalomeApp_Module::activateModule( study );
4785 setMenuShown( true );
4786 setToolShown( true );
4788 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4789 PyGILState_STATE gstate = PyGILState_Ensure();
4790 PyObject* pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4791 if ( !pluginsmanager ) {
4795 PyObject* result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toUtf8().data(),tr("SMESH_PLUGINS_OTHER").toUtf8().data());
4800 PyGILState_Release(gstate);
4801 // end of SMESH plugins loading
4803 // Reset actions accelerator keys
4804 action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
4806 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4807 GetSMESHGen()->SetCurrentStudy(SALOMEDS::Study::_nil());
4808 if ( SalomeApp_Study* s = dynamic_cast<SalomeApp_Study*>( study )) {
4809 if ( _PTR(Study) aStudy = s->studyDS() )
4810 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
4813 // get all view currently opened in the study and connect their signals to
4814 // the corresponding slots of the class.
4815 SUIT_Desktop* aDesk = study->application()->desktop();
4817 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4818 SUIT_ViewWindow* wnd;
4819 foreach ( wnd, wndList )
4823 Py_XDECREF(pluginsmanager);
4827 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4829 setMenuShown( false );
4830 setToolShown( false );
4832 EmitSignalCloseAllDialogs();
4834 // Unset actions accelerator keys
4835 action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
4837 return SalomeApp_Module::deactivateModule( study );
4840 void SMESHGUI::studyClosed( SUIT_Study* s )
4844 SMESH::RemoveVisuData( s->id() );
4845 SalomeApp_Module::studyClosed( s );
4848 void SMESHGUI::OnGUIEvent()
4850 const QObject* obj = sender();
4851 if ( !obj || !obj->inherits( "QAction" ) )
4853 int id = actionId((QAction*)obj);
4858 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4860 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
4861 if ( CORBA::is_nil( myComponentSMESH ) )
4863 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4865 aGUI.myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4866 return aGUI.myComponentSMESH;
4869 myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4870 return myComponentSMESH;
4873 QString SMESHGUI::engineIOR() const
4875 CORBA::ORB_var anORB = getApp()->orb();
4876 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4877 return QString( anIOR.in() );
4880 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4882 SalomeApp_Module::contextMenuPopup( client, menu, title );
4884 selectionMgr()->selectedObjects( lst );
4885 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4886 Handle(SALOME_InteractiveObject) io = lst.First();
4887 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4888 _PTR(Study) study = appStudy->studyDS();
4889 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4891 QString aName = QString( SMESH::fromUtf8(obj->GetName()) );
4892 while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4893 aName.remove( (aName.length() - 1), 1 );
4899 LightApp_Selection* SMESHGUI::createSelection() const
4901 return new SMESHGUI_Selection();
4904 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4906 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4907 aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
4908 #ifndef DISABLE_PYCONSOLE
4909 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4913 void SMESHGUI::viewManagers( QStringList& list ) const
4915 list.append( SVTK_Viewer::Type() );
4918 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4920 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4921 SMESH::UpdateSelectionProp( this );
4923 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
4924 for(int i = 0; i < aViews.count() ; i++){
4925 SUIT_ViewWindow *sf = aViews[i];
4928 EmitSignalActivatedViewManager();
4932 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
4934 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
4935 myClippingPlaneInfoMap.erase( theViewManager );
4938 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
4940 theActor->AddObserver( SMESH::DeleteActorEvent,
4941 myEventCallbackCommand.GetPointer(),
4945 void SMESHGUI::ProcessEvents( vtkObject* theObject,
4946 unsigned long theEvent,
4947 void* theClientData,
4950 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
4951 if( theObject && (int) theEvent == SMESH::DeleteActorEvent ) {
4952 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
4953 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
4954 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
4955 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
4956 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
4957 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
4958 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
4959 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
4960 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
4961 SMESH::TActorList::iterator anIter3 = anActorList.begin();
4962 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
4963 if( anActor == *anIter3 ) {
4964 anActorList.erase( anIter3 );
4975 void SMESHGUI::createPreferences()
4977 // General tab ------------------------------------------------------------------------
4978 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
4980 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
4981 setPreferenceProperty( autoUpdate, "columns", 2 );
4982 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
4983 setPreferenceProperty( lim, "min", 0 );
4984 setPreferenceProperty( lim, "max", 100000000 );
4985 setPreferenceProperty( lim, "step", 1000 );
4986 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4987 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
4989 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
4990 setPreferenceProperty( qaGroup, "columns", 2 );
4991 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
4992 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
4993 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
4994 setPreferenceProperty( prec, "min", 0 );
4995 setPreferenceProperty( prec, "max", 100 );
4996 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
4997 setPreferenceProperty( doubleNodesTol, "precision", 10 );
4998 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
4999 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
5000 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
5002 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
5003 setPreferenceProperty( dispgroup, "columns", 2 );
5004 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
5006 modes.append( tr("MEN_WIRE") );
5007 modes.append( tr("MEN_SHADE") );
5008 modes.append( tr("MEN_NODES") );
5009 modes.append( tr("MEN_SHRINK") );
5010 QList<QVariant> indices;
5011 indices.append( 0 );
5012 indices.append( 1 );
5013 indices.append( 2 );
5014 indices.append( 3 );
5015 setPreferenceProperty( dispmode, "strings", modes );
5016 setPreferenceProperty( dispmode, "indexes", indices );
5018 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
5019 setPreferenceProperty( arcgroup, "columns", 2 );
5020 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
5021 QStringList quadraticModes;
5022 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
5023 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
5025 indices.append( 0 );
5026 indices.append( 1 );
5027 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
5028 setPreferenceProperty( quadraticmode, "indexes", indices );
5030 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
5031 "SMESH", "max_angle" );
5032 setPreferenceProperty( maxAngle, "min", 1 );
5033 setPreferenceProperty( maxAngle, "max", 90 );
5037 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
5038 setPreferenceProperty( exportgroup, "columns", 2 );
5039 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
5040 addPreference( tr( "PREF_SHOW_WARN" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "show_warning" );
5041 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
5043 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
5044 setPreferenceProperty( computeGroup, "columns", 2 );
5045 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
5047 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5048 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5049 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5051 indices.append( 0 );
5052 indices.append( 1 );
5053 indices.append( 2 );
5054 setPreferenceProperty( notifyMode, "strings", modes );
5055 setPreferenceProperty( notifyMode, "indexes", indices );
5057 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5058 setPreferenceProperty( infoGroup, "columns", 2 );
5059 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5061 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5062 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5064 indices.append( 0 );
5065 indices.append( 1 );
5066 setPreferenceProperty( elemInfo, "strings", modes );
5067 setPreferenceProperty( elemInfo, "indexes", indices );
5068 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5069 setPreferenceProperty( nodesLim, "min", 0 );
5070 setPreferenceProperty( nodesLim, "max", 10000000 );
5071 setPreferenceProperty( nodesLim, "step", 10000 );
5072 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5073 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5074 setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5075 setPreferenceProperty( ctrlLim, "min", 0 );
5076 setPreferenceProperty( ctrlLim, "max", 10000000 );
5077 setPreferenceProperty( ctrlLim, "step", 1000 );
5078 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5079 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5080 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5081 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5082 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5084 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5085 setPreferenceProperty( segGroup, "columns", 2 );
5086 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5087 "SMESH", "segmentation" );
5088 setPreferenceProperty( segLen, "min", 1 );
5089 setPreferenceProperty( segLen, "max", 10000000 );
5090 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5091 "SMESH", "nb_segments_per_edge" );
5092 setPreferenceProperty( nbSeg, "min", 1 );
5093 setPreferenceProperty( nbSeg, "max", 10000000 );
5095 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5096 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5097 "SMESH", "forget_mesh_on_hyp_modif" );
5100 // Quantities with individual precision settings
5101 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5102 setPreferenceProperty( precGroup, "columns", 2 );
5104 const int nbQuantities = 6;
5105 int precs[nbQuantities], ii = 0;
5106 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5107 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5108 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5109 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5110 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5111 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5112 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5113 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5114 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5115 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5116 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5117 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5119 // Set property for precision value for spinboxes
5120 for ( ii = 0; ii < nbQuantities; ii++ ){
5121 setPreferenceProperty( precs[ii], "min", -14 );
5122 setPreferenceProperty( precs[ii], "max", 14 );
5123 setPreferenceProperty( precs[ii], "precision", 2 );
5126 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5127 setPreferenceProperty( previewGroup, "columns", 2 );
5128 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5129 setPreferenceProperty( chunkSize, "min", 1 );
5130 setPreferenceProperty( chunkSize, "max", 1000 );
5131 setPreferenceProperty( chunkSize, "step", 50 );
5133 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5134 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5136 // Mesh tab ------------------------------------------------------------------------
5137 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5138 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5139 setPreferenceProperty( nodeGroup, "columns", 3 );
5141 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5143 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5145 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5146 QList<QVariant> aMarkerTypeIndicesList;
5147 QList<QVariant> aMarkerTypeIconsList;
5148 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5149 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5150 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5151 aMarkerTypeIndicesList << i;
5152 aMarkerTypeIconsList << pixmap;
5154 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5155 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
5157 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5159 QList<QVariant> aMarkerScaleIndicesList;
5160 QStringList aMarkerScaleValuesList;
5161 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5162 aMarkerScaleIndicesList << i;
5163 //aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5164 aMarkerScaleValuesList << QString::number( i );
5166 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5167 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5169 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5170 //setPreferenceProperty( elemGroup, "columns", 2 );
5172 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5173 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5174 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5175 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5176 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5177 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5178 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5179 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5180 addPreference( tr( "PREF_PREVIEW_COLOR" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5183 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5184 setPreferenceProperty( grpGroup, "columns", 2 );
5186 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5187 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5189 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5190 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5191 /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5192 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5193 double ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5194 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5195 double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5196 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5197 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
5198 LightApp_Preferences::IntSpin, "SMESH", "element_width");
5199 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5200 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5201 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5202 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5204 setPreferenceProperty( size0d, "min", 1 );
5205 setPreferenceProperty( size0d, "max", 10 );
5207 // setPreferenceProperty( ballSize, "min", 1 );
5208 // setPreferenceProperty( ballSize, "max", 10 );
5210 setPreferenceProperty( ballDiameter, "min", 1e-7 );
5211 setPreferenceProperty( ballDiameter, "max", 1e9 );
5212 setPreferenceProperty( ballDiameter, "step", 0.1 );
5214 setPreferenceProperty( ballScale, "min", 1e-2 );
5215 setPreferenceProperty( ballScale, "max", 1e7 );
5216 setPreferenceProperty( ballScale, "step", 0.5 );
5218 setPreferenceProperty( elemW, "min", 1 );
5219 setPreferenceProperty( elemW, "max", 5 );
5221 setPreferenceProperty( outW, "min", 1 );
5222 setPreferenceProperty( outW, "max", 5 );
5224 setPreferenceProperty( shrink, "min", 0 );
5225 setPreferenceProperty( shrink, "max", 100 );
5227 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5228 setPreferenceProperty( numGroup, "columns", 2 );
5230 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5231 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5233 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5234 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5236 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5237 setPreferenceProperty( orientGroup, "columns", 1 );
5239 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5240 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5242 setPreferenceProperty( orientScale, "min", 0.05 );
5243 setPreferenceProperty( orientScale, "max", 0.5 );
5244 setPreferenceProperty( orientScale, "step", 0.05 );
5246 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5248 // Selection tab ------------------------------------------------------------------------
5249 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5251 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5252 setPreferenceProperty( selGroup, "columns", 2 );
5254 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5255 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5257 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5258 setPreferenceProperty( preGroup, "columns", 2 );
5260 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5262 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5263 setPreferenceProperty( precSelGroup, "columns", 2 );
5265 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5266 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5267 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5269 // Scalar Bar tab ------------------------------------------------------------------------
5270 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5271 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5272 setPreferenceProperty( fontGr, "columns", 2 );
5274 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5275 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5277 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5278 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5280 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5281 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5283 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5284 setPreferenceProperty( numcol, "min", 2 );
5285 setPreferenceProperty( numcol, "max", 256 );
5287 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5288 setPreferenceProperty( numlab, "min", 2 );
5289 setPreferenceProperty( numlab, "max", 65 );
5291 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5292 setPreferenceProperty( orientGr, "columns", 2 );
5293 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5294 QStringList orients;
5295 orients.append( tr( "SMESH_VERTICAL" ) );
5296 orients.append( tr( "SMESH_HORIZONTAL" ) );
5297 indices.clear(); indices.append( 0 ); indices.append( 1 );
5298 setPreferenceProperty( orient, "strings", orients );
5299 setPreferenceProperty( orient, "indexes", indices );
5301 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5302 setPreferenceProperty( posVSizeGr, "columns", 2 );
5303 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5304 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5305 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5306 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5307 setPreferenceProperty( xv, "step", 0.1 );
5308 setPreferenceProperty( xv, "min", 0.0 );
5309 setPreferenceProperty( xv, "max", 1.0 );
5310 setPreferenceProperty( yv, "step", 0.1 );
5311 setPreferenceProperty( yv, "min", 0.0 );
5312 setPreferenceProperty( yv, "max", 1.0 );
5313 setPreferenceProperty( wv, "step", 0.1 );
5314 setPreferenceProperty( wv, "min", 0.0 );
5315 setPreferenceProperty( wv, "max", 1.0 );
5316 setPreferenceProperty( hv, "min", 0.0 );
5317 setPreferenceProperty( hv, "max", 1.0 );
5318 setPreferenceProperty( hv, "step", 0.1 );
5320 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5321 setPreferenceProperty( posHSizeGr, "columns", 2 );
5322 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5323 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5324 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5325 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5326 setPreferenceProperty( xv, "min", 0.0 );
5327 setPreferenceProperty( xv, "max", 1.0 );
5328 setPreferenceProperty( xv, "step", 0.1 );
5329 setPreferenceProperty( xh, "min", 0.0 );
5330 setPreferenceProperty( xh, "max", 1.0 );
5331 setPreferenceProperty( xh, "step", 0.1 );
5332 setPreferenceProperty( yh, "min", 0.0 );
5333 setPreferenceProperty( yh, "max", 1.0 );
5334 setPreferenceProperty( yh, "step", 0.1 );
5335 setPreferenceProperty( wh, "min", 0.0 );
5336 setPreferenceProperty( wh, "max", 1.0 );
5337 setPreferenceProperty( wh, "step", 0.1 );
5338 setPreferenceProperty( hh, "min", 0.0 );
5339 setPreferenceProperty( hh, "max", 1.0 );
5340 setPreferenceProperty( hh, "step", 0.1 );
5342 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5343 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5344 setPreferenceProperty( distributionGr, "columns", 3 );
5346 types.append( tr( "SMESH_MONOCOLOR" ) );
5347 types.append( tr( "SMESH_MULTICOLOR" ) );
5348 indices.clear(); indices.append( 0 ); indices.append( 1 );
5349 setPreferenceProperty( coloringType, "strings", types );
5350 setPreferenceProperty( coloringType, "indexes", indices );
5351 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5355 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5357 if ( sect=="SMESH" ) {
5358 float sbX1 = 0.01, sbY1 = 0.01, sbW = 0.08, sbH = 0.08;
5359 float aTol = 1.00000009999999;
5360 std::string aWarning;
5361 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5363 if ( name== "selection_object_color" ||
5364 name=="selection_element_color" ||
5365 name== "highlight_color" ||
5366 name=="selection_precision_node" ||
5367 name=="selection_precision_element" ||
5368 name=="selection_precision_object" )
5370 SMESH::UpdateSelectionProp( this );
5372 else if (name == "scalar_bar_vertical_x" || name == "scalar_bar_vertical_width")
5374 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5375 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5376 if ( sbX1+sbW > aTol ) {
5377 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5380 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5381 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5384 else if (name == "scalar_bar_vertical_y" || name == "scalar_bar_vertical_height" )
5386 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5387 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5388 if ( sbY1 + sbH > aTol ) {
5389 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5390 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5391 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5394 else if (name == "scalar_bar_horizontal_x" || name == "scalar_bar_horizontal_width")
5396 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5397 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5398 if ( sbX1 + sbW > aTol ) {
5399 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5402 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5403 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5406 else if (name == "scalar_bar_horizontal_y" || name == "scalar_bar_horizontal_height")
5408 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5409 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5410 if ( sbY1 + sbH > aTol ) {
5411 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5414 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5415 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5418 else if ( name == "segmentation" )
5420 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5421 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5423 else if ( name == "nb_segments_per_edge" )
5425 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5426 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5428 else if ( name == "historical_python_dump" || name == "forget_mesh_on_hyp_modif" || name == "default_grp_color" )
5430 QString val = aResourceMgr->stringValue( "SMESH", name );
5431 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5433 else if ( name == "numbering_node_color" || name == "numbering_node_font" )
5435 SMESH::UpdateFontProp( this );
5437 else if ( name == "numbering_elem_color" || name == "numbering_elem_font" )
5439 SMESH::UpdateFontProp( this );
5442 if ( aWarning.size() != 0 ) {
5443 aWarning += "The default values are applied instead.";
5444 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5445 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5446 QObject::tr(aWarning.c_str()));
5451 //================================================================================
5453 * \brief Update something in accordance with update flags
5454 * \param theFlags - update flags
5456 * Update viewer or/and object browser etc. in accordance with update flags ( see
5457 * LightApp_UpdateFlags enumeration ).
5459 //================================================================================
5460 void SMESHGUI::update( const int flags )
5462 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5463 SMESH::UpdateView();
5465 SalomeApp_Module::update( flags );
5468 //================================================================================
5470 * \brief Set default selection mode
5472 * SLOT called when operation commited. Sets default selection mode
5474 //================================================================================
5475 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5477 SVTK_ViewWindow* vtkWnd =
5478 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5480 vtkWnd->SetSelectionMode( ActorSelection );
5483 //================================================================================
5485 * \brief Set default selection mode
5487 * SLOT called when operation aborted. Sets default selection mode
5489 //================================================================================
5490 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5492 SVTK_ViewWindow* vtkWnd =
5493 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5495 vtkWnd->SetSelectionMode( ActorSelection );
5498 //================================================================================
5500 * \brief Creates operation with given identifier
5501 * \param id - identifier of operation to be started
5502 * \return Pointer on created operation or NULL if operation is not created
5504 * Virtual method redefined from the base class creates operation with given id.
5505 * It is called called automatically from startOperation method of base class.
5507 //================================================================================
5508 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5510 LightApp_Operation* op = 0;
5511 // to do : create operation here
5514 case SMESHOp::OpSplitBiQuadratic:
5515 op = new SMESHGUI_SplitBiQuadOp();
5517 case SMESHOp::OpConvertMeshToQuadratic:
5518 op = new SMESHGUI_ConvToQuadOp();
5520 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5521 op = new SMESHGUI_Make2DFrom3DOp();
5523 case SMESHOp::OpReorientFaces:
5524 op = new SMESHGUI_ReorientFacesOp();
5526 case SMESHOp::OpCreateMesh:
5527 op = new SMESHGUI_MeshOp( true, true );
5529 case SMESHOp::OpCreateSubMesh:
5530 op = new SMESHGUI_MeshOp( true, false );
5532 case SMESHOp::OpEditMeshOrSubMesh:
5533 case SMESHOp::OpEditMesh:
5534 case SMESHOp::OpEditSubMesh:
5535 op = new SMESHGUI_MeshOp( false );
5537 case SMESHOp::OpCompute:
5538 case SMESHOp::OpComputeSubMesh:
5539 op = new SMESHGUI_ComputeOp();
5541 case SMESHOp::OpPreCompute:
5542 op = new SMESHGUI_PrecomputeOp();
5544 case SMESHOp::OpEvaluate:
5545 op = new SMESHGUI_EvaluateOp();
5547 case SMESHOp::OpMeshOrder:
5548 op = new SMESHGUI_MeshOrderOp();
5550 case SMESHOp::OpCreateGeometryGroup:
5551 op = new SMESHGUI_GroupOnShapeOp();
5553 case SMESHOp::OpFindElementByPoint:
5554 op = new SMESHGUI_FindElemByPointOp();
5556 case SMESHOp::OpMoveNode: // Make mesh pass through point
5557 op = new SMESHGUI_MakeNodeAtPointOp();
5559 case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
5560 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5567 op = SalomeApp_Module::createOperation( id );
5571 //================================================================================
5573 * \brief Stops current operations and starts a given one
5574 * \param id - The id of the operation to start
5576 //================================================================================
5578 void SMESHGUI::switchToOperation(int id)
5580 if ( _PTR(Study) aStudy = SMESH::GetActiveStudyDocument() )
5581 activeStudy()->abortAllOperations();
5582 startOperation( id );
5585 LightApp_Displayer* SMESHGUI::displayer()
5588 myDisplayer = new SMESHGUI_Displayer( getApp() );
5592 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5595 int aTolerance = 64;
5596 int anIterations = 0;
5602 if( anIterations % aPeriod == 0 )
5605 if( aTolerance < 1 )
5609 aHue = (int)( 360.0 * rand() / RAND_MAX );
5612 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5613 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5614 for( ; it != itEnd; ++it )
5616 SALOMEDS::Color anAutoColor = *it;
5617 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5620 aQColor.getHsv( &h, &s, &v );
5621 if( abs( h - aHue ) < aTolerance )
5633 aColor.setHsv( aHue, 255, 255 );
5635 SALOMEDS::Color aSColor;
5636 aSColor.R = aColor.redF();
5637 aSColor.G = aColor.greenF();
5638 aSColor.B = aColor.blueF();
5643 const char* gSeparator = "_"; // character used to separate parameter names
5644 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5645 const char* gPathSep = "|"; // character used to separate paths
5648 * \brief Store visual parameters
5650 * This method is called just before the study document is saved.
5651 * Store visual parameters in AttributeParameter attribue(s)
5653 void SMESHGUI::storeVisualParameters (int savePoint)
5656 Kernel_Utils::Localizer loc;
5658 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5659 if (!appStudy || !appStudy->studyDS())
5661 _PTR(Study) studyDS = appStudy->studyDS();
5663 // componentName is used for encoding of entries when storing them in IParameters
5664 std::string componentName = myComponentSMESH->ComponentDataType();
5665 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5666 //if (!aSComponent) return;
5669 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5670 componentName.c_str(),
5672 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5674 // store map of custom markers
5675 const VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5676 if( !aMarkerMap.empty() )
5678 VTK::MarkerMap::const_iterator anIter = aMarkerMap.begin();
5679 for( ; anIter != aMarkerMap.end(); anIter++ )
5681 int anId = anIter->first;
5682 VTK::MarkerData aMarkerData = anIter->second;
5683 std::string aMarkerFileName = aMarkerData.first;
5684 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5685 if( aMarkerTexture.size() < 3 )
5686 continue; // should contain at least width, height and the first value
5688 QString aPropertyName( "texture" );
5689 aPropertyName += gSeparator;
5690 aPropertyName += QString::number( anId );
5692 QString aPropertyValue = aMarkerFileName.c_str();
5693 aPropertyValue += gPathSep;
5695 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5696 ushort aWidth = *aTextureIter++;
5697 ushort aHeight = *aTextureIter++;
5698 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5699 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5700 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5701 aPropertyValue += QString::number( *aTextureIter );
5703 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5707 // viewers counters are used for storing view_numbers in IParameters
5710 // main cycle to store parameters of displayed objects
5711 QList<SUIT_ViewManager*> lst;
5712 QList<SUIT_ViewManager*>::Iterator it;
5713 getApp()->viewManagers(lst);
5714 for (it = lst.begin(); it != lst.end(); it++)
5716 SUIT_ViewManager* vman = *it;
5717 QString vType = vman->getType();
5719 // saving VTK actors properties
5720 if (vType == SVTK_Viewer::Type())
5722 // store the clipping planes attached to the view manager
5723 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5724 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5725 if( anIter != myClippingPlaneInfoMap.end() )
5726 aClippingPlaneInfoList = anIter->second;
5728 if( !aClippingPlaneInfoList.empty() ) {
5729 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5730 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5732 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5733 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5735 QString aPropertyName( "ClippingPlane" );
5736 aPropertyName += gSeparator;
5737 aPropertyName += QString::number( vtkViewers );
5738 aPropertyName += gSeparator;
5739 aPropertyName += QString::number( anId );
5741 QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
5742 aPropertyValue += gDigitsSep;
5743 aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
5744 aPropertyValue += gDigitsSep;
5745 if ( aPlane->PlaneMode == SMESH::Absolute ) {
5746 aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
5747 aPropertyValue += gDigitsSep;
5748 aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
5749 aPropertyValue += gDigitsSep;
5750 aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
5751 aPropertyValue += gDigitsSep;
5752 aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
5753 aPropertyValue += gDigitsSep;
5754 aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
5755 aPropertyValue += gDigitsSep;
5756 aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
5757 aPropertyValue += gDigitsSep;
5758 aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
5760 else if ( aPlane->PlaneMode == SMESH::Relative ) {
5761 aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
5762 aPropertyValue += gDigitsSep;
5763 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5764 aPropertyValue += gDigitsSep;
5765 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5766 aPropertyValue += gDigitsSep;
5767 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5770 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5774 QVector<SUIT_ViewWindow*> views = vman->getViews();
5775 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5777 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5779 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5780 vtkActorCollection* allActors = aCopy.GetActors();
5781 allActors->InitTraversal();
5782 while (vtkActor* actor = allActors->GetNextActor())
5784 if (actor->GetVisibility()) // store only visible actors
5786 SMESH_Actor* aSmeshActor = 0;
5787 if (actor->IsA("SMESH_Actor"))
5788 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5789 if (aSmeshActor && aSmeshActor->hasIO())
5791 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5794 // entry is "encoded" = it does NOT contain component adress,
5795 // since it is a subject to change on next component loading
5796 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5798 std::string param, vtkParam = vType.toLatin1().data();
5799 vtkParam += gSeparator;
5800 vtkParam += QString::number(vtkViewers).toLatin1().data();
5801 vtkParam += gSeparator;
5804 param = vtkParam + "Visibility";
5805 ip->setParameter(entry, param, "On");
5808 param = vtkParam + "Representation";
5809 ip->setParameter(entry, param, QString::number
5810 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5813 param = vtkParam + "IsShrunk";
5814 ip->setParameter(entry, param, QString::number
5815 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5817 // Displayed entities
5818 unsigned int aMode = aSmeshActor->GetEntityMode();
5819 bool isE = aMode & SMESH_Actor::eEdges;
5820 bool isF = aMode & SMESH_Actor::eFaces;
5821 bool isV = aMode & SMESH_Actor::eVolumes;
5822 bool is0d = aMode & SMESH_Actor::e0DElements;
5823 bool isB = aMode & SMESH_Actor::eBallElem;
5825 QString modeStr ("e");
5826 modeStr += gDigitsSep; modeStr += QString::number(isE);
5827 modeStr += gDigitsSep; modeStr += "f";
5828 modeStr += gDigitsSep; modeStr += QString::number(isF);
5829 modeStr += gDigitsSep; modeStr += "v";
5830 modeStr += gDigitsSep; modeStr += QString::number(isV);
5831 modeStr += gDigitsSep; modeStr += "0d";
5832 modeStr += gDigitsSep; modeStr += QString::number(is0d);
5833 modeStr += gDigitsSep; modeStr += "b";
5834 modeStr += gDigitsSep; modeStr += QString::number(isB);
5836 param = vtkParam + "Entities";
5837 ip->setParameter(entry, param, modeStr.toLatin1().data());
5843 aSmeshActor->GetSufaceColor(r, g, b, delta);
5844 QStringList colorStr;
5845 colorStr << "surface";
5846 colorStr << QString::number(r);
5847 colorStr << QString::number(g);
5848 colorStr << QString::number(b);
5850 colorStr << "backsurface";
5851 colorStr << QString::number(delta);
5853 aSmeshActor->GetVolumeColor(r, g, b, delta);
5854 colorStr << "volume";
5855 colorStr << QString::number(r);
5856 colorStr << QString::number(g);
5857 colorStr << QString::number(b);
5858 colorStr << QString::number(delta);
5860 aSmeshActor->GetEdgeColor(r, g, b);
5862 colorStr << QString::number(r);
5863 colorStr << QString::number(g);
5864 colorStr << QString::number(b);
5866 aSmeshActor->GetNodeColor(r, g, b);
5868 colorStr << QString::number(r);
5869 colorStr << QString::number(g);
5870 colorStr << QString::number(b);
5872 aSmeshActor->GetOutlineColor(r, g, b);
5873 colorStr << "outline";
5874 colorStr << QString::number(r);
5875 colorStr << QString::number(g);
5876 colorStr << QString::number(b);
5878 aSmeshActor->Get0DColor(r, g, b);
5879 colorStr << "elem0d";
5880 colorStr << QString::number(r);
5881 colorStr << QString::number(g);
5882 colorStr << QString::number(b);
5884 aSmeshActor->GetBallColor(r, g, b);
5886 colorStr << QString::number(r);
5887 colorStr << QString::number(g);
5888 colorStr << QString::number(b);
5890 aSmeshActor->GetFacesOrientationColor(r, g, b);
5891 colorStr << "orientation";
5892 colorStr << QString::number(r);
5893 colorStr << QString::number(g);
5894 colorStr << QString::number(b);
5896 param = vtkParam + "Colors";
5897 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
5900 QStringList sizeStr;
5902 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
5903 sizeStr << "outline";
5904 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
5905 sizeStr << "elem0d";
5906 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
5908 //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
5909 sizeStr << QString::number((double)aSmeshActor->GetBallSize());
5910 sizeStr << QString::number((double)aSmeshActor->GetBallScale());
5911 sizeStr << "shrink";
5912 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
5913 sizeStr << "orientation";
5914 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
5915 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
5917 param = vtkParam + "Sizes";
5918 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
5923 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5924 if( aMarkerType == VTK::MT_USER ) {
5925 markerStr += "custom";
5926 markerStr += gDigitsSep;
5927 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
5931 markerStr += gDigitsSep;
5932 markerStr += QString::number( (int)aMarkerType );
5933 markerStr += gDigitsSep;
5934 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
5937 param = vtkParam + "PointMarker";
5938 ip->setParameter(entry, param, markerStr.toLatin1().data());
5941 param = vtkParam + "Opacity";
5942 ip->setParameter(entry, param,
5943 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
5946 param = vtkParam + "ClippingPlane";
5948 if( !aClippingPlaneInfoList.empty() ) {
5949 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
5950 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
5952 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
5953 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
5954 SMESH::TActorList::iterator anIter2 = anActorList.begin();
5955 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
5956 if( aSmeshActor == *anIter2 ) {
5957 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
5958 QString::number( anId ).toLatin1().constData() );
5965 ip->setParameter( entry, param, "Off" );
5966 } // if (io->hasEntry())
5967 } // SMESH_Actor && hasIO
5969 } // while.. actors traversal
5973 } // if (SVTK view model)
5974 } // for (viewManagers)
5977 // data structures for clipping planes processing
5981 bool isOpenGLClipping;
5982 vtkIdType RelativeOrientation;
5985 int AbsoluteOrientation;
5986 double X, Y, Z, Dx, Dy, Dz;
5988 typedef std::list<TPlaneData> TPlaneDataList;
5989 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
5991 typedef std::list<vtkActor*> TActorList;
5994 TActorList ActorList;
5995 SUIT_ViewManager* ViewManager;
5997 typedef std::list<TPlaneInfo> TPlaneInfoList;
5998 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
6001 * \brief Restore visual parameters
6003 * This method is called after the study document is opened.
6004 * Restore visual parameters from AttributeParameter attribue(s)
6006 void SMESHGUI::restoreVisualParameters (int savePoint)
6009 Kernel_Utils::Localizer loc;
6011 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6012 if (!appStudy || !appStudy->studyDS())
6014 _PTR(Study) studyDS = appStudy->studyDS();
6016 // componentName is used for encoding of entries when storing them in IParameters
6017 std::string componentName = myComponentSMESH->ComponentDataType();
6018 //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
6019 //if (!aSComponent) return;
6022 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6023 componentName.c_str(),
6025 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6027 // restore map of custom markers and map of clipping planes
6028 VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
6029 TPlaneDataMap aPlaneDataMap;
6031 std::vector<std::string> properties = ip->getProperties();
6032 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
6034 std::string property = *propIt;
6035 QString aPropertyName( property.c_str() );
6036 QString aPropertyValue( ip->getProperty( property ).c_str() );
6038 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
6039 if( aPropertyNameList.isEmpty() )
6042 QString aPropertyType = aPropertyNameList[0];
6043 if( aPropertyType == "texture" )
6045 if( aPropertyNameList.size() != 2 )
6049 int anId = aPropertyNameList[1].toInt( &ok );
6050 if( !ok || anId < 1 )
6053 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
6054 if( aPropertyValueList.size() != 2 )
6057 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
6058 QString aMarkerTextureString = aPropertyValueList[1];
6059 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
6060 if( aMarkerTextureStringList.size() != 3 )
6064 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6069 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6073 VTK::MarkerTexture aMarkerTexture;
6074 aMarkerTexture.push_back( aWidth );
6075 aMarkerTexture.push_back( aHeight );
6077 QString aMarkerTextureData = aMarkerTextureStringList[2];
6078 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6080 QChar aChar = aMarkerTextureData.at( i );
6081 if( aChar.isDigit() )
6082 aMarkerTexture.push_back( aChar.digitValue() );
6085 aMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6087 else if( aPropertyType == "ClippingPlane" )
6089 if( aPropertyNameList.size() != 3 )
6093 int aViewId = aPropertyNameList[1].toInt( &ok );
6094 if( !ok || aViewId < 0 )
6098 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6099 if( !ok || aClippingPlaneId < 0 )
6102 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6103 if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6106 TPlaneData aPlaneData;
6107 aPlaneData.AbsoluteOrientation = false;
6108 aPlaneData.RelativeOrientation = 0;
6109 aPlaneData.Distance = aPlaneData.Angle[0] = aPlaneData.Angle[1] = 0;
6110 aPlaneData.X = aPlaneData.Y = aPlaneData.Z = 0;
6111 aPlaneData.Dx = aPlaneData.Dy = aPlaneData.Dz = 0;
6113 aPlaneData.Id = aClippingPlaneId;
6116 aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6121 aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6125 if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6128 aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6133 aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6138 aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6143 aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6148 aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6153 aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6158 aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6162 else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6164 aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6169 aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6174 aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6179 aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6184 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6185 aPlaneDataList.push_back( aPlaneData );
6189 TPlaneInfoMap aPlaneInfoMap;
6191 std::vector<std::string> entries = ip->getEntries();
6193 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6195 // entry is a normal entry - it should be "decoded" (setting base adress of component)
6196 QString entry (ip->decodeEntry(*entIt).c_str());
6198 // Check that the entry corresponds to a real object in the Study
6199 // as the object may be deleted or modified after the visual state is saved.
6200 _PTR(SObject) so = studyDS->FindObjectID(entry.toLatin1().data());
6201 if (!so) continue; //Skip the not existent entry
6203 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6204 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6206 std::vector<std::string>::iterator namesIt = paramNames.begin();
6207 std::vector<std::string>::iterator valuesIt = paramValues.begin();
6209 // actors are stored in a map after displaying of them for
6210 // quicker access in the future: map < viewID to actor >
6211 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6213 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6215 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6216 // '_' is used as separator and should not be used in viewer type or parameter names.
6217 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6218 if (lst.size() != 3)
6221 QString viewerTypStr = lst[0];
6222 QString viewIndexStr = lst[1];
6223 QString paramNameStr = lst[2];
6226 int viewIndex = viewIndexStr.toUInt(&ok);
6227 if (!ok) // bad conversion of view index to integer
6231 if (viewerTypStr == SVTK_Viewer::Type())
6233 SMESH_Actor* aSmeshActor = 0;
6234 if (vtkActors.IsBound(viewIndex))
6235 aSmeshActor = vtkActors.Find(viewIndex);
6237 QList<SUIT_ViewManager*> lst;
6238 getApp()->viewManagers(viewerTypStr, lst);
6240 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6241 SUIT_ViewManager* vman = NULL;
6242 if (viewIndex >= 0 && viewIndex < lst.count())
6243 vman = lst.at(viewIndex);
6245 if (paramNameStr == "Visibility")
6247 if (!aSmeshActor && displayer() && vman)
6249 SUIT_ViewModel* vmodel = vman->getViewModel();
6250 // SVTK view model can be casted to SALOME_View
6251 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6253 // store displayed actor in a temporary map for quicker
6254 // access later when restoring other parameters
6255 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6256 vtkRenderer* Renderer = vtkView->getRenderer();
6257 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6258 vtkActorCollection* theActors = aCopy.GetActors();
6259 theActors->InitTraversal();
6260 bool isFound = false;
6261 vtkActor *ac = theActors->GetNextActor();
6262 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6263 if (ac->IsA("SMESH_Actor")) {
6264 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6265 if (aGeomAc->hasIO()) {
6266 Handle(SALOME_InteractiveObject) io = aGeomAc->getIO();
6267 if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) {
6269 vtkActors.Bind(viewIndex, aGeomAc);
6275 } // if (paramNameStr == "Visibility")
6278 // the rest properties "work" with SMESH_Actor
6281 QString val ((*valuesIt).c_str());
6284 if (paramNameStr == "Representation") {
6285 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6288 else if (paramNameStr == "IsShrunk") {
6290 if (!aSmeshActor->IsShrunk())
6291 aSmeshActor->SetShrink();
6294 if (aSmeshActor->IsShrunk())
6295 aSmeshActor->UnShrink();
6298 // Displayed entities
6299 else if (paramNameStr == "Entities") {
6300 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6301 int aEntityMode = SMESH_Actor::eAllEntity;
6302 for ( int i = 0; i < mode.count(); i+=2 ) {
6303 if ( i < mode.count()-1 ) {
6304 QString type = mode[i];
6305 bool val = mode[i+1].toInt();
6306 if ( type == "e" && !val )
6307 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6308 else if ( type == "f" && !val )
6309 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6310 else if ( type == "v" && !val )
6311 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6312 else if ( type == "0d" && !val )
6313 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6314 else if ( type == "b" && !val )
6315 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6318 aSmeshActor->SetEntityMode( aEntityMode );
6321 else if (paramNameStr == "Colors") {
6322 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6329 QColor outlineColor;
6330 QColor orientationColor;
6336 // below lines are required to get default values for delta coefficients
6337 // of backface color for faces and color of reversed volumes
6338 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
6339 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6340 for ( int i = 0; i < colors.count(); i++ ) {
6341 QString type = colors[i];
6342 if ( type == "surface" ) {
6343 // face color is set by 3 values r:g:b, where
6344 // - r,g,b - is rgb color components
6345 if ( i+1 >= colors.count() ) break; // format error
6346 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6347 if ( i+2 >= colors.count() ) break; // format error
6348 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6349 if ( i+3 >= colors.count() ) break; // format error
6350 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6351 faceColor.setRgbF( r, g, b );
6354 else if ( type == "backsurface" ) {
6355 // backface color can be defined in several ways
6356 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6357 // - in latest versions, it is set as delta coefficient
6358 bool rgbOk = false, deltaOk;
6359 if ( i+1 >= colors.count() ) break; // format error
6360 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6361 int delta = colors[i+1].toInt( &deltaOk );
6363 if ( i+1 < colors.count() ) // index is shifted to 1
6364 g = colors[i+1].toDouble( &rgbOk );
6365 if ( rgbOk ) i++; // shift index
6366 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6367 b = colors[i+1].toDouble( &rgbOk );
6369 // - as currently there's no way to set directly backsurface color as it was before,
6370 // we ignore old dump where r,g,b triple was set
6371 // - also we check that delta parameter is set properly
6372 if ( !rgbOk && deltaOk )
6375 else if ( type == "volume" ) {
6376 // volume color is set by 4 values r:g:b:delta, where
6377 // - r,g,b - is a normal volume rgb color components
6378 // - delta - is a reversed volume color delta coefficient
6379 if ( i+1 >= colors.count() ) break; // format error
6380 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6381 if ( i+2 >= colors.count() ) break; // format error
6382 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6383 if ( i+3 >= colors.count() ) break; // format error
6384 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6385 if ( i+4 >= colors.count() ) break; // format error
6386 int delta = colors[i+4].toInt( &bOk );
6387 if ( !bOk ) break; // format error
6388 volumeColor.setRgbF( r, g, b );
6392 else if ( type == "edge" ) {
6393 // edge color is set by 3 values r:g:b, where
6394 // - r,g,b - is rgb color components
6395 if ( i+1 >= colors.count() ) break; // format error
6396 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6397 if ( i+2 >= colors.count() ) break; // format error
6398 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6399 if ( i+3 >= colors.count() ) break; // format error
6400 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6401 edgeColor.setRgbF( r, g, b );
6404 else if ( type == "node" ) {
6405 // node 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 nodeColor.setRgbF( r, g, b );
6416 else if ( type == "elem0d" ) {
6417 // 0d element 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 elem0dColor.setRgbF( r, g, b );
6428 else if ( type == "ball" ) {
6429 // ball 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 ballColor.setRgbF( r, g, b );
6440 else if ( type == "outline" ) {
6441 // outline 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 outlineColor.setRgbF( r, g, b );
6452 else if ( type == "orientation" ) {
6453 // orientation 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 orientationColor.setRgbF( r, g, b );
6466 if ( nodeColor.isValid() )
6467 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6469 if ( edgeColor.isValid() )
6470 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6472 if ( faceColor.isValid() )
6473 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6475 if ( volumeColor.isValid() )
6476 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6477 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6478 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6480 if ( elem0dColor.isValid() )
6481 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6483 if ( ballColor.isValid() )
6484 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6486 if ( outlineColor.isValid() )
6487 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6488 // orientation color
6489 if ( orientationColor.isValid() )
6490 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6493 else if (paramNameStr == "Sizes") {
6494 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6497 int outlineWidth = -1;
6498 int elem0dSize = -1;
6499 //int ballSize = -1;
6500 double ballDiameter = -1.0;
6501 double ballScale = -1.0;
6502 double shrinkSize = -1;
6503 double orientationSize = -1;
6504 bool orientation3d = false;
6505 for ( int i = 0; i < sizes.count(); i++ ) {
6506 QString type = sizes[i];
6507 if ( type == "line" ) {
6508 // line (wireframe) width is given as single integer value
6509 if ( i+1 >= sizes.count() ) break; // format error
6510 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6514 if ( type == "outline" ) {
6515 // outline width is given as single integer value
6516 if ( i+1 >= sizes.count() ) break; // format error
6517 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6521 else if ( type == "elem0d" ) {
6522 // 0d element size is given as single integer value
6523 if ( i+1 >= sizes.count() ) break; // format error
6524 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6528 else if ( type == "ball" ) {
6529 // balls are specified by two values: size:scale, where
6530 // - size - is a integer value specifying size
6531 // - scale - is a double value specifying scale factor
6532 if ( i+1 >= sizes.count() ) break; // format error
6533 //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6534 double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6535 if ( i+2 >= sizes.count() ) break; // format error
6536 double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6542 else if ( type == "shrink" ) {
6543 // shrink factor is given as single floating point value
6544 if ( i+1 >= sizes.count() ) break; // format error
6545 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6549 else if ( type == "orientation" ) {
6550 // orientation vectors are specified by two values size:3d, where
6551 // - size - is a floating point value specifying scale factor
6552 // - 3d - is a boolean
6553 if ( i+1 >= sizes.count() ) break; // format error
6554 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6555 if ( i+2 >= sizes.count() ) break; // format error
6556 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6557 orientationSize = v1;
6558 orientation3d = (bool)v2;
6562 // line (wireframe) width
6563 if ( lineWidth > 0 )
6564 aSmeshActor->SetLineWidth( lineWidth );
6566 if ( outlineWidth > 0 )
6567 aSmeshActor->SetOutlineWidth( outlineWidth );
6568 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6569 aSmeshActor->SetOutlineWidth( lineWidth );
6571 if ( elem0dSize > 0 )
6572 aSmeshActor->Set0DSize( elem0dSize );
6574 /*if ( ballSize > 0 )
6575 aSmeshActor->SetBallSize( ballSize );*/
6577 if ( ballDiameter > 0 )
6578 aSmeshActor->SetBallSize( ballDiameter );
6580 if ( ballScale > 0.0 )
6581 aSmeshActor->SetBallScale( ballScale );
6583 if ( shrinkSize > 0 )
6584 aSmeshActor->SetShrinkFactor( shrinkSize );
6585 // orientation vectors
6586 if ( orientationSize > 0 ) {
6587 aSmeshActor->SetFacesOrientationScale( orientationSize );
6588 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6592 else if (paramNameStr == "PointMarker") {
6593 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6594 if( data.count() >= 2 ) {
6596 int aParam1 = data[1].toInt( &ok );
6598 if( data[0] == "std" && data.count() == 3 ) {
6599 int aParam2 = data[2].toInt( &ok );
6600 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6602 else if( data[0] == "custom" ) {
6603 VTK::MarkerMap::const_iterator markerIt = aMarkerMap.find( aParam1 );
6604 if( markerIt != aMarkerMap.end() ) {
6605 VTK::MarkerData aMarkerData = markerIt->second;
6606 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6613 else if (paramNameStr == "Opacity") {
6614 aSmeshActor->SetOpacity(val.toFloat());
6617 else if (paramNameStr.startsWith("ClippingPlane")) {
6618 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6619 // old format - val looks like "Off" or "1:0:0:0.5:0:0"
6620 // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
6621 // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
6622 // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
6623 // new format - val looks like "Off" or "0" (plane id)
6624 // (note: in new format "Off" value is used only for consistency,
6625 // so it is processed together with values in old format)
6626 bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
6627 if( anIsOldFormat ) {
6628 if (paramNameStr == "ClippingPlane1" || val == "Off")
6629 aSmeshActor->RemoveAllClippingPlanes();
6631 QList<SUIT_ViewManager*> lst;
6632 getApp()->viewManagers(viewerTypStr, lst);
6633 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6634 if (viewIndex >= 0 && viewIndex < lst.count()) {
6635 SUIT_ViewManager* vman = lst.at(viewIndex);
6636 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6638 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6640 SMESH::TActorList anActorList;
6641 anActorList.push_back( aSmeshActor );
6642 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
6643 aPlane->myViewWindow = vtkView;
6644 SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
6645 aPlane->PlaneMode = aMode;
6646 bool isOpenGLClipping = ( bool )vals[1].toInt();
6647 aPlane->IsOpenGLClipping = isOpenGLClipping;
6648 if ( aMode == SMESH::Absolute ) {
6649 aPlane->myAbsoluteOrientation = vals[2].toInt();
6650 aPlane->X = vals[3].toFloat();
6651 aPlane->Y = vals[4].toFloat();
6652 aPlane->Z = vals[5].toFloat();
6653 aPlane->Dx = vals[6].toFloat();
6654 aPlane->Dy = vals[7].toFloat();
6655 aPlane->Dz = vals[8].toFloat();
6657 else if ( aMode == SMESH::Relative ) {
6658 aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
6659 aPlane->myDistance = vals[3].toFloat();
6660 aPlane->myAngle[0] = vals[4].toFloat();
6661 aPlane->myAngle[1] = vals[5].toFloat();
6665 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6666 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6667 aClippingPlaneInfo.Plane = aPlane;
6668 aClippingPlaneInfo.ActorList = anActorList;
6669 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6677 int aPlaneId = val.toInt( &ok );
6678 if( ok && aPlaneId >= 0 ) {
6679 bool anIsDefinedPlane = false;
6680 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6681 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6682 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6683 TPlaneInfo& aPlaneInfo = *anIter;
6684 if( aPlaneInfo.PlaneId == aPlaneId ) {
6685 aPlaneInfo.ActorList.push_back( aSmeshActor );
6686 anIsDefinedPlane = true;
6690 if( !anIsDefinedPlane ) {
6691 TPlaneInfo aPlaneInfo;
6692 aPlaneInfo.PlaneId = aPlaneId;
6693 aPlaneInfo.ActorList.push_back( aSmeshActor );
6694 aPlaneInfo.ViewManager = vman;
6696 // to make the list sorted by plane id
6697 anIter = aPlaneInfoList.begin();
6698 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6699 const TPlaneInfo& aPlaneInfoRef = *anIter;
6700 if( aPlaneInfoRef.PlaneId > aPlaneId )
6703 aPlaneInfoList.insert( anIter, aPlaneInfo );
6708 } // if (aSmeshActor)
6709 } // other parameters than Visibility
6711 } // for names/parameters iterator
6712 } // for entries iterator
6714 // take into account planes with empty list of actors referred to them
6715 QList<SUIT_ViewManager*> aVMList;
6716 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6718 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6719 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6720 int aViewId = aPlaneDataIter->first;
6721 if( aViewId >= 0 && aViewId < aVMList.count() ) {
6722 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6724 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6726 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6727 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6728 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6729 const TPlaneData& aPlaneData = *anIter2;
6730 int aPlaneId = aPlaneData.Id;
6732 bool anIsFound = false;
6733 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6734 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6735 const TPlaneInfo& aPlaneInfo = *anIter3;
6736 if( aPlaneInfo.PlaneId == aPlaneId ) {
6743 TPlaneInfo aPlaneInfo; // ActorList field is empty
6744 aPlaneInfo.PlaneId = aPlaneId;
6745 aPlaneInfo.ViewManager = aViewManager;
6747 // to make the list sorted by plane id
6748 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6749 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6750 const TPlaneInfo& aPlaneInfoRef = *anIter4;
6751 if( aPlaneInfoRef.PlaneId > aPlaneId )
6754 aPlaneInfoList.insert( anIter4, aPlaneInfo );
6760 // add clipping planes to actors according to the restored parameters
6761 // and update the clipping plane map
6762 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6763 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6764 int aViewId = anIter1->first;
6765 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6767 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6768 if( anIter2 == aPlaneDataMap.end() )
6770 const TPlaneDataList& aPlaneDataList = anIter2->second;
6772 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6773 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6774 const TPlaneInfo& aPlaneInfo = *anIter3;
6775 int aPlaneId = aPlaneInfo.PlaneId;
6776 const TActorList& anActorList = aPlaneInfo.ActorList;
6777 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6781 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6785 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6787 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6788 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6789 const TPlaneData& aPlaneData = *anIter4;
6790 if( aPlaneData.Id == aPlaneId ) {
6791 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
6792 aPlane->myViewWindow = aViewWindow;
6793 aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
6794 aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
6795 if ( aPlane->PlaneMode == SMESH::Absolute ) {
6796 aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
6797 aPlane->X = aPlaneData.X;
6798 aPlane->Y = aPlaneData.Y;
6799 aPlane->Z = aPlaneData.Z;
6800 aPlane->Dx = aPlaneData.Dx;
6801 aPlane->Dy = aPlaneData.Dy;
6802 aPlane->Dz = aPlaneData.Dz;
6804 else if ( aPlane->PlaneMode == SMESH::Relative ) {
6805 aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
6806 aPlane->myDistance = aPlaneData.Distance;
6807 aPlane->myAngle[0] = aPlaneData.Angle[0];
6808 aPlane->myAngle[1] = aPlaneData.Angle[1];
6811 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6812 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6813 aClippingPlaneInfo.Plane = aPlane;
6814 aClippingPlaneInfo.ActorList = anActorList;
6815 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6826 // update all VTK views
6827 QList<SUIT_ViewManager*> lst;
6828 getApp()->viewManagers(lst);
6829 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6830 SUIT_ViewModel* vmodel = (*it)->getViewModel();
6831 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6832 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6833 // set OpenGL clipping planes
6834 VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
6835 vtkActorCollection* anAllActors = aCopy.GetActors();
6836 anAllActors->InitTraversal();
6837 while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
6838 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
6839 anActor->SetOpenGLClippingPlane();
6841 vtkView->getRenderer()->ResetCameraClippingRange();
6848 \brief Adds preferences for dfont of VTK viewer
6850 \param pIf group identifier
6851 \param param parameter
6852 \return identifier of preferences
6854 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
6856 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6858 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6861 fam.append( tr( "SMESH_FONT_ARIAL" ) );
6862 fam.append( tr( "SMESH_FONT_COURIER" ) );
6863 fam.append( tr( "SMESH_FONT_TIMES" ) );
6865 setPreferenceProperty( tfont, "fonts", fam );
6867 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6868 if ( needSize ) f = f | QtxFontEdit::Size;
6869 setPreferenceProperty( tfont, "features", f );
6875 \brief Actions after hypothesis edition
6876 Updates object browser after hypothesis edition
6878 void SMESHGUI::onHypothesisEdit( int result )
6881 SMESHGUI::Modified();
6882 updateObjBrowser( true );
6886 \brief Actions after choosing menu of control modes
6887 Updates control mode actions according to current selection
6889 void SMESHGUI::onUpdateControlActions()
6891 SALOME_ListIO selected;
6892 if ( LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr() )
6893 aSel->selectedObjects( selected );
6895 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
6896 if ( selected.Extent() ) {
6897 if ( selected.First()->hasEntry() ) {
6898 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( selected.First()->getEntry() )) {
6899 aControl = anActor->GetControlMode();
6900 SALOME_ListIteratorOfListIO it(selected);
6901 for ( it.Next(); it.More(); it.Next() ) {
6902 Handle(SALOME_InteractiveObject) anIO = it.Value();
6903 if ( anIO->hasEntry() ) {
6904 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
6905 if ( aControl != anActor->GetControlMode() ) {
6906 aControl = SMESH_Actor::eNone;
6916 int anAction = ActionToControl( aControl, true );
6918 action( anAction )->setChecked( true );
6920 QMenu* send = (QMenu*)sender();
6921 QList<QAction*> actions = send->actions();
6922 for ( int i = 0; i < actions.size(); i++ )
6923 actions[i]->setChecked( false );
6929 \brief Signal handler closing(SUIT_ViewWindow*) of a view
6930 \param pview view being closed
6932 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
6933 #ifndef DISABLE_PLOT2DVIEWER
6934 //Crear all Plot2d Viewers if need.
6935 SMESH::ClearPlot2Viewers(pview);
6937 EmitSignalCloseView();
6940 void SMESHGUI::message( const QString& msg )
6943 QStringList data = msg.split("/");
6944 if ( data.count() > 0 ) {
6945 if ( data.first() == "mesh_loading" ) {
6947 QString entry = data.count() > 1 ? data[1] : QString();
6948 if ( entry.isEmpty() )
6951 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
6953 _PTR(SObject) obj = study->FindObjectID( entry.toLatin1().constData() );
6956 name = SMESH::fromUtf8(obj->GetName());
6957 if ( name.isEmpty() )
6960 if ( data.last() == "stop" )
6961 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
6963 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
6964 QApplication::processEvents();
6970 \brief Connects or disconnects signals about activating and cloning view on the module slots
6971 \param pview view which is connected/disconnected
6973 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
6977 SUIT_ViewManager* viewMgr = pview->getViewManager();
6979 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6980 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6982 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6983 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6988 \brief Return \c true if object can be renamed
6990 bool SMESHGUI::renameAllowed( const QString& entry) const {
6991 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6995 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6999 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
7004 if(appStudy->isComponent(entry) || obj->isReference())
7007 // check type to prevent renaming of inappropriate objects
7008 int aType = SMESHGUI_Selection::type(qPrintable(entry), SMESH::GetActiveStudyDocument());
7009 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7010 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7011 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7012 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7013 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
7020 Rename object by entry.
7021 \param entry entry of the object
7022 \param name new name of the object
7023 \brief Return \c true if rename operation finished successfully, \c false otherwise.
7025 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
7027 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7031 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7036 _PTR(Study) aStudy = appStudy->studyDS();
7041 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
7043 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
7048 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
7049 _PTR(GenericAttribute) anAttr;
7050 _PTR(AttributeName) aName;
7052 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
7054 // check type to prevent renaming of inappropriate objects
7055 int aType = SMESHGUI_Selection::type( qPrintable(entry), SMESH::GetActiveStudyDocument() );
7056 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7057 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7058 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7059 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7060 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
7061 if ( !name.isEmpty() ) {
7062 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
7064 // update name of group object and its actor
7065 Handle(SALOME_InteractiveObject) IObject =
7066 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
7068 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
7069 if( !aGroupObject->_is_nil() ) {
7070 aGroupObject->SetName( qPrintable(name) );
7071 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
7072 anActor->setName( qPrintable(name) );
7082 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
7084 static QList<QColor> colors;
7086 if ( colors.isEmpty() ) {
7088 for (int s = 0; s < 2 ; s++)
7090 for (int v = 100; v >= 40; v = v - 20)
7092 for (int h = 0; h < 359 ; h = h + 60)
7094 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
7099 static int currentColor = randomize( colors.size() );
7101 SALOMEDS::Color color;
7102 color.R = (double)colors[currentColor].red() / 255.0;
7103 color.G = (double)colors[currentColor].green() / 255.0;
7104 color.B = (double)colors[currentColor].blue() / 255.0;
7106 currentColor = (currentColor+1) % colors.count();