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