1 // Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
3 // Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
6 // This library is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU Lesser General Public
8 // License as published by the Free Software Foundation; either
9 // version 2.1 of the License, or (at your option) any later version.
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 // Lesser General Public License for more details.
16 // You should have received a copy of the GNU Lesser General Public
17 // License along with this library; if not, write to the Free Software
18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
22 // File : SMESHGUI.cxx
23 // Author : Nicolas REJNERI, Open CASCADE S.A.S.
25 #include <Standard_math.hxx> // E.A. must be included before Python.h to fix compilation on windows
27 #undef HAVE_FINITE // VSR: avoid compilation warning on Linux : "HAVE_FINITE" redefined
33 #include "SMESHGUI_Add0DElemsOnAllNodesDlg.h"
34 #include "SMESHGUI_AddMeshElementDlg.h"
35 #include "SMESHGUI_AddQuadraticElementDlg.h"
36 #include "SMESHGUI_BuildCompoundDlg.h"
37 #include "SMESHGUI_ClippingDlg.h"
38 #include "SMESHGUI_ComputeDlg.h"
39 #include "SMESHGUI_ConvToQuadOp.h"
40 #include "SMESHGUI_CopyMeshDlg.h"
41 #include "SMESHGUI_CreatePolyhedralVolumeDlg.h"
42 #include "SMESHGUI_DeleteGroupDlg.h"
43 #include "SMESHGUI_Displayer.h"
44 #include "SMESHGUI_DuplicateNodesDlg.h"
45 #include "SMESHGUI_ExtrusionAlongPathDlg.h"
46 #include "SMESHGUI_ExtrusionDlg.h"
47 #include "SMESHGUI_FieldSelectorWdg.h"
48 #include "SMESHGUI_FileInfoDlg.h"
49 #include "SMESHGUI_FileValidator.h"
50 #include "SMESHGUI_FilterDlg.h"
51 #include "SMESHGUI_FilterLibraryDlg.h"
52 #include "SMESHGUI_FindElemByPointDlg.h"
53 #include "SMESHGUI_GroupDlg.h"
54 #include "SMESHGUI_GroupOnShapeDlg.h"
55 #include "SMESHGUI_GroupOpDlg.h"
56 #include "SMESHGUI_Hypotheses.h"
57 #include "SMESHGUI_Make2DFrom3DOp.h"
58 #include "SMESHGUI_MakeNodeAtPointDlg.h"
59 #include "SMESHGUI_Measurements.h"
60 #include "SMESHGUI_MergeDlg.h"
61 #include "SMESHGUI_MeshInfo.h"
62 #include "SMESHGUI_MeshOp.h"
63 #include "SMESHGUI_MeshOrderOp.h"
64 #include "SMESHGUI_MeshPatternDlg.h"
65 #include "SMESHGUI_MultiEditDlg.h"
66 #include "SMESHGUI_NodesDlg.h"
67 #include "SMESHGUI_Operations.h"
68 #include "SMESHGUI_Preferences_ScalarBarDlg.h"
69 #include "SMESHGUI_PropertiesDlg.h"
70 #include "SMESHGUI_RemoveElementsDlg.h"
71 #include "SMESHGUI_RemoveNodesDlg.h"
72 #include "SMESHGUI_RenumberingDlg.h"
73 #include "SMESHGUI_ReorientFacesDlg.h"
74 #include "SMESHGUI_RevolutionDlg.h"
75 #include "SMESHGUI_RotationDlg.h"
76 #include "SMESHGUI_ScaleDlg.h"
77 #include "SMESHGUI_OffsetDlg.h"
78 #include "SMESHGUI_Selection.h"
79 #include "SMESHGUI_SewingDlg.h"
80 #include "SMESHGUI_SingleEditDlg.h"
81 #include "SMESHGUI_SmoothingDlg.h"
82 #include "SMESHGUI_SymmetryDlg.h"
83 #include "SMESHGUI_TranslationDlg.h"
84 #include "SMESHGUI_TransparencyDlg.h"
85 #include "SMESHGUI_DisplayEntitiesDlg.h"
86 #include "SMESHGUI_SplitBiQuad.h"
88 #include "SMESHGUI_FilterUtils.h"
89 #include "SMESHGUI_GEOMGenUtils.h"
90 #include "SMESHGUI_GroupUtils.h"
91 #include "SMESHGUI_HypothesesUtils.h"
92 #include "SMESHGUI_MeshUtils.h"
93 #include "SMESHGUI_PatternUtils.h"
94 #include "SMESHGUI_Utils.h"
95 #include "SMESHGUI_VTKUtils.h"
97 #include "SMESH_version.h"
99 #include "SMESH_ControlsDef.hxx"
100 #include "SMESH_Actor.h"
101 #include "SMESH_ActorUtils.h"
102 #include "SMESH_Client.hxx"
103 #include "SMESH_ScalarBarActor.h"
104 #include "SMESH_TypeFilter.hxx"
106 // SALOME GUI includes
107 #include <SalomeApp_Application.h>
108 #include <SalomeApp_CheckFileDlg.h>
109 #include <SalomeApp_DataObject.h>
110 #include <SalomeApp_Study.h>
111 #include <SalomeApp_Tools.h>
113 #include <LightApp_DataOwner.h>
114 #include <LightApp_NameDlg.h>
115 #include <LightApp_Preferences.h>
116 #include <LightApp_SelectionMgr.h>
117 #include <LightApp_UpdateFlags.h>
119 #include <SVTK_ViewManager.h>
120 #include <SVTK_ViewModel.h>
121 #include <SVTK_ViewWindow.h>
123 #include <VTKViewer_Algorithm.h>
125 #include <SUIT_Desktop.h>
126 #include <SUIT_FileDlg.h>
127 #include <SUIT_MessageBox.h>
128 #include <SUIT_OverrideCursor.h>
129 #include <SUIT_ResourceMgr.h>
130 #include <SUIT_Session.h>
132 #include <QtxPopupMgr.h>
133 #include <QtxFontEdit.h>
135 #include <SALOME_ListIO.hxx>
137 #ifndef DISABLE_PLOT2DVIEWER
138 #include <SPlot2d_ViewModel.h>
139 #include <SPlot2d_Histogram.h>
143 #include <SALOMEconfig.h>
144 #include CORBA_CLIENT_HEADER(SALOMEDS_Attributes)
145 #include CORBA_CLIENT_HEADER(SMESH_MeshEditor)
146 #include CORBA_CLIENT_HEADER(SMESH_Measurements)
147 #include CORBA_CLIENT_HEADER(SMESH_Mesh)
150 // #define INCLUDE_MENUITEM_DEF // VSR commented ????????
151 #include <QApplication>
153 #include <QTextStream>
158 #include <QDialogButtonBox>
161 #include <boost/shared_ptr.hpp>
164 #include <vtkCallbackCommand.h>
165 #include <vtkCamera.h>
166 #include <vtkLookupTable.h>
167 #include <vtkPlane.h>
168 #include <vtkRenderer.h>
170 // SALOME KERNEL includes
171 #include <SALOMEDSClient_ClientFactory.hxx>
172 #include <SALOMEDSClient_IParameters.hxx>
173 #include <SALOMEDSClient_SComponent.hxx>
174 #include <SALOMEDSClient_StudyBuilder.hxx>
175 #include <SALOMEDS_Study.hxx>
176 #include <SALOMEDS_SObject.hxx>
177 #include "utilities.h"
180 #include <Standard_ErrorHandler.hxx>
181 #include <NCollection_DataMap.hxx>
182 #include <NCollection_DoubleMap.hxx>
184 #include <Basics_Utils.hxx>
186 // Below macro, when uncommented, switches on simplified (more performant) algorithm
187 // of auto-color picking up
188 #define SIMPLE_AUTOCOLOR
193 //=============================================================
194 void ImportMeshesFromFile(SMESH::SMESH_Gen_ptr theComponentMesh,
197 void ExportMeshToFile(int theCommandID);
199 void SetDisplayMode(int theCommandID, VTK::MarkerMap& theMarkerMap);
201 void SetDisplayEntity(int theCommandID);
203 int ActionToControl( int theID, bool theReversed = false );
205 void Control( int theCommandID );
208 //================================================================================
210 * \brief Reads meshes from file
212 //================================================================================
214 void ImportMeshesFromFile( SMESH::SMESH_Gen_ptr theComponentMesh,
218 std::string myExtension;
220 if ( theCommandID == SMESHOp::OpImportMED ||
221 theCommandID == SMESHOp::OpPopupImportMED ) {
222 filter.append( QObject::tr( "MED_FILES_FILTER" ) + " (*.*med)" );
223 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
225 else if ( theCommandID == SMESHOp::OpImportUNV ||
226 theCommandID == SMESHOp::OpPopupImportUNV ) {
227 filter.append( QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)" );
229 else if ( theCommandID == SMESHOp::OpImportDAT ||
230 theCommandID == SMESHOp::OpPopupImportDAT ) {
231 filter.append( QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)" );
233 else if ( theCommandID == SMESHOp::OpImportSTL ||
234 theCommandID == SMESHOp::OpPopupImportSTL ) {
235 filter.append( QObject::tr( "STL_FILES_FILTER" ) + " (*.stl)" );
237 else if ( theCommandID == SMESHOp::OpImportCGNS ||
238 theCommandID == SMESHOp::OpPopupImportCGNS ) {
239 filter.append( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
241 else if ( theCommandID == SMESHOp::OpImportSAUV ||
242 theCommandID == SMESHOp::OpPopupImportSAUV ) {
243 filter.append( QObject::tr( "SAUV_FILES_FILTER" ) + " (*.sauv *.sauve)" );
244 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
246 else if ( theCommandID == SMESHOp::OpImportGMF ||
247 theCommandID == SMESHOp::OpPopupImportGMF ) {
248 filter.append( QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" );
249 filter.append( QObject::tr( "GMF_BINARY_FILES_FILTER") + " (*.meshb)" );
252 QString anInitialPath = "";
253 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
254 anInitialPath = QDir::currentPath();
256 QStringList filenames;
257 bool toCreateGroups = true;
259 // if ( theCommandID == SMESHOp::OpImportGMF ) { // GMF
260 // SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg
261 // ( SMESHGUI::desktop(), true, QObject::tr("SMESH_REQUIRED_GROUPS"), true, true );
262 // fd->setWindowTitle( QObject::tr( "SMESH_IMPORT_MESH" ) );
263 // fd->setNameFilters( filter );
264 // fd->SetChecked( true );
266 // filenames << fd->selectedFile();
267 // toCreateGroups = fd->IsChecked();
273 filenames = SUIT_FileDlg::getOpenFileNames( SMESHGUI::desktop(),
276 QObject::tr( "SMESH_IMPORT_MESH" ) );
278 if ( filenames.count() > 0 )
280 SUIT_OverrideCursor wc;
281 _PTR(Study) aStudy = SMESH::getStudy();
284 QStringList anEntryList;
285 bool isEmpty = false;
286 for ( QStringList::ConstIterator it = filenames.begin(); it != filenames.end(); ++it )
288 QString filename = *it;
289 SMESH::mesh_array_var aMeshes = new SMESH::mesh_array;
291 switch ( theCommandID ) {
292 case SMESHOp::OpImportDAT:
293 case SMESHOp::OpPopupImportDAT:
295 // DAT format (currently unsupported)
296 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
297 arg( QObject::tr( "SMESH_ERR_NOT_SUPPORTED_FORMAT" ) ) );
300 case SMESHOp::OpImportUNV:
301 case SMESHOp::OpPopupImportUNV:
304 aMeshes->length( 1 );
305 aMeshes[0] = theComponentMesh->CreateMeshesFromUNV( filename.toUtf8().constData() );
306 if ( aMeshes[0]->_is_nil() )
307 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
308 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
311 case SMESHOp::OpImportMED:
312 case SMESHOp::OpPopupImportMED:
315 SMESH::DriverMED_ReadStatus res;
316 aMeshes = theComponentMesh->CreateMeshesFromMED( filename.toUtf8().constData(), res );
317 if ( res != SMESH::DRS_OK ) {
318 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
319 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
323 case SMESHOp::OpImportSTL:
324 case SMESHOp::OpPopupImportSTL:
327 aMeshes->length( 1 );
328 aMeshes[0] = theComponentMesh->CreateMeshesFromSTL( filename.toUtf8().constData() );
329 if ( aMeshes[0]->_is_nil() ) {
330 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
331 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
335 case SMESHOp::OpImportCGNS:
336 case SMESHOp::OpPopupImportCGNS:
339 SMESH::DriverMED_ReadStatus res;
340 aMeshes = theComponentMesh->CreateMeshesFromCGNS( filename.toUtf8().constData(), res );
341 if ( res != SMESH::DRS_OK ) {
342 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
343 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
347 case SMESHOp::OpImportSAUV:
348 case SMESHOp::OpPopupImportSAUV:
351 SMESH::DriverMED_ReadStatus res;
352 aMeshes = theComponentMesh->CreateMeshesFromSAUV( filename.toUtf8().constData(), res );
353 if ( res != SMESH::DRS_OK ) {
354 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
355 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
359 case SMESHOp::OpImportGMF:
360 case SMESHOp::OpPopupImportGMF:
363 SMESH::ComputeError_var res;
364 aMeshes->length( 1 );
365 aMeshes[0] = theComponentMesh->CreateMeshesFromGMF( filename.toUtf8().constData(),
368 if ( res->code != SMESH::DRS_OK ) {
369 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
370 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res->code ).toLatin1().data() ) ) );
371 if ( strlen( res->comment.in() ) > 0 ) {
372 errors.back() += ": ";
373 errors.back() += res->comment.in();
380 catch ( const SALOME::SALOME_Exception& S_ex ) {
381 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
382 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
385 for ( int i = 0, iEnd = aMeshes->length(); i < iEnd; i++ )
387 _PTR(SObject) aMeshSO = SMESH::FindSObject( aMeshes[i] );
389 _PTR(StudyBuilder) aBuilder = aStudy->NewBuilder();
390 _PTR(AttributePixMap) aPixmap = aBuilder->FindOrCreateAttribute( aMeshSO, "AttributePixMap" );
391 aPixmap->SetPixMap( "ICON_SMESH_TREE_MESH_IMPORTED" );
392 if ( theCommandID == SMESHOp::OpImportUNV ) // mesh names aren't taken from the file for UNV import
393 SMESH::SetName( aMeshSO, QFileInfo(filename).fileName() );
395 anEntryList.append( aMeshSO->GetID().c_str() );
403 // update Object browser
404 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
406 // browse to the published meshes
407 if( LightApp_Application* anApp =
408 dynamic_cast<LightApp_Application*>( SUIT_Session::session()->activeApplication() ) )
409 anApp->browseObjects( anEntryList );
411 // show Error message box if there were errors
412 if ( errors.count() > 0 ) {
413 SUIT_MessageBox::critical( SMESHGUI::desktop(),
414 QObject::tr( "SMESH_ERROR" ),
415 QObject::tr( "SMESH_IMPORT_ERRORS" ) + "\n" + errors.join( "\n" ) );
418 // show warning message box, if some imported mesh is empty
420 SUIT_MessageBox::warning( SMESHGUI::desktop(),
421 QObject::tr( "SMESH_WRN_WARNING" ),
422 QObject::tr( "SMESH_DRS_SOME_EMPTY" ) );
427 //================================================================================
429 * \brief Export selected meshes or groups into a file
431 //================================================================================
433 void ExportMeshToFile( int theCommandID )
435 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
436 SALOME_ListIO selected;
438 aSel->selectedObjects( selected );
440 const bool isDAT = ( theCommandID == SMESHOp::OpExportDAT ||
441 theCommandID == SMESHOp::OpPopupExportDAT );
442 const bool isMED = ( theCommandID == SMESHOp::OpExportMED ||
443 theCommandID == SMESHOp::OpPopupExportMED );
444 const bool isUNV = ( theCommandID == SMESHOp::OpExportUNV ||
445 theCommandID == SMESHOp::OpPopupExportUNV );
446 const bool isSTL = ( theCommandID == SMESHOp::OpExportSTL ||
447 theCommandID == SMESHOp::OpPopupExportSTL );
448 const bool isCGNS= ( theCommandID == SMESHOp::OpExportCGNS ||
449 theCommandID == SMESHOp::OpPopupExportCGNS );
450 const bool isSAUV= ( theCommandID == SMESHOp::OpExportSAUV ||
451 theCommandID == SMESHOp::OpPopupExportSAUV );
452 const bool isGMF = ( theCommandID == SMESHOp::OpExportGMF ||
453 theCommandID == SMESHOp::OpPopupExportGMF );
455 const bool multiMeshSupported = ( isMED || isCGNS ); // file can hold several meshes
456 if ( selected.Extent() == 0 || ( selected.Extent() > 1 && !multiMeshSupported ))
458 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
459 bool aCheckWarn = true;
461 aCheckWarn = resMgr->booleanValue( "SMESH", "show_warning", false );
462 // get mesh object from selection and check duplication of their names
463 bool hasDuplicatedMeshNames = false;
464 QList< QPair< SMESH::SMESH_IDSource_var, QString > > aMeshList;
465 QList< QPair< SMESH::SMESH_IDSource_var, QString > >::iterator aMeshIter;
466 SALOME_ListIteratorOfListIO It( selected );
467 for( ; It.More(); It.Next() )
469 Handle(SALOME_InteractiveObject) anIObject = It.Value();
470 SMESH::SMESH_IDSource_var aMeshItem =
471 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIObject);
472 if ( aMeshItem->_is_nil() ) {
473 SUIT_MessageBox::warning( SMESHGUI::desktop(),
474 QObject::tr( "SMESH_WRN_WARNING" ),
475 QObject::tr( "SMESH_BAD_MESH_SELECTION" ));
478 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( aMeshItem );
479 if ( aCheckWarn && !aGroup->_is_nil() )
481 QMessageBox msgBox(SUIT_MessageBox::Warning,
482 QObject::tr("SMESH_WRN_WARNING"),
483 QObject::tr("SMESH_EXPORT_ONLY_GPOUP"),
484 QMessageBox::StandardButton::NoButton,
485 SMESHGUI::desktop());
486 QCheckBox dontShowCheckBox(QObject::tr("SMESH_WRN_SHOW_DLG_CHECKBOX"));
487 msgBox.addButton(QMessageBox::Ok);
488 msgBox.addButton(QMessageBox::Cancel);
489 msgBox.setDefaultButton(QMessageBox::Cancel);
490 QGridLayout* lt = qobject_cast<QGridLayout*>(msgBox.layout());
491 QDialogButtonBox* btnbox = msgBox.findChild<QDialogButtonBox*>();
492 lt->addWidget(&dontShowCheckBox, lt->rowCount(), lt->columnCount()-1, lt->rowCount(), lt->columnCount());
493 lt->addWidget(btnbox, lt->rowCount(), 0, lt->rowCount(), lt->columnCount());
494 if(msgBox.exec() == QMessageBox::Ok)
496 if(dontShowCheckBox.checkState() == Qt::Checked)
499 resMgr->setValue( "SMESH", "show_warning", false);
507 QString aMeshName = anIObject->getName();
509 // check for name duplications
510 if ( !hasDuplicatedMeshNames )
511 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
512 if( aMeshName == (*aMeshIter).second ) {
513 hasDuplicatedMeshNames = true;
518 aMeshList.append( QPair< SMESH::SMESH_IDSource_var, QString >( aMeshItem, aMeshName ) );
521 if( hasDuplicatedMeshNames && isMED ) {
522 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
523 QObject::tr("SMESH_WRN_WARNING"),
524 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_MESH_NAMES"),
525 QObject::tr("SMESH_BUT_YES"),
526 QObject::tr("SMESH_BUT_NO"), 0, 1);
531 aMeshIter = aMeshList.begin();
532 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
533 SMESH::SMESH_Mesh_var aMesh = aMeshOrGroup->GetMesh();
534 QString aMeshName = (*aMeshIter).second;
536 if ( isMED || isCGNS || isSAUV ) // formats where group names must be unique
538 // check for equal group names within each mesh
539 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
540 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
541 if ( !aMeshItem->_is_nil() && aMeshItem->HasDuplicatedGroupNamesMED()) {
542 int aRet = SUIT_MessageBox::warning
543 (SMESHGUI::desktop(),
544 QObject::tr("SMESH_WRN_WARNING"),
545 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_GRP").arg((*aMeshIter).second),
546 QObject::tr("SMESH_BUT_YES"),
547 QObject::tr("SMESH_BUT_NO"), 0, 1);
554 // Warn the user about presence of not supported elements
556 std::vector< SMESH::EntityType > notSupportedElemTypes, presentNotSupported;
560 notSupportedElemTypes.push_back( SMESH::Entity_0D );
561 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
566 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
567 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
568 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
569 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
570 notSupportedElemTypes.push_back( SMESH::Entity_Pyramid );
571 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
572 notSupportedElemTypes.push_back( SMESH::Entity_0D );
573 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
578 notSupportedElemTypes.push_back( SMESH::Entity_Edge );
579 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Edge );
580 notSupportedElemTypes.push_back( SMESH::Entity_0D );
581 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
586 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
591 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
592 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Triangle );
593 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Quadrangle );
594 notSupportedElemTypes.push_back( SMESH::Entity_TriQuad_Hexa );
595 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
596 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
597 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
598 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
603 notSupportedElemTypes.push_back( SMESH::Entity_0D );
604 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
605 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
606 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Pyramid );
607 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Penta );
608 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Penta );
609 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
610 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
611 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
612 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
614 if ( ! notSupportedElemTypes.empty() )
616 SMESH::long_array_var nbElems = aMeshOrGroup->GetMeshInfo();
617 for ( size_t iType = 0; iType < notSupportedElemTypes.size(); ++iType )
618 if ( nbElems[ notSupportedElemTypes[ iType ]] > 0 )
619 presentNotSupported.push_back( notSupportedElemTypes[ iType ]);
621 if ( !presentNotSupported.empty() )
624 const char* typeMsg[] = {
625 "SMESH_NODES", "SMESH_ELEMS0D","SMESH_EDGES","SMESH_QUADRATIC_EDGES",
626 "SMESH_TRIANGLES", "SMESH_QUADRATIC_TRIANGLES", "SMESH_BIQUADRATIC_TRIANGLES",
627 "SMESH_QUADRANGLES","SMESH_QUADRATIC_QUADRANGLES", "SMESH_BIQUADRATIC_QUADRANGLES",
628 "SMESH_POLYGONS","SMESH_QUADRATIC_POLYGONS",
629 "SMESH_TETRAHEDRA","SMESH_QUADRATIC_TETRAHEDRONS","SMESH_PYRAMIDS",
630 "SMESH_QUADRATIC_PYRAMIDS","SMESH_HEXAHEDRA","SMESH_QUADRATIC_HEXAHEDRONS",
631 "SMESH_TRIQUADRATIC_HEXAHEDRONS","SMESH_PENTAHEDRA","SMESH_QUADRATIC_PENTAHEDRONS",
632 "SMESH_BIQUADRATIC_PENTAHEDRONS",
633 "SMESH_OCTAHEDRA","SMESH_POLYEDRONS","SMESH_QUADRATIC_POLYEDRONS","SMESH_BALLS"
635 // is typeMsg complete? (compilation failure mains that enum SMDSAbs_EntityType changed)
636 const int nbTypes = sizeof( typeMsg ) / sizeof( const char* );
637 int _assert[( nbTypes == SMESH::Entity_Last ) ? 2 : -1 ]; _assert[0]=_assert[1]=0;
639 QString andStr = " " + QObject::tr("SMESH_AND") + " ", comma(", ");
640 for ( size_t iType = 0; iType < presentNotSupported.size(); ++iType ) {
641 typeNames += QObject::tr( typeMsg[ presentNotSupported[ iType ]]);
642 if ( iType != presentNotSupported.size() - 1 )
643 typeNames += ( iType == presentNotSupported.size() - 2 ) ? andStr : comma;
645 int aRet = SUIT_MessageBox::warning
646 (SMESHGUI::desktop(),
647 QObject::tr("SMESH_WRN_WARNING"),
648 QObject::tr("EXPORT_NOT_SUPPORTED").arg(aMeshName).arg(format).arg(typeNames),
649 QObject::tr("SMESH_BUT_YES"),
650 QObject::tr("SMESH_BUT_NO"), 0, 1);
655 // Get parameters of export operation
658 int aFormat =-1; // for MED minor versions
659 bool isOkToWrite = true; // to check MED file version compatibility before adding a mesh in an existing file
661 // Init the parameters with the default values
662 bool aIsASCII_STL = true;
663 bool toCreateGroups = false;
665 toCreateGroups = resMgr->booleanValue( "SMESH", "auto_groups", false );
666 bool toOverwrite = true;
667 bool toFindOutDim = true;
669 QString aFilter, aTitle = QObject::tr("SMESH_EXPORT_MESH");
670 QString anInitialPath = "";
671 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
672 anInitialPath = QDir::currentPath();
674 QList< QPair< GEOM::ListOfFields_var, QString > > aFieldList;
676 // Get a file name to write in and additional otions
677 if ( isUNV || isDAT || isGMF ) // Export w/o options
680 aFilter = QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)";
682 aFilter = QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)";
684 aFilter = QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" +
685 ";;" + QObject::tr( "GMF_BINARY_FILES_FILTER" ) + " (*.meshb)";
686 if ( anInitialPath.isEmpty() ) anInitialPath = SUIT_FileDlg::getLastVisitedPath();
687 aFilename = SUIT_FileDlg::getFileName(SMESHGUI::desktop(),
688 anInitialPath + QString("/") + aMeshName,
689 aFilter, aTitle, false);
691 else if ( isCGNS )// Export to CGNS
693 const char* theByTypeResource = "cgns_group_elems_by_type";
694 toCreateGroups = SMESHGUI::resourceMgr()->booleanValue( "SMESH", theByTypeResource, false );
696 QStringList checkBoxes;
697 checkBoxes << QObject::tr("CGNS_EXPORT_ELEMS_BY_TYPE");
699 SalomeApp_CheckFileDlg* fd =
700 new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true );
701 fd->setWindowTitle( aTitle );
702 fd->setNameFilter( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
703 if ( !anInitialPath.isEmpty() )
704 fd->setDirectory( anInitialPath );
705 fd->selectFile(aMeshName);
706 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
707 fd->setValidator( fv );
708 fd->SetChecked( toCreateGroups, 0 );
711 aFilename = fd->selectedFile();
712 toOverwrite = fv->isOverwrite(aFilename);
713 toCreateGroups = fd->IsChecked(0);
714 SMESHGUI::resourceMgr()->setValue("SMESH", theByTypeResource, toCreateGroups );
718 else if ( isSTL ) // Export to STL
720 QMap<QString, int> aFilterMap;
721 aFilterMap.insert( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)", 1 );
722 aFilterMap.insert( QObject::tr( "STL_BIN_FILES_FILTER" ) + " (*.stl)", 0 );
725 QMap<QString, int>::const_iterator it = aFilterMap.begin();
726 for ( ; it != aFilterMap.end(); ++it )
727 filters.push_back( it.key() );
729 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
730 fd->setWindowTitle( aTitle );
731 fd->setNameFilters( filters );
732 fd->selectNameFilter( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
733 if ( !anInitialPath.isEmpty() )
734 fd->setDirectory( anInitialPath );
735 fd->selectFile(aMeshName);
739 aFilename = fd->selectedFile();
740 aIsASCII_STL = (aFilterMap[fd->selectedNameFilter()]) == 1 ? true: false;
745 else if ( isMED || isSAUV ) // Export to MED or SAUV
747 QMap<QString, int> aFilterMap;
749 //filters << QObject::tr( "MED_FILES_FILTER" ) + " (*.med)";
750 QString vmed (aMesh->GetVersionString(-1, 2));
751 //MESSAGE("MED version: " << vmed.toStdString());
752 int minor = vmed.split(".").last().toInt();
753 //MESSAGE("MED version minor: "<< minor);
754 //minor +=3; // TODO remove: test multiple minor
755 aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( vmed ) + " (*.med)", minor );
756 for (int ii=0; ii<minor; ii++)
758 QString vs = aMesh->GetVersionString(ii, 2);
759 //std::ostringstream vss; // TODO remove: test multiple minor
760 //vss << "4."; // TODO remove: test multiple minor
761 //vss << ii; // TODO remove: test multiple minor
762 //vs = vss.str().c_str(); // TODO remove: test multiple minor
763 //MESSAGE("MED version: " << vs.toStdString());
764 aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( vs ) + " (*.med)", ii);
768 aFilterMap.insert("All files (*)", -1 );
769 aFilterMap.insert("SAUV files (*.sauv)", -1 );
770 aFilterMap.insert("SAUV files (*.sauve)", -1 );
774 QString aDefaultFilter;
775 QMap<QString, int>::const_iterator it = aFilterMap.begin();
776 for ( ; it != aFilterMap.end(); ++it ) {
777 filters.push_back( it.key() );
779 aDefaultFilter = it.key();
781 QStringList checkBoxes;
782 checkBoxes << QObject::tr("SMESH_AUTO_GROUPS") << QObject::tr("SMESH_AUTO_DIM");
784 SMESHGUI_FieldSelectorWdg* fieldSelWdg = new SMESHGUI_FieldSelectorWdg();
785 QList< QWidget* > wdgList;
786 if ( fieldSelWdg->GetAllFields( aMeshList, aFieldList ))
787 wdgList.append( fieldSelWdg );
789 SalomeApp_CheckFileDlg* fd =
790 new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true, wdgList );
791 fd->setWindowTitle( aTitle );
792 fd->setNameFilters( filters );
793 fd->SetChecked( toCreateGroups, 0 );
794 fd->SetChecked( toFindOutDim, 1 );
795 if ( !anInitialPath.isEmpty() )
796 fd->setDirectory( anInitialPath );
797 fd->selectFile(aMeshName);
800 QListView *lview = fd->findChild<QListView*>("listView");
802 lview->setMinimumHeight(200);
804 QTreeView *tview = fd->findChild<QTreeView*>("treeView");
806 tview->setMinimumHeight(200);
809 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
810 fd->setValidator( fv );
814 MESSAGE("******* Loop on file dialog ***********");
817 aFilename = fd->selectedFile();
819 aFilename = QString::null;
822 aFormat = aFilterMap[fd->selectedNameFilter()];
823 MESSAGE("selected minor: " << aFormat << " file: " << aFilename.toUtf8().constData());
824 toOverwrite = fv->isOverwrite(aFilename);
825 MESSAGE("toOverwrite:" << toOverwrite);
827 if ( !aFilename.isEmpty() ) {
829 // can't append to an existing using other format
830 bool isVersionOk = SMESHGUI::GetSMESHGen()->CheckWriteCompatibility( aFilename.toUtf8().constData() );
831 MESSAGE("Append check, isVersionOk:" << isVersionOk);
832 if ( !isVersionOk ) {
833 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
834 QObject::tr("SMESH_WRN_WARNING"),
835 QObject::tr("SMESH_EXPORT_MED_VERSION_COLLISION").arg(aFilename),
836 QObject::tr("SMESH_BUT_YES"),
837 QObject::tr("SMESH_BUT_NO"), 0, 1);
841 MESSAGE("incompatible MED file version for add, overwrite accepted");
847 MESSAGE("incompatible MED file version for add, overwrite refused");
850 QStringList aMeshNamesCollisionList;
851 SMESH::string_array_var aMeshNames = SMESHGUI::GetSMESHGen()->GetMeshNames( aFilename.toUtf8().constData() );
852 for( int i = 0, n = aMeshNames->length(); i < n; i++ ) {
853 QString anExistingMeshName( aMeshNames[ i ] );
854 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
855 QString anExportMeshName = (*aMeshIter).second;
856 if( anExportMeshName == anExistingMeshName ) {
857 aMeshNamesCollisionList.append( anExportMeshName );
862 if( !aMeshNamesCollisionList.isEmpty() ) {
864 QString aMeshNamesCollisionString = aMeshNamesCollisionList.join( ", " );
865 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
866 QObject::tr("SMESH_WRN_WARNING"),
867 QObject::tr("SMESH_EXPORT_MED_MESH_NAMES_COLLISION").arg(aMeshNamesCollisionString),
868 QObject::tr("SMESH_BUT_YES"),
869 QObject::tr("SMESH_BUT_NO"),
870 QObject::tr("SMESH_BUT_CANCEL"), 0, 2);
871 MESSAGE("answer collision name " << aRet);
882 MESSAGE(" ****** end of file dialog loop, toOverwrite:" << toOverwrite << " isOkToWrite:" << isOkToWrite);
883 toCreateGroups = fd->IsChecked(0);
884 toFindOutDim = fd->IsChecked(1);
885 fieldSelWdg->GetSelectedFields();
886 if ( !fieldSelWdg->parent() )
897 if ( !aFilename.isEmpty() ) {
898 // Check whether the file already exists and delete it if yes
899 QFile aFile( aFilename );
900 if ( aFile.exists() && toOverwrite )
902 SUIT_OverrideCursor wc;
905 // Renumbering is not needed since SMDS redesign in V6.2.0 (Nov 2010)
906 // bool Renumber = false;
907 // // PAL 14172 : Check of we have to renumber or not from the preferences before export
909 // Renumber= resMgr->booleanValue("renumbering");
911 // SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
912 // aMeshEditor->RenumberNodes();
913 // aMeshEditor->RenumberElements();
914 // if ( SMESHGUI::automaticUpdate() )
915 // SMESH::UpdateView();
917 if ( isMED && isOkToWrite)
919 MESSAGE("OK to write MED file "<< aFilename.toUtf8().constData());
920 aMeshIter = aMeshList.begin();
921 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
923 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
924 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
925 const GEOM::ListOfFields& fields = aFieldList[ aMeshIndex ].first.in();
926 const QString& geoAssFields = aFieldList[ aMeshIndex ].second;
927 const bool hasFields = ( fields.length() || !geoAssFields.isEmpty() );
928 if ( !hasFields && aMeshOrGroup->_is_equivalent( aMeshItem ))
929 aMeshItem->ExportMED( aFilename.toUtf8().data(), toCreateGroups, aFormat,
930 toOverwrite && aMeshIndex == 0, toFindOutDim );
932 aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups, aFormat,
933 toOverwrite && aMeshIndex == 0, toFindOutDim,
934 fields, geoAssFields.toLatin1().data() );
939 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ )
941 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
942 if( !aMeshItem->_is_nil() )
943 aMeshItem->ExportSAUV( aFilename.toUtf8().data(), toCreateGroups );
948 if ( aMeshOrGroup->_is_equivalent( aMesh ))
949 aMesh->ExportDAT( aFilename.toUtf8().data() );
951 aMesh->ExportPartToDAT( aMeshOrGroup, aFilename.toUtf8().data() );
955 if ( aMeshOrGroup->_is_equivalent( aMesh ))
956 aMesh->ExportUNV( aFilename.toUtf8().data() );
958 aMesh->ExportPartToUNV( aMeshOrGroup, aFilename.toUtf8().data() );
962 if ( aMeshOrGroup->_is_equivalent( aMesh ))
963 aMesh->ExportSTL( aFilename.toUtf8().data(), aIsASCII_STL );
965 aMesh->ExportPartToSTL( aMeshOrGroup, aFilename.toUtf8().data(), aIsASCII_STL );
969 aMeshIter = aMeshList.begin();
970 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
972 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
973 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
974 aMeshItem->ExportCGNS( aMeshOrGroup,
975 aFilename.toUtf8().data(),
976 toOverwrite && aMeshIndex == 0,
982 toCreateGroups = true;
983 aMesh->ExportGMF( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups );
986 catch (const SALOME::SALOME_Exception& S_ex){
988 SUIT_MessageBox::warning(SMESHGUI::desktop(),
989 QObject::tr("SMESH_WRN_WARNING"),
990 QObject::tr("SMESH_EXPORT_FAILED"));
996 inline void InverseEntityMode(unsigned int& theOutputMode,
997 unsigned int theMode)
999 bool anIsNotPresent = ~theOutputMode & theMode;
1001 theOutputMode |= theMode;
1003 theOutputMode &= ~theMode;
1006 void SetDisplayEntity(int theCommandID)
1008 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1009 SALOME_ListIO selected;
1011 aSel->selectedObjects( selected );
1013 if ( selected.Extent() >= 1 ) {
1014 SUIT_OverrideCursor wc;
1015 SALOME_ListIteratorOfListIO It( selected );
1016 for( ; It.More(); It.Next()){
1017 Handle(SALOME_InteractiveObject) IObject = It.Value();
1018 if(IObject->hasEntry()){
1019 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1020 unsigned int aMode = anActor->GetEntityMode();
1021 switch(theCommandID){
1022 case SMESHOp::OpDE0DElements: InverseEntityMode(aMode,SMESH_Actor::e0DElements); break;
1023 case SMESHOp::OpDEEdges: InverseEntityMode(aMode,SMESH_Actor::eEdges); break;
1024 case SMESHOp::OpDEFaces: InverseEntityMode(aMode,SMESH_Actor::eFaces); break;
1025 case SMESHOp::OpDEVolumes: InverseEntityMode(aMode,SMESH_Actor::eVolumes); break;
1026 case SMESHOp::OpDEBalls: InverseEntityMode(aMode,SMESH_Actor::eBallElem); break;
1027 case SMESHOp::OpDEAllEntity: aMode = SMESH_Actor::eAllEntity; break;
1030 anActor->SetEntityMode(aMode);
1039 SalomeApp_Application* app =
1040 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1044 LightApp_SelectionMgr* aSel = app->selectionMgr();
1045 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1046 if ( !aSel || !appStudy )
1049 SALOME_ListIO selected;
1050 aSel->selectedObjects( selected );
1051 if ( selected.IsEmpty() )
1054 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1056 _PTR(Study) aStudy = appStudy->studyDS();
1057 _PTR(SObject) aMainSObject = aStudy->FindObjectID( anIObject->getEntry() );
1058 SMESH::SMESH_Mesh_var aMainObject = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1059 if ( aMainObject->_is_nil() )
1062 SUIT_OverrideCursor wc;
1064 aMainObject->SetAutoColor( true ); // mesh groups are re-colored here
1066 QList<SALOMEDS::Color> aReservedColors;
1068 SMESH::ListOfGroups aListOfGroups = *aMainObject->GetGroups();
1069 for ( int i = 0, n = aListOfGroups.length(); i < n; i++ )
1071 SMESH::SMESH_GroupBase_var aGroupObject = aListOfGroups[i];
1073 #ifdef SIMPLE_AUTOCOLOR // simplified algorithm for auto-colors
1074 SALOMEDS::Color aColor = SMESHGUI::getPredefinedUniqueColor();
1075 #else // old algorithm for auto-colors
1076 SALOMEDS::Color aColor = SMESHGUI::getUniqueColor( aReservedColors );
1077 aReservedColors.append( aColor );
1078 #endif // SIMPLE_AUTOCOLOR
1079 aGroupObject->SetColor( aColor );
1081 _PTR(SObject) aGroupSObject = SMESH::FindSObject(aGroupObject);
1082 if ( aGroupSObject ) {
1085 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry(aGroupSObject->GetID().c_str())) {
1086 switch ( aGroupObject->GetType ()) {
1088 anActor->SetNodeColor( aColor.R, aColor.G, aColor.B ); break;
1090 anActor->SetEdgeColor( aColor.R, aColor.G, aColor.B ); break;
1092 anActor->Set0DColor( aColor.R, aColor.G, aColor.B ); break;
1094 anActor->SetBallColor( aColor.R, aColor.G, aColor.B ); break;
1096 SMESH::GetColor("SMESH", "volume_color", c, delta, "255,0,170|-100");
1097 anActor->SetVolumeColor( aColor.R, aColor.G, aColor.B, delta ); break;
1100 SMESH::GetColor("SMESH", "fill_color", c, delta, "0,170,255|-100");
1101 anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B, delta );
1107 SMESH::RepaintCurrentView();
1110 void OverallMeshQuality()
1112 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1113 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1114 SALOME_ListIO selected;
1116 aSel->selectedObjects( selected );
1118 if ( selected.IsEmpty() ) return;
1119 SALOME_ListIteratorOfListIO It( selected );
1120 for ( ; It.More(); It.Next() ) {
1121 SMESHGUI_CtrlInfoDlg* ctrlDlg = new SMESHGUI_CtrlInfoDlg( SMESHGUI::desktop() );
1122 ctrlDlg->showInfo( It.Value() );
1127 QString functorToString( SMESH::Controls::FunctorPtr f )
1129 QString type = QObject::tr( "UNKNOWN_CONTROL" );
1130 if ( dynamic_cast< SMESH::Controls::Volume* >( f.get() ) )
1131 type = QObject::tr( "VOLUME_3D_ELEMENTS" );
1132 else if ( dynamic_cast< SMESH::Controls::MaxElementLength2D* >( f.get() ) )
1133 type = QObject::tr( "MAX_ELEMENT_LENGTH_2D" );
1134 else if ( dynamic_cast< SMESH::Controls::MaxElementLength3D* >( f.get() ) )
1135 type = QObject::tr( "MAX_ELEMENT_LENGTH_3D" );
1136 else if ( dynamic_cast< SMESH::Controls::MinimumAngle* >( f.get() ) )
1137 type = QObject::tr( "MINIMUMANGLE_ELEMENTS" );
1138 else if ( dynamic_cast< SMESH::Controls::AspectRatio* >( f.get() ) )
1139 type = QObject::tr( "ASPECTRATIO_ELEMENTS" );
1140 else if ( dynamic_cast< SMESH::Controls::AspectRatio3D* >( f.get() ) )
1141 type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" );
1142 else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) )
1143 type = QObject::tr( "WARP_ELEMENTS" );
1144 else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) )
1145 type = QObject::tr( "TAPER_ELEMENTS" );
1146 else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) )
1147 type = QObject::tr( "SKEW_ELEMENTS" );
1148 else if ( dynamic_cast< SMESH::Controls::Area* >( f.get() ) )
1149 type = QObject::tr( "AREA_ELEMENTS" );
1150 else if ( dynamic_cast< SMESH::Controls::Length* >( f.get() ) )
1151 type = QObject::tr( "LENGTH_EDGES" );
1152 else if ( dynamic_cast< SMESH::Controls::Length2D* >( f.get() ) )
1153 type = QObject::tr( "LENGTH2D_EDGES" );
1154 else if ( dynamic_cast< SMESH::Controls::Deflection2D* >( f.get() ) )
1155 type = QObject::tr( "DEFLECTION2D_FACES" );
1156 else if ( dynamic_cast< SMESH::Controls::MultiConnection* >( f.get() ) )
1157 type = QObject::tr( "MULTI_BORDERS" );
1158 else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) )
1159 type = QObject::tr( "MULTI2D_BORDERS" );
1160 else if ( dynamic_cast< SMESH::Controls::FreeNodes* >( f.get() ) )
1161 type = QObject::tr( "FREE_NODES" );
1162 else if ( dynamic_cast< SMESH::Controls::FreeEdges* >( f.get() ) )
1163 type = QObject::tr( "FREE_EDGES" );
1164 else if ( dynamic_cast< SMESH::Controls::FreeBorders* >( f.get() ) )
1165 type = QObject::tr( "FREE_BORDERS" );
1166 else if ( dynamic_cast< SMESH::Controls::FreeFaces* >( f.get() ) )
1167 type = QObject::tr( "FREE_FACES" );
1168 else if ( dynamic_cast< SMESH::Controls::BareBorderVolume* >( f.get() ) )
1169 type = QObject::tr( "BARE_BORDER_VOLUME" );
1170 else if ( dynamic_cast< SMESH::Controls::BareBorderFace* >( f.get() ) )
1171 type = QObject::tr( "BARE_BORDER_FACE" );
1172 else if ( dynamic_cast< SMESH::Controls::OverConstrainedVolume* >( f.get() ) )
1173 type = QObject::tr( "OVER_CONSTRAINED_VOLUME" );
1174 else if ( dynamic_cast< SMESH::Controls::OverConstrainedFace* >( f.get() ) )
1175 type = QObject::tr( "OVER_CONSTRAINED_FACE" );
1176 else if ( dynamic_cast< SMESH::Controls::CoincidentNodes* >( f.get() ) )
1177 type = QObject::tr( "EQUAL_NODE" );
1178 else if ( dynamic_cast< SMESH::Controls::CoincidentElements1D* >( f.get() ) )
1179 type = QObject::tr( "EQUAL_EDGE" );
1180 else if ( dynamic_cast< SMESH::Controls::CoincidentElements2D* >( f.get() ) )
1181 type = QObject::tr( "EQUAL_FACE" );
1182 else if ( dynamic_cast< SMESH::Controls::CoincidentElements3D* >( f.get() ) )
1183 type = QObject::tr( "EQUAL_VOLUME" );
1184 else if ( dynamic_cast< SMESH::Controls::NodeConnectivityNumber* >( f.get() ) )
1185 type = QObject::tr( "NODE_CONNECTIVITY_NB" );
1189 void SaveDistribution()
1191 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1192 SALOME_ListIO selected;
1194 aSel->selectedObjects( selected );
1196 if ( selected.Extent() == 1 ) {
1197 Handle(SALOME_InteractiveObject) anIO = selected.First();
1198 if ( anIO->hasEntry() ) {
1199 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1201 anActor->GetScalarBarActor() &&
1202 anActor->GetControlMode() != SMESH_Actor::eNone )
1204 SMESH_ScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor();
1205 SMESH::Controls::FunctorPtr aFunctor = anActor->GetFunctor();
1206 if ( aScalarBarActor && aFunctor ) {
1207 SMESH::Controls::NumericalFunctor* aNumFun =
1208 dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
1210 std::vector<int> elements;
1211 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
1212 if ( mesh->_is_nil() ) {
1213 SMESH::SMESH_IDSource_var idSource =
1214 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
1215 if ( !idSource->_is_nil() )
1217 SMESH::long_array_var ids = idSource->GetIDs();
1218 elements.resize( ids->length() );
1219 for ( unsigned i = 0; i < elements.size(); ++i )
1220 elements[i] = ids[i];
1223 int nbIntervals = aScalarBarActor->GetMaximumNumberOfColors();
1224 vtkLookupTable* lookupTable =
1225 static_cast<vtkLookupTable*>(aScalarBarActor->GetLookupTable());
1226 double * minmax = lookupTable->GetRange();
1227 bool isLogarithmic = lookupTable->GetScale() == VTK_SCALE_LOG10;
1228 std::vector<int> nbEvents;
1229 std::vector<double> funValues;
1230 aNumFun->GetHistogram( nbIntervals, nbEvents, funValues,
1231 elements, minmax, isLogarithmic );
1232 QString anInitialPath = "";
1233 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
1234 anInitialPath = QDir::currentPath();
1235 QString aMeshName = anIO->getName();
1237 filter.append( QObject::tr( "TEXT_FILES_FILTER" ) + " (*.txt)" );
1238 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
1239 QString aFilename = anInitialPath + "/" + aMeshName + "_" +
1240 functorToString( aFunctor ).toLower().simplified().replace( QRegExp( " |-" ), "_" ) + ".txt";
1241 aFilename = SUIT_FileDlg::getFileName( SMESHGUI::desktop(),
1244 QObject::tr( "SMESH_SAVE_DISTRIBUTION" ),
1246 if ( !aFilename.isEmpty() ) {
1247 QFile f( aFilename );
1248 if ( f.open( QFile::WriteOnly | QFile::Truncate ) ) {
1249 QTextStream out( &f );
1250 out << "# Mesh: " << aMeshName << endl;
1251 out << "# Control: " << functorToString( aFunctor ) << endl;
1253 out.setFieldWidth( 10 );
1254 for ( int i = 0; i < (int)qMin( nbEvents.size(), funValues.size()-1 ); i++ )
1255 out << funValues[i] << "\t" << funValues[i+1] << "\t" << nbEvents[i] << endl;
1266 void ShowElement( int theCommandID )
1268 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1269 SALOME_ListIO selected;
1271 aSel->selectedObjects( selected );
1273 if ( selected.Extent() == 1 ) {
1274 Handle(SALOME_InteractiveObject) anIO = selected.First();
1275 if ( anIO->hasEntry() ) {
1276 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1278 anActor->GetScalarBarActor() &&
1279 anActor->GetControlMode() != SMESH_Actor::eNone )
1281 SMESH_ScalarBarActor *aScalarBarActor = anActor->GetScalarBarActor();
1282 if ( theCommandID == SMESHOp::OpShowDistribution ) {
1283 aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility());
1285 else if ( theCommandID == SMESHOp::OpShowScalarBar ) {
1286 aScalarBarActor->SetVisibility( !aScalarBarActor->GetVisibility());
1293 #ifndef DISABLE_PLOT2DVIEWER
1294 void PlotDistribution()
1296 SalomeApp_Application* app =
1297 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1301 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1302 SALOME_ListIO selected;
1304 aSel->selectedObjects( selected );
1306 if ( selected.Extent() == 1 ) {
1307 Handle(SALOME_InteractiveObject) anIO = selected.First();
1308 if ( anIO->hasEntry() ) {
1309 //Find Actor by entry before getting Plot2d viewer,
1310 //because after call getViewManager( Plot2d_Viewer::Type(), true ) active window is Plot2d Viewer
1311 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1313 SUIT_ViewManager* aViewManager =
1314 app->getViewManager( Plot2d_Viewer::Type(), true ); // create if necessary
1318 SPlot2d_Viewer* aView = dynamic_cast<SPlot2d_Viewer*>(aViewManager->getViewModel());
1322 Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
1326 if ( anActor && anActor->GetControlMode() != SMESH_Actor::eNone )
1328 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1329 QString functorName = functorToString( anActor->GetFunctor());
1330 QString aHistogramName("%1 : %2");
1331 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1332 aHistogram->setName(aHistogramName);
1333 aHistogram->setHorTitle(functorName);
1334 aHistogram->setVerTitle(QObject::tr("DISTRIBUTION_NB_ENT"));
1335 aPlot->displayObject(aHistogram, true);
1340 #endif //DISABLE_PLOT2DVIEWER
1342 void DisableAutoColor()
1344 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1345 SALOME_ListIO selected;
1347 aSel->selectedObjects( selected );
1349 if ( selected.Extent() ) {
1350 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1351 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1352 if ( !aMesh->_is_nil() ) {
1353 aMesh->SetAutoColor( false );
1360 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1361 SALOME_ListIO selected;
1363 aSel->selectedObjects( selected );
1364 if ( selected.Extent() )
1366 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1367 _PTR(Study) aStudy = SMESH::getStudy();
1368 _PTR(SObject) aSObj = aStudy->FindObjectID(anIObject->getEntry());
1370 if ( aStudy->GetUseCaseBuilder()->SortChildren( aSObj, true/*AscendingOrder*/ ) ) {
1371 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1378 void SetDisplayMode(int theCommandID, VTK::MarkerMap& theMarkerMap)
1380 SALOME_ListIO selected;
1381 SalomeApp_Application* app =
1382 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1386 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1387 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1388 if ( !aSel || !appStudy )
1391 if ( theCommandID == SMESHOp::OpClipping ) { // Clipping dialog can be activated without selection
1392 if ( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
1393 aModule->EmitSignalDeactivateDialog();
1394 if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
1395 (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
1400 aSel->selectedObjects( selected );
1402 if ( selected.Extent() >= 1 )
1404 switch ( theCommandID ) {
1405 case SMESHOp::OpTransparency:
1407 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1408 (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
1411 case SMESHOp::OpProperties:
1414 QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
1415 QColor orientationColor, outlineColor, volumeColor;
1416 int deltaF = 0, deltaV = 0;
1419 double ballScale = 1.0;
1421 int outlineWidth = 1;
1422 double shrinkCoef = 0.0;
1423 double orientationScale = 0.0;
1424 bool orientation3d = false;
1425 VTK::MarkerType markerType = VTK::MT_NONE;
1426 VTK::MarkerScale markerScale = VTK::MS_NONE;
1428 bool hasNodes = false;
1429 int presentEntities = 0;
1430 bool firstTime = true;
1432 SALOME_ListIteratorOfListIO It( selected );
1433 for ( ; It.More(); It.Next() ) {
1434 Handle(SALOME_InteractiveObject) IObject = It.Value();
1435 if ( !IObject->hasEntry() ) continue;
1436 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1437 if ( !anActor || !anActor->GetObject() ) continue;
1440 // nodes: color, marker
1441 anActor->GetNodeColor( color[0], color[1], color[2] );
1442 nodeColor.setRgbF( color[0], color[1], color[2] );
1443 markerType = anActor->GetMarkerType();
1444 markerScale = anActor->GetMarkerScale();
1445 markerId = anActor->GetMarkerTexture();
1446 // edges: color, width
1447 anActor->GetEdgeColor( color[0], color[1], color[2] );
1448 edgeColor.setRgbF( color[0], color[1], color[2] );
1449 edgeWidth = qMax( (int)anActor->GetLineWidth(), 1 ); // minimum allowed width is 1
1450 // faces: front color, back color (delta)
1451 anActor->GetSufaceColor( color[0], color[1], color[2], deltaF );
1452 faceColor.setRgbF( color[0], color[1], color[2] );
1453 // faces: front color, back color (delta)
1454 anActor->GetVolumeColor( color[0], color[1], color[2], deltaV );
1455 volumeColor.setRgbF( color[0], color[1], color[2] );
1456 // 0d elements: color, size
1457 anActor->Get0DColor( color[0], color[1], color[2] );
1458 elem0dColor.setRgbF( color[0], color[1], color[2] );
1459 elem0dSize = qMax( (int)anActor->Get0DSize(), 1 ); // minimum allowed size is 1
1460 // balls: color, size
1461 anActor->GetBallColor( color[0], color[1], color[2] );
1462 ballColor.setRgbF( color[0], color[1], color[2] );
1463 //ballSize = qMax( (int)anActor->GetBallSize(), 1 ); // minimum allowed size is 1
1464 ballScale = qMax( (double)anActor->GetBallScale(), 1e-2 ); // minimum allowed scale is 1e-2
1466 anActor->GetOutlineColor( color[0], color[1], color[2] );
1467 outlineColor.setRgbF( color[0], color[1], color[2] );
1468 outlineWidth = qMax( (int)anActor->GetOutlineWidth(), 1 ); // minimum allowed width is 1
1469 // orientation vectors: color, scale, 3d flag
1470 anActor->GetFacesOrientationColor( color[0], color[1], color[2] );
1471 orientationColor.setRgbF( color[0], color[1], color[2] );
1472 orientationScale = anActor->GetFacesOrientationScale();
1473 orientation3d = anActor->GetFacesOrientation3DVectors();
1475 shrinkCoef = anActor->GetShrinkFactor();
1478 firstTime = false; // we only take properties from first object (for performance reasons)
1481 hasNodes = anActor->GetObject()->GetNbEntities( SMDSAbs_Node );
1482 if ( !(presentEntities & SMESH_Actor::eEdges) && anActor->GetObject()->GetNbEntities( SMDSAbs_Edge ) )
1483 presentEntities = presentEntities | SMESH_Actor::eEdges;
1484 if ( !(presentEntities & SMESH_Actor::eFaces) && anActor->GetObject()->GetNbEntities( SMDSAbs_Face ) )
1485 presentEntities = presentEntities | SMESH_Actor::eFaces;
1486 if ( !(presentEntities & SMESH_Actor::eVolumes) && anActor->GetObject()->GetNbEntities( SMDSAbs_Volume ) )
1487 presentEntities = presentEntities | SMESH_Actor::eVolumes;
1488 if ( !(presentEntities & SMESH_Actor::e0DElements) && anActor->GetObject()->GetNbEntities( SMDSAbs_0DElement ) )
1489 presentEntities = presentEntities | SMESH_Actor::e0DElements;
1490 if ( !(presentEntities & SMESH_Actor::eBallElem) && anActor->GetObject()->GetNbEntities( SMDSAbs_Ball ) )
1491 presentEntities = presentEntities | SMESH_Actor::eBallElem;
1493 // as we know that all types of elements are present, we can exit the loop
1494 if ( presentEntities == SMESH_Actor::eAllEntity )
1498 SMESHGUI_PropertiesDlg dlg( theMarkerMap, SMESHGUI::desktop() );
1499 // nodes: color, marker
1500 dlg.setNodeColor( nodeColor );
1501 if( markerType != VTK::MT_USER )
1502 dlg.setNodeMarker( markerType, markerScale );
1504 dlg.setNodeCustomMarker( markerId );
1505 // edges: color, line width
1506 dlg.setEdgeColor( edgeColor );
1507 dlg.setEdgeWidth( edgeWidth );
1508 // faces: front color, back color
1509 dlg.setFaceColor( faceColor, deltaF );
1510 // volumes: normal color, reversed color
1511 dlg.setVolumeColor( volumeColor, deltaV );
1512 // outlines: color, line width
1513 dlg.setOutlineColor( outlineColor );
1514 dlg.setOutlineWidth( outlineWidth );
1515 // 0d elements: color, size
1516 dlg.setElem0dColor( elem0dColor );
1517 dlg.setElem0dSize( elem0dSize );
1518 // balls: color, size
1519 dlg.setBallColor( ballColor );
1520 //dlg.setBallSize( ballSize );
1521 dlg.setBallScale( ballScale );
1522 // orientation: color, scale, 3d flag
1523 dlg.setOrientationColor( orientationColor );
1524 dlg.setOrientationSize( int( orientationScale * 100. ) );
1525 dlg.setOrientation3d( orientation3d );
1526 // shrink: scale factor
1527 dlg.setShrinkCoef( int( shrinkCoef * 100. ) );
1528 // hide unused controls
1529 dlg.showControls( presentEntities, hasNodes );
1532 nodeColor = dlg.nodeColor();
1533 markerType = dlg.nodeMarkerType();
1534 markerScale = dlg.nodeMarkerScale();
1535 markerId = dlg.nodeMarkerId();
1536 edgeColor = dlg.edgeColor();
1537 edgeWidth = dlg.edgeWidth();
1538 faceColor = dlg.faceColor();
1539 deltaF = dlg.faceColorDelta();
1540 volumeColor = dlg.volumeColor();
1541 deltaV = dlg.volumeColorDelta();
1542 outlineColor = dlg.outlineColor();
1543 outlineWidth = dlg.outlineWidth();
1544 elem0dColor = dlg.elem0dColor();
1545 elem0dSize = dlg.elem0dSize();
1546 ballColor = dlg.ballColor();
1547 // ballSize = dlg.ballSize();
1548 ballScale = dlg.ballScale();
1549 orientationColor = dlg.orientationColor();
1550 orientationScale = dlg.orientationSize() / 100.;
1551 orientation3d = dlg.orientation3d();
1552 shrinkCoef = dlg.shrinkCoef() / 100.;
1554 // store point markers that might be changed by the user
1555 theMarkerMap = dlg.customMarkers();
1557 // set properties from dialog box to the presentations
1558 SALOME_ListIteratorOfListIO It( selected );
1559 for ( ; It.More(); It.Next() ) {
1560 Handle(SALOME_InteractiveObject) IObject = It.Value();
1561 if ( !IObject->hasEntry() ) continue;
1562 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1563 if ( !anActor ) continue;
1565 // nodes: color, marker
1566 anActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
1567 if ( markerType != VTK::MT_USER ) {
1568 anActor->SetMarkerStd( markerType, markerScale );
1571 VTK::MarkerMap::const_iterator iter = theMarkerMap.find( markerId );
1572 if ( iter != theMarkerMap.end() )
1573 anActor->SetMarkerTexture( markerId, iter->second.second );
1575 // volumes: normal color, reversed color (delta)
1576 anActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
1577 // faces: front color, back color (delta)
1578 anActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
1579 // edges: color, width
1580 anActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
1581 anActor->SetLineWidth( edgeWidth );
1583 anActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
1584 anActor->SetOutlineWidth( outlineWidth );
1585 // 0D elements: color, size
1586 anActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
1587 anActor->Set0DSize( elem0dSize );
1588 // balls: color, size
1589 anActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
1590 // anActor->SetBallSize( ballSize );
1591 anActor->SetBallScale( ballScale );
1592 // orientation: color, scale, 3d flag
1593 anActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
1594 anActor->SetFacesOrientationScale( orientationScale );
1595 anActor->SetFacesOrientation3DVectors( orientation3d );
1597 anActor->SetShrinkFactor( shrinkCoef );
1599 // for groups, set also proper color
1600 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1601 if ( !aGroupObject->_is_nil() ) {
1602 SMESH::ElementType anElementType = aGroupObject->GetType();
1604 switch( anElementType ) {
1606 aColor = nodeColor; break;
1608 aColor = edgeColor; break;
1610 aColor = faceColor; break;
1612 aColor = volumeColor; break;
1614 aColor = elem0dColor; break;
1616 aColor = ballColor; break;
1620 if ( aColor.isValid() ) {
1621 SALOMEDS::Color aGroupColor;
1622 aGroupColor.R = aColor.redF();
1623 aGroupColor.G = aColor.greenF();
1624 aGroupColor.B = aColor.blueF();
1625 aGroupObject->SetColor( aGroupColor );
1627 } // if ( !aGroupObject->_is_nil() )
1628 } // for ( ; It.More(); It.Next() )
1629 SMESH::RepaintCurrentView();
1630 } // if ( dlg.exec() )
1632 } // case SMESHOp::OpProperties:
1633 } // switch(theCommandID)
1634 SUIT_OverrideCursor wc;
1635 SALOME_ListIteratorOfListIO It( selected );
1636 for( ; It.More(); It.Next()){
1637 Handle(SALOME_InteractiveObject) IObject = It.Value();
1638 if(IObject->hasEntry()){
1639 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1640 switch(theCommandID){
1641 case SMESHOp::OpDMWireframe:
1642 anActor->SetRepresentation(SMESH_Actor::eEdge);
1644 case SMESHOp::OpDMShading:
1645 anActor->SetRepresentation(SMESH_Actor::eSurface);
1647 case SMESHOp::OpDMShrink:
1648 if(anActor->IsShrunk())
1649 anActor->UnShrink();
1651 anActor->SetShrink();
1653 case SMESHOp::OpDMNodes:
1654 anActor->SetRepresentation(SMESH_Actor::ePoint);
1656 case SMESHOp::OpRepresentationLines:
1657 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1658 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1660 case SMESHOp::OpRepresentationArcs:
1661 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1662 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1668 SMESH::RepaintCurrentView();
1672 int ActionToControl( int theID, bool theReversed )
1674 NCollection_DoubleMap<int,int> ActionControl;
1675 ActionControl.Bind( 0, SMESH_Actor::eNone );
1676 ActionControl.Bind( SMESHOp::OpFreeNode, SMESH_Actor::eFreeNodes );
1677 ActionControl.Bind( SMESHOp::OpEqualNode, SMESH_Actor::eCoincidentNodes );
1678 ActionControl.Bind( SMESHOp::OpNodeConnectivityNb, SMESH_Actor::eNodeConnectivityNb );
1679 ActionControl.Bind( SMESHOp::OpFreeEdge, SMESH_Actor::eFreeEdges );
1680 ActionControl.Bind( SMESHOp::OpFreeBorder, SMESH_Actor::eFreeBorders );
1681 ActionControl.Bind( SMESHOp::OpLength, SMESH_Actor::eLength );
1682 ActionControl.Bind( SMESHOp::OpConnection, SMESH_Actor::eMultiConnection );
1683 ActionControl.Bind( SMESHOp::OpEqualEdge, SMESH_Actor::eCoincidentElems1D );
1684 ActionControl.Bind( SMESHOp::OpFreeFace, SMESH_Actor::eFreeFaces );
1685 ActionControl.Bind( SMESHOp::OpBareBorderFace, SMESH_Actor::eBareBorderFace );
1686 ActionControl.Bind( SMESHOp::OpOverConstrainedFace, SMESH_Actor::eOverConstrainedFace );
1687 ActionControl.Bind( SMESHOp::OpLength2D, SMESH_Actor::eLength2D );
1688 ActionControl.Bind( SMESHOp::OpDeflection2D, SMESH_Actor::eDeflection2D );
1689 ActionControl.Bind( SMESHOp::OpConnection2D, SMESH_Actor::eMultiConnection2D );
1690 ActionControl.Bind( SMESHOp::OpArea, SMESH_Actor::eArea );
1691 ActionControl.Bind( SMESHOp::OpTaper, SMESH_Actor::eTaper );
1692 ActionControl.Bind( SMESHOp::OpAspectRatio, SMESH_Actor::eAspectRatio );
1693 ActionControl.Bind( SMESHOp::OpMinimumAngle, SMESH_Actor::eMinimumAngle );
1694 ActionControl.Bind( SMESHOp::OpWarpingAngle, SMESH_Actor::eWarping );
1695 ActionControl.Bind( SMESHOp::OpSkew, SMESH_Actor::eSkew );
1696 ActionControl.Bind( SMESHOp::OpMaxElementLength2D, SMESH_Actor::eMaxElementLength2D );
1697 ActionControl.Bind( SMESHOp::OpEqualFace, SMESH_Actor::eCoincidentElems2D );
1698 ActionControl.Bind( SMESHOp::OpAspectRatio3D, SMESH_Actor::eAspectRatio3D );
1699 ActionControl.Bind( SMESHOp::OpVolume, SMESH_Actor::eVolume3D );
1700 ActionControl.Bind( SMESHOp::OpMaxElementLength3D, SMESH_Actor::eMaxElementLength3D );
1701 ActionControl.Bind( SMESHOp::OpBareBorderVolume, SMESH_Actor::eBareBorderVolume );
1702 ActionControl.Bind( SMESHOp::OpOverConstrainedVolume, SMESH_Actor::eOverConstrainedVolume );
1703 ActionControl.Bind( SMESHOp::OpEqualVolume, SMESH_Actor::eCoincidentElems3D );
1706 return ActionControl.IsBound2( theID ) ? ActionControl.Find2( theID ) : 0;
1707 return ActionControl.IsBound1( theID ) ? ActionControl.Find1( theID ) : 0;
1710 void Control( int theCommandID )
1712 SMESH_Actor::eControl aControl = SMESH_Actor::eControl( ActionToControl( theCommandID ));
1713 _PTR(Study) aStudy = SMESH::getStudy();
1715 SALOME_ListIO selected;
1716 if ( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
1717 aSel->selectedObjects( selected );
1719 if ( !selected.IsEmpty() ) {
1720 SALOME_ListIteratorOfListIO It(selected);
1721 for ( ; It.More(); It.Next())
1723 Handle(SALOME_InteractiveObject) anIO = It.Value();
1724 if ( !anIO.IsNull() ) {
1725 _PTR(SObject) SO = aStudy->FindObjectID( It.Value()->getEntry() );
1727 CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
1728 SMESH::SMESH_IDSource_var anIDSrc = SMESH::SMESH_IDSource::_narrow( aObject );
1729 if ( !anIDSrc->_is_nil() ) {
1730 SMESH_Actor *anActor = SMESH::FindActorByEntry( anIO->getEntry());
1731 if (( !anActor && selected.Extent() == 1 ) &&
1732 ( anActor = SMESH::CreateActor( anIO->getEntry() )))
1734 anActor->SetControlMode( aControl );
1735 SMESH::DisplayActor( SMESH::GetCurrentVtkView(), anActor );
1736 SMESH::UpdateView ( SMESH::eDisplay, anIO->getEntry() );
1740 if ( anActor->GetControlMode() != aControl )
1741 anActor->SetControlMode( aControl );
1742 QString functorName = functorToString( anActor->GetFunctor() );
1743 int anEntitiesCount = anActor->GetNumberControlEntities();
1744 if (anEntitiesCount >= 0)
1745 functorName = functorName + ": " + QString::number(anEntitiesCount);
1746 anActor->GetScalarBarActor()->SetTitle( functorName.toLatin1().constData() );
1747 SMESH::RepaintCurrentView();
1748 #ifndef DISABLE_PLOT2DVIEWER
1749 if ( anActor->GetPlot2Histogram() ) {
1750 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1751 QString aHistogramName("%1 : %2");
1752 aHistogramName = aHistogramName.arg( anIO->getName() ).arg( functorName );
1753 aHistogram->setName( aHistogramName );
1754 aHistogram->setHorTitle( functorName );
1755 SMESH::ProcessIn2DViewers( anActor );
1767 bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1768 SMESH::MeshObjectType theType,
1769 const QString theInTypeName,
1770 QString & theOutTypeName)
1772 SMESH_TypeFilter aTypeFilter( theType );
1774 if ( !theIO.IsNull() )
1776 entry = theIO->getEntry();
1777 LightApp_DataOwner owner( entry );
1778 if ( aTypeFilter.isOk( &owner )) {
1779 theOutTypeName = theInTypeName;
1787 QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1789 _PTR(Study) aStudy = SMESH::getStudy();
1790 _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1792 _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1793 CORBA::String_var anID = aSComp->GetID().c_str();
1794 if ( !strcmp(anID.in(),theIO->getEntry()) )
1800 CheckOIType ( theIO, SMESH::HYPOTHESIS, "Hypothesis", aTypeName ) ||
1801 CheckOIType ( theIO, SMESH::ALGORITHM, "Algorithm", aTypeName ) ||
1802 CheckOIType ( theIO, SMESH::MESH, "Mesh", aTypeName ) ||
1803 CheckOIType ( theIO, SMESH::SUBMESH, "SubMesh", aTypeName ) ||
1804 CheckOIType ( theIO, SMESH::GROUP, "Group", aTypeName )
1812 // QString CheckHomogeneousSelection()
1814 // LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1815 // SALOME_ListIO selected;
1817 // aSel->selectedObjects( selected );
1819 // QString RefType = CheckTypeObject(selected.First());
1820 // SALOME_ListIteratorOfListIO It(selected);
1821 // for ( ; It.More(); It.Next())
1823 // Handle(SALOME_InteractiveObject) IObject = It.Value();
1824 // QString Type = CheckTypeObject(IObject);
1825 // if ( Type.compare(RefType) != 0 )
1826 // return "Heterogeneous Selection";
1832 uint randomize( uint size )
1834 static bool initialized = false;
1835 if ( !initialized ) {
1836 qsrand( QDateTime::currentDateTime().toTime_t() );
1840 v = uint( (double)( v ) / RAND_MAX * size );
1841 v = qMax( uint(0), qMin ( v, size-1 ) );
1847 void SMESHGUI::OnEditDelete()
1849 // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1850 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1851 SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1853 _PTR(Study) aStudy = SMESH::getStudy();
1854 _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1855 _PTR(GenericAttribute) anAttr;
1856 _PTR(AttributeIOR) anIOR;
1858 int objectCount = 0;
1860 QString aParentComponent = QString::null;
1862 for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1864 Handle(SALOME_InteractiveObject) anIO = anIt.Value();
1865 if ( anIO.IsNull() ) continue;
1867 QString father = "unknown";
1869 _PTR(SObject) aSO = aStudy->FindObjectID( anIO->getEntry() );
1871 father = QString::fromStdString( aSO->GetFatherComponent()->ComponentDataType() );
1872 // check if object is reference
1873 _PTR(SObject) aRefSObj;
1874 aNameList.append("\n - ");
1875 if ( aSO->ReferencedObject( aRefSObj ) ) {
1876 QString aRefName = QString::fromStdString ( aRefSObj->GetName() );
1877 aNameList.append( aRefName );
1878 father = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1881 aNameList.append(anIO->getName());
1885 if( aParentComponent.isNull() )
1886 aParentComponent = father;
1887 else if( !aParentComponent.isEmpty() && aParentComponent!=father )
1888 aParentComponent = "";
1891 if ( objectCount == 0 )
1892 return; // No Valid Objects Selected
1894 if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
1895 SUIT_MessageBox::warning( SMESHGUI::desktop(),
1896 QObject::tr("ERR_ERROR"),
1897 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
1900 // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
1901 if (SUIT_MessageBox::warning
1902 (SMESHGUI::desktop(),
1903 QObject::tr("SMESH_WRN_WARNING"),
1904 QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
1905 SUIT_MessageBox::Yes | SUIT_MessageBox::No,
1906 SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
1909 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1911 // Put the whole hierarchy of sub-objects of the selected SO's into a list and
1912 // then treat them all starting from the deepest objects (at list back)
1913 std::list< _PTR(SObject) > listSO;
1914 SALOME_ListIteratorOfListIO It(selected);
1915 for( ; It.More(); It.Next()) // loop on selected IO's
1917 Handle(SALOME_InteractiveObject) IObject = It.Value();
1918 if(IObject->hasEntry()) {
1919 _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
1921 // disable removal of "SMESH" component object
1922 if(aSO->FindAttribute(anAttr, "AttributeIOR")){
1924 if ( engineIOR() == anIOR->Value().c_str() )
1927 //Check the referenced object
1928 _PTR(SObject) aRefSObject;
1929 if ( aSO && aSO->ReferencedObject( aRefSObject ) )
1930 aSO = aRefSObject; // Delete main Object instead of reference
1932 listSO.push_back( aSO );
1933 std::list< _PTR(SObject) >::iterator itSO = --listSO.end();
1934 for ( ; itSO != listSO.end(); ++itSO ) {
1935 _PTR(ChildIterator) it = aStudy->NewChildIterator( *itSO );
1936 for (it->InitEx(false); it->More(); it->Next())
1937 listSO.push_back( it->Value() );
1941 // Check if none of objects to delete is referred from outside
1942 std::list< _PTR(SObject) >::reverse_iterator ritSO;
1943 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1945 _PTR(SObject) SO = *ritSO;
1946 if ( !SO ) continue;
1947 std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( *ritSO );
1948 for (size_t i = 0; i < aReferences.size(); i++) {
1949 _PTR(SComponent) aComponent = aReferences[i]->GetFatherComponent();
1950 std::string type = aComponent->ComponentDataType();
1951 if ( type != "SMESH" )
1953 SUIT_MessageBox::warning( anApp->desktop(),
1954 QObject::tr("WRN_WARNING"),
1955 QObject::tr("DEP_OBJECT") );
1956 return; // outside SMESH, there is an object depending on a SMESH object
1961 // Call mesh->Clear() to prevent loading mesh from file caused by hypotheses removal
1962 for( It.Initialize( selected ); It.More(); It.Next()) // loop on selected IO's
1964 Handle(SALOME_InteractiveObject) IObject = It.Value();
1965 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface< SMESH::SMESH_Mesh >( IObject );
1966 if ( !mesh->_is_nil() )
1970 // Treat SO's in the list starting from the back
1971 aStudyBuilder->NewCommand(); // There is a transaction
1972 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1974 _PTR(SObject) SO = *ritSO;
1975 if ( !SO ) continue;
1976 std::string anEntry = SO->GetID();
1978 /** Erase graphical object and remove all its data **/
1979 if(SO->FindAttribute(anAttr, "AttributeIOR")) {
1980 SMESH::RemoveVisualObjectWithActors( anEntry.c_str(), true);
1982 /** Remove an object from data structures **/
1983 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
1984 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
1985 if ( !aGroup->_is_nil() ) { // DELETE GROUP
1986 SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
1987 aMesh->RemoveGroup( aGroup );
1989 else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
1990 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
1991 aMesh->RemoveSubMesh( aSubMesh );
1994 Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
1995 ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
1996 QString objType = CheckTypeObject(IObject);
1997 if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
1998 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
1999 aStudyBuilder->RemoveObjectWithChildren( SO );
2001 else {// default action: remove SObject from the study
2002 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
2003 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
2005 aStudyBuilder->RemoveObjectWithChildren( SO );
2009 } /* listSO back loop */
2011 aStudyBuilder->CommitCommand();
2013 /* Clear any previous selection */
2015 aSel->setSelectedObjects( l1 );
2017 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
2021 SMESHGUI_EXPORT CAM_Module* createModule()
2023 return new SMESHGUI();
2026 SMESHGUI_EXPORT char* getModuleVersion() {
2027 return (char*)SMESH_VERSION_STR;
2031 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
2033 //=============================================================================
2037 //=============================================================================
2038 SMESHGUI::SMESHGUI() :
2039 SalomeApp_Module( "SMESH" )
2041 if ( CORBA::is_nil( myComponentSMESH ) )
2043 CORBA::Boolean anIsEmbeddedMode;
2044 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
2045 //MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
2047 // 0019923: EDF 765 SMESH : default values of hypothesis
2048 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
2049 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
2050 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
2051 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
2052 myComponentSMESH->SetDefaultNbSegments( nbSeg );
2054 const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif", "default_grp_color" };
2055 for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
2056 if ( aResourceMgr->hasValue( "SMESH", options[i] ))
2058 QString val = aResourceMgr->stringValue( "SMESH", options[i] );
2059 myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
2063 myActiveDialogBox = 0;
2064 myFilterLibraryDlg = 0;
2068 myEventCallbackCommand = vtkCallbackCommand::New();
2069 myEventCallbackCommand->Delete();
2070 myEventCallbackCommand->SetClientData( this );
2071 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
2074 /* load resources for all available meshers */
2075 SMESH::InitAvailableHypotheses();
2078 //=============================================================================
2082 //=============================================================================
2083 SMESHGUI::~SMESHGUI()
2087 //=============================================================================
2091 //=============================================================================
2092 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
2094 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2096 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
2101 //=============================================================================
2105 //=============================================================================
2106 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
2108 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2112 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2113 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2114 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2115 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2116 return autoUpdate && !exceeded;
2119 //=============================================================================
2123 //=============================================================================
2124 bool SMESHGUI::automaticUpdate( SMESH::SMESH_IDSource_ptr theMesh,
2125 int* entities, bool* limitExceeded, int* hidden, long* nbElements )
2127 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2131 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2132 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2133 bool incrementalLimit = resMgr->booleanValue( "SMESH", "incremental_limit", false );
2135 SMESH::long_array_var info = theMesh->GetMeshInfo();
2136 long nbOdElems = info[SMDSEntity_0D];
2137 long nbEdges = info[SMDSEntity_Edge] + info[SMDSEntity_Quad_Edge];
2138 long nbFaces = info[SMDSEntity_Triangle] + info[SMDSEntity_Quad_Triangle] + info[SMDSEntity_BiQuad_Triangle] +
2139 info[SMDSEntity_Quadrangle] + info[SMDSEntity_Quad_Quadrangle] + info[SMDSEntity_BiQuad_Quadrangle] +
2140 info[SMDSEntity_Polygon] + info[SMDSEntity_Quad_Polygon];
2141 long nbVolumes = info[SMDSEntity_Tetra] + info[SMDSEntity_Quad_Tetra] +
2142 info[SMDSEntity_Hexa] + info[SMDSEntity_Quad_Hexa] + info[SMDSEntity_TriQuad_Hexa] +
2143 info[SMDSEntity_Pyramid] + info[SMDSEntity_Quad_Pyramid] +
2144 info[SMDSEntity_Penta] + info[SMDSEntity_Quad_Penta] + info[SMDSEntity_BiQuad_Penta] +
2145 info[SMDSEntity_Polyhedra] +
2146 info[SMDSEntity_Hexagonal_Prism];
2147 long nbBalls = info[SMDSEntity_Ball];
2149 long requestedSize = nbOdElems + nbBalls + nbEdges + nbFaces + nbVolumes;
2150 *nbElements = requestedSize;
2152 *entities = SMESH_Actor::eAllEntity;
2155 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2157 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2159 if ( incrementalLimit ) {
2162 if ( nbOdElems > 0 ) {
2163 if ( total + nbOdElems > updateLimit ) {
2164 *entities = *entities & ~SMESH_Actor::e0DElements;
2165 *hidden = *hidden | SMESH_Actor::e0DElements;
2172 if ( nbEdges > 0 ) {
2173 if ( total + nbEdges > updateLimit ) {
2174 *entities = *entities & ~SMESH_Actor::eEdges;
2175 *hidden = *hidden | SMESH_Actor::eEdges;
2182 if ( nbFaces > 0 ) {
2183 if ( total + nbFaces > updateLimit ) {
2184 *entities = *entities & ~SMESH_Actor::eFaces;
2185 *hidden = *hidden | SMESH_Actor::eFaces;
2192 if ( nbVolumes > 0 ) {
2193 if ( total + nbVolumes > updateLimit ) {
2194 *entities = *entities & ~SMESH_Actor::eVolumes;
2195 *hidden = *hidden | SMESH_Actor::eVolumes;
2202 if ( nbBalls > 0 ) {
2203 if ( total + nbBalls > updateLimit ) {
2204 *entities = *entities & ~SMESH_Actor::eBallElem;
2205 *hidden = *hidden | SMESH_Actor::eBallElem;
2213 return autoUpdate && !exceeded;
2216 //=============================================================================
2220 //=============================================================================
2221 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
2223 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
2226 //=============================================================================
2230 //=============================================================================
2231 SMESHGUI* SMESHGUI::GetSMESHGUI()
2233 SMESHGUI* smeshMod = 0;
2234 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
2237 CAM_Module* module = app->module( "Mesh" );
2238 smeshMod = dynamic_cast<SMESHGUI*>( module );
2246 Standard_EXPORT SMESHGUI* GetComponentGUI()
2248 return SMESHGUI::GetSMESHGUI();
2252 //=============================================================================
2256 //=============================================================================
2257 void SMESHGUI::SetState(int aState)
2262 //=============================================================================
2266 //=============================================================================
2267 void SMESHGUI::ResetState()
2272 //=============================================================================
2276 //=============================================================================
2277 void SMESHGUI::EmitSignalDeactivateDialog()
2279 emit SignalDeactivateActiveDialog();
2282 //=============================================================================
2286 //=============================================================================
2287 void SMESHGUI::EmitSignalStudyFrameChanged()
2289 emit SignalStudyFrameChanged();
2292 //=============================================================================
2296 //=============================================================================
2297 void SMESHGUI::EmitSignalCloseAllDialogs()
2299 emit SignalCloseAllDialogs();
2302 //=============================================================================
2306 //=============================================================================
2307 void SMESHGUI::EmitSignalVisibilityChanged()
2309 emit SignalVisibilityChanged();
2312 //=============================================================================
2316 //=============================================================================
2317 void SMESHGUI::EmitSignalCloseView()
2319 emit SignalCloseView();
2322 //=============================================================================
2326 //=============================================================================
2327 void SMESHGUI::EmitSignalActivatedViewManager()
2329 emit SignalActivatedViewManager();
2332 //=============================================================================
2336 //=============================================================================
2337 QDialog *SMESHGUI::GetActiveDialogBox()
2339 return myActiveDialogBox;
2342 //=============================================================================
2346 //=============================================================================
2347 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2349 myActiveDialogBox = (QDialog *) aDlg;
2353 //=============================================================================
2357 //=============================================================================
2358 SUIT_Desktop* SMESHGUI::desktop()
2360 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2362 return app->desktop();
2367 //=============================================================================
2371 //=============================================================================
2372 SalomeApp_Study* SMESHGUI::activeStudy()
2374 SUIT_Application* app = SUIT_Session::session()->activeApplication();
2376 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2381 //=============================================================================
2385 //=============================================================================
2386 void SMESHGUI::Modified( bool theIsUpdateActions )
2388 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2389 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2390 appStudy->Modified();
2391 if( theIsUpdateActions )
2392 app->updateActions();
2397 //=============================================================================
2401 //=============================================================================
2402 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2404 /* Here the position is on the bottom right corner - 10 */
2405 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2407 SUIT_Desktop *PP = desktop();
2408 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2409 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2414 * \brief Verifies whether study of operation is locked
2415 * \param theMess - specifies whether message box must be shown if study is locked
2416 * \return State of study.
2418 * Verifies whether study of operation is locked. If second parameter is TRUE and study
2419 * is locked when corresponding message box appears
2421 bool SMESHGUI::isStudyLocked( bool theMessage )
2423 if ( SMESH::getStudy()->GetProperties()->IsLocked() )
2426 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2427 QObject::tr( "WRN_WARNING" ),
2428 QObject::tr( "WRN_STUDY_LOCKED" ) );
2434 //=============================================================================
2438 //=============================================================================
2439 bool SMESHGUI::OnGUIEvent( int theCommandID )
2441 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2445 SUIT_ResourceMgr* mgr = resourceMgr();
2449 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2450 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2452 //QAction* act = action( theCommandID );
2454 switch (theCommandID) {
2455 case SMESHOp::OpDelete:
2456 if(isStudyLocked()) break;
2459 case SMESHOp::OpImportDAT:
2460 case SMESHOp::OpImportUNV:
2461 case SMESHOp::OpImportMED:
2462 case SMESHOp::OpImportSTL:
2463 case SMESHOp::OpImportCGNS:
2464 case SMESHOp::OpImportSAUV:
2465 case SMESHOp::OpImportGMF:
2466 case SMESHOp::OpPopupImportDAT:
2467 case SMESHOp::OpPopupImportUNV:
2468 case SMESHOp::OpPopupImportMED:
2469 case SMESHOp::OpPopupImportSTL:
2470 case SMESHOp::OpPopupImportCGNS:
2471 case SMESHOp::OpPopupImportSAUV:
2472 case SMESHOp::OpPopupImportGMF:
2474 if(isStudyLocked()) break;
2475 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2479 case SMESHOp::OpFileInformation:
2481 SALOME_ListIO selected;
2482 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2484 aSel->selectedObjects( selected );
2485 if( selected.Extent() )
2487 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2488 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2489 if ( !aMesh->_is_nil() )
2491 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2497 case SMESHOp::OpExportDAT:
2498 case SMESHOp::OpExportMED:
2499 case SMESHOp::OpExportUNV:
2500 case SMESHOp::OpExportSTL:
2501 case SMESHOp::OpExportCGNS:
2502 case SMESHOp::OpExportSAUV:
2503 case SMESHOp::OpExportGMF:
2504 case SMESHOp::OpPopupExportDAT:
2505 case SMESHOp::OpPopupExportMED:
2506 case SMESHOp::OpPopupExportUNV:
2507 case SMESHOp::OpPopupExportSTL:
2508 case SMESHOp::OpPopupExportCGNS:
2509 case SMESHOp::OpPopupExportSAUV:
2510 case SMESHOp::OpPopupExportGMF:
2512 ::ExportMeshToFile(theCommandID);
2516 case SMESHOp::OpReset: // SCALAR BAR
2518 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2519 SALOME_ListIO selected;
2521 aSel->selectedObjects( selected );
2523 SALOME_ListIteratorOfListIO it(selected);
2524 for( ; it.More(); it.Next()) {
2525 Handle(SALOME_InteractiveObject) anIO = it.Value();
2526 if( anIO->hasEntry() ) {
2527 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2528 anActor->SetControlMode( SMESH_Actor::eNone );
2529 #ifndef DISABLE_PLOT2DVIEWER
2530 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2535 SMESH::UpdateView();
2538 case SMESHOp::OpScalarBarProperties:
2540 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2543 case SMESHOp::OpShowScalarBar:
2545 // show/hide scalar bar
2546 ::ShowElement(theCommandID);
2549 case SMESHOp::OpSaveDistribution:
2551 // dump control distribution data to the text file
2552 ::SaveDistribution();
2556 case SMESHOp::OpShowDistribution:
2558 // show/hide distribution
2559 ::ShowElement(theCommandID);
2563 #ifndef DISABLE_PLOT2DVIEWER
2564 case SMESHOp::OpPlotDistribution:
2566 // plot distribution
2567 ::PlotDistribution();
2573 case SMESHOp::OpAutoColor:
2577 case SMESHOp::OpDisableAutoColor:
2578 ::DisableAutoColor();
2581 case SMESHOp::OpClipping:
2582 case SMESHOp::OpTransparency:
2583 case SMESHOp::OpProperties: // Display preferences (colors, shrink size, line width, ...)
2586 case SMESHOp::OpDMWireframe:
2587 case SMESHOp::OpDMShading:
2588 case SMESHOp::OpDMNodes:
2589 case SMESHOp::OpDMShrink:
2590 ::SetDisplayMode(theCommandID, myMarkerMap);
2593 //2D quadratic representation
2594 case SMESHOp::OpRepresentationLines:
2595 case SMESHOp::OpRepresentationArcs:
2596 ::SetDisplayMode(theCommandID, myMarkerMap);
2600 case SMESHOp::OpDE0DElements:
2601 case SMESHOp::OpDEEdges:
2602 case SMESHOp::OpDEFaces:
2603 case SMESHOp::OpDEVolumes:
2604 case SMESHOp::OpDEBalls:
2605 case SMESHOp::OpDEAllEntity:
2606 ::SetDisplayEntity(theCommandID);
2609 // Choose entities to be displayed
2610 case SMESHOp::OpDEChoose:
2612 ( new SMESHGUI_DisplayEntitiesDlg( SMESHGUI::desktop() ) )->exec();
2616 case SMESHOp::OpOrientationOnFaces:
2618 SUIT_OverrideCursor wc;
2619 LightApp_SelectionMgr* mgr = selectionMgr();
2620 SALOME_ListIO selected; mgr->selectedObjects( selected );
2622 SALOME_ListIteratorOfListIO it(selected);
2623 for( ; it.More(); it.Next()) {
2624 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2625 if(anIObject->hasEntry()) {
2626 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2627 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2634 case SMESHOp::OpUpdate:
2636 if(isStudyLocked()) break;
2637 SUIT_OverrideCursor wc;
2640 SMESH::UpdateView();
2642 catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2643 SMESH::OnVisuException();
2645 catch (...) { // PAL16774 (Crash after display of many groups)
2646 SMESH::OnVisuException();
2650 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2651 aSel->selectedObjects( l );
2652 aSel->setSelectedObjects( l );
2656 case SMESHOp::OpHide:
2657 case SMESHOp::OpShow:
2658 case SMESHOp::OpShowOnly:
2660 SUIT_OverrideCursor wc;
2661 SMESH::EDisplaing anAction;
2662 switch (theCommandID) {
2663 case SMESHOp::OpHide: anAction = SMESH::eErase; break;
2664 case SMESHOp::OpShow: anAction = SMESH::eDisplay; break;
2665 case SMESHOp::OpShowOnly: anAction = SMESH::eDisplayOnly; break;
2668 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2669 SALOME_ListIO sel_objects, to_process;
2671 aSel->selectedObjects( sel_objects );
2673 if ( theCommandID==SMESHOp::OpShowOnly )
2675 //MESSAGE("anAction = SMESH::eDisplayOnly");
2676 startOperation( myEraseAll );
2679 extractContainers( sel_objects, to_process );
2684 SALOME_ListIteratorOfListIO It( to_process );
2685 for ( ; It.More(); It.Next())
2687 Handle(SALOME_InteractiveObject) IOS = It.Value();
2688 if ( IOS->hasEntry() )
2690 if ( !SMESH::UpdateView( anAction, IOS->getEntry() )) {
2691 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2692 break; // PAL16774 (Crash after display of many groups)
2694 if (anAction == SMESH::eDisplayOnly)
2695 anAction = SMESH::eDisplay;
2700 // PAL13338 + PAL15161 -->
2701 if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !isStudyLocked()) {
2702 SMESH::UpdateView();
2703 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2705 // PAL13338 + PAL15161 <--
2707 catch (...) { // PAL16774 (Crash after display of many groups)
2708 SMESH::OnVisuException();
2711 if (anAction == SMESH::eErase) {
2713 aSel->setSelectedObjects( l1 );
2716 aSel->setSelectedObjects( to_process );
2721 case SMESHOp::OpNode:
2723 if(isStudyLocked()) break;
2726 EmitSignalDeactivateDialog();
2728 ( new SMESHGUI_NodesDlg( this ) )->show();
2731 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"),tr("SMESH_WRN_VIEWER_VTK"));
2736 case SMESHOp::OpCreateMesh:
2737 case SMESHOp::OpCreateSubMesh:
2738 case SMESHOp::OpEditMeshOrSubMesh:
2739 case SMESHOp::OpEditMesh:
2740 case SMESHOp::OpEditSubMesh:
2741 case SMESHOp::OpCompute:
2742 case SMESHOp::OpComputeSubMesh:
2743 case SMESHOp::OpPreCompute:
2744 case SMESHOp::OpEvaluate:
2745 case SMESHOp::OpMeshOrder:
2746 startOperation( theCommandID );
2748 case SMESHOp::OpCopyMesh:
2750 if (isStudyLocked()) break;
2751 EmitSignalDeactivateDialog();
2752 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2755 case SMESHOp::OpBuildCompoundMesh:
2757 if (isStudyLocked()) break;
2758 EmitSignalDeactivateDialog();
2759 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2763 case SMESHOp::OpDiagonalInversion:
2764 case SMESHOp::OpUnionOfTwoTriangle:
2768 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2772 if ( isStudyLocked() )
2775 /*Standard_Boolean aRes;
2776 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2777 if ( aMesh->_is_nil() )
2779 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2780 tr( "SMESH_BAD_SELECTION" ) );
2784 EmitSignalDeactivateDialog();
2785 if ( theCommandID == SMESHOp::OpDiagonalInversion )
2786 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2788 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2791 case SMESHOp::OpOrientation:
2792 case SMESHOp::OpUnionOfTriangles:
2793 case SMESHOp::OpCuttingOfQuadrangles:
2794 case SMESHOp::OpSplitVolumes:
2798 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2802 if ( isStudyLocked() )
2805 EmitSignalDeactivateDialog();
2806 SMESHGUI_MultiEditDlg* aDlg = NULL;
2807 if ( theCommandID == SMESHOp::OpOrientation )
2808 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2809 else if ( theCommandID == SMESHOp::OpUnionOfTriangles )
2810 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2811 else if ( theCommandID == SMESHOp::OpSplitVolumes )
2812 aDlg = new SMESHGUI_SplitVolumesDlg(this);
2814 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2819 case SMESHOp::OpSmoothing:
2821 if(isStudyLocked()) break;
2823 EmitSignalDeactivateDialog();
2824 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2827 SUIT_MessageBox::warning(desktop(), tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2831 case SMESHOp::OpExtrusion:
2833 if (isStudyLocked()) break;
2835 EmitSignalDeactivateDialog();
2836 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2838 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2842 case SMESHOp::OpExtrusionAlongAPath:
2844 if (isStudyLocked()) break;
2846 EmitSignalDeactivateDialog();
2847 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2849 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2853 case SMESHOp::OpRevolution:
2855 if(isStudyLocked()) break;
2857 EmitSignalDeactivateDialog();
2858 ( new SMESHGUI_RevolutionDlg( this ) )->show();
2861 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2865 case SMESHOp::OpPatternMapping:
2867 if ( isStudyLocked() )
2871 EmitSignalDeactivateDialog();
2872 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2875 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2879 case SMESHOp::OpSplitBiQuadratic:
2880 case SMESHOp::OpConvertMeshToQuadratic:
2881 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
2882 case SMESHOp::OpReorientFaces:
2883 case SMESHOp::OpCreateGeometryGroup:
2885 startOperation( theCommandID );
2888 case SMESHOp::OpCreateGroup:
2892 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2896 if(isStudyLocked()) break;
2897 EmitSignalDeactivateDialog();
2898 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2900 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2901 SALOME_ListIO selected;
2903 aSel->selectedObjects( selected );
2905 int nbSel = selected.Extent();
2907 // check if mesh is selected
2908 aMesh = SMESH::GetMeshByIO( selected.First() );
2910 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2915 case SMESHOp::OpConstructGroup:
2919 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2923 if(isStudyLocked()) break;
2924 EmitSignalDeactivateDialog();
2926 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2927 SALOME_ListIO selected;
2929 aSel->selectedObjects( selected );
2931 int nbSel = selected.Extent();
2933 // check if submesh is selected
2934 Handle(SALOME_InteractiveObject) IObject = selected.First();
2935 if (IObject->hasEntry()) {
2936 _PTR(SObject) aSObj = SMESH::getStudy()->FindObjectID(IObject->getEntry());
2938 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2939 if (!aSubMesh->_is_nil()) {
2941 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2942 // get submesh elements list by types
2943 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2944 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2945 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2946 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2947 // create group for each type o elements
2948 QString aName = IObject->getName();
2949 QStringList anEntryList;
2950 if (aNodes->length() > 0) {
2951 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2952 aGroup->Add(aNodes.inout());
2953 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2954 anEntryList.append( aSObject->GetID().c_str() );
2956 if (aEdges->length() > 0) {
2957 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2958 aGroup->Add(aEdges.inout());
2959 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2960 anEntryList.append( aSObject->GetID().c_str() );
2962 if (aFaces->length() > 0) {
2963 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2964 aGroup->Add(aFaces.inout());
2965 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2966 anEntryList.append( aSObject->GetID().c_str() );
2968 if (aVolumes->length() > 0) {
2969 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2970 aGroup->Add(aVolumes.inout());
2971 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2972 anEntryList.append( aSObject->GetID().c_str() );
2975 anApp->browseObjects( anEntryList );
2977 catch(const SALOME::SALOME_Exception & S_ex){
2978 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2985 SUIT_MessageBox::warning(desktop(),
2986 tr("SMESH_WRN_WARNING"),
2987 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
2992 case SMESHOp::OpEditGroup:
2996 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3000 if(isStudyLocked()) break;
3001 EmitSignalDeactivateDialog();
3003 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3004 SALOME_ListIO selected;
3006 aSel->selectedObjects( selected );
3008 SALOME_ListIteratorOfListIO It (selected);
3009 int nbSelectedGroups = 0;
3010 for ( ; It.More(); It.Next() )
3012 SMESH::SMESH_GroupBase_var aGroup =
3013 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
3014 if (!aGroup->_is_nil()) {
3016 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
3020 if (nbSelectedGroups == 0)
3022 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
3028 case SMESHOp::OpAddElemGroupPopup: // Add elements to group
3030 if(isStudyLocked()) break;
3031 if (myState == 800) {
3032 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3033 if (aDlg) aDlg->onAdd();
3038 case SMESHOp::OpRemoveElemGroupPopup: // Remove elements from group
3040 if(isStudyLocked()) break;
3041 if (myState == 800) {
3042 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3043 if (aDlg) aDlg->onRemove();
3048 case SMESHOp::OpEditGeomGroupAsGroup:
3052 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3056 if(isStudyLocked()) break;
3057 EmitSignalDeactivateDialog();
3059 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3060 SALOME_ListIO selected;
3062 aSel->selectedObjects( selected );
3064 SALOME_ListIteratorOfListIO It (selected);
3065 for ( ; It.More(); It.Next() )
3067 SMESH::SMESH_GroupOnGeom_var aGroup =
3068 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
3069 if (!aGroup->_is_nil()) {
3070 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3075 SMESH::SMESH_GroupOnFilter_var aGroup =
3076 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
3077 if (!aGroup->_is_nil()) {
3078 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3086 case SMESHOp::OpUnionGroups:
3087 case SMESHOp::OpIntersectGroups:
3088 case SMESHOp::OpCutGroups:
3092 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3096 if ( isStudyLocked() )
3099 EmitSignalDeactivateDialog();
3101 SMESHGUI_GroupOpDlg* aDlg = 0;
3102 if ( theCommandID == SMESHOp::OpUnionGroups )
3103 aDlg = new SMESHGUI_UnionGroupsDlg( this );
3104 else if ( theCommandID == SMESHOp::OpIntersectGroups )
3105 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3107 aDlg = new SMESHGUI_CutGroupsDlg( this );
3114 case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
3116 if ( isStudyLocked() )
3119 EmitSignalDeactivateDialog();
3120 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3126 case SMESHOp::OpDeleteGroup: // Delete groups with their contents
3130 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3134 if ( isStudyLocked() )
3137 EmitSignalDeactivateDialog();
3139 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3143 case SMESHOp::OpMeshInformation:
3144 case SMESHOp::OpWhatIs:
3146 int page = theCommandID == SMESHOp::OpMeshInformation ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3147 EmitSignalDeactivateDialog();
3148 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3149 SALOME_ListIO selected;
3151 aSel->selectedObjects( selected );
3153 if ( selected.Extent() > 1 ) { // a dlg for each IO
3154 SALOME_ListIteratorOfListIO It( selected );
3155 for ( ; It.More(); It.Next() ) {
3156 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3157 dlg->showInfo( It.Value() );
3162 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3168 case SMESHOp::OpFindElementByPoint:
3170 startOperation( theCommandID );
3174 case SMESHOp::OpEditHypothesis:
3176 if(isStudyLocked()) break;
3178 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3179 SALOME_ListIO selected;
3181 aSel->selectedObjects( selected );
3183 int nbSel = selected.Extent();
3186 Handle(SALOME_InteractiveObject) anIObject = selected.First();
3187 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3189 if ( !aHypothesis->_is_nil() )
3191 SMESHGUI_GenericHypothesisCreator* aCreator =
3192 SMESH::GetHypothesisCreator( SMESH::toQStr( aHypothesis->GetName() ));
3195 // set geometry of mesh and sub-mesh to aCreator
3196 aSel->selectedObjects( selected, "", /*convertReferences=*/false);
3197 if ( selected.Extent() == 1 )
3199 QString subGeomID, meshGeomID;
3200 Handle(SALOME_InteractiveObject) hypIO = selected.First();
3201 if ( SMESH::GetGeomEntries( hypIO, subGeomID, meshGeomID ))
3203 if ( subGeomID.isEmpty() ) subGeomID = meshGeomID;
3204 aCreator->setShapeEntry( subGeomID );
3205 aCreator->setMainShapeEntry( meshGeomID );
3209 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3219 case SMESHOp::OpUnassign: // REMOVE HYPOTHESIS / ALGORITHMS
3221 if(isStudyLocked()) break;
3222 SUIT_OverrideCursor wc;
3224 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3225 SALOME_ListIO selected;
3227 aSel->selectedObjects( selected, QString::null, false );
3229 SALOME_ListIteratorOfListIO It(selected);
3230 for (int i = 0; It.More(); It.Next(), i++) {
3231 Handle(SALOME_InteractiveObject) IObject = It.Value();
3232 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3235 aSel->setSelectedObjects( l1 );
3240 case SMESHOp::OpElem0D:
3241 case SMESHOp::OpBall:
3242 case SMESHOp::OpEdge:
3243 case SMESHOp::OpTriangle:
3244 case SMESHOp::OpQuadrangle:
3245 case SMESHOp::OpPolygon:
3246 case SMESHOp::OpTetrahedron:
3247 case SMESHOp::OpHexahedron:
3248 case SMESHOp::OpPentahedron:
3249 case SMESHOp::OpPyramid:
3250 case SMESHOp::OpHexagonalPrism:
3252 if(isStudyLocked()) break;
3254 EmitSignalDeactivateDialog();
3255 SMDSAbs_EntityType type = SMDSEntity_Edge;
3256 switch (theCommandID) {
3257 case SMESHOp::OpElem0D: type = SMDSEntity_0D; break;
3258 case SMESHOp::OpBall: type = SMDSEntity_Ball; break;
3259 case SMESHOp::OpTriangle: type = SMDSEntity_Triangle; break;
3260 case SMESHOp::OpQuadrangle: type = SMDSEntity_Quadrangle; break;
3261 case SMESHOp::OpTetrahedron: type = SMDSEntity_Tetra; break;
3262 case SMESHOp::OpPolygon: type = SMDSEntity_Polygon; break;
3263 case SMESHOp::OpHexahedron: type = SMDSEntity_Hexa; break;
3264 case SMESHOp::OpPentahedron: type = SMDSEntity_Penta; break;
3265 case SMESHOp::OpPyramid: type = SMDSEntity_Pyramid; break;
3266 case SMESHOp::OpHexagonalPrism: type = SMDSEntity_Hexagonal_Prism; break;
3269 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3272 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3276 case SMESHOp::OpPolyhedron:
3278 if(isStudyLocked()) break;
3280 EmitSignalDeactivateDialog();
3281 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3284 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3288 case SMESHOp::OpQuadraticEdge:
3289 case SMESHOp::OpQuadraticTriangle:
3290 case SMESHOp::OpBiQuadraticTriangle:
3291 case SMESHOp::OpQuadraticQuadrangle:
3292 case SMESHOp::OpBiQuadraticQuadrangle:
3293 case SMESHOp::OpQuadraticPolygon:
3294 case SMESHOp::OpQuadraticTetrahedron:
3295 case SMESHOp::OpQuadraticPyramid:
3296 case SMESHOp::OpQuadraticPentahedron:
3297 case SMESHOp::OpBiQuadraticPentahedron:
3298 case SMESHOp::OpQuadraticHexahedron:
3299 case SMESHOp::OpTriQuadraticHexahedron:
3301 if(isStudyLocked()) break;
3303 EmitSignalDeactivateDialog();
3304 SMDSAbs_EntityType type = SMDSEntity_Last;
3306 switch (theCommandID) {
3307 case SMESHOp::OpQuadraticEdge: type = SMDSEntity_Quad_Edge; break;
3308 case SMESHOp::OpQuadraticTriangle: type = SMDSEntity_Quad_Triangle; break;
3309 case SMESHOp::OpBiQuadraticTriangle: type = SMDSEntity_BiQuad_Triangle; break;
3310 case SMESHOp::OpQuadraticQuadrangle: type = SMDSEntity_Quad_Quadrangle; break;
3311 case SMESHOp::OpBiQuadraticQuadrangle: type = SMDSEntity_BiQuad_Quadrangle; break;
3312 case SMESHOp::OpQuadraticPolygon: type = SMDSEntity_Quad_Polygon; break;
3313 case SMESHOp::OpQuadraticTetrahedron: type = SMDSEntity_Quad_Tetra; break;
3314 case SMESHOp::OpQuadraticPyramid: type = SMDSEntity_Quad_Pyramid; break;
3315 case SMESHOp::OpQuadraticPentahedron: type = SMDSEntity_Quad_Penta; break;
3316 case SMESHOp::OpBiQuadraticPentahedron: type = SMDSEntity_BiQuad_Penta; break;
3317 case SMESHOp::OpQuadraticHexahedron: type = SMDSEntity_Quad_Hexa; break;
3318 case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
3321 if ( type != SMDSEntity_Last )
3322 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3325 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3326 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3330 case SMESHOp::OpRemoveNodes:
3332 if(isStudyLocked()) break;
3334 EmitSignalDeactivateDialog();
3335 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3338 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3339 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3343 case SMESHOp::OpRemoveElements: // REMOVES ELEMENTS
3345 if(isStudyLocked()) break;
3347 EmitSignalDeactivateDialog();
3348 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3352 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3353 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3357 case SMESHOp::OpClearMesh: {
3359 if(isStudyLocked()) break;
3361 SALOME_ListIO selected;
3362 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3363 aSel->selectedObjects( selected );
3365 SUIT_OverrideCursor wc;
3366 SALOME_ListIteratorOfListIO It (selected);
3367 for ( ; It.More(); It.Next() )
3369 Handle(SALOME_InteractiveObject) IOS = It.Value();
3370 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3371 if ( aMesh->_is_nil()) continue;
3374 if ( aMesh->NbNodes() == 0 ) // imported mesh is not empty
3375 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3376 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3377 // hide groups and submeshes
3378 _PTR(ChildIterator) anIter =
3379 SMESH::getStudy()->NewChildIterator( aMeshSObj );
3380 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3382 _PTR(SObject) so = anIter->Value();
3383 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3386 catch (const SALOME::SALOME_Exception& S_ex){
3388 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3392 SMESH::UpdateView();
3396 case SMESHOp::OpRemoveOrphanNodes:
3398 if(isStudyLocked()) break;
3399 SALOME_ListIO selected;
3400 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3401 aSel->selectedObjects( selected );
3402 if ( selected.Extent() == 1 ) {
3403 Handle(SALOME_InteractiveObject) anIO = selected.First();
3404 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3405 if ( !aMesh->_is_nil() ) {
3406 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3407 tr( "SMESH_WARNING" ),
3408 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3409 SUIT_MessageBox::Yes |
3410 SUIT_MessageBox::No,
3411 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3414 SUIT_OverrideCursor wc;
3415 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3416 int removed = aMeshEditor->RemoveOrphanNodes();
3417 SUIT_MessageBox::information(SMESHGUI::desktop(),
3418 tr("SMESH_INFORMATION"),
3419 tr("NB_NODES_REMOVED").arg(removed));
3420 if ( removed > 0 ) {
3421 SMESH::UpdateView();
3422 SMESHGUI::Modified();
3425 catch (const SALOME::SALOME_Exception& S_ex) {
3426 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3435 case SMESHOp::OpRenumberingNodes:
3437 if(isStudyLocked()) break;
3439 EmitSignalDeactivateDialog();
3440 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3444 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3445 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3449 case SMESHOp::OpRenumberingElements:
3451 if(isStudyLocked()) break;
3453 EmitSignalDeactivateDialog();
3454 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3458 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3459 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3463 case SMESHOp::OpTranslation:
3465 if(isStudyLocked()) break;
3467 EmitSignalDeactivateDialog();
3468 ( new SMESHGUI_TranslationDlg( this ) )->show();
3471 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3472 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3476 case SMESHOp::OpRotation:
3478 if(isStudyLocked()) break;
3480 EmitSignalDeactivateDialog();
3481 ( new SMESHGUI_RotationDlg( this ) )->show();
3484 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3485 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3489 case SMESHOp::OpSymmetry:
3491 if(isStudyLocked()) break;
3493 EmitSignalDeactivateDialog();
3494 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3497 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3498 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3502 case SMESHOp::OpScale:
3504 if(isStudyLocked()) break;
3506 EmitSignalDeactivateDialog();
3507 ( new SMESHGUI_ScaleDlg( this ) )->show();
3510 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3511 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3516 case SMESHOp::OpOffset:
3518 if(isStudyLocked()) break;
3520 EmitSignalDeactivateDialog();
3521 ( new SMESHGUI_OffsetDlg( this ) )->show();
3524 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3525 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3530 case SMESHOp::OpSewing:
3532 if(isStudyLocked()) break;
3534 EmitSignalDeactivateDialog();
3535 ( new SMESHGUI_SewingDlg( this ) )->show();
3538 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3539 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3543 case SMESHOp::OpMergeNodes:
3545 if(isStudyLocked()) break;
3547 EmitSignalDeactivateDialog();
3548 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3551 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3552 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3556 case SMESHOp::OpMergeElements:
3558 if (isStudyLocked()) break;
3560 EmitSignalDeactivateDialog();
3561 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3563 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3564 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3569 case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
3570 startOperation( SMESHOp::OpMoveNode );
3573 case SMESHOp::OpDuplicateNodes:
3575 if(isStudyLocked()) break;
3577 EmitSignalDeactivateDialog();
3578 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3581 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3582 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3587 case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
3588 startOperation( SMESHOp::OpElem0DOnElemNodes );
3591 case SMESHOp::OpSelectFiltersLibrary: // Library of selection filters
3593 static QList<int> aTypes;
3594 if ( aTypes.isEmpty() )
3596 aTypes.append( SMESH::NODE );
3597 aTypes.append( SMESH::EDGE );
3598 aTypes.append( SMESH::FACE );
3599 aTypes.append( SMESH::VOLUME );
3601 if (!myFilterLibraryDlg)
3602 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3603 else if (myFilterLibraryDlg->isHidden())
3604 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3605 myFilterLibraryDlg->raise();
3609 case SMESHOp::OpFreeNode:
3610 case SMESHOp::OpEqualNode:
3611 case SMESHOp::OpNodeConnectivityNb:
3612 case SMESHOp::OpFreeEdge:
3613 case SMESHOp::OpFreeBorder:
3614 case SMESHOp::OpLength:
3615 case SMESHOp::OpConnection:
3616 case SMESHOp::OpEqualEdge:
3617 case SMESHOp::OpFreeFace:
3618 case SMESHOp::OpBareBorderFace:
3619 case SMESHOp::OpOverConstrainedFace:
3620 case SMESHOp::OpLength2D:
3621 case SMESHOp::OpDeflection2D:
3622 case SMESHOp::OpConnection2D:
3623 case SMESHOp::OpArea:
3624 case SMESHOp::OpTaper:
3625 case SMESHOp::OpAspectRatio:
3626 case SMESHOp::OpMinimumAngle:
3627 case SMESHOp::OpWarpingAngle:
3628 case SMESHOp::OpSkew:
3629 case SMESHOp::OpMaxElementLength2D:
3630 case SMESHOp::OpEqualFace:
3631 case SMESHOp::OpAspectRatio3D:
3632 case SMESHOp::OpVolume:
3633 case SMESHOp::OpMaxElementLength3D:
3634 case SMESHOp::OpBareBorderVolume:
3635 case SMESHOp::OpOverConstrainedVolume:
3636 case SMESHOp::OpEqualVolume:
3639 LightApp_SelectionMgr* mgr = selectionMgr();
3640 SALOME_ListIO selected; mgr->selectedObjects( selected );
3642 if( !selected.IsEmpty() ) {
3643 SUIT_OverrideCursor wc;
3644 ::Control( theCommandID );
3647 SUIT_MessageBox::warning(desktop(),
3648 tr( "SMESH_WRN_WARNING" ),
3649 tr( "SMESH_BAD_SELECTION" ) );
3653 SUIT_MessageBox::warning(desktop(),
3654 tr( "SMESH_WRN_WARNING" ),
3655 tr( "NOT_A_VTK_VIEWER" ) );
3658 case SMESHOp::OpOverallMeshQuality:
3659 OverallMeshQuality();
3661 case SMESHOp::OpNumberingNodes:
3663 SUIT_OverrideCursor wc;
3664 LightApp_SelectionMgr* mgr = selectionMgr();
3665 SALOME_ListIO selected; mgr->selectedObjects( selected );
3667 SALOME_ListIteratorOfListIO it(selected);
3668 for( ; it.More(); it.Next()) {
3669 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3670 if(anIObject->hasEntry()) {
3671 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3672 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3678 case SMESHOp::OpNumberingElements:
3680 SUIT_OverrideCursor wc;
3681 LightApp_SelectionMgr* mgr = selectionMgr();
3682 SALOME_ListIO selected; mgr->selectedObjects( selected );
3684 SALOME_ListIteratorOfListIO it(selected);
3685 for( ; it.More(); it.Next()) {
3686 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3687 if(anIObject->hasEntry())
3688 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3689 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3694 case SMESHOp::OpPropertiesLength:
3695 case SMESHOp::OpPropertiesArea:
3696 case SMESHOp::OpPropertiesVolume:
3697 case SMESHOp::OpMinimumDistance:
3698 case SMESHOp::OpBoundingBox:
3700 int page = SMESHGUI_MeasureDlg::MinDistance;
3701 if ( theCommandID == SMESHOp::OpBoundingBox )
3702 page = SMESHGUI_MeasureDlg::BoundingBox;
3703 else if ( theCommandID == SMESHOp::OpPropertiesLength )
3704 page = SMESHGUI_MeasureDlg::Length;
3705 else if ( theCommandID == SMESHOp::OpPropertiesArea )
3706 page = SMESHGUI_MeasureDlg::Area;
3707 else if ( theCommandID == SMESHOp::OpPropertiesVolume )
3708 page = SMESHGUI_MeasureDlg::Volume;
3710 EmitSignalDeactivateDialog();
3711 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3715 case SMESHOp::OpSortChild:
3721 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3722 //updateObjBrowser();
3726 //=============================================================================
3730 //=============================================================================
3731 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3736 //=============================================================================
3740 //=============================================================================
3741 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3746 //=============================================================================
3750 //=============================================================================
3751 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3756 //=============================================================================
3757 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3758 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3760 //=============================================================================
3761 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3762 SUIT_ViewWindow* wnd )
3764 if(theIO->hasEntry()){
3765 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3766 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3770 //=======================================================================
3771 // function : createSMESHAction
3773 //=======================================================================
3774 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3775 const int key, const bool toggle, const QString& shortcutAction )
3778 QWidget* parent = application()->desktop();
3779 SUIT_ResourceMgr* resMgr = resourceMgr();
3781 if ( !icon_id.isEmpty() )
3782 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3784 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3785 if ( !pix.isNull() )
3786 icon = QIcon( pix );
3788 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3789 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3790 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3792 createAction( id, tooltip, icon, menu, status_bar, key, parent,
3793 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3796 //=======================================================================
3797 // function : createPopupItem
3799 //=======================================================================
3800 void SMESHGUI::createPopupItem( const int id,
3801 const QString& clients,
3802 const QString& types,
3803 const QString& theRule,
3806 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3807 popupMgr()->insert( action( id ), pId, 0 );
3809 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3810 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
3811 QString rule = "(%1) and (%2) and (%3)";
3812 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3813 if( clients.isEmpty() )
3814 rule = rule.arg( QString( "true" ) );
3816 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3817 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3820 bool cont = myRules.contains( id );
3822 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3824 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3825 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3828 //=======================================================================
3829 // function : initialize
3831 //=======================================================================
3832 void SMESHGUI::initialize( CAM_Application* app )
3834 SalomeApp_Module::initialize( app );
3836 // SUIT_ResourceMgr* mgr = app->resourceMgr();
3838 /* Automatic Update flag */
3839 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3841 // ----- create actions --------------
3843 //createSMESHAction( SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
3844 createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_I) );
3845 createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
3846 createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL" );
3848 createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
3850 createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
3851 createSMESHAction( SMESHOp::OpImportGMF, "IMPORT_GMF" );
3852 createSMESHAction( SMESHOp::OpPopupImportUNV, "IMPORT_UNV");
3853 createSMESHAction( SMESHOp::OpPopupImportMED, "IMPORT_MED");
3854 createSMESHAction( SMESHOp::OpPopupImportSTL, "IMPORT_STL" );
3856 createSMESHAction( SMESHOp::OpPopupImportCGNS, "IMPORT_CGNS" );
3858 createSMESHAction( SMESHOp::OpPopupImportSAUV, "IMPORT_SAUV" );
3859 createSMESHAction( SMESHOp::OpPopupImportGMF, "IMPORT_GMF" );
3861 createSMESHAction( SMESHOp::OpExportDAT, "DAT" );
3862 createSMESHAction( SMESHOp::OpExportMED, "MED" );
3863 createSMESHAction( SMESHOp::OpExportUNV, "UNV" );
3864 createSMESHAction( SMESHOp::OpExportSTL, "STL" );
3866 createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
3868 createSMESHAction( SMESHOp::OpExportSAUV, "SAUV");
3869 createSMESHAction( SMESHOp::OpExportGMF, "GMF" );
3870 createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
3871 createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
3872 createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
3873 createSMESHAction( SMESHOp::OpPopupExportSTL, "STL" );
3875 createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
3877 createSMESHAction( SMESHOp::OpPopupExportSAUV, "SAUV");
3878 createSMESHAction( SMESHOp::OpPopupExportGMF, "GMF" );
3879 createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
3880 createSMESHAction( SMESHOp::OpDelete, "DELETE", "ICON_DELETE", Qt::Key_Delete );
3881 createSMESHAction( SMESHOp::OpSelectFiltersLibrary, "SEL_FILTER_LIB" );
3882 createSMESHAction( SMESHOp::OpCreateMesh, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
3883 createSMESHAction( SMESHOp::OpCreateSubMesh, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
3884 createSMESHAction( SMESHOp::OpEditMeshOrSubMesh, "EDIT_MESHSUBMESH", "ICON_DLG_EDIT_MESH" );
3885 createSMESHAction( SMESHOp::OpEditMesh, "EDIT_MESH", "ICON_DLG_EDIT_MESH" );
3886 createSMESHAction( SMESHOp::OpEditSubMesh, "EDIT_SUBMESH", "ICON_DLG_EDIT_MESH" );
3887 createSMESHAction( SMESHOp::OpBuildCompoundMesh, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
3888 createSMESHAction( SMESHOp::OpCopyMesh, "COPY_MESH", "ICON_COPY_MESH" );
3889 createSMESHAction( SMESHOp::OpCompute, "COMPUTE", "ICON_COMPUTE" );
3890 createSMESHAction( SMESHOp::OpComputeSubMesh, "COMPUTE_SUBMESH", "ICON_COMPUTE" );
3891 createSMESHAction( SMESHOp::OpPreCompute, "PRECOMPUTE", "ICON_PRECOMPUTE" );
3892 createSMESHAction( SMESHOp::OpEvaluate, "EVALUATE", "ICON_EVALUATE" );
3893 createSMESHAction( SMESHOp::OpMeshOrder, "MESH_ORDER", "ICON_MESH_ORDER");
3894 createSMESHAction( SMESHOp::OpCreateGroup, "CREATE_GROUP", "ICON_CREATE_GROUP" );
3895 createSMESHAction( SMESHOp::OpCreateGeometryGroup, "CREATE_GEO_GROUP", "ICON_CREATE_GEO_GROUP" );
3896 createSMESHAction( SMESHOp::OpConstructGroup, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
3897 createSMESHAction( SMESHOp::OpEditGroup, "EDIT_GROUP", "ICON_EDIT_GROUP" );
3898 createSMESHAction( SMESHOp::OpEditGeomGroupAsGroup, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3899 createSMESHAction( SMESHOp::OpUnionGroups, "UN_GROUP", "ICON_UNION" );
3900 createSMESHAction( SMESHOp::OpIntersectGroups, "INT_GROUP", "ICON_INTERSECT" );
3901 createSMESHAction( SMESHOp::OpCutGroups, "CUT_GROUP", "ICON_CUT" );
3902 createSMESHAction( SMESHOp::OpGroupUnderlyingElem, "UNDERLYING_ELEMS", "ICON_UNDERLYING_ELEMS" );
3903 createSMESHAction( SMESHOp::OpAddElemGroupPopup, "ADD_TO_GROUP" );
3904 createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE_FROM_GROUP" );
3905 createSMESHAction( SMESHOp::OpDeleteGroup, "DEL_GROUP", "ICON_DEL_GROUP" );
3906 createSMESHAction( SMESHOp::OpMeshInformation , "ADV_INFO", "ICON_ADV_INFO" );
3907 //createSMESHAction( SMESHOp::OpStdInfo, "STD_INFO", "ICON_STD_INFO" );
3908 //createSMESHAction( SMESHOp::OpWhatIs, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3909 createSMESHAction( SMESHOp::OpFindElementByPoint, "FIND_ELEM", "ICON_FIND_ELEM" );
3911 createSMESHAction( SMESHOp::OpFreeNode, "FREE_NODE", "ICON_FREE_NODE", 0, true );
3912 createSMESHAction( SMESHOp::OpEqualNode, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
3913 createSMESHAction( SMESHOp::OpNodeConnectivityNb, "NODE_CONNECTIVITY_NB", "ICON_NODE_CONN_NB", 0, true );
3914 createSMESHAction( SMESHOp::OpFreeEdge, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
3915 createSMESHAction( SMESHOp::OpFreeBorder, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
3916 createSMESHAction( SMESHOp::OpLength, "LENGTH", "ICON_LENGTH", 0, true );
3917 createSMESHAction( SMESHOp::OpConnection, "CONNECTION", "ICON_CONNECTION", 0, true );
3918 createSMESHAction( SMESHOp::OpEqualEdge, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
3919 createSMESHAction( SMESHOp::OpFreeFace, "FREE_FACES", "ICON_FREE_FACES", 0, true );
3920 createSMESHAction( SMESHOp::OpBareBorderFace, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
3921 createSMESHAction( SMESHOp::OpOverConstrainedFace, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
3922 createSMESHAction( SMESHOp::OpLength2D, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
3923 createSMESHAction( SMESHOp::OpDeflection2D, "DEFLECTION_2D", "ICON_DEFLECTION_2D", 0, true );
3924 createSMESHAction( SMESHOp::OpConnection2D, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
3925 createSMESHAction( SMESHOp::OpArea, "AREA", "ICON_AREA", 0, true );
3926 createSMESHAction( SMESHOp::OpTaper, "TAPER", "ICON_TAPER", 0, true );
3927 createSMESHAction( SMESHOp::OpAspectRatio, "ASPECT", "ICON_ASPECT", 0, true );
3928 createSMESHAction( SMESHOp::OpMinimumAngle, "MIN_ANG", "ICON_ANGLE", 0, true );
3929 createSMESHAction( SMESHOp::OpWarpingAngle, "WARP", "ICON_WARP", 0, true );
3930 createSMESHAction( SMESHOp::OpSkew, "SKEW", "ICON_SKEW", 0, true );
3931 createSMESHAction( SMESHOp::OpMaxElementLength2D, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
3932 createSMESHAction( SMESHOp::OpEqualFace, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
3933 createSMESHAction( SMESHOp::OpAspectRatio3D, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
3934 createSMESHAction( SMESHOp::OpVolume, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
3935 createSMESHAction( SMESHOp::OpMaxElementLength3D, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
3936 createSMESHAction( SMESHOp::OpBareBorderVolume, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
3937 createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
3938 createSMESHAction( SMESHOp::OpEqualVolume, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
3939 createSMESHAction( SMESHOp::OpOverallMeshQuality, "OVERALL_MESH_QUALITY", "ICON_OVL_MESH_QUALITY" );
3941 createSMESHAction( SMESHOp::OpNode, "NODE", "ICON_DLG_NODE" );
3942 createSMESHAction( SMESHOp::OpElem0D, "ELEM0D", "ICON_DLG_ELEM0D" );
3943 createSMESHAction( SMESHOp::OpElem0DOnElemNodes, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
3944 createSMESHAction( SMESHOp::OpBall, "BALL", "ICON_DLG_BALL" );
3945 createSMESHAction( SMESHOp::OpEdge, "EDGE", "ICON_DLG_EDGE" );
3946 createSMESHAction( SMESHOp::OpTriangle, "TRIANGLE", "ICON_DLG_TRIANGLE" );
3947 createSMESHAction( SMESHOp::OpQuadrangle, "QUAD", "ICON_DLG_QUADRANGLE" );
3948 createSMESHAction( SMESHOp::OpPolygon, "POLYGON", "ICON_DLG_POLYGON" );
3949 createSMESHAction( SMESHOp::OpTetrahedron, "TETRA", "ICON_DLG_TETRAS" );
3950 createSMESHAction( SMESHOp::OpHexahedron, "HEXA", "ICON_DLG_HEXAS" );
3951 createSMESHAction( SMESHOp::OpPentahedron, "PENTA", "ICON_DLG_PENTA" );
3952 createSMESHAction( SMESHOp::OpPyramid , "PYRAMID", "ICON_DLG_PYRAMID" );
3953 createSMESHAction( SMESHOp::OpHexagonalPrism, "OCTA", "ICON_DLG_OCTA" );
3954 createSMESHAction( SMESHOp::OpPolyhedron, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
3955 createSMESHAction( SMESHOp::OpQuadraticEdge, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
3956 createSMESHAction( SMESHOp::OpQuadraticTriangle, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
3957 createSMESHAction( SMESHOp::OpBiQuadraticTriangle, "BIQUADRATIC_TRIANGLE", "ICON_DLG_BIQUADRATIC_TRIANGLE" );
3958 createSMESHAction( SMESHOp::OpQuadraticQuadrangle, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
3959 createSMESHAction( SMESHOp::OpBiQuadraticQuadrangle, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
3960 createSMESHAction( SMESHOp::OpQuadraticPolygon, "QUADRATIC_POLYGON", "ICON_DLG_QUADRATIC_POLYGON" );
3961 createSMESHAction( SMESHOp::OpQuadraticTetrahedron, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
3962 createSMESHAction( SMESHOp::OpQuadraticPyramid, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
3963 createSMESHAction( SMESHOp::OpQuadraticPentahedron, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
3964 createSMESHAction( SMESHOp::OpBiQuadraticPentahedron, "BIQUADRATIC_PENTAHEDRON", "ICON_DLG_BIQUADRATIC_PENTAHEDRON" );
3965 createSMESHAction( SMESHOp::OpQuadraticHexahedron, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
3966 createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
3968 createSMESHAction( SMESHOp::OpRemoveNodes, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
3969 createSMESHAction( SMESHOp::OpRemoveElements, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
3970 createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
3971 createSMESHAction( SMESHOp::OpClearMesh, "CLEAR_MESH", "ICON_CLEAR_MESH" );
3973 //createSMESHAction( SMESHOp::OpRenumberingNodes, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
3974 //createSMESHAction( SMESHOp::OpRenumberingElements, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
3976 createSMESHAction( SMESHOp::OpTranslation, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
3977 createSMESHAction( SMESHOp::OpRotation, "ROT", "ICON_DLG_MESH_ROTATION" );
3978 createSMESHAction( SMESHOp::OpSymmetry, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
3979 createSMESHAction( SMESHOp::OpScale, "SCALE", "ICON_DLG_MESH_SCALE" );
3980 createSMESHAction( SMESHOp::OpOffset, "OFFSET", "ICON_DLG_MESH_OFFSET" );
3981 createSMESHAction( SMESHOp::OpSewing, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
3982 createSMESHAction( SMESHOp::OpMergeNodes, "MERGE", "ICON_SMESH_MERGE_NODES" );
3983 createSMESHAction( SMESHOp::OpMergeElements, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
3984 createSMESHAction( SMESHOp::OpMoveNode, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
3985 createSMESHAction( SMESHOp::OpDuplicateNodes, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
3986 createSMESHAction( SMESHOp::OpDiagonalInversion, "INV", "ICON_DLG_MESH_DIAGONAL" );
3987 createSMESHAction( SMESHOp::OpUnionOfTwoTriangle, "UNION2", "ICON_UNION2TRI" );
3988 createSMESHAction( SMESHOp::OpOrientation, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
3989 createSMESHAction( SMESHOp::OpReorientFaces, "REORIENT_2D", "ICON_REORIENT_2D" );
3990 createSMESHAction( SMESHOp::OpUnionOfTriangles, "UNION", "ICON_UNIONTRI" );
3991 createSMESHAction( SMESHOp::OpCuttingOfQuadrangles, "CUT", "ICON_CUTQUAD" );
3992 createSMESHAction( SMESHOp::OpSplitVolumes, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
3993 createSMESHAction( SMESHOp::OpSplitBiQuadratic, "SPLIT_BIQUAD", "ICON_SPLIT_BIQUAD" );
3994 createSMESHAction( SMESHOp::OpSmoothing, "SMOOTH", "ICON_DLG_SMOOTHING" );
3995 createSMESHAction( SMESHOp::OpExtrusion, "EXTRUSION", "ICON_EXTRUSION" );
3996 createSMESHAction( SMESHOp::OpExtrusionAlongAPath, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
3997 createSMESHAction( SMESHOp::OpRevolution, "REVOLUTION", "ICON_REVOLUTION" );
3998 createSMESHAction( SMESHOp::OpPatternMapping, "MAP", "ICON_MAP" );
3999 createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
4000 createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D", "ICON_2D_FROM_3D" );
4002 createSMESHAction( SMESHOp::OpReset, "RESET" );
4003 createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
4004 createSMESHAction( SMESHOp::OpShowScalarBar, "SHOW_SCALAR_BAR","",0, true );
4005 createSMESHAction( SMESHOp::OpSaveDistribution, "SAVE_DISTRIBUTION" );
4006 createSMESHAction( SMESHOp::OpShowDistribution, "SHOW_DISTRIBUTION","",0, true );
4007 #ifndef DISABLE_PLOT2DVIEWER
4008 createSMESHAction( SMESHOp::OpPlotDistribution, "PLOT_DISTRIBUTION" );
4010 createSMESHAction( SMESHOp::OpDMWireframe, "WIRE", "ICON_WIRE", 0, true );
4011 createSMESHAction( SMESHOp::OpDMShading, "SHADE", "ICON_SHADE", 0, true );
4012 createSMESHAction( SMESHOp::OpDMNodes, "NODES", "ICON_POINTS", 0, true );
4013 createSMESHAction( SMESHOp::OpDMShrink, "SHRINK", "ICON_SHRINK", 0, true );
4014 createSMESHAction( SMESHOp::OpUpdate, "UPDATE", "ICON_UPDATE" );
4015 createSMESHAction( SMESHOp::OpDE0DElements, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
4016 createSMESHAction( SMESHOp::OpDEEdges, "EDGES", "ICON_DLG_EDGE", 0, true );
4017 createSMESHAction( SMESHOp::OpDEFaces, "FACES", "ICON_DLG_TRIANGLE", 0, true );
4018 createSMESHAction( SMESHOp::OpDEVolumes, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
4019 createSMESHAction( SMESHOp::OpDEBalls, "BALLS", "ICON_DLG_BALL", 0, true );
4020 createSMESHAction( SMESHOp::OpDEChoose, "CHOOSE", "ICON_DLG_CHOOSE", 0, false );
4021 createSMESHAction( SMESHOp::OpDEAllEntity, "ALL", "ICON_DLG_CHOOSE_ALL", 0, false );
4022 createSMESHAction( SMESHOp::OpOrientationOnFaces, "FACE_ORIENTATION", "", 0, true );
4024 createSMESHAction( SMESHOp::OpRepresentationLines, "LINE_REPRESENTATION", "", 0, true );
4025 createSMESHAction( SMESHOp::OpRepresentationArcs, "ARC_REPRESENTATION", "", 0, true );
4027 createSMESHAction( SMESHOp::OpEditHypothesis, "EDIT_HYPO" );
4028 createSMESHAction( SMESHOp::OpUnassign, "UNASSIGN" );
4029 createSMESHAction( SMESHOp::OpNumberingNodes, "NUM_NODES", "", 0, true );
4030 createSMESHAction( SMESHOp::OpNumberingElements, "NUM_ELEMENTS", "", 0, true );
4031 createSMESHAction( SMESHOp::OpProperties, "COLORS" );
4032 createSMESHAction( SMESHOp::OpTransparency, "TRANSP" );
4033 createSMESHAction( SMESHOp::OpClipping, "CLIP" );
4034 createSMESHAction( SMESHOp::OpAutoColor, "AUTO_COLOR" );
4035 createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
4037 createSMESHAction( SMESHOp::OpMinimumDistance, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
4038 createSMESHAction( SMESHOp::OpBoundingBox, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
4039 createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH", "ICON_MEASURE_LENGTH" );
4040 createSMESHAction( SMESHOp::OpPropertiesArea, "MEASURE_AREA", "ICON_MEASURE_AREA" );
4041 createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME", "ICON_MEASURE_VOLUME" );
4043 createSMESHAction( SMESHOp::OpHide, "HIDE", "ICON_HIDE" );
4044 createSMESHAction( SMESHOp::OpShow, "SHOW", "ICON_SHOW" );
4045 createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
4047 createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
4049 QList<int> aCtrlActions;
4050 aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode
4051 << SMESHOp::OpNodeConnectivityNb // node controls
4052 << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
4053 << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge // edge controls
4054 << SMESHOp::OpDeflection2D
4055 << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
4056 << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
4057 << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
4058 << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
4059 << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace // face controls
4060 << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
4061 << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
4062 << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume; // volume controls
4063 QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
4064 aCtrlGroup->setExclusive( true );
4065 for( int i = 0; i < aCtrlActions.size(); i++ )
4066 aCtrlGroup->addAction( action( aCtrlActions[i] ) );
4068 // ----- create menu --------------
4069 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
4070 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
4071 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
4072 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
4073 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
4074 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
4075 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
4076 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
4078 createMenu( separator(), fileId );
4080 QMenu* nodeMenu = new QMenu(); QMenu* edgeMenu = new QMenu();
4081 QMenu* faceMenu = new QMenu(); QMenu* volumeMenu = new QMenu();
4082 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
4083 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
4084 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10, -1, nodeMenu ),
4085 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10, -1, edgeMenu ),
4086 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10, -1, faceMenu ),
4087 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10, -1, volumeMenu ),
4088 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
4089 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
4090 //renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
4091 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
4092 basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
4094 //createMenu( SMESHOp::OpImportDAT, importId, -1 );
4095 createMenu( SMESHOp::OpImportUNV, importId, -1 );
4096 createMenu( SMESHOp::OpImportMED, importId, -1 );
4097 createMenu( SMESHOp::OpImportSTL, importId, -1 );
4099 createMenu( SMESHOp::OpImportCGNS, importId, -1 );
4101 createMenu( SMESHOp::OpImportSAUV, importId, -1 );
4102 createMenu( SMESHOp::OpImportGMF, importId, -1 );
4103 createMenu( SMESHOp::OpExportDAT, exportId, -1 );
4104 createMenu( SMESHOp::OpExportMED, exportId, -1 );
4105 createMenu( SMESHOp::OpExportUNV, exportId, -1 );
4106 createMenu( SMESHOp::OpExportSTL, exportId, -1 );
4108 createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
4110 createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
4111 createMenu( SMESHOp::OpExportGMF, exportId, -1 );
4112 createMenu( separator(), fileId, 10 );
4114 createMenu( SMESHOp::OpDelete, editId, -1 );
4116 createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
4118 createMenu( SMESHOp::OpCreateMesh, meshId, -1 ); // "Mesh" menu
4119 createMenu( SMESHOp::OpCreateSubMesh, meshId, -1 );
4120 createMenu( SMESHOp::OpEditMeshOrSubMesh, meshId, -1 );
4121 createMenu( SMESHOp::OpBuildCompoundMesh, meshId, -1 );
4122 createMenu( SMESHOp::OpCopyMesh, meshId, -1 );
4123 createMenu( separator(), meshId, -1 );
4124 createMenu( SMESHOp::OpCompute, meshId, -1 );
4125 createMenu( SMESHOp::OpPreCompute, meshId, -1 );
4126 createMenu( SMESHOp::OpEvaluate, meshId, -1 );
4127 createMenu( SMESHOp::OpMeshOrder, meshId, -1 );
4128 createMenu( separator(), meshId, -1 );
4129 createMenu( SMESHOp::OpCreateGroup, meshId, -1 );
4130 createMenu( SMESHOp::OpCreateGeometryGroup, meshId, -1 );
4131 createMenu( SMESHOp::OpConstructGroup, meshId, -1 );
4132 createMenu( SMESHOp::OpEditGroup, meshId, -1 );
4133 createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4134 createMenu( separator(), meshId, -1 );
4135 createMenu( SMESHOp::OpUnionGroups, meshId, -1 );
4136 createMenu( SMESHOp::OpIntersectGroups, meshId, -1 );
4137 createMenu( SMESHOp::OpCutGroups, meshId, -1 );
4138 createMenu( separator(), meshId, -1 );
4139 createMenu( SMESHOp::OpGroupUnderlyingElem, meshId, -1 );
4140 createMenu( separator(), meshId, -1 );
4141 createMenu( SMESHOp::OpMeshInformation, meshId, -1 );
4142 //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4143 //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4144 createMenu( SMESHOp::OpFindElementByPoint, meshId, -1 );
4145 createMenu( separator(), meshId, -1 );
4147 createMenu( SMESHOp::OpFreeNode, nodeId, -1 );
4148 createMenu( SMESHOp::OpEqualNode, nodeId, -1 );
4149 //createMenu( SMESHOp::OpNodeConnectivityNb, nodeId, -1 );
4150 createMenu( SMESHOp::OpFreeBorder, edgeId, -1 );
4151 createMenu( SMESHOp::OpLength, edgeId, -1 );
4152 createMenu( SMESHOp::OpConnection, edgeId, -1 );
4153 createMenu( SMESHOp::OpEqualEdge, edgeId, -1 );
4154 createMenu( SMESHOp::OpFreeEdge, faceId, -1 );
4155 createMenu( SMESHOp::OpFreeFace, faceId, -1 );
4156 createMenu( SMESHOp::OpBareBorderFace, faceId, -1 );
4157 createMenu( SMESHOp::OpOverConstrainedFace, faceId, -1 );
4158 createMenu( SMESHOp::OpLength2D, faceId, -1 );
4159 createMenu( SMESHOp::OpConnection2D, faceId, -1 );
4160 createMenu( SMESHOp::OpArea, faceId, -1 );
4161 createMenu( SMESHOp::OpTaper, faceId, -1 );
4162 createMenu( SMESHOp::OpAspectRatio, faceId, -1 );
4163 createMenu( SMESHOp::OpMinimumAngle, faceId, -1 );
4164 createMenu( SMESHOp::OpWarpingAngle, faceId, -1 );
4165 createMenu( SMESHOp::OpSkew, faceId, -1 );
4166 createMenu( SMESHOp::OpMaxElementLength2D, faceId, -1 );
4167 createMenu( SMESHOp::OpEqualFace, faceId, -1 );
4168 createMenu( SMESHOp::OpDeflection2D, faceId, -1 );
4169 createMenu( SMESHOp::OpAspectRatio3D, volumeId, -1 );
4170 createMenu( SMESHOp::OpVolume, volumeId, -1 );
4171 createMenu( SMESHOp::OpMaxElementLength3D, volumeId, -1 );
4172 createMenu( SMESHOp::OpBareBorderVolume, volumeId, -1 );
4173 createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4174 createMenu( SMESHOp::OpEqualVolume, volumeId, -1 );
4175 createMenu( separator(), ctrlId, -1 );
4176 createMenu( SMESHOp::OpReset, ctrlId, -1 );
4177 createMenu( separator(), ctrlId, -1 );
4178 createMenu( SMESHOp::OpOverallMeshQuality, ctrlId, -1 );
4180 createMenu( SMESHOp::OpNode, addId, -1 );
4181 createMenu( SMESHOp::OpElem0D, addId, -1 );
4182 createMenu( SMESHOp::OpElem0DOnElemNodes, addId, -1 );
4183 createMenu( SMESHOp::OpBall, addId, -1 );
4184 createMenu( SMESHOp::OpEdge, addId, -1 );
4185 createMenu( SMESHOp::OpTriangle, addId, -1 );
4186 createMenu( SMESHOp::OpQuadrangle, addId, -1 );
4187 createMenu( SMESHOp::OpPolygon, addId, -1 );
4188 createMenu( SMESHOp::OpTetrahedron, addId, -1 );
4189 createMenu( SMESHOp::OpHexahedron, addId, -1 );
4190 createMenu( SMESHOp::OpPentahedron, addId, -1 );
4191 createMenu( SMESHOp::OpPyramid, addId, -1 );
4192 createMenu( SMESHOp::OpHexagonalPrism, addId, -1 );
4193 createMenu( SMESHOp::OpPolyhedron, addId, -1 );
4194 createMenu( separator(), addId, -1 );
4195 createMenu( SMESHOp::OpQuadraticEdge, addId, -1 );
4196 createMenu( SMESHOp::OpQuadraticTriangle, addId, -1 );
4197 createMenu( SMESHOp::OpBiQuadraticTriangle , addId, -1 );
4198 createMenu( SMESHOp::OpQuadraticQuadrangle, addId, -1 );
4199 createMenu( SMESHOp::OpBiQuadraticQuadrangle, addId, -1 );
4200 createMenu( SMESHOp::OpQuadraticPolygon, addId, -1 );
4201 createMenu( SMESHOp::OpQuadraticTetrahedron, addId, -1 );
4202 createMenu( SMESHOp::OpQuadraticPyramid, addId, -1 );
4203 createMenu( SMESHOp::OpQuadraticPentahedron, addId, -1 );
4204 createMenu( SMESHOp::OpBiQuadraticPentahedron, addId, -1 );
4205 createMenu( SMESHOp::OpQuadraticHexahedron, addId, -1 );
4206 createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4208 createMenu( SMESHOp::OpRemoveNodes, removeId, -1 );
4209 createMenu( SMESHOp::OpRemoveElements, removeId, -1 );
4210 createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4211 createMenu( separator(), removeId, -1 );
4212 createMenu( SMESHOp::OpDeleteGroup, removeId, -1 );
4213 createMenu( separator(), removeId, -1 );
4214 createMenu( SMESHOp::OpClearMesh, removeId, -1 );
4216 //createMenu( SMESHOp::OpRenumberingNodes, renumId, -1 );
4217 //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4219 createMenu( SMESHOp::OpMergeNodes, transfId, -1 );
4220 createMenu( SMESHOp::OpMergeElements, transfId, -1 );
4221 createMenu( SMESHOp::OpTranslation, transfId, -1 );
4222 createMenu( SMESHOp::OpRotation, transfId, -1 );
4223 createMenu( SMESHOp::OpSymmetry, transfId, -1 );
4224 createMenu( SMESHOp::OpScale, transfId, -1 );
4225 createMenu( SMESHOp::OpOffset, transfId, -1 );
4226 createMenu( SMESHOp::OpSewing, transfId, -1 );
4227 createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4229 createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4230 createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4231 createMenu( SMESHOp::OpExtrusion, modifyId, -1 );
4232 createMenu( SMESHOp::OpExtrusionAlongAPath, modifyId, -1 );
4233 createMenu( SMESHOp::OpRevolution, modifyId, -1 );
4234 createMenu( SMESHOp::OpOrientation, modifyId, -1 );
4235 createMenu( SMESHOp::OpReorientFaces, modifyId, -1 );
4236 createMenu( SMESHOp::OpMoveNode, modifyId, -1 );
4237 createMenu( SMESHOp::OpDiagonalInversion, modifyId, -1 );
4238 createMenu( SMESHOp::OpUnionOfTwoTriangle, modifyId, -1 );
4239 createMenu( SMESHOp::OpUnionOfTriangles, modifyId, -1 );
4240 createMenu( SMESHOp::OpCuttingOfQuadrangles, modifyId, -1 );
4241 createMenu( SMESHOp::OpSplitVolumes, modifyId, -1 );
4242 createMenu( SMESHOp::OpSplitBiQuadratic, modifyId, -1 );
4243 createMenu( SMESHOp::OpSmoothing, modifyId, -1 );
4244 createMenu( SMESHOp::OpPatternMapping, modifyId, -1 );
4246 createMenu( SMESHOp::OpMinimumDistance, measureId, -1 );
4247 createMenu( SMESHOp::OpBoundingBox, measureId, -1 );
4248 createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4249 createMenu( SMESHOp::OpPropertiesArea, basicPropId, -1 );
4250 createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4251 createMenu( SMESHOp::OpUpdate, viewId, -1 );
4253 connect( nodeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4254 connect( edgeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4255 connect( faceMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4256 connect( volumeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4258 // ----- create toolbars --------------
4259 int meshTb = createTool( tr( "TB_MESH" ), QString( "SMESHMeshToolbar" ) ),
4260 info = createTool( tr( "TB_INFO" ), QString( "SMESHInformationToolbar" ) ),
4261 groupTb = createTool( tr( "TB_GROUP" ), QString( "SMESHGroupToolbar" ) ),
4262 ctrl0dTb = createTool( tr( "TB_CTRL0D" ), QString( "SMESHNodeControlsToolbar" ) ),
4263 ctrl1dTb = createTool( tr( "TB_CTRL1D" ), QString( "SMESHEdgeControlsToolbar" ) ),
4264 ctrl2dTb = createTool( tr( "TB_CTRL2D" ), QString( "SMESHFaceControlsToolbar" ) ),
4265 ctrl3dTb = createTool( tr( "TB_CTRL3D" ), QString( "SMESHVolumeControlsToolbar" ) ),
4266 addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ),
4267 addNonElemTb = createTool( tr( "TB_ADDNON" ), QString( "SMESHAddElementToolbar" ) ),
4268 remTb = createTool( tr( "TB_REM" ), QString( "SMESHRemoveToolbar" ) ),
4269 //renumbTb = createTool( tr( "TB_RENUMBER" ), QString( "SMESHRenumberingToolbar" ) ),
4270 transformTb = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ),
4271 modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ),
4272 measuremTb = createTool( tr( "TB_MEASUREM" ), QString( "SMESHMeasurementsToolbar" ) ),
4273 dispModeTb = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4275 createTool( SMESHOp::OpCreateMesh, meshTb );
4276 createTool( SMESHOp::OpCreateSubMesh, meshTb );
4277 createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4278 createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4279 createTool( SMESHOp::OpCopyMesh, meshTb );
4280 createTool( separator(), meshTb );
4281 createTool( SMESHOp::OpCompute, meshTb );
4282 createTool( SMESHOp::OpPreCompute, meshTb );
4283 createTool( SMESHOp::OpEvaluate, meshTb );
4284 createTool( SMESHOp::OpMeshOrder, meshTb );
4286 createTool( SMESHOp::OpCreateGroup, groupTb );
4287 createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4288 createTool( SMESHOp::OpConstructGroup, groupTb );
4289 createTool( SMESHOp::OpEditGroup, groupTb );
4291 createTool( SMESHOp::OpMeshInformation, info );
4292 //createTool( SMESHOp::OpStdInfo, meshTb );
4293 //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4294 createTool( SMESHOp::OpFindElementByPoint, info );
4296 createTool( SMESHOp::OpFreeNode, ctrl0dTb );
4297 createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4298 //createTool( SMESHOp::OpNodeConnectivityNb, ctrl0dTb );
4300 createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4301 createTool( SMESHOp::OpLength, ctrl1dTb );
4302 createTool( SMESHOp::OpConnection, ctrl1dTb );
4303 createTool( SMESHOp::OpEqualEdge, ctrl1dTb );
4305 createTool( SMESHOp::OpFreeEdge, ctrl2dTb );
4306 createTool( SMESHOp::OpFreeFace, ctrl2dTb );
4307 createTool( SMESHOp::OpBareBorderFace, ctrl2dTb );
4308 createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4309 createTool( SMESHOp::OpLength2D, ctrl2dTb );
4310 createTool( SMESHOp::OpConnection2D, ctrl2dTb );
4311 createTool( SMESHOp::OpArea, ctrl2dTb );
4312 createTool( SMESHOp::OpTaper, ctrl2dTb );
4313 createTool( SMESHOp::OpAspectRatio, ctrl2dTb );
4314 createTool( SMESHOp::OpMinimumAngle, ctrl2dTb );
4315 createTool( SMESHOp::OpWarpingAngle, ctrl2dTb );
4316 createTool( SMESHOp::OpSkew, ctrl2dTb );
4317 createTool( SMESHOp::OpMaxElementLength2D, ctrl2dTb );
4318 createTool( SMESHOp::OpEqualFace, ctrl2dTb );
4319 createTool( SMESHOp::OpDeflection2D, ctrl2dTb );
4321 createTool( SMESHOp::OpAspectRatio3D, ctrl3dTb );
4322 createTool( SMESHOp::OpVolume, ctrl3dTb );
4323 createTool( SMESHOp::OpMaxElementLength3D, ctrl3dTb );
4324 createTool( SMESHOp::OpBareBorderVolume, ctrl3dTb );
4325 createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
4326 createTool( SMESHOp::OpEqualVolume, ctrl3dTb );
4328 createTool( SMESHOp::OpNode, addElemTb );
4329 createTool( SMESHOp::OpElem0D, addElemTb );
4330 createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4331 createTool( SMESHOp::OpBall, addElemTb );
4332 createTool( SMESHOp::OpEdge, addElemTb );
4333 createTool( SMESHOp::OpTriangle, addElemTb );
4334 createTool( SMESHOp::OpQuadrangle, addElemTb );
4335 createTool( SMESHOp::OpPolygon, addElemTb );
4336 createTool( SMESHOp::OpTetrahedron, addElemTb );
4337 createTool( SMESHOp::OpHexahedron, addElemTb );
4338 createTool( SMESHOp::OpPentahedron, addElemTb );
4339 createTool( SMESHOp::OpPyramid, addElemTb );
4340 createTool( SMESHOp::OpHexagonalPrism, addElemTb );
4341 createTool( SMESHOp::OpPolyhedron, addElemTb );
4343 createTool( SMESHOp::OpQuadraticEdge, addNonElemTb );
4344 createTool( SMESHOp::OpQuadraticTriangle, addNonElemTb );
4345 createTool( SMESHOp::OpBiQuadraticTriangle, addNonElemTb );
4346 createTool( SMESHOp::OpQuadraticQuadrangle, addNonElemTb );
4347 createTool( SMESHOp::OpBiQuadraticQuadrangle, addNonElemTb );
4348 createTool( SMESHOp::OpQuadraticPolygon, addNonElemTb );
4349 createTool( SMESHOp::OpQuadraticTetrahedron, addNonElemTb );
4350 createTool( SMESHOp::OpQuadraticPyramid, addNonElemTb );
4351 createTool( SMESHOp::OpQuadraticPentahedron, addNonElemTb );
4352 createTool( SMESHOp::OpBiQuadraticPentahedron, addNonElemTb );
4353 createTool( SMESHOp::OpQuadraticHexahedron, addNonElemTb );
4354 createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4356 createTool( SMESHOp::OpRemoveNodes, remTb );
4357 createTool( SMESHOp::OpRemoveElements, remTb );
4358 createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4359 createTool( SMESHOp::OpClearMesh, remTb );
4361 //createTool( SMESHOp::OpRenumberingNodes, renumbTb );
4362 //createTool( SMESHOp::OpRenumberingElements, renumbTb );
4364 createTool( SMESHOp::OpMergeNodes, transformTb );
4365 createTool( SMESHOp::OpMergeElements, transformTb );
4366 createTool( SMESHOp::OpTranslation, transformTb );
4367 createTool( SMESHOp::OpRotation, transformTb );
4368 createTool( SMESHOp::OpSymmetry, transformTb );
4369 createTool( SMESHOp::OpScale, transformTb );
4370 createTool( SMESHOp::OpOffset, transformTb );
4371 createTool( SMESHOp::OpSewing, transformTb );
4372 createTool( SMESHOp::OpDuplicateNodes, transformTb );
4374 createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4375 createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4376 createTool( SMESHOp::OpExtrusion, modifyTb );
4377 createTool( SMESHOp::OpExtrusionAlongAPath, modifyTb );
4378 createTool( SMESHOp::OpRevolution, modifyTb );
4379 createTool( SMESHOp::OpOrientation, modifyTb );
4380 createTool( SMESHOp::OpReorientFaces, modifyTb );
4381 createTool( SMESHOp::OpMoveNode, modifyTb );
4382 createTool( SMESHOp::OpDiagonalInversion, modifyTb );
4383 createTool( SMESHOp::OpUnionOfTwoTriangle, modifyTb );
4384 createTool( SMESHOp::OpUnionOfTriangles, modifyTb );
4385 createTool( SMESHOp::OpCuttingOfQuadrangles, modifyTb );
4386 createTool( SMESHOp::OpSplitVolumes, modifyTb );
4387 createTool( SMESHOp::OpSplitBiQuadratic, modifyTb );
4388 createTool( SMESHOp::OpSmoothing, modifyTb );
4389 createTool( SMESHOp::OpPatternMapping, modifyTb );
4391 createTool( SMESHOp::OpMinimumDistance, measuremTb );
4393 createTool( SMESHOp::OpUpdate, dispModeTb );
4395 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4396 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4400 OB = "'ObjectBrowser'",
4401 View = "'" + SVTK_Viewer::Type() + "'",
4403 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4404 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4405 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4406 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4407 smesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::COMPONENT ) ),
4408 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4409 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4410 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4411 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4412 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4413 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4414 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4416 mesh_part = mesh + " " + subMesh + " " + group,
4417 mesh_group = mesh + " " + group,
4418 mesh_submesh = mesh + " " + subMesh,
4419 hyp_alg = hypo + " " + algo;
4421 // popup for object browser
4423 isInvisible("not( isVisible )"),
4424 isEmpty("numberOfNodes = 0"),
4425 isNotEmpty("numberOfNodes <> 0"),
4427 // has nodes, edges, etc in VISIBLE! actor
4428 hasNodes("(numberOfNodes > 0 ) && hasActor"),
4429 hasElems("(count( elemTypes ) > 0)"),
4430 hasDifferentElems("(count( elemTypes ) > 1)"),
4431 hasDifferentObjElems("(count( objElemTypes ) > 1)"),
4432 hasBalls("({'BallElem'} in elemTypes)"),
4433 hasElems0d("({'Elem0d'} in elemTypes)"),
4434 hasEdges("({'Edge'} in elemTypes)"),
4435 hasFaces("({'Face'} in elemTypes)"),
4436 hasVolumes("({'Volume'} in elemTypes)"),
4437 hasFacesOrVolumes("(({'Face'} in elemTypes) || ({'Volume'} in elemTypes)) ");
4439 createPopupItem( SMESHOp::OpFileInformation, OB, mesh, "&& selcount=1 && isImported" );
4440 createPopupItem( SMESHOp::OpCreateSubMesh, OB, mesh, "&& hasGeomReference");
4441 createPopupItem( SMESHOp::OpEditMesh, OB, mesh, "&& selcount=1" );
4442 createPopupItem( SMESHOp::OpEditSubMesh, OB, subMesh, "&& selcount=1 && hasGeomReference" );
4443 createPopupItem( SMESHOp::OpEditGroup, OB, group );
4444 createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4446 popupMgr()->insert( separator(), -1, 0 );
4447 createPopupItem( SMESHOp::OpCompute, OB, mesh, "&& selcount=1 && isComputable" );
4448 createPopupItem( SMESHOp::OpComputeSubMesh, OB, subMesh, "&& selcount=1 && isComputable" );
4449 createPopupItem( SMESHOp::OpPreCompute, OB, mesh, "&& selcount=1 && isPreComputable" );
4450 createPopupItem( SMESHOp::OpEvaluate, OB, mesh, "&& selcount=1 && isComputable" );
4451 createPopupItem( SMESHOp::OpMeshOrder, OB, mesh, "&& selcount=1 && isComputable && hasGeomReference" );
4452 createPopupItem( SMESHOp::OpUpdate, OB, mesh_part );
4453 createPopupItem( SMESHOp::OpMeshInformation, OB, mesh_part );
4454 createPopupItem( SMESHOp::OpFindElementByPoint,OB, mesh_group, "&& selcount=1" );
4455 createPopupItem( SMESHOp::OpOverallMeshQuality,OB, mesh_part );
4456 popupMgr()->insert( separator(), -1, 0 );
4457 createPopupItem( SMESHOp::OpCreateGroup, OB, mesh, "&& selcount=1" );
4458 createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh, "&& selcount=1 && hasGeomReference" );
4459 createPopupItem( SMESHOp::OpConstructGroup, OB, subMesh );
4460 popupMgr()->insert( separator(), -1, 0 );
4461 createPopupItem( SMESHOp::OpEditHypothesis, OB, hypo, "&& isEditableHyp");
4462 createPopupItem( SMESHOp::OpUnassign, OB, hyp_alg );
4463 popupMgr()->insert( separator(), -1, 0 );
4464 createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh_submesh );
4465 createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh_group, "&& selcount=1 && dim>=2");
4466 popupMgr()->insert( separator(), -1, 0 );
4467 createPopupItem( SMESHOp::OpClearMesh, OB, mesh );
4468 //popupMgr()->insert( separator(), -1, 0 );
4470 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4471 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4472 QString only_one_2D = only_one_non_empty + " && dim>1";
4474 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4475 createPopupItem( SMESHOp::OpPopupExportMED, OB, mesh_group, multiple_non_empty, anId );
4476 createPopupItem( SMESHOp::OpPopupExportUNV, OB, mesh_group, only_one_non_empty, anId );
4477 createPopupItem( SMESHOp::OpPopupExportSTL, OB, mesh_group, only_one_2D, anId );
4479 createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4481 createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, only_one_non_empty, anId );
4482 createPopupItem( SMESHOp::OpPopupExportGMF, OB, mesh_group, only_one_non_empty, anId );
4483 createPopupItem( SMESHOp::OpPopupExportDAT, OB, mesh_group, only_one_non_empty, anId );
4484 createPopupItem( SMESHOp::OpDelete, OB, mesh_part + " " + hyp_alg );
4485 createPopupItem( SMESHOp::OpDeleteGroup, OB, group );
4487 anId = popupMgr()->insert( tr( "MEN_IMPORT" ), -1, -1 ); // IMPORT submenu
4488 createPopupItem( SMESHOp::OpPopupImportMED, OB, smesh, "", anId );
4489 createPopupItem( SMESHOp::OpPopupImportUNV, OB, smesh, "", anId );
4490 createPopupItem( SMESHOp::OpPopupImportSTL, OB, smesh, "", anId );
4492 createPopupItem( SMESHOp::OpPopupImportCGNS, OB, smesh, "", anId );
4494 createPopupItem( SMESHOp::OpPopupImportSAUV, OB, smesh, "", anId );
4495 createPopupItem( SMESHOp::OpPopupImportGMF, OB, smesh, "", anId );
4496 createPopupItem( SMESHOp::OpPopupImportDAT, OB, smesh, "", anId );
4497 popupMgr()->insert( separator(), -1, 0 );
4500 createPopupItem( SMESHOp::OpEditGroup, View, group );
4501 createPopupItem( SMESHOp::OpAddElemGroupPopup, View, elems, "&& guiState = 800" );
4502 createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems, "&& guiState = 800" );
4504 popupMgr()->insert( separator(), -1, 0 );
4505 createPopupItem( SMESHOp::OpUpdate, View, mesh_part );
4506 createPopupItem( SMESHOp::OpMeshInformation, View, mesh_part );
4507 createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4508 createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh );
4509 popupMgr()->insert( separator(), -1, 0 );
4511 createPopupItem( SMESHOp::OpAutoColor, OB + " " + View, mesh, "&& (not isAutoColor)" );
4512 createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4513 popupMgr()->insert( separator(), -1, 0 );
4515 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4516 QString aType = QString( "%1type in {%2}" ).arg( lc );
4517 aType = aType.arg( mesh_part );
4518 QString aMeshInVTK = aClient + "&&" + aType;
4520 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4521 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4522 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4524 //-------------------------------------------------
4526 //-------------------------------------------------
4527 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4529 popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4530 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4531 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4533 popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4534 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4535 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4537 popupMgr()->insert( separator(), -1, -1 );
4539 //-------------------------------------------------
4541 //-------------------------------------------------
4542 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4544 popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4545 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4546 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4548 popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4549 popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4550 popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4552 popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4553 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4554 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4556 popupMgr()->insert( separator(), anId, -1 );
4558 popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4559 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4560 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4562 //-------------------------------------------------
4564 //-------------------------------------------------
4565 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4567 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4569 popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4570 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4571 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4573 popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4574 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4575 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4577 popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4578 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4579 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4581 popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4582 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4583 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4585 popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4586 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4587 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4589 popupMgr()->insert( separator(), anId, -1 );
4591 popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4592 popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&& $type in {" + mesh + "} &&" + hasDifferentObjElems, QtxPopupMgr::VisibleRule );
4594 popupMgr()->insert( separator(), anId, -1 );
4596 popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4597 popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4600 //-------------------------------------------------
4601 // Representation of the 2D Quadratic elements
4602 //-------------------------------------------------
4603 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4604 popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4605 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "&& isVisible && isQuadratic",QtxPopupMgr::VisibleRule );
4606 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4608 popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4609 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "&& isVisible && isQuadratic", QtxPopupMgr::VisibleRule );
4610 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4612 //-------------------------------------------------
4613 // Orientation of faces
4614 //-------------------------------------------------
4615 popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4616 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4617 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4619 //-------------------------------------------------
4621 //-------------------------------------------------
4622 popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4623 popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4625 //-------------------------------------------------
4627 //-------------------------------------------------
4628 popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4629 popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4631 //-------------------------------------------------
4633 //-------------------------------------------------
4635 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4636 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4637 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4638 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4640 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4642 popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4643 popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4645 popupMgr()->insert( separator(), anId, -1 );
4647 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4649 popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4650 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4651 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4653 popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4654 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4655 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4657 // popupMgr()->insert( action( SMESHOp::OpNodeConnectivityNb ), aSubId, -1 );
4658 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4659 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), "controlMode = 'eNodeConnectivityNb'", QtxPopupMgr::ToggleRule );
4661 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4663 popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4664 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVTK + "&&" + hasEdges + "&&" + hasFacesOrVolumes, QtxPopupMgr::VisibleRule );
4665 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4667 popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4668 popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4669 popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4671 popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4672 popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4673 popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4674 popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4675 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4676 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4678 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4680 popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4681 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4682 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4684 popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4685 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4686 QtxPopupMgr::VisibleRule );
4687 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4689 popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4690 popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4691 popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4693 popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4694 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4695 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4697 popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
4698 popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4699 popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4701 popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
4702 popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4703 popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4705 popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
4706 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4707 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4709 popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
4710 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4711 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4713 popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
4714 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4715 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4717 popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
4718 popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4719 popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4721 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
4722 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4723 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4725 popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
4726 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4727 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4729 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
4730 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4731 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4733 popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
4734 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4735 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4737 popupMgr()->insert ( action( SMESHOp::OpDeflection2D ), aSubId, -1 );
4738 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), aMeshInVtkHasFaces + " && hasGeomReference", QtxPopupMgr::VisibleRule );
4739 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), "controlMode = 'eDeflection2D'", QtxPopupMgr::ToggleRule );
4741 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4743 popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D ), aSubId, -1 );
4744 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4745 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4747 popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
4748 popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4749 popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4751 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
4752 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4753 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4755 popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
4756 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4757 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4759 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
4760 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4761 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4763 popupMgr()->insert ( action( SMESHOp::OpEqualVolume ), aSubId, -1 );
4764 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4765 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4767 popupMgr()->insert( separator(), anId, -1 );
4769 popupMgr()->insert( action( SMESHOp::OpShowScalarBar ), anId, -1 );
4770 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4771 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone' && isScalarBarVisible", QtxPopupMgr::ToggleRule );
4772 popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
4773 popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4775 popupMgr()->insert( separator(), anId, -1 );
4777 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4779 popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
4780 popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4782 popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
4783 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4784 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isScalarBarVisible && isDistributionVisible", QtxPopupMgr::ToggleRule);
4786 #ifndef DISABLE_PLOT2DVIEWER
4787 popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
4788 popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4791 //-------------------------------------------------
4793 //-------------------------------------------------
4794 popupMgr()->insert( separator(), -1, -1 );
4795 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4796 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4797 popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
4798 popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4800 popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
4801 popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4803 popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
4804 popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4806 popupMgr()->insert( separator(), -1, -1 );
4808 //-------------------------------------------------
4810 //-------------------------------------------------
4811 popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
4812 popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4814 popupMgr()->insert( separator(), -1, -1 );
4816 popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
4817 popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
4818 popupMgr()->insert( separator(), -1, -1 );
4820 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4821 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4823 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4824 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4827 //================================================================================
4829 * \brief Return true if SMESH or GEOM objects are selected.
4830 * Is called form LightApp_Module::activateModule() which clear selection if
4831 * not isSelectionCompatible()
4833 //================================================================================
4835 bool SMESHGUI::isSelectionCompatible()
4837 bool isCompatible = true;
4838 SALOME_ListIO selected;
4839 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4840 Sel->selectedObjects( selected );
4842 SALOME_ListIteratorOfListIO It( selected );
4843 for ( ; isCompatible && It.More(); It.Next())
4845 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4846 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4848 return isCompatible;
4852 bool SMESHGUI::reusableOperation( const int id )
4854 // compute, evaluate and precompute are not reusable operations
4855 return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate ) ? false : SalomeApp_Module::reusableOperation( id );
4858 bool SMESHGUI::activateModule( SUIT_Study* study )
4860 bool res = SalomeApp_Module::activateModule( study );
4862 setMenuShown( true );
4863 setToolShown( true );
4865 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4866 PyGILState_STATE gstate = PyGILState_Ensure();
4867 PyObject* pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4868 if ( !pluginsmanager ) {
4872 PyObject* result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toUtf8().data(),tr("SMESH_PLUGINS_OTHER").toUtf8().data());
4877 PyGILState_Release(gstate);
4878 // end of SMESH plugins loading
4880 // Reset actions accelerator keys
4881 action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
4883 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4884 GetSMESHGen()->UpdateStudy();
4886 // get all view currently opened in the study and connect their signals to
4887 // the corresponding slots of the class.
4888 SUIT_Desktop* aDesk = study->application()->desktop();
4890 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4891 SUIT_ViewWindow* wnd;
4892 foreach ( wnd, wndList )
4896 Py_XDECREF(pluginsmanager);
4900 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4902 setMenuShown( false );
4903 setToolShown( false );
4905 EmitSignalCloseAllDialogs();
4907 // Unset actions accelerator keys
4908 action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
4910 return SalomeApp_Module::deactivateModule( study );
4913 void SMESHGUI::studyClosed( SUIT_Study* s )
4917 SMESH::RemoveVisuData();
4918 SalomeApp_Module::studyClosed( s );
4921 void SMESHGUI::OnGUIEvent()
4923 const QObject* obj = sender();
4924 if ( !obj || !obj->inherits( "QAction" ) )
4926 int id = actionId((QAction*)obj);
4931 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4933 if ( CORBA::is_nil( myComponentSMESH ) )
4935 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4936 return aGUI.myComponentSMESH;
4938 return myComponentSMESH;
4941 QString SMESHGUI::engineIOR() const
4943 CORBA::ORB_var anORB = getApp()->orb();
4944 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4945 return QString( anIOR.in() );
4948 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4950 SalomeApp_Module::contextMenuPopup( client, menu, title );
4952 selectionMgr()->selectedObjects( lst );
4953 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4954 Handle(SALOME_InteractiveObject) io = lst.First();
4955 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4956 _PTR(Study) study = appStudy->studyDS();
4957 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4959 QString aName = QString( SMESH::fromUtf8(obj->GetName()) );
4960 while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4961 aName.remove( (aName.length() - 1), 1 );
4967 LightApp_Selection* SMESHGUI::createSelection() const
4969 return new SMESHGUI_Selection();
4972 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4974 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4975 aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
4976 #ifndef DISABLE_PYCONSOLE
4977 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4981 void SMESHGUI::viewManagers( QStringList& list ) const
4983 list.append( SVTK_Viewer::Type() );
4986 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4988 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4989 SMESH::UpdateSelectionProp( this );
4991 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
4992 for(int i = 0; i < aViews.count() ; i++){
4993 SUIT_ViewWindow *sf = aViews[i];
4996 EmitSignalActivatedViewManager();
5000 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
5002 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
5003 myClippingPlaneInfoMap.erase( theViewManager );
5006 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
5008 theActor->AddObserver( SMESH::DeleteActorEvent,
5009 myEventCallbackCommand.GetPointer(),
5013 void SMESHGUI::ProcessEvents( vtkObject* theObject,
5014 unsigned long theEvent,
5015 void* theClientData,
5018 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
5019 if( theObject && (int) theEvent == SMESH::DeleteActorEvent ) {
5020 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
5021 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
5022 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
5023 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
5024 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
5025 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
5026 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
5027 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
5028 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
5029 SMESH::TActorList::iterator anIter3 = anActorList.begin();
5030 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
5031 if( anActor == *anIter3 ) {
5032 anActorList.erase( anIter3 );
5043 void SMESHGUI::createPreferences()
5045 // General tab ------------------------------------------------------------------------
5046 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
5048 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
5049 setPreferenceProperty( autoUpdate, "columns", 2 );
5050 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
5051 setPreferenceProperty( lim, "min", 0 );
5052 setPreferenceProperty( lim, "max", 100000000 );
5053 setPreferenceProperty( lim, "step", 1000 );
5054 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5055 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
5057 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
5058 setPreferenceProperty( dispgroup, "columns", 2 );
5059 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
5061 modes.append( tr("MEN_WIRE") );
5062 modes.append( tr("MEN_SHADE") );
5063 modes.append( tr("MEN_NODES") );
5064 modes.append( tr("MEN_SHRINK") );
5065 QList<QVariant> indices;
5066 indices.append( 0 );
5067 indices.append( 1 );
5068 indices.append( 2 );
5069 indices.append( 3 );
5070 setPreferenceProperty( dispmode, "strings", modes );
5071 setPreferenceProperty( dispmode, "indexes", indices );
5073 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
5074 setPreferenceProperty( arcgroup, "columns", 2 );
5075 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
5076 QStringList quadraticModes;
5077 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
5078 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
5080 indices.append( 0 );
5081 indices.append( 1 );
5082 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
5083 setPreferenceProperty( quadraticmode, "indexes", indices );
5085 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
5086 "SMESH", "max_angle" );
5087 setPreferenceProperty( maxAngle, "min", 1 );
5088 setPreferenceProperty( maxAngle, "max", 90 );
5090 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
5091 setPreferenceProperty( qaGroup, "columns", 2 );
5092 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
5093 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
5094 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
5095 setPreferenceProperty( prec, "min", 0 );
5096 setPreferenceProperty( prec, "max", 100 );
5097 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
5098 setPreferenceProperty( doubleNodesTol, "precision", 10 );
5099 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
5100 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
5101 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
5104 int cinc = addPreference(tr("PREF_CONTROLS_INCREMENT"), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_increment");
5105 setPreferenceProperty( cinc, "min", 0 );
5106 setPreferenceProperty( cinc, "max", 5 );
5109 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
5110 setPreferenceProperty( exportgroup, "columns", 2 );
5111 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
5112 addPreference( tr( "PREF_SHOW_WARN" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "show_warning" );
5113 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
5115 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
5116 setPreferenceProperty( computeGroup, "columns", 2 );
5117 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
5119 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5120 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5121 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5123 indices.append( 0 );
5124 indices.append( 1 );
5125 indices.append( 2 );
5126 setPreferenceProperty( notifyMode, "strings", modes );
5127 setPreferenceProperty( notifyMode, "indexes", indices );
5129 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5130 setPreferenceProperty( infoGroup, "columns", 2 );
5131 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5133 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5134 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5136 indices.append( 0 );
5137 indices.append( 1 );
5138 setPreferenceProperty( elemInfo, "strings", modes );
5139 setPreferenceProperty( elemInfo, "indexes", indices );
5140 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5141 setPreferenceProperty( nodesLim, "min", 0 );
5142 setPreferenceProperty( nodesLim, "max", 10000000 );
5143 setPreferenceProperty( nodesLim, "step", 10000 );
5144 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5145 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5146 setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5147 setPreferenceProperty( ctrlLim, "min", 0 );
5148 setPreferenceProperty( ctrlLim, "max", 10000000 );
5149 setPreferenceProperty( ctrlLim, "step", 1000 );
5150 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5151 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5152 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5153 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5154 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5156 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5157 setPreferenceProperty( segGroup, "columns", 2 );
5158 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5159 "SMESH", "segmentation" );
5160 setPreferenceProperty( segLen, "min", 1 );
5161 setPreferenceProperty( segLen, "max", 10000000 );
5162 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5163 "SMESH", "nb_segments_per_edge" );
5164 setPreferenceProperty( nbSeg, "min", 1 );
5165 setPreferenceProperty( nbSeg, "max", 10000000 );
5167 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5168 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5169 "SMESH", "forget_mesh_on_hyp_modif" );
5172 // Quantities with individual precision settings
5173 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5174 setPreferenceProperty( precGroup, "columns", 2 );
5176 const int nbQuantities = 6;
5177 int precs[nbQuantities], ii = 0;
5178 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5179 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5180 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5181 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5182 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5183 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5184 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5185 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5186 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5187 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5188 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5189 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5191 // Set property for precision value for spinboxes
5192 for ( ii = 0; ii < nbQuantities; ii++ ){
5193 setPreferenceProperty( precs[ii], "min", -14 );
5194 setPreferenceProperty( precs[ii], "max", 14 );
5195 setPreferenceProperty( precs[ii], "precision", 2 );
5198 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5199 setPreferenceProperty( previewGroup, "columns", 2 );
5200 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5201 setPreferenceProperty( chunkSize, "min", 1 );
5202 setPreferenceProperty( chunkSize, "max", 1000 );
5203 setPreferenceProperty( chunkSize, "step", 50 );
5205 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5206 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5208 // Mesh tab ------------------------------------------------------------------------
5209 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5210 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5211 setPreferenceProperty( nodeGroup, "columns", 3 );
5213 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5215 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5217 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5218 QList<QVariant> aMarkerTypeIndicesList;
5219 QList<QVariant> aMarkerTypeIconsList;
5220 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5221 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5222 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5223 aMarkerTypeIndicesList << i;
5224 aMarkerTypeIconsList << pixmap;
5226 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5227 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
5229 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5231 QList<QVariant> aMarkerScaleIndicesList;
5232 QStringList aMarkerScaleValuesList;
5233 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5234 aMarkerScaleIndicesList << i;
5235 //aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5236 aMarkerScaleValuesList << QString::number( i );
5238 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5239 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5241 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5242 //setPreferenceProperty( elemGroup, "columns", 2 );
5244 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5245 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5246 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5247 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5248 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5249 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5250 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5251 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5252 addPreference( tr( "PREF_PREVIEW_COLOR" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5255 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5256 setPreferenceProperty( grpGroup, "columns", 2 );
5258 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5259 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5261 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5262 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5263 /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5264 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5265 double ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5266 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5267 double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5268 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5269 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
5270 LightApp_Preferences::IntSpin, "SMESH", "element_width");
5271 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5272 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5273 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5274 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5276 setPreferenceProperty( size0d, "min", 1 );
5277 setPreferenceProperty( size0d, "max", 10 );
5279 // setPreferenceProperty( ballSize, "min", 1 );
5280 // setPreferenceProperty( ballSize, "max", 10 );
5282 setPreferenceProperty( ballDiameter, "min", 1e-7 );
5283 setPreferenceProperty( ballDiameter, "max", 1e9 );
5284 setPreferenceProperty( ballDiameter, "step", 0.1 );
5286 setPreferenceProperty( ballScale, "min", 1e-2 );
5287 setPreferenceProperty( ballScale, "max", 1e7 );
5288 setPreferenceProperty( ballScale, "step", 0.5 );
5290 setPreferenceProperty( elemW, "min", 1 );
5291 setPreferenceProperty( elemW, "max", 5 );
5293 setPreferenceProperty( outW, "min", 1 );
5294 setPreferenceProperty( outW, "max", 5 );
5296 setPreferenceProperty( shrink, "min", 0 );
5297 setPreferenceProperty( shrink, "max", 100 );
5299 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5300 setPreferenceProperty( numGroup, "columns", 2 );
5302 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5303 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5305 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5306 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5308 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5309 setPreferenceProperty( orientGroup, "columns", 1 );
5311 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5312 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5314 setPreferenceProperty( orientScale, "min", 0.05 );
5315 setPreferenceProperty( orientScale, "max", 0.5 );
5316 setPreferenceProperty( orientScale, "step", 0.05 );
5318 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5320 // Selection tab ------------------------------------------------------------------------
5321 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5323 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5324 setPreferenceProperty( selGroup, "columns", 2 );
5326 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5327 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5329 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5330 setPreferenceProperty( preGroup, "columns", 2 );
5332 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5334 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5335 setPreferenceProperty( precSelGroup, "columns", 2 );
5337 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5338 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5339 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5341 int sinc = addPreference(tr("PREF_SELECTION_INCREMENT"), selTab, LightApp_Preferences::IntSpin, "SMESH", "selection_increment");
5342 setPreferenceProperty( sinc, "min", 0 );
5343 setPreferenceProperty( sinc, "max", 5 );
5345 // Scalar Bar tab ------------------------------------------------------------------------
5346 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5347 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5348 setPreferenceProperty( fontGr, "columns", 2 );
5350 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5351 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5353 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5354 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5356 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5357 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5359 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5360 setPreferenceProperty( numcol, "min", 2 );
5361 setPreferenceProperty( numcol, "max", 256 );
5363 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5364 setPreferenceProperty( numlab, "min", 2 );
5365 setPreferenceProperty( numlab, "max", 65 );
5367 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5368 setPreferenceProperty( orientGr, "columns", 2 );
5369 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5370 QStringList orients;
5371 orients.append( tr( "SMESH_VERTICAL" ) );
5372 orients.append( tr( "SMESH_HORIZONTAL" ) );
5373 indices.clear(); indices.append( 0 ); indices.append( 1 );
5374 setPreferenceProperty( orient, "strings", orients );
5375 setPreferenceProperty( orient, "indexes", indices );
5377 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5378 setPreferenceProperty( posVSizeGr, "columns", 2 );
5379 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5380 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5381 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5382 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5383 setPreferenceProperty( xv, "step", 0.1 );
5384 setPreferenceProperty( xv, "min", 0.0 );
5385 setPreferenceProperty( xv, "max", 1.0 );
5386 setPreferenceProperty( yv, "step", 0.1 );
5387 setPreferenceProperty( yv, "min", 0.0 );
5388 setPreferenceProperty( yv, "max", 1.0 );
5389 setPreferenceProperty( wv, "step", 0.1 );
5390 setPreferenceProperty( wv, "min", 0.0 );
5391 setPreferenceProperty( wv, "max", 1.0 );
5392 setPreferenceProperty( hv, "min", 0.0 );
5393 setPreferenceProperty( hv, "max", 1.0 );
5394 setPreferenceProperty( hv, "step", 0.1 );
5396 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5397 setPreferenceProperty( posHSizeGr, "columns", 2 );
5398 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5399 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5400 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5401 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5402 setPreferenceProperty( xv, "min", 0.0 );
5403 setPreferenceProperty( xv, "max", 1.0 );
5404 setPreferenceProperty( xv, "step", 0.1 );
5405 setPreferenceProperty( xh, "min", 0.0 );
5406 setPreferenceProperty( xh, "max", 1.0 );
5407 setPreferenceProperty( xh, "step", 0.1 );
5408 setPreferenceProperty( yh, "min", 0.0 );
5409 setPreferenceProperty( yh, "max", 1.0 );
5410 setPreferenceProperty( yh, "step", 0.1 );
5411 setPreferenceProperty( wh, "min", 0.0 );
5412 setPreferenceProperty( wh, "max", 1.0 );
5413 setPreferenceProperty( wh, "step", 0.1 );
5414 setPreferenceProperty( hh, "min", 0.0 );
5415 setPreferenceProperty( hh, "max", 1.0 );
5416 setPreferenceProperty( hh, "step", 0.1 );
5418 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5419 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5420 setPreferenceProperty( distributionGr, "columns", 3 );
5422 types.append( tr( "SMESH_MONOCOLOR" ) );
5423 types.append( tr( "SMESH_MULTICOLOR" ) );
5424 indices.clear(); indices.append( 0 ); indices.append( 1 );
5425 setPreferenceProperty( coloringType, "strings", types );
5426 setPreferenceProperty( coloringType, "indexes", indices );
5427 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5431 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5433 if ( sect=="SMESH" ) {
5434 float sbX1 = 0.01, sbY1 = 0.01, sbW = 0.08, sbH = 0.08;
5435 float aTol = 1.00000009999999;
5436 std::string aWarning;
5437 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5439 if ( name== "selection_object_color" ||
5440 name=="selection_element_color" ||
5441 name== "highlight_color" ||
5442 name=="selection_precision_node" ||
5443 name=="selection_precision_element" ||
5444 name=="selection_precision_object" ||
5445 name=="selection_increment")
5447 SMESH::UpdateSelectionProp( this );
5449 else if (name == "scalar_bar_vertical_x" || name == "scalar_bar_vertical_width")
5451 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5452 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5453 if ( sbX1+sbW > aTol ) {
5454 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5457 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5458 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5461 else if (name == "scalar_bar_vertical_y" || name == "scalar_bar_vertical_height" )
5463 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5464 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5465 if ( sbY1 + sbH > aTol ) {
5466 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5467 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5468 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5471 else if (name == "scalar_bar_horizontal_x" || name == "scalar_bar_horizontal_width")
5473 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5474 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5475 if ( sbX1 + sbW > aTol ) {
5476 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5479 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5480 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5483 else if (name == "scalar_bar_horizontal_y" || name == "scalar_bar_horizontal_height")
5485 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5486 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5487 if ( sbY1 + sbH > aTol ) {
5488 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5491 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5492 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5495 else if ( name == "segmentation" )
5497 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5498 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5500 else if ( name == "nb_segments_per_edge" )
5502 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5503 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5505 else if ( name == "historical_python_dump" || name == "forget_mesh_on_hyp_modif" || name == "default_grp_color" )
5507 QString val = aResourceMgr->stringValue( "SMESH", name );
5508 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5510 else if ( name == "numbering_node_color" || name == "numbering_node_font" )
5512 SMESH::UpdateFontProp( this );
5514 else if ( name == "numbering_elem_color" || name == "numbering_elem_font" )
5516 SMESH::UpdateFontProp( this );
5519 if ( aWarning.size() != 0 ) {
5520 aWarning += "The default values are applied instead.";
5521 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5522 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5523 QObject::tr(aWarning.c_str()));
5528 //================================================================================
5530 * \brief Update something in accordance with update flags
5531 * \param theFlags - update flags
5533 * Update viewer or/and object browser etc. in accordance with update flags ( see
5534 * LightApp_UpdateFlags enumeration ).
5536 //================================================================================
5537 void SMESHGUI::update( const int flags )
5539 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5540 SMESH::UpdateView();
5542 SalomeApp_Module::update( flags );
5545 //================================================================================
5547 * \brief Set default selection mode
5549 * SLOT called when operation committed. Sets default selection mode
5551 //================================================================================
5552 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5554 SVTK_ViewWindow* vtkWnd =
5555 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5557 vtkWnd->SetSelectionMode( ActorSelection );
5560 //================================================================================
5562 * \brief Set default selection mode
5564 * SLOT called when operation aborted. Sets default selection mode
5566 //================================================================================
5567 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5569 SVTK_ViewWindow* vtkWnd =
5570 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5572 vtkWnd->SetSelectionMode( ActorSelection );
5575 //================================================================================
5577 * \brief Creates operation with given identifier
5578 * \param id - identifier of operation to be started
5579 * \return Pointer on created operation or NULL if operation is not created
5581 * Virtual method redefined from the base class creates operation with given id.
5582 * It is called called automatically from startOperation method of base class.
5584 //================================================================================
5585 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5587 LightApp_Operation* op = 0;
5588 // to do : create operation here
5591 case SMESHOp::OpSplitBiQuadratic:
5592 op = new SMESHGUI_SplitBiQuadOp();
5594 case SMESHOp::OpConvertMeshToQuadratic:
5595 op = new SMESHGUI_ConvToQuadOp();
5597 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5598 op = new SMESHGUI_Make2DFrom3DOp();
5600 case SMESHOp::OpReorientFaces:
5601 op = new SMESHGUI_ReorientFacesOp();
5603 case SMESHOp::OpCreateMesh:
5604 op = new SMESHGUI_MeshOp( true, true );
5606 case SMESHOp::OpCreateSubMesh:
5607 op = new SMESHGUI_MeshOp( true, false );
5609 case SMESHOp::OpEditMeshOrSubMesh:
5610 case SMESHOp::OpEditMesh:
5611 case SMESHOp::OpEditSubMesh:
5612 op = new SMESHGUI_MeshOp( false );
5614 case SMESHOp::OpCompute:
5615 case SMESHOp::OpComputeSubMesh:
5616 op = new SMESHGUI_ComputeOp();
5618 case SMESHOp::OpPreCompute:
5619 op = new SMESHGUI_PrecomputeOp();
5621 case SMESHOp::OpEvaluate:
5622 op = new SMESHGUI_EvaluateOp();
5624 case SMESHOp::OpMeshOrder:
5625 op = new SMESHGUI_MeshOrderOp();
5627 case SMESHOp::OpCreateGeometryGroup:
5628 op = new SMESHGUI_GroupOnShapeOp();
5630 case SMESHOp::OpFindElementByPoint:
5631 op = new SMESHGUI_FindElemByPointOp();
5633 case SMESHOp::OpMoveNode: // Make mesh pass through point
5634 op = new SMESHGUI_MakeNodeAtPointOp();
5636 case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
5637 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5644 op = SalomeApp_Module::createOperation( id );
5648 //================================================================================
5650 * \brief Stops current operations and starts a given one
5651 * \param id - The id of the operation to start
5653 //================================================================================
5655 void SMESHGUI::switchToOperation(int id)
5657 activeStudy()->abortAllOperations();
5658 startOperation( id );
5661 LightApp_Displayer* SMESHGUI::displayer()
5664 myDisplayer = new SMESHGUI_Displayer( getApp() );
5668 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5671 int aTolerance = 64;
5672 int anIterations = 0;
5678 if( anIterations % aPeriod == 0 )
5681 if( aTolerance < 1 )
5685 aHue = (int)( 360.0 * rand() / RAND_MAX );
5688 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5689 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5690 for( ; it != itEnd; ++it )
5692 SALOMEDS::Color anAutoColor = *it;
5693 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5696 aQColor.getHsv( &h, &s, &v );
5697 if( abs( h - aHue ) < aTolerance )
5709 aColor.setHsv( aHue, 255, 255 );
5711 SALOMEDS::Color aSColor;
5712 aSColor.R = aColor.redF();
5713 aSColor.G = aColor.greenF();
5714 aSColor.B = aColor.blueF();
5719 const char* gSeparator = "_"; // character used to separate parameter names
5720 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5721 const char* gPathSep = "|"; // character used to separate paths
5724 * \brief Store visual parameters
5726 * This method is called just before the study document is saved.
5727 * Store visual parameters in AttributeParameter attribue(s)
5729 void SMESHGUI::storeVisualParameters (int savePoint)
5732 Kernel_Utils::Localizer loc;
5734 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5735 if (!appStudy || !appStudy->studyDS())
5737 _PTR(Study) studyDS = appStudy->studyDS();
5739 // componentName is used for encoding of entries when storing them in IParameters
5740 std::string componentName = myComponentSMESH->ComponentDataType();
5741 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5742 //if (!aSComponent) return;
5745 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5746 componentName.c_str(),
5748 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5750 // store custom markers
5751 if( !myMarkerMap.empty() )
5753 VTK::MarkerMap::const_iterator anIter = myMarkerMap.begin();
5754 for( ; anIter != myMarkerMap.end(); anIter++ )
5756 int anId = anIter->first;
5757 VTK::MarkerData aMarkerData = anIter->second;
5758 std::string aMarkerFileName = aMarkerData.first;
5759 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5760 if( aMarkerTexture.size() < 3 )
5761 continue; // should contain at least width, height and the first value
5763 QString aPropertyName( "texture" );
5764 aPropertyName += gSeparator;
5765 aPropertyName += QString::number( anId );
5767 QString aPropertyValue = aMarkerFileName.c_str();
5768 aPropertyValue += gPathSep;
5770 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5771 ushort aWidth = *aTextureIter++;
5772 ushort aHeight = *aTextureIter++;
5773 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5774 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5775 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5776 aPropertyValue += QString::number( *aTextureIter );
5778 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5782 // viewers counters are used for storing view_numbers in IParameters
5785 // main cycle to store parameters of displayed objects
5786 QList<SUIT_ViewManager*> lst;
5787 QList<SUIT_ViewManager*>::Iterator it;
5788 getApp()->viewManagers(lst);
5789 for (it = lst.begin(); it != lst.end(); it++)
5791 SUIT_ViewManager* vman = *it;
5792 QString vType = vman->getType();
5794 // saving VTK actors properties
5795 if (vType == SVTK_Viewer::Type())
5797 // store the clipping planes attached to the view manager
5798 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5799 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5800 if( anIter != myClippingPlaneInfoMap.end() )
5801 aClippingPlaneInfoList = anIter->second;
5803 if( !aClippingPlaneInfoList.empty() ) {
5804 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5805 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5807 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5808 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5810 QString aPropertyName( "ClippingPlane" );
5811 aPropertyName += gSeparator;
5812 aPropertyName += QString::number( vtkViewers );
5813 aPropertyName += gSeparator;
5814 aPropertyName += QString::number( anId );
5816 QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
5817 aPropertyValue += gDigitsSep;
5818 aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
5819 aPropertyValue += gDigitsSep;
5820 if ( aPlane->PlaneMode == SMESH::Absolute ) {
5821 aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
5822 aPropertyValue += gDigitsSep;
5823 aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
5824 aPropertyValue += gDigitsSep;
5825 aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
5826 aPropertyValue += gDigitsSep;
5827 aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
5828 aPropertyValue += gDigitsSep;
5829 aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
5830 aPropertyValue += gDigitsSep;
5831 aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
5832 aPropertyValue += gDigitsSep;
5833 aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
5835 else if ( aPlane->PlaneMode == SMESH::Relative ) {
5836 aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
5837 aPropertyValue += gDigitsSep;
5838 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5839 aPropertyValue += gDigitsSep;
5840 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5841 aPropertyValue += gDigitsSep;
5842 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5845 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5849 QVector<SUIT_ViewWindow*> views = vman->getViews();
5850 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5852 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5854 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5855 vtkActorCollection* allActors = aCopy.GetActors();
5856 allActors->InitTraversal();
5857 while (vtkActor* actor = allActors->GetNextActor())
5859 if (actor->GetVisibility()) // store only visible actors
5861 SMESH_Actor* aSmeshActor = 0;
5862 if (actor->IsA("SMESH_Actor"))
5863 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5864 if (aSmeshActor && aSmeshActor->hasIO())
5866 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5869 // entry is "encoded" = it does NOT contain component address,
5870 // since it is a subject to change on next component loading
5871 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5873 std::string param, vtkParam = vType.toLatin1().data();
5874 vtkParam += gSeparator;
5875 vtkParam += QString::number(vtkViewers).toLatin1().data();
5876 vtkParam += gSeparator;
5879 param = vtkParam + "Visibility";
5880 ip->setParameter(entry, param, "On");
5883 param = vtkParam + "Representation";
5884 ip->setParameter(entry, param, QString::number
5885 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5888 param = vtkParam + "IsShrunk";
5889 ip->setParameter(entry, param, QString::number
5890 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5892 // Displayed entities
5893 unsigned int aMode = aSmeshActor->GetEntityMode();
5894 bool isE = aMode & SMESH_Actor::eEdges;
5895 bool isF = aMode & SMESH_Actor::eFaces;
5896 bool isV = aMode & SMESH_Actor::eVolumes;
5897 bool is0d = aMode & SMESH_Actor::e0DElements;
5898 bool isB = aMode & SMESH_Actor::eBallElem;
5900 QString modeStr ("e");
5901 modeStr += gDigitsSep; modeStr += QString::number(isE);
5902 modeStr += gDigitsSep; modeStr += "f";
5903 modeStr += gDigitsSep; modeStr += QString::number(isF);
5904 modeStr += gDigitsSep; modeStr += "v";
5905 modeStr += gDigitsSep; modeStr += QString::number(isV);
5906 modeStr += gDigitsSep; modeStr += "0d";
5907 modeStr += gDigitsSep; modeStr += QString::number(is0d);
5908 modeStr += gDigitsSep; modeStr += "b";
5909 modeStr += gDigitsSep; modeStr += QString::number(isB);
5911 param = vtkParam + "Entities";
5912 ip->setParameter(entry, param, modeStr.toLatin1().data());
5918 aSmeshActor->GetSufaceColor(r, g, b, delta);
5919 QStringList colorStr;
5920 colorStr << "surface";
5921 colorStr << QString::number(r);
5922 colorStr << QString::number(g);
5923 colorStr << QString::number(b);
5925 colorStr << "backsurface";
5926 colorStr << QString::number(delta);
5928 aSmeshActor->GetVolumeColor(r, g, b, delta);
5929 colorStr << "volume";
5930 colorStr << QString::number(r);
5931 colorStr << QString::number(g);
5932 colorStr << QString::number(b);
5933 colorStr << QString::number(delta);
5935 aSmeshActor->GetEdgeColor(r, g, b);
5937 colorStr << QString::number(r);
5938 colorStr << QString::number(g);
5939 colorStr << QString::number(b);
5941 aSmeshActor->GetNodeColor(r, g, b);
5943 colorStr << QString::number(r);
5944 colorStr << QString::number(g);
5945 colorStr << QString::number(b);
5947 aSmeshActor->GetOutlineColor(r, g, b);
5948 colorStr << "outline";
5949 colorStr << QString::number(r);
5950 colorStr << QString::number(g);
5951 colorStr << QString::number(b);
5953 aSmeshActor->Get0DColor(r, g, b);
5954 colorStr << "elem0d";
5955 colorStr << QString::number(r);
5956 colorStr << QString::number(g);
5957 colorStr << QString::number(b);
5959 aSmeshActor->GetBallColor(r, g, b);
5961 colorStr << QString::number(r);
5962 colorStr << QString::number(g);
5963 colorStr << QString::number(b);
5965 aSmeshActor->GetFacesOrientationColor(r, g, b);
5966 colorStr << "orientation";
5967 colorStr << QString::number(r);
5968 colorStr << QString::number(g);
5969 colorStr << QString::number(b);
5971 param = vtkParam + "Colors";
5972 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
5975 QStringList sizeStr;
5977 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
5978 sizeStr << "outline";
5979 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
5980 sizeStr << "elem0d";
5981 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
5983 //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
5984 sizeStr << QString::number((double)aSmeshActor->GetBallSize());
5985 sizeStr << QString::number((double)aSmeshActor->GetBallScale());
5986 sizeStr << "shrink";
5987 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
5988 sizeStr << "orientation";
5989 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
5990 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
5992 param = vtkParam + "Sizes";
5993 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
5998 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5999 if( aMarkerType == VTK::MT_USER ) {
6000 markerStr += "custom";
6001 markerStr += gDigitsSep;
6002 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
6006 markerStr += gDigitsSep;
6007 markerStr += QString::number( (int)aMarkerType );
6008 markerStr += gDigitsSep;
6009 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
6012 param = vtkParam + "PointMarker";
6013 ip->setParameter(entry, param, markerStr.toLatin1().data());
6016 param = vtkParam + "Opacity";
6017 ip->setParameter(entry, param,
6018 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
6021 param = vtkParam + "ClippingPlane";
6023 if( !aClippingPlaneInfoList.empty() ) {
6024 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
6025 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
6027 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
6028 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
6029 SMESH::TActorList::iterator anIter2 = anActorList.begin();
6030 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
6031 if( aSmeshActor == *anIter2 ) {
6032 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
6033 QString::number( anId ).toLatin1().constData() );
6040 ip->setParameter( entry, param, "Off" );
6041 } // if (io->hasEntry())
6042 } // SMESH_Actor && hasIO
6044 } // while.. actors traversal
6048 } // if (SVTK view model)
6049 } // for (viewManagers)
6052 // data structures for clipping planes processing
6056 bool isOpenGLClipping;
6057 vtkIdType RelativeOrientation;
6060 int AbsoluteOrientation;
6061 double X, Y, Z, Dx, Dy, Dz;
6063 typedef std::list<TPlaneData> TPlaneDataList;
6064 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
6066 typedef std::list<vtkActor*> TActorList;
6069 TActorList ActorList;
6070 SUIT_ViewManager* ViewManager;
6072 typedef std::list<TPlaneInfo> TPlaneInfoList;
6073 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
6076 * \brief Restore visual parameters
6078 * This method is called after the study document is opened.
6079 * Restore visual parameters from AttributeParameter attribue(s)
6081 void SMESHGUI::restoreVisualParameters (int savePoint)
6084 Kernel_Utils::Localizer loc;
6086 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6087 if (!appStudy || !appStudy->studyDS())
6089 _PTR(Study) studyDS = appStudy->studyDS();
6091 // componentName is used for encoding of entries when storing them in IParameters
6092 std::string componentName = myComponentSMESH->ComponentDataType();
6093 //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
6094 //if (!aSComponent) return;
6097 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6098 componentName.c_str(),
6100 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6102 // restore custom markers and map of clipping planes
6103 TPlaneDataMap aPlaneDataMap;
6105 std::vector<std::string> properties = ip->getProperties();
6106 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
6108 std::string property = *propIt;
6109 QString aPropertyName( property.c_str() );
6110 QString aPropertyValue( ip->getProperty( property ).c_str() );
6112 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
6113 if( aPropertyNameList.isEmpty() )
6116 QString aPropertyType = aPropertyNameList[0];
6117 if( aPropertyType == "texture" )
6119 if( aPropertyNameList.size() != 2 )
6123 int anId = aPropertyNameList[1].toInt( &ok );
6124 if( !ok || anId < 1 )
6127 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
6128 if( aPropertyValueList.size() != 2 )
6131 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
6132 QString aMarkerTextureString = aPropertyValueList[1];
6133 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
6134 if( aMarkerTextureStringList.size() != 3 )
6138 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6143 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6147 VTK::MarkerTexture aMarkerTexture;
6148 aMarkerTexture.push_back( aWidth );
6149 aMarkerTexture.push_back( aHeight );
6151 QString aMarkerTextureData = aMarkerTextureStringList[2];
6152 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6154 QChar aChar = aMarkerTextureData.at( i );
6155 if( aChar.isDigit() )
6156 aMarkerTexture.push_back( aChar.digitValue() );
6159 myMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6161 else if( aPropertyType == "ClippingPlane" )
6163 if( aPropertyNameList.size() != 3 )
6167 int aViewId = aPropertyNameList[1].toInt( &ok );
6168 if( !ok || aViewId < 0 )
6172 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6173 if( !ok || aClippingPlaneId < 0 )
6176 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6177 if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6180 TPlaneData aPlaneData;
6181 aPlaneData.AbsoluteOrientation = false;
6182 aPlaneData.RelativeOrientation = 0;
6183 aPlaneData.Distance = aPlaneData.Angle[0] = aPlaneData.Angle[1] = 0;
6184 aPlaneData.X = aPlaneData.Y = aPlaneData.Z = 0;
6185 aPlaneData.Dx = aPlaneData.Dy = aPlaneData.Dz = 0;
6187 aPlaneData.Id = aClippingPlaneId;
6190 aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6195 aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6199 if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6202 aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6207 aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6212 aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6217 aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6222 aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6227 aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6232 aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6236 else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6238 aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6243 aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6248 aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6253 aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6258 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6259 aPlaneDataList.push_back( aPlaneData );
6263 TPlaneInfoMap aPlaneInfoMap;
6265 std::vector<std::string> entries = ip->getEntries();
6267 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6269 // entry is a normal entry - it should be "decoded" (setting base address of component)
6270 QString entry (ip->decodeEntry(*entIt).c_str());
6272 // Check that the entry corresponds to a real object in the Study
6273 // as the object may be deleted or modified after the visual state is saved.
6274 _PTR(SObject) so = studyDS->FindObjectID(entry.toUtf8().data());
6275 if (!so) continue; //Skip the not existent entry
6277 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6278 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6280 std::vector<std::string>::iterator namesIt = paramNames.begin();
6281 std::vector<std::string>::iterator valuesIt = paramValues.begin();
6283 // actors are stored in a map after displaying of them for
6284 // quicker access in the future: map < viewID to actor >
6285 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6287 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6289 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6290 // '_' is used as separator and should not be used in viewer type or parameter names.
6291 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6292 if (lst.size() != 3)
6295 QString viewerTypStr = lst[0];
6296 QString viewIndexStr = lst[1];
6297 QString paramNameStr = lst[2];
6300 int viewIndex = viewIndexStr.toUInt(&ok);
6301 if (!ok) // bad conversion of view index to integer
6305 if (viewerTypStr == SVTK_Viewer::Type())
6307 SMESH_Actor* aSmeshActor = 0;
6308 if (vtkActors.IsBound(viewIndex))
6309 aSmeshActor = vtkActors.Find(viewIndex);
6311 QList<SUIT_ViewManager*> lst;
6312 getApp()->viewManagers(viewerTypStr, lst);
6314 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6315 SUIT_ViewManager* vman = NULL;
6316 if (viewIndex >= 0 && viewIndex < lst.count())
6317 vman = lst.at(viewIndex);
6319 if (paramNameStr == "Visibility")
6321 if (!aSmeshActor && displayer() && vman)
6323 SUIT_ViewModel* vmodel = vman->getViewModel();
6324 // SVTK view model can be casted to SALOME_View
6325 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6327 // store displayed actor in a temporary map for quicker
6328 // access later when restoring other parameters
6329 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6330 vtkRenderer* Renderer = vtkView->getRenderer();
6331 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6332 vtkActorCollection* theActors = aCopy.GetActors();
6333 theActors->InitTraversal();
6334 bool isFound = false;
6335 vtkActor *ac = theActors->GetNextActor();
6336 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6337 if (ac->IsA("SMESH_Actor")) {
6338 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6339 if (aGeomAc->hasIO()) {
6340 Handle(SALOME_InteractiveObject) io = aGeomAc->getIO();
6341 if (io->hasEntry() && strcmp(io->getEntry(), entry.toUtf8().data()) == 0) {
6343 vtkActors.Bind(viewIndex, aGeomAc);
6349 } // if (paramNameStr == "Visibility")
6352 // the rest properties "work" with SMESH_Actor
6355 QString val ((*valuesIt).c_str());
6358 if (paramNameStr == "Representation") {
6359 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6362 else if (paramNameStr == "IsShrunk") {
6364 if (!aSmeshActor->IsShrunk())
6365 aSmeshActor->SetShrink();
6368 if (aSmeshActor->IsShrunk())
6369 aSmeshActor->UnShrink();
6372 // Displayed entities
6373 else if (paramNameStr == "Entities") {
6374 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6375 int aEntityMode = SMESH_Actor::eAllEntity;
6376 for ( int i = 0; i < mode.count(); i+=2 ) {
6377 if ( i < mode.count()-1 ) {
6378 QString type = mode[i];
6379 bool val = mode[i+1].toInt();
6380 if ( type == "e" && !val )
6381 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6382 else if ( type == "f" && !val )
6383 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6384 else if ( type == "v" && !val )
6385 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6386 else if ( type == "0d" && !val )
6387 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6388 else if ( type == "b" && !val )
6389 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6392 aSmeshActor->SetEntityMode( aEntityMode );
6395 else if (paramNameStr == "Colors") {
6396 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6403 QColor outlineColor;
6404 QColor orientationColor;
6410 // below lines are required to get default values for delta coefficients
6411 // of backface color for faces and color of reversed volumes
6412 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
6413 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6414 for ( int i = 0; i < colors.count(); i++ ) {
6415 QString type = colors[i];
6416 if ( type == "surface" ) {
6417 // face color is set by 3 values r:g:b, where
6418 // - r,g,b - is rgb color components
6419 if ( i+1 >= colors.count() ) break; // format error
6420 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6421 if ( i+2 >= colors.count() ) break; // format error
6422 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6423 if ( i+3 >= colors.count() ) break; // format error
6424 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6425 faceColor.setRgbF( r, g, b );
6428 else if ( type == "backsurface" ) {
6429 // backface color can be defined in several ways
6430 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6431 // - in latest versions, it is set as delta coefficient
6432 bool rgbOk = false, deltaOk;
6433 if ( i+1 >= colors.count() ) break; // format error
6434 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6435 int delta = colors[i+1].toInt( &deltaOk );
6437 if ( i+1 < colors.count() ) // index is shifted to 1
6438 g = colors[i+1].toDouble( &rgbOk );
6439 if ( rgbOk ) i++; // shift index
6440 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6441 b = colors[i+1].toDouble( &rgbOk );
6443 // - as currently there's no way to set directly backsurface color as it was before,
6444 // we ignore old dump where r,g,b triple was set
6445 // - also we check that delta parameter is set properly
6446 if ( !rgbOk && deltaOk )
6449 else if ( type == "volume" ) {
6450 // volume color is set by 4 values r:g:b:delta, where
6451 // - r,g,b - is a normal volume rgb color components
6452 // - delta - is a reversed volume color delta coefficient
6453 if ( i+1 >= colors.count() ) break; // format error
6454 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6455 if ( i+2 >= colors.count() ) break; // format error
6456 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6457 if ( i+3 >= colors.count() ) break; // format error
6458 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6459 if ( i+4 >= colors.count() ) break; // format error
6460 int delta = colors[i+4].toInt( &bOk );
6461 if ( !bOk ) break; // format error
6462 volumeColor.setRgbF( r, g, b );
6466 else if ( type == "edge" ) {
6467 // edge color is set by 3 values r:g:b, where
6468 // - r,g,b - is rgb color components
6469 if ( i+1 >= colors.count() ) break; // format error
6470 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6471 if ( i+2 >= colors.count() ) break; // format error
6472 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6473 if ( i+3 >= colors.count() ) break; // format error
6474 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6475 edgeColor.setRgbF( r, g, b );
6478 else if ( type == "node" ) {
6479 // node color is set by 3 values r:g:b, where
6480 // - r,g,b - is rgb color components
6481 if ( i+1 >= colors.count() ) break; // format error
6482 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6483 if ( i+2 >= colors.count() ) break; // format error
6484 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6485 if ( i+3 >= colors.count() ) break; // format error
6486 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6487 nodeColor.setRgbF( r, g, b );
6490 else if ( type == "elem0d" ) {
6491 // 0d element color is set by 3 values r:g:b, where
6492 // - r,g,b - is rgb color components
6493 if ( i+1 >= colors.count() ) break; // format error
6494 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6495 if ( i+2 >= colors.count() ) break; // format error
6496 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6497 if ( i+3 >= colors.count() ) break; // format error
6498 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6499 elem0dColor.setRgbF( r, g, b );
6502 else if ( type == "ball" ) {
6503 // ball color is set by 3 values r:g:b, where
6504 // - r,g,b - is rgb color components
6505 if ( i+1 >= colors.count() ) break; // format error
6506 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6507 if ( i+2 >= colors.count() ) break; // format error
6508 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6509 if ( i+3 >= colors.count() ) break; // format error
6510 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6511 ballColor.setRgbF( r, g, b );
6514 else if ( type == "outline" ) {
6515 // outline color is set by 3 values r:g:b, where
6516 // - r,g,b - is rgb color components
6517 if ( i+1 >= colors.count() ) break; // format error
6518 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6519 if ( i+2 >= colors.count() ) break; // format error
6520 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6521 if ( i+3 >= colors.count() ) break; // format error
6522 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6523 outlineColor.setRgbF( r, g, b );
6526 else if ( type == "orientation" ) {
6527 // orientation color is set by 3 values r:g:b, where
6528 // - r,g,b - is rgb color components
6529 if ( i+1 >= colors.count() ) break; // format error
6530 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6531 if ( i+2 >= colors.count() ) break; // format error
6532 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6533 if ( i+3 >= colors.count() ) break; // format error
6534 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6535 orientationColor.setRgbF( r, g, b );
6540 if ( nodeColor.isValid() )
6541 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6543 if ( edgeColor.isValid() )
6544 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6546 if ( faceColor.isValid() )
6547 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6549 if ( volumeColor.isValid() )
6550 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6551 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6552 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6554 if ( elem0dColor.isValid() )
6555 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6557 if ( ballColor.isValid() )
6558 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6560 if ( outlineColor.isValid() )
6561 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6562 // orientation color
6563 if ( orientationColor.isValid() )
6564 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6567 else if (paramNameStr == "Sizes") {
6568 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6571 int outlineWidth = -1;
6572 int elem0dSize = -1;
6573 //int ballSize = -1;
6574 double ballDiameter = -1.0;
6575 double ballScale = -1.0;
6576 double shrinkSize = -1;
6577 double orientationSize = -1;
6578 bool orientation3d = false;
6579 for ( int i = 0; i < sizes.count(); i++ ) {
6580 QString type = sizes[i];
6581 if ( type == "line" ) {
6582 // line (wireframe) width is given as single integer value
6583 if ( i+1 >= sizes.count() ) break; // format error
6584 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6588 if ( type == "outline" ) {
6589 // outline width is given as single integer value
6590 if ( i+1 >= sizes.count() ) break; // format error
6591 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6595 else if ( type == "elem0d" ) {
6596 // 0d element size is given as single integer value
6597 if ( i+1 >= sizes.count() ) break; // format error
6598 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6602 else if ( type == "ball" ) {
6603 // balls are specified by two values: size:scale, where
6604 // - size - is a integer value specifying size
6605 // - scale - is a double value specifying scale factor
6606 if ( i+1 >= sizes.count() ) break; // format error
6607 //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6608 double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6609 if ( i+2 >= sizes.count() ) break; // format error
6610 double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6616 else if ( type == "shrink" ) {
6617 // shrink factor is given as single floating point value
6618 if ( i+1 >= sizes.count() ) break; // format error
6619 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6623 else if ( type == "orientation" ) {
6624 // orientation vectors are specified by two values size:3d, where
6625 // - size - is a floating point value specifying scale factor
6626 // - 3d - is a boolean
6627 if ( i+1 >= sizes.count() ) break; // format error
6628 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6629 if ( i+2 >= sizes.count() ) break; // format error
6630 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6631 orientationSize = v1;
6632 orientation3d = (bool)v2;
6636 // line (wireframe) width
6637 if ( lineWidth > 0 )
6638 aSmeshActor->SetLineWidth( lineWidth );
6640 if ( outlineWidth > 0 )
6641 aSmeshActor->SetOutlineWidth( outlineWidth );
6642 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6643 aSmeshActor->SetOutlineWidth( lineWidth );
6645 if ( elem0dSize > 0 )
6646 aSmeshActor->Set0DSize( elem0dSize );
6648 /*if ( ballSize > 0 )
6649 aSmeshActor->SetBallSize( ballSize );*/
6651 if ( ballDiameter > 0 )
6652 aSmeshActor->SetBallSize( ballDiameter );
6654 if ( ballScale > 0.0 )
6655 aSmeshActor->SetBallScale( ballScale );
6657 if ( shrinkSize > 0 )
6658 aSmeshActor->SetShrinkFactor( shrinkSize );
6659 // orientation vectors
6660 if ( orientationSize > 0 ) {
6661 aSmeshActor->SetFacesOrientationScale( orientationSize );
6662 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6666 else if (paramNameStr == "PointMarker") {
6667 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6668 if( data.count() >= 2 ) {
6670 int aParam1 = data[1].toInt( &ok );
6672 if( data[0] == "std" && data.count() == 3 ) {
6673 int aParam2 = data[2].toInt( &ok );
6674 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6676 else if( data[0] == "custom" ) {
6677 VTK::MarkerMap::const_iterator markerIt = myMarkerMap.find( aParam1 );
6678 if( markerIt != myMarkerMap.end() ) {
6679 VTK::MarkerData aMarkerData = markerIt->second;
6680 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6687 else if (paramNameStr == "Opacity") {
6688 aSmeshActor->SetOpacity(val.toFloat());
6691 else if (paramNameStr.startsWith("ClippingPlane")) {
6692 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6693 // old format - val looks like "Off" or "1:0:0:0.5:0:0"
6694 // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
6695 // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
6696 // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
6697 // new format - val looks like "Off" or "0" (plane id)
6698 // (note: in new format "Off" value is used only for consistency,
6699 // so it is processed together with values in old format)
6700 bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
6701 if( anIsOldFormat ) {
6702 if (paramNameStr == "ClippingPlane1" || val == "Off")
6703 aSmeshActor->RemoveAllClippingPlanes();
6705 QList<SUIT_ViewManager*> lst;
6706 getApp()->viewManagers(viewerTypStr, lst);
6707 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6708 if (viewIndex >= 0 && viewIndex < lst.count()) {
6709 SUIT_ViewManager* vman = lst.at(viewIndex);
6710 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6712 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6714 SMESH::TActorList anActorList;
6715 anActorList.push_back( aSmeshActor );
6716 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
6717 aPlane->myViewWindow = vtkView;
6718 SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
6719 aPlane->PlaneMode = aMode;
6720 bool isOpenGLClipping = ( bool )vals[1].toInt();
6721 aPlane->IsOpenGLClipping = isOpenGLClipping;
6722 if ( aMode == SMESH::Absolute ) {
6723 aPlane->myAbsoluteOrientation = vals[2].toInt();
6724 aPlane->X = vals[3].toFloat();
6725 aPlane->Y = vals[4].toFloat();
6726 aPlane->Z = vals[5].toFloat();
6727 aPlane->Dx = vals[6].toFloat();
6728 aPlane->Dy = vals[7].toFloat();
6729 aPlane->Dz = vals[8].toFloat();
6731 else if ( aMode == SMESH::Relative ) {
6732 aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
6733 aPlane->myDistance = vals[3].toFloat();
6734 aPlane->myAngle[0] = vals[4].toFloat();
6735 aPlane->myAngle[1] = vals[5].toFloat();
6739 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6740 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6741 aClippingPlaneInfo.Plane = aPlane;
6742 aClippingPlaneInfo.ActorList = anActorList;
6743 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6751 int aPlaneId = val.toInt( &ok );
6752 if( ok && aPlaneId >= 0 ) {
6753 bool anIsDefinedPlane = false;
6754 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6755 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6756 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6757 TPlaneInfo& aPlaneInfo = *anIter;
6758 if( aPlaneInfo.PlaneId == aPlaneId ) {
6759 aPlaneInfo.ActorList.push_back( aSmeshActor );
6760 anIsDefinedPlane = true;
6764 if( !anIsDefinedPlane ) {
6765 TPlaneInfo aPlaneInfo;
6766 aPlaneInfo.PlaneId = aPlaneId;
6767 aPlaneInfo.ActorList.push_back( aSmeshActor );
6768 aPlaneInfo.ViewManager = vman;
6770 // to make the list sorted by plane id
6771 anIter = aPlaneInfoList.begin();
6772 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6773 const TPlaneInfo& aPlaneInfoRef = *anIter;
6774 if( aPlaneInfoRef.PlaneId > aPlaneId )
6777 aPlaneInfoList.insert( anIter, aPlaneInfo );
6782 } // if (aSmeshActor)
6783 } // other parameters than Visibility
6785 } // for names/parameters iterator
6786 } // for entries iterator
6788 // take into account planes with empty list of actors referred to them
6789 QList<SUIT_ViewManager*> aVMList;
6790 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6792 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6793 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6794 int aViewId = aPlaneDataIter->first;
6795 if( aViewId >= 0 && aViewId < aVMList.count() ) {
6796 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6798 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6800 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6801 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6802 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6803 const TPlaneData& aPlaneData = *anIter2;
6804 int aPlaneId = aPlaneData.Id;
6806 bool anIsFound = false;
6807 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6808 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6809 const TPlaneInfo& aPlaneInfo = *anIter3;
6810 if( aPlaneInfo.PlaneId == aPlaneId ) {
6817 TPlaneInfo aPlaneInfo; // ActorList field is empty
6818 aPlaneInfo.PlaneId = aPlaneId;
6819 aPlaneInfo.ViewManager = aViewManager;
6821 // to make the list sorted by plane id
6822 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6823 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6824 const TPlaneInfo& aPlaneInfoRef = *anIter4;
6825 if( aPlaneInfoRef.PlaneId > aPlaneId )
6828 aPlaneInfoList.insert( anIter4, aPlaneInfo );
6834 // add clipping planes to actors according to the restored parameters
6835 // and update the clipping plane map
6836 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6837 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6838 int aViewId = anIter1->first;
6839 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6841 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6842 if( anIter2 == aPlaneDataMap.end() )
6844 const TPlaneDataList& aPlaneDataList = anIter2->second;
6846 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6847 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6848 const TPlaneInfo& aPlaneInfo = *anIter3;
6849 int aPlaneId = aPlaneInfo.PlaneId;
6850 const TActorList& anActorList = aPlaneInfo.ActorList;
6851 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6855 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6859 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6861 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6862 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6863 const TPlaneData& aPlaneData = *anIter4;
6864 if( aPlaneData.Id == aPlaneId ) {
6865 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
6866 aPlane->myViewWindow = aViewWindow;
6867 aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
6868 aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
6869 if ( aPlane->PlaneMode == SMESH::Absolute ) {
6870 aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
6871 aPlane->X = aPlaneData.X;
6872 aPlane->Y = aPlaneData.Y;
6873 aPlane->Z = aPlaneData.Z;
6874 aPlane->Dx = aPlaneData.Dx;
6875 aPlane->Dy = aPlaneData.Dy;
6876 aPlane->Dz = aPlaneData.Dz;
6878 else if ( aPlane->PlaneMode == SMESH::Relative ) {
6879 aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
6880 aPlane->myDistance = aPlaneData.Distance;
6881 aPlane->myAngle[0] = aPlaneData.Angle[0];
6882 aPlane->myAngle[1] = aPlaneData.Angle[1];
6885 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6886 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6887 aClippingPlaneInfo.Plane = aPlane;
6888 aClippingPlaneInfo.ActorList = anActorList;
6889 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6900 // update all VTK views
6901 QList<SUIT_ViewManager*> lst;
6902 getApp()->viewManagers(lst);
6903 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6904 SUIT_ViewModel* vmodel = (*it)->getViewModel();
6905 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6906 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6907 // set OpenGL clipping planes
6908 VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
6909 vtkActorCollection* anAllActors = aCopy.GetActors();
6910 anAllActors->InitTraversal();
6911 while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
6912 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
6913 anActor->SetOpenGLClippingPlane();
6915 vtkView->getRenderer()->ResetCameraClippingRange();
6922 \brief Adds preferences for dfont of VTK viewer
6924 \param pIf group identifier
6925 \param param parameter
6926 \return identifier of preferences
6928 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
6930 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6932 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6935 fam.append( tr( "SMESH_FONT_ARIAL" ) );
6936 fam.append( tr( "SMESH_FONT_COURIER" ) );
6937 fam.append( tr( "SMESH_FONT_TIMES" ) );
6939 setPreferenceProperty( tfont, "fonts", fam );
6941 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6942 if ( needSize ) f = f | QtxFontEdit::Size;
6943 setPreferenceProperty( tfont, "features", f );
6949 \brief Actions after hypothesis edition
6950 Updates object browser after hypothesis edition
6952 void SMESHGUI::onHypothesisEdit( int result )
6955 SMESHGUI::Modified();
6956 updateObjBrowser( true );
6960 \brief Actions after choosing menu of control modes
6961 Updates control mode actions according to current selection
6963 void SMESHGUI::onUpdateControlActions()
6965 SALOME_ListIO selected;
6966 if ( LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr() )
6967 aSel->selectedObjects( selected );
6969 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
6970 if ( selected.Extent() ) {
6971 if ( selected.First()->hasEntry() ) {
6972 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( selected.First()->getEntry() )) {
6973 aControl = anActor->GetControlMode();
6974 SALOME_ListIteratorOfListIO it(selected);
6975 for ( it.Next(); it.More(); it.Next() ) {
6976 Handle(SALOME_InteractiveObject) anIO = it.Value();
6977 if ( anIO->hasEntry() ) {
6978 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
6979 if ( aControl != anActor->GetControlMode() ) {
6980 aControl = SMESH_Actor::eNone;
6990 int anAction = ActionToControl( aControl, true );
6992 action( anAction )->setChecked( true );
6994 QMenu* send = (QMenu*)sender();
6995 QList<QAction*> actions = send->actions();
6996 for ( int i = 0; i < actions.size(); i++ )
6997 actions[i]->setChecked( false );
7003 \brief Signal handler closing(SUIT_ViewWindow*) of a view
7004 \param pview view being closed
7006 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
7007 #ifndef DISABLE_PLOT2DVIEWER
7008 //Crear all Plot2d Viewers if need.
7009 SMESH::ClearPlot2Viewers(pview);
7011 EmitSignalCloseView();
7014 void SMESHGUI::message( const QString& msg )
7017 QStringList data = msg.split("/");
7018 if ( data.count() > 0 ) {
7019 if ( data.first() == "mesh_loading" ) {
7021 QString entry = data.count() > 1 ? data[1] : QString();
7022 if ( entry.isEmpty() )
7025 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
7027 _PTR(SObject) obj = study->FindObjectID( entry.toUtf8().constData() );
7030 name = SMESH::fromUtf8(obj->GetName());
7031 if ( name.isEmpty() )
7034 if ( data.last() == "stop" )
7035 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
7037 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
7038 QApplication::processEvents();
7044 \brief Connects or disconnects signals about activating and cloning view on the module slots
7045 \param pview view which is connected/disconnected
7047 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
7051 SUIT_ViewManager* viewMgr = pview->getViewManager();
7053 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7054 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7056 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7057 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7062 \brief Return \c true if object can be renamed
7064 bool SMESHGUI::renameAllowed( const QString& entry) const {
7065 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7069 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7073 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
7078 if(appStudy->isComponent(entry) || obj->isReference())
7081 // check type to prevent renaming of inappropriate objects
7082 int aType = SMESHGUI_Selection::type(qPrintable(entry));
7083 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7084 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7085 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7086 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7087 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
7094 Rename object by entry.
7095 \param entry entry of the object
7096 \param name new name of the object
7097 \brief Return \c true if rename operation finished successfully, \c false otherwise.
7099 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
7101 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7105 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7110 _PTR(Study) aStudy = appStudy->studyDS();
7115 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
7117 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
7122 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
7123 _PTR(GenericAttribute) anAttr;
7124 _PTR(AttributeName) aName;
7126 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
7128 // check type to prevent renaming of inappropriate objects
7129 int aType = SMESHGUI_Selection::type( qPrintable(entry));
7130 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7131 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7132 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7133 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7134 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
7135 if ( !name.isEmpty() ) {
7136 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qUtf8Printable(name) );
7138 // update name of group object and its actor
7139 Handle(SALOME_InteractiveObject) IObject =
7140 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
7142 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
7143 if( !aGroupObject->_is_nil() ) {
7144 aGroupObject->SetName( qUtf8Printable(name) );
7145 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
7146 anActor->setName( qUtf8Printable(name) );
7156 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
7158 static QList<QColor> colors;
7160 if ( colors.isEmpty() ) {
7162 for (int s = 0; s < 2 ; s++)
7164 for (int v = 100; v >= 40; v = v - 20)
7166 for (int h = 0; h < 359 ; h = h + 60)
7168 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
7173 static int currentColor = randomize( colors.size() );
7175 SALOMEDS::Color color;
7176 color.R = (double)colors[currentColor].red() / 255.0;
7177 color.G = (double)colors[currentColor].green() / 255.0;
7178 color.B = (double)colors[currentColor].blue() / 255.0;
7180 currentColor = (currentColor+1) % colors.count();