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 version used for write
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 int defaultVersion = 0;
748 QMap<QString, int> aFilterMap;
750 //filters << QObject::tr( "MED_FILES_FILTER" ) + " (*.med)";
751 //QString vmed (aMesh->GetVersionString(-1, 2));
752 //MESSAGE("MED version: " << vmed.toStdString());
753 SMESH::long_array_var mvok = aMesh->GetMEDVersionsCompatibleForAppend();
754 for ( int i = 0; i < mvok->length(); ++i ) // i=0 must correspond to the current version to set the default filter on it
756 int versionInt = mvok[i];
758 defaultVersion = versionInt;
759 std::ostringstream vss;
760 vss << versionInt/10;
762 vss << versionInt%10;
763 QString vs = vss.str().c_str();
764 MESSAGE("MED version: " << vs.toStdString());
765 aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( vs ) + " (*.med)", versionInt);
769 aFilterMap.insert("All files (*)", -1 );
770 aFilterMap.insert("SAUV files (*.sauv)", defaultVersion ); // 0 = default filter (defaultVersion)
771 aFilterMap.insert("SAUV files (*.sauve)", -1 );
773 MESSAGE("default version="<< defaultVersion);
775 QMap<QString, int>::const_iterator it = aFilterMap.begin();
776 QString aDefaultFilter = it.key();
777 for ( ; it != aFilterMap.end(); ++it ) {
778 filters.push_back( it.key() );
779 if (it.value() == defaultVersion) // explicit default for MED = current MED version
780 aDefaultFilter = it.key();
782 QStringList checkBoxes;
783 checkBoxes << QObject::tr("SMESH_AUTO_GROUPS") << QObject::tr("SMESH_AUTO_DIM");
785 SMESHGUI_FieldSelectorWdg* fieldSelWdg = new SMESHGUI_FieldSelectorWdg();
786 QList< QWidget* > wdgList;
787 if ( fieldSelWdg->GetAllFields( aMeshList, aFieldList ))
788 wdgList.append( fieldSelWdg );
790 SalomeApp_CheckFileDlg* fd =
791 new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true, wdgList );
792 fd->setWindowTitle( aTitle );
793 fd->setNameFilters( filters );
794 fd->selectNameFilter( aDefaultFilter );
795 fd->SetChecked( toCreateGroups, 0 );
796 fd->SetChecked( toFindOutDim, 1 );
797 if ( !anInitialPath.isEmpty() )
798 fd->setDirectory( anInitialPath );
799 fd->selectFile(aMeshName);
802 QListView *lview = fd->findChild<QListView*>("listView");
804 lview->setMinimumHeight(200);
806 QTreeView *tview = fd->findChild<QTreeView*>("treeView");
808 tview->setMinimumHeight(200);
811 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
812 fd->setValidator( fv );
816 MESSAGE("******* Loop on file dialog ***********");
819 aFilename = fd->selectedFile();
821 aFilename = QString::null;
824 aFormat = aFilterMap[fd->selectedNameFilter()];
825 MESSAGE("selected version: " << aFormat << " file: " << aFilename.toUtf8().constData());
826 toOverwrite = fv->isOverwrite(aFilename);
827 MESSAGE("toOverwrite:" << toOverwrite);
829 if ( !aFilename.isEmpty() ) {
831 // append is only possible if the existing file format is compatible
832 bool isVersionOk = SMESHGUI::GetSMESHGen()->CheckWriteCompatibility( aFilename.toUtf8().constData() );
833 MESSAGE("Append check, isVersionOk:" << isVersionOk);
834 if ( !isVersionOk ) {
835 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
836 QObject::tr("SMESH_WRN_WARNING"),
837 QObject::tr("SMESH_EXPORT_MED_VERSION_COLLISION").arg(aFilename),
838 QObject::tr("SMESH_BUT_YES"),
839 QObject::tr("SMESH_BUT_NO"), 0, 1);
843 MESSAGE("incompatible MED file version for add, overwrite accepted");
849 MESSAGE("incompatible MED file version for add, overwrite refused");
852 QStringList aMeshNamesCollisionList;
853 SMESH::string_array_var aMeshNames = SMESHGUI::GetSMESHGen()->GetMeshNames( aFilename.toUtf8().constData() );
854 for( int i = 0, n = aMeshNames->length(); i < n; i++ ) {
855 QString anExistingMeshName( aMeshNames[ i ] );
856 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
857 QString anExportMeshName = (*aMeshIter).second;
858 if( anExportMeshName == anExistingMeshName ) {
859 aMeshNamesCollisionList.append( anExportMeshName );
864 if( !aMeshNamesCollisionList.isEmpty() ) {
866 QString aMeshNamesCollisionString = aMeshNamesCollisionList.join( ", " );
867 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
868 QObject::tr("SMESH_WRN_WARNING"),
869 QObject::tr("SMESH_EXPORT_MED_MESH_NAMES_COLLISION").arg(aMeshNamesCollisionString),
870 QObject::tr("SMESH_BUT_YES"),
871 QObject::tr("SMESH_BUT_NO"),
872 QObject::tr("SMESH_BUT_CANCEL"), 0, 2);
873 MESSAGE("answer collision name " << aRet);
884 MESSAGE(" ****** end of file dialog loop, toOverwrite:" << toOverwrite << " isOkToWrite:" << isOkToWrite);
885 toCreateGroups = fd->IsChecked(0);
886 toFindOutDim = fd->IsChecked(1);
887 fieldSelWdg->GetSelectedFields();
888 if ( !fieldSelWdg->parent() )
899 if ( !aFilename.isEmpty() ) {
900 // Check whether the file already exists and delete it if yes
901 QFile aFile( aFilename );
902 if ( aFile.exists() && toOverwrite )
904 SUIT_OverrideCursor wc;
907 // Renumbering is not needed since SMDS redesign in V6.2.0 (Nov 2010)
908 // bool Renumber = false;
909 // // PAL 14172 : Check of we have to renumber or not from the preferences before export
911 // Renumber= resMgr->booleanValue("renumbering");
913 // SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
914 // aMeshEditor->RenumberNodes();
915 // aMeshEditor->RenumberElements();
916 // if ( SMESHGUI::automaticUpdate() )
917 // SMESH::UpdateView();
919 if ( isMED && isOkToWrite)
921 MESSAGE("OK to write MED file "<< aFilename.toUtf8().constData());
922 aMeshIter = aMeshList.begin();
923 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
925 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
926 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
927 const GEOM::ListOfFields& fields = aFieldList[ aMeshIndex ].first.in();
928 const QString& geoAssFields = aFieldList[ aMeshIndex ].second;
929 const bool hasFields = ( fields.length() || !geoAssFields.isEmpty() );
930 if ( !hasFields && aMeshOrGroup->_is_equivalent( aMeshItem ))
931 aMeshItem->ExportMED( aFilename.toUtf8().data(), toCreateGroups, aFormat,
932 toOverwrite && aMeshIndex == 0, toFindOutDim );
934 aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups, aFormat,
935 toOverwrite && aMeshIndex == 0, toFindOutDim,
936 fields, geoAssFields.toLatin1().data() );
941 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ )
943 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
944 if( !aMeshItem->_is_nil() )
945 aMeshItem->ExportSAUV( aFilename.toUtf8().data(), toCreateGroups );
950 if ( aMeshOrGroup->_is_equivalent( aMesh ))
951 aMesh->ExportDAT( aFilename.toUtf8().data() );
953 aMesh->ExportPartToDAT( aMeshOrGroup, aFilename.toUtf8().data() );
957 if ( aMeshOrGroup->_is_equivalent( aMesh ))
958 aMesh->ExportUNV( aFilename.toUtf8().data() );
960 aMesh->ExportPartToUNV( aMeshOrGroup, aFilename.toUtf8().data() );
964 if ( aMeshOrGroup->_is_equivalent( aMesh ))
965 aMesh->ExportSTL( aFilename.toUtf8().data(), aIsASCII_STL );
967 aMesh->ExportPartToSTL( aMeshOrGroup, aFilename.toUtf8().data(), aIsASCII_STL );
971 aMeshIter = aMeshList.begin();
972 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
974 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
975 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
976 aMeshItem->ExportCGNS( aMeshOrGroup,
977 aFilename.toUtf8().data(),
978 toOverwrite && aMeshIndex == 0,
984 toCreateGroups = true;
985 aMesh->ExportGMF( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups );
988 catch (const SALOME::SALOME_Exception& S_ex){
990 SUIT_MessageBox::warning(SMESHGUI::desktop(),
991 QObject::tr("SMESH_WRN_WARNING"),
992 QObject::tr("SMESH_EXPORT_FAILED") + SalomeApp_Tools::ExceptionToString(S_ex));
998 inline void InverseEntityMode(unsigned int& theOutputMode,
999 unsigned int theMode)
1001 bool anIsNotPresent = ~theOutputMode & theMode;
1003 theOutputMode |= theMode;
1005 theOutputMode &= ~theMode;
1008 void SetDisplayEntity(int theCommandID)
1010 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1011 SALOME_ListIO selected;
1013 aSel->selectedObjects( selected );
1015 if ( selected.Extent() >= 1 ) {
1016 SUIT_OverrideCursor wc;
1017 SALOME_ListIteratorOfListIO It( selected );
1018 for( ; It.More(); It.Next()){
1019 Handle(SALOME_InteractiveObject) IObject = It.Value();
1020 if(IObject->hasEntry()){
1021 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1022 unsigned int aMode = anActor->GetEntityMode();
1023 switch(theCommandID){
1024 case SMESHOp::OpDE0DElements: InverseEntityMode(aMode,SMESH_Actor::e0DElements); break;
1025 case SMESHOp::OpDEEdges: InverseEntityMode(aMode,SMESH_Actor::eEdges); break;
1026 case SMESHOp::OpDEFaces: InverseEntityMode(aMode,SMESH_Actor::eFaces); break;
1027 case SMESHOp::OpDEVolumes: InverseEntityMode(aMode,SMESH_Actor::eVolumes); break;
1028 case SMESHOp::OpDEBalls: InverseEntityMode(aMode,SMESH_Actor::eBallElem); break;
1029 case SMESHOp::OpDEAllEntity: aMode = SMESH_Actor::eAllEntity; break;
1032 anActor->SetEntityMode(aMode);
1041 SalomeApp_Application* app =
1042 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1046 LightApp_SelectionMgr* aSel = app->selectionMgr();
1047 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1048 if ( !aSel || !appStudy )
1051 SALOME_ListIO selected;
1052 aSel->selectedObjects( selected );
1053 if ( selected.IsEmpty() )
1056 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1058 _PTR(Study) aStudy = appStudy->studyDS();
1059 _PTR(SObject) aMainSObject = aStudy->FindObjectID( anIObject->getEntry() );
1060 SMESH::SMESH_Mesh_var aMainObject = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1061 if ( aMainObject->_is_nil() )
1064 SUIT_OverrideCursor wc;
1066 aMainObject->SetAutoColor( true ); // mesh groups are re-colored here
1068 QList<SALOMEDS::Color> aReservedColors;
1070 SMESH::ListOfGroups aListOfGroups = *aMainObject->GetGroups();
1071 for ( int i = 0, n = aListOfGroups.length(); i < n; i++ )
1073 SMESH::SMESH_GroupBase_var aGroupObject = aListOfGroups[i];
1075 #ifdef SIMPLE_AUTOCOLOR // simplified algorithm for auto-colors
1076 SALOMEDS::Color aColor = SMESHGUI::getPredefinedUniqueColor();
1077 #else // old algorithm for auto-colors
1078 SALOMEDS::Color aColor = SMESHGUI::getUniqueColor( aReservedColors );
1079 aReservedColors.append( aColor );
1080 #endif // SIMPLE_AUTOCOLOR
1081 aGroupObject->SetColor( aColor );
1083 _PTR(SObject) aGroupSObject = SMESH::FindSObject(aGroupObject);
1084 if ( aGroupSObject ) {
1087 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry(aGroupSObject->GetID().c_str())) {
1088 switch ( aGroupObject->GetType ()) {
1090 anActor->SetNodeColor( aColor.R, aColor.G, aColor.B ); break;
1092 anActor->SetEdgeColor( aColor.R, aColor.G, aColor.B ); break;
1094 anActor->Set0DColor( aColor.R, aColor.G, aColor.B ); break;
1096 anActor->SetBallColor( aColor.R, aColor.G, aColor.B ); break;
1098 SMESH::GetColor("SMESH", "volume_color", c, delta, "255,0,170|-100");
1099 anActor->SetVolumeColor( aColor.R, aColor.G, aColor.B, delta ); break;
1102 SMESH::GetColor("SMESH", "fill_color", c, delta, "0,170,255|-100");
1103 anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B, delta );
1109 SMESH::RepaintCurrentView();
1112 void OverallMeshQuality()
1114 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1115 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1116 SALOME_ListIO selected;
1118 aSel->selectedObjects( selected );
1120 if ( selected.IsEmpty() ) return;
1121 SALOME_ListIteratorOfListIO It( selected );
1122 for ( ; It.More(); It.Next() ) {
1123 SMESHGUI_CtrlInfoDlg* ctrlDlg = new SMESHGUI_CtrlInfoDlg( SMESHGUI::desktop() );
1124 ctrlDlg->showInfo( It.Value() );
1129 QString functorToString( SMESH::Controls::FunctorPtr f )
1131 QString type = QObject::tr( "UNKNOWN_CONTROL" );
1132 if ( dynamic_cast< SMESH::Controls::Volume* >( f.get() ) )
1133 type = QObject::tr( "VOLUME_3D_ELEMENTS" );
1134 else if ( dynamic_cast< SMESH::Controls::MaxElementLength2D* >( f.get() ) )
1135 type = QObject::tr( "MAX_ELEMENT_LENGTH_2D" );
1136 else if ( dynamic_cast< SMESH::Controls::MaxElementLength3D* >( f.get() ) )
1137 type = QObject::tr( "MAX_ELEMENT_LENGTH_3D" );
1138 else if ( dynamic_cast< SMESH::Controls::MinimumAngle* >( f.get() ) )
1139 type = QObject::tr( "MINIMUMANGLE_ELEMENTS" );
1140 else if ( dynamic_cast< SMESH::Controls::AspectRatio* >( f.get() ) )
1141 type = QObject::tr( "ASPECTRATIO_ELEMENTS" );
1142 else if ( dynamic_cast< SMESH::Controls::AspectRatio3D* >( f.get() ) )
1143 type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" );
1144 else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) )
1145 type = QObject::tr( "WARP_ELEMENTS" );
1146 else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) )
1147 type = QObject::tr( "TAPER_ELEMENTS" );
1148 else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) )
1149 type = QObject::tr( "SKEW_ELEMENTS" );
1150 else if ( dynamic_cast< SMESH::Controls::Area* >( f.get() ) )
1151 type = QObject::tr( "AREA_ELEMENTS" );
1152 else if ( dynamic_cast< SMESH::Controls::Length* >( f.get() ) )
1153 type = QObject::tr( "LENGTH_EDGES" );
1154 else if ( dynamic_cast< SMESH::Controls::Length2D* >( f.get() ) )
1155 type = QObject::tr( "LENGTH2D_EDGES" );
1156 else if ( dynamic_cast< SMESH::Controls::Deflection2D* >( f.get() ) )
1157 type = QObject::tr( "DEFLECTION2D_FACES" );
1158 else if ( dynamic_cast< SMESH::Controls::MultiConnection* >( f.get() ) )
1159 type = QObject::tr( "MULTI_BORDERS" );
1160 else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) )
1161 type = QObject::tr( "MULTI2D_BORDERS" );
1162 else if ( dynamic_cast< SMESH::Controls::FreeNodes* >( f.get() ) )
1163 type = QObject::tr( "FREE_NODES" );
1164 else if ( dynamic_cast< SMESH::Controls::FreeEdges* >( f.get() ) )
1165 type = QObject::tr( "FREE_EDGES" );
1166 else if ( dynamic_cast< SMESH::Controls::FreeBorders* >( f.get() ) )
1167 type = QObject::tr( "FREE_BORDERS" );
1168 else if ( dynamic_cast< SMESH::Controls::FreeFaces* >( f.get() ) )
1169 type = QObject::tr( "FREE_FACES" );
1170 else if ( dynamic_cast< SMESH::Controls::BareBorderVolume* >( f.get() ) )
1171 type = QObject::tr( "BARE_BORDER_VOLUME" );
1172 else if ( dynamic_cast< SMESH::Controls::BareBorderFace* >( f.get() ) )
1173 type = QObject::tr( "BARE_BORDER_FACE" );
1174 else if ( dynamic_cast< SMESH::Controls::OverConstrainedVolume* >( f.get() ) )
1175 type = QObject::tr( "OVER_CONSTRAINED_VOLUME" );
1176 else if ( dynamic_cast< SMESH::Controls::OverConstrainedFace* >( f.get() ) )
1177 type = QObject::tr( "OVER_CONSTRAINED_FACE" );
1178 else if ( dynamic_cast< SMESH::Controls::CoincidentNodes* >( f.get() ) )
1179 type = QObject::tr( "EQUAL_NODE" );
1180 else if ( dynamic_cast< SMESH::Controls::CoincidentElements1D* >( f.get() ) )
1181 type = QObject::tr( "EQUAL_EDGE" );
1182 else if ( dynamic_cast< SMESH::Controls::CoincidentElements2D* >( f.get() ) )
1183 type = QObject::tr( "EQUAL_FACE" );
1184 else if ( dynamic_cast< SMESH::Controls::CoincidentElements3D* >( f.get() ) )
1185 type = QObject::tr( "EQUAL_VOLUME" );
1186 else if ( dynamic_cast< SMESH::Controls::NodeConnectivityNumber* >( f.get() ) )
1187 type = QObject::tr( "NODE_CONNECTIVITY_NB" );
1191 void SaveDistribution()
1193 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1194 SALOME_ListIO selected;
1196 aSel->selectedObjects( selected );
1198 if ( selected.Extent() == 1 ) {
1199 Handle(SALOME_InteractiveObject) anIO = selected.First();
1200 if ( anIO->hasEntry() ) {
1201 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1203 anActor->GetScalarBarActor() &&
1204 anActor->GetControlMode() != SMESH_Actor::eNone )
1206 SMESH_ScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor();
1207 SMESH::Controls::FunctorPtr aFunctor = anActor->GetFunctor();
1208 if ( aScalarBarActor && aFunctor ) {
1209 SMESH::Controls::NumericalFunctor* aNumFun =
1210 dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
1212 std::vector<int> elements;
1213 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
1214 if ( mesh->_is_nil() ) {
1215 SMESH::SMESH_IDSource_var idSource =
1216 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
1217 if ( !idSource->_is_nil() )
1219 SMESH::long_array_var ids = idSource->GetIDs();
1220 elements.resize( ids->length() );
1221 for ( unsigned i = 0; i < elements.size(); ++i )
1222 elements[i] = ids[i];
1225 int nbIntervals = aScalarBarActor->GetMaximumNumberOfColors();
1226 vtkLookupTable* lookupTable =
1227 static_cast<vtkLookupTable*>(aScalarBarActor->GetLookupTable());
1228 double * minmax = lookupTable->GetRange();
1229 bool isLogarithmic = lookupTable->GetScale() == VTK_SCALE_LOG10;
1230 std::vector<int> nbEvents;
1231 std::vector<double> funValues;
1232 aNumFun->GetHistogram( nbIntervals, nbEvents, funValues,
1233 elements, minmax, isLogarithmic );
1234 QString anInitialPath = "";
1235 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
1236 anInitialPath = QDir::currentPath();
1237 QString aMeshName = anIO->getName();
1239 filter.append( QObject::tr( "TEXT_FILES_FILTER" ) + " (*.txt)" );
1240 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
1241 QString aFilename = anInitialPath + "/" + aMeshName + "_" +
1242 functorToString( aFunctor ).toLower().simplified().replace( QRegExp( " |-" ), "_" ) + ".txt";
1243 aFilename = SUIT_FileDlg::getFileName( SMESHGUI::desktop(),
1246 QObject::tr( "SMESH_SAVE_DISTRIBUTION" ),
1248 if ( !aFilename.isEmpty() ) {
1249 QFile f( aFilename );
1250 if ( f.open( QFile::WriteOnly | QFile::Truncate ) ) {
1251 QTextStream out( &f );
1252 out << "# Mesh: " << aMeshName << endl;
1253 out << "# Control: " << functorToString( aFunctor ) << endl;
1255 out.setFieldWidth( 10 );
1256 for ( int i = 0; i < (int)qMin( nbEvents.size(), funValues.size()-1 ); i++ )
1257 out << funValues[i] << "\t" << funValues[i+1] << "\t" << nbEvents[i] << endl;
1268 void ShowElement( int theCommandID )
1270 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1271 SALOME_ListIO selected;
1273 aSel->selectedObjects( selected );
1275 if ( selected.Extent() == 1 ) {
1276 Handle(SALOME_InteractiveObject) anIO = selected.First();
1277 if ( anIO->hasEntry() ) {
1278 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1280 anActor->GetScalarBarActor() &&
1281 anActor->GetControlMode() != SMESH_Actor::eNone )
1283 SMESH_ScalarBarActor *aScalarBarActor = anActor->GetScalarBarActor();
1284 if ( theCommandID == SMESHOp::OpShowDistribution ) {
1285 aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility());
1287 else if ( theCommandID == SMESHOp::OpShowScalarBar ) {
1288 aScalarBarActor->SetVisibility( !aScalarBarActor->GetVisibility());
1295 #ifndef DISABLE_PLOT2DVIEWER
1296 void PlotDistribution()
1298 SalomeApp_Application* app =
1299 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1303 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1304 SALOME_ListIO selected;
1306 aSel->selectedObjects( selected );
1308 if ( selected.Extent() == 1 ) {
1309 Handle(SALOME_InteractiveObject) anIO = selected.First();
1310 if ( anIO->hasEntry() ) {
1311 //Find Actor by entry before getting Plot2d viewer,
1312 //because after call getViewManager( Plot2d_Viewer::Type(), true ) active window is Plot2d Viewer
1313 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1315 SUIT_ViewManager* aViewManager =
1316 app->getViewManager( Plot2d_Viewer::Type(), true ); // create if necessary
1320 SPlot2d_Viewer* aView = dynamic_cast<SPlot2d_Viewer*>(aViewManager->getViewModel());
1324 Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
1328 if ( anActor && anActor->GetControlMode() != SMESH_Actor::eNone )
1330 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1331 QString functorName = functorToString( anActor->GetFunctor());
1332 QString aHistogramName("%1 : %2");
1333 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1334 aHistogram->setName(aHistogramName);
1335 aHistogram->setHorTitle(functorName);
1336 aHistogram->setVerTitle(QObject::tr("DISTRIBUTION_NB_ENT"));
1337 aPlot->displayObject(aHistogram, true);
1342 #endif //DISABLE_PLOT2DVIEWER
1344 void DisableAutoColor()
1346 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1347 SALOME_ListIO selected;
1349 aSel->selectedObjects( selected );
1351 if ( selected.Extent() ) {
1352 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1353 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1354 if ( !aMesh->_is_nil() ) {
1355 aMesh->SetAutoColor( false );
1362 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1363 SALOME_ListIO selected;
1365 aSel->selectedObjects( selected );
1366 if ( selected.Extent() )
1368 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1369 _PTR(Study) aStudy = SMESH::getStudy();
1370 _PTR(SObject) aSObj = aStudy->FindObjectID(anIObject->getEntry());
1372 if ( aStudy->GetUseCaseBuilder()->SortChildren( aSObj, true/*AscendingOrder*/ ) ) {
1373 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1380 void SetDisplayMode(int theCommandID, VTK::MarkerMap& theMarkerMap)
1382 SALOME_ListIO selected;
1383 SalomeApp_Application* app =
1384 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1388 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1389 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1390 if ( !aSel || !appStudy )
1393 if ( theCommandID == SMESHOp::OpClipping ) { // Clipping dialog can be activated without selection
1394 if ( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
1395 aModule->EmitSignalDeactivateDialog();
1396 if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
1397 (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
1402 aSel->selectedObjects( selected );
1404 if ( selected.Extent() >= 1 )
1406 switch ( theCommandID ) {
1407 case SMESHOp::OpTransparency:
1409 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1410 (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
1413 case SMESHOp::OpProperties:
1416 QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
1417 QColor orientationColor, outlineColor, volumeColor;
1418 int deltaF = 0, deltaV = 0;
1421 double ballScale = 1.0;
1423 int outlineWidth = 1;
1424 double shrinkCoef = 0.0;
1425 double orientationScale = 0.0;
1426 bool orientation3d = false;
1427 VTK::MarkerType markerType = VTK::MT_NONE;
1428 VTK::MarkerScale markerScale = VTK::MS_NONE;
1430 bool hasNodes = false;
1431 int presentEntities = 0;
1432 bool firstTime = true;
1434 SALOME_ListIteratorOfListIO It( selected );
1435 for ( ; It.More(); It.Next() ) {
1436 Handle(SALOME_InteractiveObject) IObject = It.Value();
1437 if ( !IObject->hasEntry() ) continue;
1438 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1439 if ( !anActor || !anActor->GetObject() ) continue;
1442 // nodes: color, marker
1443 anActor->GetNodeColor( color[0], color[1], color[2] );
1444 nodeColor.setRgbF( color[0], color[1], color[2] );
1445 markerType = anActor->GetMarkerType();
1446 markerScale = anActor->GetMarkerScale();
1447 markerId = anActor->GetMarkerTexture();
1448 // edges: color, width
1449 anActor->GetEdgeColor( color[0], color[1], color[2] );
1450 edgeColor.setRgbF( color[0], color[1], color[2] );
1451 edgeWidth = qMax( (int)anActor->GetLineWidth(), 1 ); // minimum allowed width is 1
1452 // faces: front color, back color (delta)
1453 anActor->GetSufaceColor( color[0], color[1], color[2], deltaF );
1454 faceColor.setRgbF( color[0], color[1], color[2] );
1455 // faces: front color, back color (delta)
1456 anActor->GetVolumeColor( color[0], color[1], color[2], deltaV );
1457 volumeColor.setRgbF( color[0], color[1], color[2] );
1458 // 0d elements: color, size
1459 anActor->Get0DColor( color[0], color[1], color[2] );
1460 elem0dColor.setRgbF( color[0], color[1], color[2] );
1461 elem0dSize = qMax( (int)anActor->Get0DSize(), 1 ); // minimum allowed size is 1
1462 // balls: color, size
1463 anActor->GetBallColor( color[0], color[1], color[2] );
1464 ballColor.setRgbF( color[0], color[1], color[2] );
1465 //ballSize = qMax( (int)anActor->GetBallSize(), 1 ); // minimum allowed size is 1
1466 ballScale = qMax( (double)anActor->GetBallScale(), 1e-2 ); // minimum allowed scale is 1e-2
1468 anActor->GetOutlineColor( color[0], color[1], color[2] );
1469 outlineColor.setRgbF( color[0], color[1], color[2] );
1470 outlineWidth = qMax( (int)anActor->GetOutlineWidth(), 1 ); // minimum allowed width is 1
1471 // orientation vectors: color, scale, 3d flag
1472 anActor->GetFacesOrientationColor( color[0], color[1], color[2] );
1473 orientationColor.setRgbF( color[0], color[1], color[2] );
1474 orientationScale = anActor->GetFacesOrientationScale();
1475 orientation3d = anActor->GetFacesOrientation3DVectors();
1477 shrinkCoef = anActor->GetShrinkFactor();
1480 firstTime = false; // we only take properties from first object (for performance reasons)
1483 hasNodes = anActor->GetObject()->GetNbEntities( SMDSAbs_Node );
1484 if ( !(presentEntities & SMESH_Actor::eEdges) && anActor->GetObject()->GetNbEntities( SMDSAbs_Edge ) )
1485 presentEntities = presentEntities | SMESH_Actor::eEdges;
1486 if ( !(presentEntities & SMESH_Actor::eFaces) && anActor->GetObject()->GetNbEntities( SMDSAbs_Face ) )
1487 presentEntities = presentEntities | SMESH_Actor::eFaces;
1488 if ( !(presentEntities & SMESH_Actor::eVolumes) && anActor->GetObject()->GetNbEntities( SMDSAbs_Volume ) )
1489 presentEntities = presentEntities | SMESH_Actor::eVolumes;
1490 if ( !(presentEntities & SMESH_Actor::e0DElements) && anActor->GetObject()->GetNbEntities( SMDSAbs_0DElement ) )
1491 presentEntities = presentEntities | SMESH_Actor::e0DElements;
1492 if ( !(presentEntities & SMESH_Actor::eBallElem) && anActor->GetObject()->GetNbEntities( SMDSAbs_Ball ) )
1493 presentEntities = presentEntities | SMESH_Actor::eBallElem;
1495 // as we know that all types of elements are present, we can exit the loop
1496 if ( presentEntities == SMESH_Actor::eAllEntity )
1500 SMESHGUI_PropertiesDlg dlg( theMarkerMap, SMESHGUI::desktop() );
1501 // nodes: color, marker
1502 dlg.setNodeColor( nodeColor );
1503 if( markerType != VTK::MT_USER )
1504 dlg.setNodeMarker( markerType, markerScale );
1506 dlg.setNodeCustomMarker( markerId );
1507 // edges: color, line width
1508 dlg.setEdgeColor( edgeColor );
1509 dlg.setEdgeWidth( edgeWidth );
1510 // faces: front color, back color
1511 dlg.setFaceColor( faceColor, deltaF );
1512 // volumes: normal color, reversed color
1513 dlg.setVolumeColor( volumeColor, deltaV );
1514 // outlines: color, line width
1515 dlg.setOutlineColor( outlineColor );
1516 dlg.setOutlineWidth( outlineWidth );
1517 // 0d elements: color, size
1518 dlg.setElem0dColor( elem0dColor );
1519 dlg.setElem0dSize( elem0dSize );
1520 // balls: color, size
1521 dlg.setBallColor( ballColor );
1522 //dlg.setBallSize( ballSize );
1523 dlg.setBallScale( ballScale );
1524 // orientation: color, scale, 3d flag
1525 dlg.setOrientationColor( orientationColor );
1526 dlg.setOrientationSize( int( orientationScale * 100. ) );
1527 dlg.setOrientation3d( orientation3d );
1528 // shrink: scale factor
1529 dlg.setShrinkCoef( int( shrinkCoef * 100. ) );
1530 // hide unused controls
1531 dlg.showControls( presentEntities, hasNodes );
1534 nodeColor = dlg.nodeColor();
1535 markerType = dlg.nodeMarkerType();
1536 markerScale = dlg.nodeMarkerScale();
1537 markerId = dlg.nodeMarkerId();
1538 edgeColor = dlg.edgeColor();
1539 edgeWidth = dlg.edgeWidth();
1540 faceColor = dlg.faceColor();
1541 deltaF = dlg.faceColorDelta();
1542 volumeColor = dlg.volumeColor();
1543 deltaV = dlg.volumeColorDelta();
1544 outlineColor = dlg.outlineColor();
1545 outlineWidth = dlg.outlineWidth();
1546 elem0dColor = dlg.elem0dColor();
1547 elem0dSize = dlg.elem0dSize();
1548 ballColor = dlg.ballColor();
1549 // ballSize = dlg.ballSize();
1550 ballScale = dlg.ballScale();
1551 orientationColor = dlg.orientationColor();
1552 orientationScale = dlg.orientationSize() / 100.;
1553 orientation3d = dlg.orientation3d();
1554 shrinkCoef = dlg.shrinkCoef() / 100.;
1556 // store point markers that might be changed by the user
1557 theMarkerMap = dlg.customMarkers();
1559 // set properties from dialog box to the presentations
1560 SALOME_ListIteratorOfListIO It( selected );
1561 for ( ; It.More(); It.Next() ) {
1562 Handle(SALOME_InteractiveObject) IObject = It.Value();
1563 if ( !IObject->hasEntry() ) continue;
1564 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1565 if ( !anActor ) continue;
1567 // nodes: color, marker
1568 anActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
1569 if ( markerType != VTK::MT_USER ) {
1570 anActor->SetMarkerStd( markerType, markerScale );
1573 VTK::MarkerMap::const_iterator iter = theMarkerMap.find( markerId );
1574 if ( iter != theMarkerMap.end() )
1575 anActor->SetMarkerTexture( markerId, iter->second.second );
1577 // volumes: normal color, reversed color (delta)
1578 anActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
1579 // faces: front color, back color (delta)
1580 anActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
1581 // edges: color, width
1582 anActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
1583 anActor->SetLineWidth( edgeWidth );
1585 anActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
1586 anActor->SetOutlineWidth( outlineWidth );
1587 // 0D elements: color, size
1588 anActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
1589 anActor->Set0DSize( elem0dSize );
1590 // balls: color, size
1591 anActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
1592 // anActor->SetBallSize( ballSize );
1593 anActor->SetBallScale( ballScale );
1594 // orientation: color, scale, 3d flag
1595 anActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
1596 anActor->SetFacesOrientationScale( orientationScale );
1597 anActor->SetFacesOrientation3DVectors( orientation3d );
1599 anActor->SetShrinkFactor( shrinkCoef );
1601 // for groups, set also proper color
1602 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1603 if ( !aGroupObject->_is_nil() ) {
1604 SMESH::ElementType anElementType = aGroupObject->GetType();
1606 switch( anElementType ) {
1608 aColor = nodeColor; break;
1610 aColor = edgeColor; break;
1612 aColor = faceColor; break;
1614 aColor = volumeColor; break;
1616 aColor = elem0dColor; break;
1618 aColor = ballColor; break;
1622 if ( aColor.isValid() ) {
1623 SALOMEDS::Color aGroupColor;
1624 aGroupColor.R = aColor.redF();
1625 aGroupColor.G = aColor.greenF();
1626 aGroupColor.B = aColor.blueF();
1627 aGroupObject->SetColor( aGroupColor );
1629 } // if ( !aGroupObject->_is_nil() )
1630 } // for ( ; It.More(); It.Next() )
1631 SMESH::RepaintCurrentView();
1632 } // if ( dlg.exec() )
1634 } // case SMESHOp::OpProperties:
1635 } // switch(theCommandID)
1636 SUIT_OverrideCursor wc;
1637 SALOME_ListIteratorOfListIO It( selected );
1638 for( ; It.More(); It.Next()){
1639 Handle(SALOME_InteractiveObject) IObject = It.Value();
1640 if(IObject->hasEntry()){
1641 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1642 switch(theCommandID){
1643 case SMESHOp::OpDMWireframe:
1644 anActor->SetRepresentation(SMESH_Actor::eEdge);
1646 case SMESHOp::OpDMShading:
1647 anActor->SetRepresentation(SMESH_Actor::eSurface);
1649 case SMESHOp::OpDMShrink:
1650 if(anActor->IsShrunk())
1651 anActor->UnShrink();
1653 anActor->SetShrink();
1655 case SMESHOp::OpDMNodes:
1656 anActor->SetRepresentation(SMESH_Actor::ePoint);
1658 case SMESHOp::OpRepresentationLines:
1659 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1660 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1662 case SMESHOp::OpRepresentationArcs:
1663 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1664 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1670 SMESH::RepaintCurrentView();
1674 int ActionToControl( int theID, bool theReversed )
1676 NCollection_DoubleMap<int,int> ActionControl;
1677 ActionControl.Bind( 0, SMESH_Actor::eNone );
1678 ActionControl.Bind( SMESHOp::OpFreeNode, SMESH_Actor::eFreeNodes );
1679 ActionControl.Bind( SMESHOp::OpEqualNode, SMESH_Actor::eCoincidentNodes );
1680 ActionControl.Bind( SMESHOp::OpNodeConnectivityNb, SMESH_Actor::eNodeConnectivityNb );
1681 ActionControl.Bind( SMESHOp::OpFreeEdge, SMESH_Actor::eFreeEdges );
1682 ActionControl.Bind( SMESHOp::OpFreeBorder, SMESH_Actor::eFreeBorders );
1683 ActionControl.Bind( SMESHOp::OpLength, SMESH_Actor::eLength );
1684 ActionControl.Bind( SMESHOp::OpConnection, SMESH_Actor::eMultiConnection );
1685 ActionControl.Bind( SMESHOp::OpEqualEdge, SMESH_Actor::eCoincidentElems1D );
1686 ActionControl.Bind( SMESHOp::OpFreeFace, SMESH_Actor::eFreeFaces );
1687 ActionControl.Bind( SMESHOp::OpBareBorderFace, SMESH_Actor::eBareBorderFace );
1688 ActionControl.Bind( SMESHOp::OpOverConstrainedFace, SMESH_Actor::eOverConstrainedFace );
1689 ActionControl.Bind( SMESHOp::OpLength2D, SMESH_Actor::eLength2D );
1690 ActionControl.Bind( SMESHOp::OpDeflection2D, SMESH_Actor::eDeflection2D );
1691 ActionControl.Bind( SMESHOp::OpConnection2D, SMESH_Actor::eMultiConnection2D );
1692 ActionControl.Bind( SMESHOp::OpArea, SMESH_Actor::eArea );
1693 ActionControl.Bind( SMESHOp::OpTaper, SMESH_Actor::eTaper );
1694 ActionControl.Bind( SMESHOp::OpAspectRatio, SMESH_Actor::eAspectRatio );
1695 ActionControl.Bind( SMESHOp::OpMinimumAngle, SMESH_Actor::eMinimumAngle );
1696 ActionControl.Bind( SMESHOp::OpWarpingAngle, SMESH_Actor::eWarping );
1697 ActionControl.Bind( SMESHOp::OpSkew, SMESH_Actor::eSkew );
1698 ActionControl.Bind( SMESHOp::OpMaxElementLength2D, SMESH_Actor::eMaxElementLength2D );
1699 ActionControl.Bind( SMESHOp::OpEqualFace, SMESH_Actor::eCoincidentElems2D );
1700 ActionControl.Bind( SMESHOp::OpAspectRatio3D, SMESH_Actor::eAspectRatio3D );
1701 ActionControl.Bind( SMESHOp::OpVolume, SMESH_Actor::eVolume3D );
1702 ActionControl.Bind( SMESHOp::OpMaxElementLength3D, SMESH_Actor::eMaxElementLength3D );
1703 ActionControl.Bind( SMESHOp::OpBareBorderVolume, SMESH_Actor::eBareBorderVolume );
1704 ActionControl.Bind( SMESHOp::OpOverConstrainedVolume, SMESH_Actor::eOverConstrainedVolume );
1705 ActionControl.Bind( SMESHOp::OpEqualVolume, SMESH_Actor::eCoincidentElems3D );
1708 return ActionControl.IsBound2( theID ) ? ActionControl.Find2( theID ) : 0;
1709 return ActionControl.IsBound1( theID ) ? ActionControl.Find1( theID ) : 0;
1712 void Control( int theCommandID )
1714 SMESH_Actor::eControl aControl = SMESH_Actor::eControl( ActionToControl( theCommandID ));
1715 _PTR(Study) aStudy = SMESH::getStudy();
1717 SALOME_ListIO selected;
1718 if ( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
1719 aSel->selectedObjects( selected );
1721 if ( !selected.IsEmpty() ) {
1722 SALOME_ListIteratorOfListIO It(selected);
1723 for ( ; It.More(); It.Next())
1725 Handle(SALOME_InteractiveObject) anIO = It.Value();
1726 if ( !anIO.IsNull() ) {
1727 _PTR(SObject) SO = aStudy->FindObjectID( It.Value()->getEntry() );
1729 CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
1730 SMESH::SMESH_IDSource_var anIDSrc = SMESH::SMESH_IDSource::_narrow( aObject );
1731 if ( !anIDSrc->_is_nil() ) {
1732 SMESH_Actor *anActor = SMESH::FindActorByEntry( anIO->getEntry());
1733 if (( !anActor && selected.Extent() == 1 ) &&
1734 ( anActor = SMESH::CreateActor( anIO->getEntry() )))
1736 anActor->SetControlMode( aControl );
1737 SMESH::DisplayActor( SMESH::GetCurrentVtkView(), anActor );
1738 SMESH::UpdateView ( SMESH::eDisplay, anIO->getEntry() );
1742 if ( anActor->GetControlMode() != aControl )
1743 anActor->SetControlMode( aControl );
1744 QString functorName = functorToString( anActor->GetFunctor() );
1745 int anEntitiesCount = anActor->GetNumberControlEntities();
1746 if (anEntitiesCount >= 0)
1747 functorName = functorName + ": " + QString::number(anEntitiesCount);
1748 anActor->GetScalarBarActor()->SetTitle( functorName.toLatin1().constData() );
1749 SMESH::RepaintCurrentView();
1750 #ifndef DISABLE_PLOT2DVIEWER
1751 if ( anActor->GetPlot2Histogram() ) {
1752 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1753 QString aHistogramName("%1 : %2");
1754 aHistogramName = aHistogramName.arg( anIO->getName() ).arg( functorName );
1755 aHistogram->setName( aHistogramName );
1756 aHistogram->setHorTitle( functorName );
1757 SMESH::ProcessIn2DViewers( anActor );
1769 bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1770 SMESH::MeshObjectType theType,
1771 const QString theInTypeName,
1772 QString & theOutTypeName)
1774 SMESH_TypeFilter aTypeFilter( theType );
1776 if ( !theIO.IsNull() )
1778 entry = theIO->getEntry();
1779 LightApp_DataOwner owner( entry );
1780 if ( aTypeFilter.isOk( &owner )) {
1781 theOutTypeName = theInTypeName;
1789 QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1791 _PTR(Study) aStudy = SMESH::getStudy();
1792 _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1794 _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1795 CORBA::String_var anID = aSComp->GetID().c_str();
1796 if ( !strcmp(anID.in(),theIO->getEntry()) )
1802 CheckOIType ( theIO, SMESH::HYPOTHESIS, "Hypothesis", aTypeName ) ||
1803 CheckOIType ( theIO, SMESH::ALGORITHM, "Algorithm", aTypeName ) ||
1804 CheckOIType ( theIO, SMESH::MESH, "Mesh", aTypeName ) ||
1805 CheckOIType ( theIO, SMESH::SUBMESH, "SubMesh", aTypeName ) ||
1806 CheckOIType ( theIO, SMESH::GROUP, "Group", aTypeName )
1814 // QString CheckHomogeneousSelection()
1816 // LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1817 // SALOME_ListIO selected;
1819 // aSel->selectedObjects( selected );
1821 // QString RefType = CheckTypeObject(selected.First());
1822 // SALOME_ListIteratorOfListIO It(selected);
1823 // for ( ; It.More(); It.Next())
1825 // Handle(SALOME_InteractiveObject) IObject = It.Value();
1826 // QString Type = CheckTypeObject(IObject);
1827 // if ( Type.compare(RefType) != 0 )
1828 // return "Heterogeneous Selection";
1834 uint randomize( uint size )
1836 static bool initialized = false;
1837 if ( !initialized ) {
1838 qsrand( QDateTime::currentDateTime().toTime_t() );
1842 v = uint( (double)( v ) / RAND_MAX * size );
1843 v = qMax( uint(0), qMin ( v, size-1 ) );
1849 void SMESHGUI::OnEditDelete()
1851 // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1852 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1853 SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1855 _PTR(Study) aStudy = SMESH::getStudy();
1856 _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1857 _PTR(GenericAttribute) anAttr;
1858 _PTR(AttributeIOR) anIOR;
1860 int objectCount = 0;
1862 QString aParentComponent = QString::null;
1864 for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1866 Handle(SALOME_InteractiveObject) anIO = anIt.Value();
1867 if ( anIO.IsNull() ) continue;
1869 QString father = "unknown";
1871 _PTR(SObject) aSO = aStudy->FindObjectID( anIO->getEntry() );
1873 father = QString::fromStdString( aSO->GetFatherComponent()->ComponentDataType() );
1874 // check if object is reference
1875 _PTR(SObject) aRefSObj;
1876 aNameList.append("\n - ");
1877 if ( aSO->ReferencedObject( aRefSObj ) ) {
1878 QString aRefName = QString::fromStdString ( aRefSObj->GetName() );
1879 aNameList.append( aRefName );
1880 father = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1883 aNameList.append(anIO->getName());
1887 if( aParentComponent.isNull() )
1888 aParentComponent = father;
1889 else if( !aParentComponent.isEmpty() && aParentComponent!=father )
1890 aParentComponent = "";
1893 if ( objectCount == 0 )
1894 return; // No Valid Objects Selected
1896 if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
1897 SUIT_MessageBox::warning( SMESHGUI::desktop(),
1898 QObject::tr("ERR_ERROR"),
1899 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
1902 // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
1903 if (SUIT_MessageBox::warning
1904 (SMESHGUI::desktop(),
1905 QObject::tr("SMESH_WRN_WARNING"),
1906 QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
1907 SUIT_MessageBox::Yes | SUIT_MessageBox::No,
1908 SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
1911 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1913 // Put the whole hierarchy of sub-objects of the selected SO's into a list and
1914 // then treat them all starting from the deepest objects (at list back)
1915 std::list< _PTR(SObject) > listSO;
1916 SALOME_ListIteratorOfListIO It(selected);
1917 for( ; It.More(); It.Next()) // loop on selected IO's
1919 Handle(SALOME_InteractiveObject) IObject = It.Value();
1920 if(IObject->hasEntry()) {
1921 _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
1923 // disable removal of "SMESH" component object
1924 if(aSO->FindAttribute(anAttr, "AttributeIOR")){
1926 if ( engineIOR() == anIOR->Value().c_str() )
1929 //Check the referenced object
1930 _PTR(SObject) aRefSObject;
1931 if ( aSO && aSO->ReferencedObject( aRefSObject ) )
1932 aSO = aRefSObject; // Delete main Object instead of reference
1934 listSO.push_back( aSO );
1935 std::list< _PTR(SObject) >::iterator itSO = --listSO.end();
1936 for ( ; itSO != listSO.end(); ++itSO ) {
1937 _PTR(ChildIterator) it = aStudy->NewChildIterator( *itSO );
1938 for (it->InitEx(false); it->More(); it->Next())
1939 listSO.push_back( it->Value() );
1943 // Check if none of objects to delete is referred from outside
1944 std::list< _PTR(SObject) >::reverse_iterator ritSO;
1945 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1947 _PTR(SObject) SO = *ritSO;
1948 if ( !SO ) continue;
1949 std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( *ritSO );
1950 for (size_t i = 0; i < aReferences.size(); i++) {
1951 _PTR(SComponent) aComponent = aReferences[i]->GetFatherComponent();
1952 std::string type = aComponent->ComponentDataType();
1953 if ( type != "SMESH" )
1955 SUIT_MessageBox::warning( anApp->desktop(),
1956 QObject::tr("WRN_WARNING"),
1957 QObject::tr("DEP_OBJECT") );
1958 return; // outside SMESH, there is an object depending on a SMESH object
1963 // Call mesh->Clear() to prevent loading mesh from file caused by hypotheses removal
1964 for( It.Initialize( selected ); It.More(); It.Next()) // loop on selected IO's
1966 Handle(SALOME_InteractiveObject) IObject = It.Value();
1967 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface< SMESH::SMESH_Mesh >( IObject );
1968 if ( !mesh->_is_nil() )
1972 // Treat SO's in the list starting from the back
1973 aStudyBuilder->NewCommand(); // There is a transaction
1974 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1976 _PTR(SObject) SO = *ritSO;
1977 if ( !SO ) continue;
1978 std::string anEntry = SO->GetID();
1980 /** Erase graphical object and remove all its data **/
1981 if(SO->FindAttribute(anAttr, "AttributeIOR")) {
1982 SMESH::RemoveVisualObjectWithActors( anEntry.c_str(), true);
1984 /** Remove an object from data structures **/
1985 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
1986 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
1987 if ( !aGroup->_is_nil() ) { // DELETE GROUP
1988 SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
1989 aMesh->RemoveGroup( aGroup );
1991 else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
1992 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
1993 aMesh->RemoveSubMesh( aSubMesh );
1996 Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
1997 ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
1998 QString objType = CheckTypeObject(IObject);
1999 if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
2000 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
2001 aStudyBuilder->RemoveObjectWithChildren( SO );
2003 else {// default action: remove SObject from the study
2004 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
2005 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
2007 aStudyBuilder->RemoveObjectWithChildren( SO );
2011 } /* listSO back loop */
2013 aStudyBuilder->CommitCommand();
2015 /* Clear any previous selection */
2017 aSel->setSelectedObjects( l1 );
2019 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
2023 SMESHGUI_EXPORT CAM_Module* createModule()
2025 return new SMESHGUI();
2028 SMESHGUI_EXPORT char* getModuleVersion() {
2029 return (char*)SMESH_VERSION_STR;
2033 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
2035 //=============================================================================
2039 //=============================================================================
2040 SMESHGUI::SMESHGUI() :
2041 SalomeApp_Module( "SMESH" )
2043 if ( CORBA::is_nil( myComponentSMESH ) )
2045 CORBA::Boolean anIsEmbeddedMode;
2046 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
2047 //MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
2049 // 0019923: EDF 765 SMESH : default values of hypothesis
2050 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
2051 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
2052 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
2053 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
2054 myComponentSMESH->SetDefaultNbSegments( nbSeg );
2056 const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif", "default_grp_color" };
2057 for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
2058 if ( aResourceMgr->hasValue( "SMESH", options[i] ))
2060 QString val = aResourceMgr->stringValue( "SMESH", options[i] );
2061 myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
2065 myActiveDialogBox = 0;
2066 myFilterLibraryDlg = 0;
2070 myEventCallbackCommand = vtkCallbackCommand::New();
2071 myEventCallbackCommand->Delete();
2072 myEventCallbackCommand->SetClientData( this );
2073 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
2076 /* load resources for all available meshers */
2077 SMESH::InitAvailableHypotheses();
2080 //=============================================================================
2084 //=============================================================================
2085 SMESHGUI::~SMESHGUI()
2089 //=============================================================================
2093 //=============================================================================
2094 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
2096 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2098 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
2103 //=============================================================================
2107 //=============================================================================
2108 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
2110 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2114 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2115 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2116 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2117 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2118 return autoUpdate && !exceeded;
2121 //=============================================================================
2125 //=============================================================================
2126 bool SMESHGUI::automaticUpdate( SMESH::SMESH_IDSource_ptr theMesh,
2127 int* entities, bool* limitExceeded, int* hidden, long* nbElements )
2129 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2133 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2134 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2135 bool incrementalLimit = resMgr->booleanValue( "SMESH", "incremental_limit", false );
2137 SMESH::long_array_var info = theMesh->GetMeshInfo();
2138 long nbOdElems = info[SMDSEntity_0D];
2139 long nbEdges = info[SMDSEntity_Edge] + info[SMDSEntity_Quad_Edge];
2140 long nbFaces = info[SMDSEntity_Triangle] + info[SMDSEntity_Quad_Triangle] + info[SMDSEntity_BiQuad_Triangle] +
2141 info[SMDSEntity_Quadrangle] + info[SMDSEntity_Quad_Quadrangle] + info[SMDSEntity_BiQuad_Quadrangle] +
2142 info[SMDSEntity_Polygon] + info[SMDSEntity_Quad_Polygon];
2143 long nbVolumes = info[SMDSEntity_Tetra] + info[SMDSEntity_Quad_Tetra] +
2144 info[SMDSEntity_Hexa] + info[SMDSEntity_Quad_Hexa] + info[SMDSEntity_TriQuad_Hexa] +
2145 info[SMDSEntity_Pyramid] + info[SMDSEntity_Quad_Pyramid] +
2146 info[SMDSEntity_Penta] + info[SMDSEntity_Quad_Penta] + info[SMDSEntity_BiQuad_Penta] +
2147 info[SMDSEntity_Polyhedra] +
2148 info[SMDSEntity_Hexagonal_Prism];
2149 long nbBalls = info[SMDSEntity_Ball];
2151 long requestedSize = nbOdElems + nbBalls + nbEdges + nbFaces + nbVolumes;
2152 *nbElements = requestedSize;
2154 *entities = SMESH_Actor::eAllEntity;
2157 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2159 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2161 if ( incrementalLimit ) {
2164 if ( nbOdElems > 0 ) {
2165 if ( total + nbOdElems > updateLimit ) {
2166 *entities = *entities & ~SMESH_Actor::e0DElements;
2167 *hidden = *hidden | SMESH_Actor::e0DElements;
2174 if ( nbEdges > 0 ) {
2175 if ( total + nbEdges > updateLimit ) {
2176 *entities = *entities & ~SMESH_Actor::eEdges;
2177 *hidden = *hidden | SMESH_Actor::eEdges;
2184 if ( nbFaces > 0 ) {
2185 if ( total + nbFaces > updateLimit ) {
2186 *entities = *entities & ~SMESH_Actor::eFaces;
2187 *hidden = *hidden | SMESH_Actor::eFaces;
2194 if ( nbVolumes > 0 ) {
2195 if ( total + nbVolumes > updateLimit ) {
2196 *entities = *entities & ~SMESH_Actor::eVolumes;
2197 *hidden = *hidden | SMESH_Actor::eVolumes;
2204 if ( nbBalls > 0 ) {
2205 if ( total + nbBalls > updateLimit ) {
2206 *entities = *entities & ~SMESH_Actor::eBallElem;
2207 *hidden = *hidden | SMESH_Actor::eBallElem;
2215 return autoUpdate && !exceeded;
2218 //=============================================================================
2222 //=============================================================================
2223 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
2225 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
2228 //=============================================================================
2232 //=============================================================================
2233 SMESHGUI* SMESHGUI::GetSMESHGUI()
2235 SMESHGUI* smeshMod = 0;
2236 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
2239 CAM_Module* module = app->module( "Mesh" );
2240 smeshMod = dynamic_cast<SMESHGUI*>( module );
2248 Standard_EXPORT SMESHGUI* GetComponentGUI()
2250 return SMESHGUI::GetSMESHGUI();
2254 //=============================================================================
2258 //=============================================================================
2259 void SMESHGUI::SetState(int aState)
2264 //=============================================================================
2268 //=============================================================================
2269 void SMESHGUI::ResetState()
2274 //=============================================================================
2278 //=============================================================================
2279 void SMESHGUI::EmitSignalDeactivateDialog()
2281 emit SignalDeactivateActiveDialog();
2284 //=============================================================================
2288 //=============================================================================
2289 void SMESHGUI::EmitSignalStudyFrameChanged()
2291 emit SignalStudyFrameChanged();
2294 //=============================================================================
2298 //=============================================================================
2299 void SMESHGUI::EmitSignalCloseAllDialogs()
2301 emit SignalCloseAllDialogs();
2304 //=============================================================================
2308 //=============================================================================
2309 void SMESHGUI::EmitSignalVisibilityChanged()
2311 emit SignalVisibilityChanged();
2314 //=============================================================================
2318 //=============================================================================
2319 void SMESHGUI::EmitSignalCloseView()
2321 emit SignalCloseView();
2324 //=============================================================================
2328 //=============================================================================
2329 void SMESHGUI::EmitSignalActivatedViewManager()
2331 emit SignalActivatedViewManager();
2334 //=============================================================================
2338 //=============================================================================
2339 QDialog *SMESHGUI::GetActiveDialogBox()
2341 return myActiveDialogBox;
2344 //=============================================================================
2348 //=============================================================================
2349 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2351 myActiveDialogBox = (QDialog *) aDlg;
2355 //=============================================================================
2359 //=============================================================================
2360 SUIT_Desktop* SMESHGUI::desktop()
2362 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2364 return app->desktop();
2369 //=============================================================================
2373 //=============================================================================
2374 SalomeApp_Study* SMESHGUI::activeStudy()
2376 SUIT_Application* app = SUIT_Session::session()->activeApplication();
2378 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2383 //=============================================================================
2387 //=============================================================================
2388 void SMESHGUI::Modified( bool theIsUpdateActions )
2390 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2391 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2392 appStudy->Modified();
2393 if( theIsUpdateActions )
2394 app->updateActions();
2399 //=============================================================================
2403 //=============================================================================
2404 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2406 /* Here the position is on the bottom right corner - 10 */
2407 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2409 SUIT_Desktop *PP = desktop();
2410 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2411 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2416 * \brief Verifies whether study of operation is locked
2417 * \param theMess - specifies whether message box must be shown if study is locked
2418 * \return State of study.
2420 * Verifies whether study of operation is locked. If second parameter is TRUE and study
2421 * is locked when corresponding message box appears
2423 bool SMESHGUI::isStudyLocked( bool theMessage )
2425 if ( SMESH::getStudy()->GetProperties()->IsLocked() )
2428 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2429 QObject::tr( "WRN_WARNING" ),
2430 QObject::tr( "WRN_STUDY_LOCKED" ) );
2436 //=============================================================================
2440 //=============================================================================
2441 bool SMESHGUI::OnGUIEvent( int theCommandID )
2443 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2447 SUIT_ResourceMgr* mgr = resourceMgr();
2451 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2452 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2454 //QAction* act = action( theCommandID );
2456 switch (theCommandID) {
2457 case SMESHOp::OpDelete:
2458 if(isStudyLocked()) break;
2461 case SMESHOp::OpImportDAT:
2462 case SMESHOp::OpImportUNV:
2463 case SMESHOp::OpImportMED:
2464 case SMESHOp::OpImportSTL:
2465 case SMESHOp::OpImportCGNS:
2466 case SMESHOp::OpImportSAUV:
2467 case SMESHOp::OpImportGMF:
2468 case SMESHOp::OpPopupImportDAT:
2469 case SMESHOp::OpPopupImportUNV:
2470 case SMESHOp::OpPopupImportMED:
2471 case SMESHOp::OpPopupImportSTL:
2472 case SMESHOp::OpPopupImportCGNS:
2473 case SMESHOp::OpPopupImportSAUV:
2474 case SMESHOp::OpPopupImportGMF:
2476 if(isStudyLocked()) break;
2477 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2481 case SMESHOp::OpFileInformation:
2483 SALOME_ListIO selected;
2484 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2486 aSel->selectedObjects( selected );
2487 if( selected.Extent() )
2489 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2490 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2491 if ( !aMesh->_is_nil() )
2493 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2499 case SMESHOp::OpExportDAT:
2500 case SMESHOp::OpExportMED:
2501 case SMESHOp::OpExportUNV:
2502 case SMESHOp::OpExportSTL:
2503 case SMESHOp::OpExportCGNS:
2504 case SMESHOp::OpExportSAUV:
2505 case SMESHOp::OpExportGMF:
2506 case SMESHOp::OpPopupExportDAT:
2507 case SMESHOp::OpPopupExportMED:
2508 case SMESHOp::OpPopupExportUNV:
2509 case SMESHOp::OpPopupExportSTL:
2510 case SMESHOp::OpPopupExportCGNS:
2511 case SMESHOp::OpPopupExportSAUV:
2512 case SMESHOp::OpPopupExportGMF:
2514 ::ExportMeshToFile(theCommandID);
2518 case SMESHOp::OpReset: // SCALAR BAR
2520 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2521 SALOME_ListIO selected;
2523 aSel->selectedObjects( selected );
2525 SALOME_ListIteratorOfListIO it(selected);
2526 for( ; it.More(); it.Next()) {
2527 Handle(SALOME_InteractiveObject) anIO = it.Value();
2528 if( anIO->hasEntry() ) {
2529 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2530 anActor->SetControlMode( SMESH_Actor::eNone );
2531 #ifndef DISABLE_PLOT2DVIEWER
2532 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2537 SMESH::UpdateView();
2540 case SMESHOp::OpScalarBarProperties:
2542 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2545 case SMESHOp::OpShowScalarBar:
2547 // show/hide scalar bar
2548 ::ShowElement(theCommandID);
2551 case SMESHOp::OpSaveDistribution:
2553 // dump control distribution data to the text file
2554 ::SaveDistribution();
2558 case SMESHOp::OpShowDistribution:
2560 // show/hide distribution
2561 ::ShowElement(theCommandID);
2565 #ifndef DISABLE_PLOT2DVIEWER
2566 case SMESHOp::OpPlotDistribution:
2568 // plot distribution
2569 ::PlotDistribution();
2575 case SMESHOp::OpAutoColor:
2579 case SMESHOp::OpDisableAutoColor:
2580 ::DisableAutoColor();
2583 case SMESHOp::OpClipping:
2584 case SMESHOp::OpTransparency:
2585 case SMESHOp::OpProperties: // Display preferences (colors, shrink size, line width, ...)
2588 case SMESHOp::OpDMWireframe:
2589 case SMESHOp::OpDMShading:
2590 case SMESHOp::OpDMNodes:
2591 case SMESHOp::OpDMShrink:
2592 ::SetDisplayMode(theCommandID, myMarkerMap);
2595 //2D quadratic representation
2596 case SMESHOp::OpRepresentationLines:
2597 case SMESHOp::OpRepresentationArcs:
2598 ::SetDisplayMode(theCommandID, myMarkerMap);
2602 case SMESHOp::OpDE0DElements:
2603 case SMESHOp::OpDEEdges:
2604 case SMESHOp::OpDEFaces:
2605 case SMESHOp::OpDEVolumes:
2606 case SMESHOp::OpDEBalls:
2607 case SMESHOp::OpDEAllEntity:
2608 ::SetDisplayEntity(theCommandID);
2611 // Choose entities to be displayed
2612 case SMESHOp::OpDEChoose:
2614 ( new SMESHGUI_DisplayEntitiesDlg( SMESHGUI::desktop() ) )->exec();
2618 case SMESHOp::OpOrientationOnFaces:
2620 SUIT_OverrideCursor wc;
2621 LightApp_SelectionMgr* mgr = selectionMgr();
2622 SALOME_ListIO selected; mgr->selectedObjects( selected );
2624 SALOME_ListIteratorOfListIO it(selected);
2625 for( ; it.More(); it.Next()) {
2626 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2627 if(anIObject->hasEntry()) {
2628 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2629 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2636 case SMESHOp::OpUpdate:
2638 if(isStudyLocked()) break;
2639 SUIT_OverrideCursor wc;
2642 SMESH::UpdateView();
2644 catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2645 SMESH::OnVisuException();
2647 catch (...) { // PAL16774 (Crash after display of many groups)
2648 SMESH::OnVisuException();
2652 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2653 aSel->selectedObjects( l );
2654 aSel->setSelectedObjects( l );
2658 case SMESHOp::OpHide:
2659 case SMESHOp::OpShow:
2660 case SMESHOp::OpShowOnly:
2662 SUIT_OverrideCursor wc;
2663 SMESH::EDisplaing anAction;
2664 switch (theCommandID) {
2665 case SMESHOp::OpHide: anAction = SMESH::eErase; break;
2666 case SMESHOp::OpShow: anAction = SMESH::eDisplay; break;
2667 case SMESHOp::OpShowOnly: anAction = SMESH::eDisplayOnly; break;
2670 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2671 SALOME_ListIO sel_objects, to_process;
2673 aSel->selectedObjects( sel_objects );
2675 if ( theCommandID==SMESHOp::OpShowOnly )
2677 //MESSAGE("anAction = SMESH::eDisplayOnly");
2678 startOperation( myEraseAll );
2681 extractContainers( sel_objects, to_process );
2686 SALOME_ListIteratorOfListIO It( to_process );
2687 for ( ; It.More(); It.Next())
2689 Handle(SALOME_InteractiveObject) IOS = It.Value();
2690 if ( IOS->hasEntry() )
2692 if ( !SMESH::UpdateView( anAction, IOS->getEntry() )) {
2693 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2694 break; // PAL16774 (Crash after display of many groups)
2696 if (anAction == SMESH::eDisplayOnly)
2697 anAction = SMESH::eDisplay;
2702 // PAL13338 + PAL15161 -->
2703 if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !isStudyLocked()) {
2704 SMESH::UpdateView();
2705 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2707 // PAL13338 + PAL15161 <--
2709 catch (...) { // PAL16774 (Crash after display of many groups)
2710 SMESH::OnVisuException();
2713 if (anAction == SMESH::eErase) {
2715 aSel->setSelectedObjects( l1 );
2718 aSel->setSelectedObjects( to_process );
2723 case SMESHOp::OpNode:
2725 if(isStudyLocked()) break;
2728 EmitSignalDeactivateDialog();
2730 ( new SMESHGUI_NodesDlg( this ) )->show();
2733 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"),tr("SMESH_WRN_VIEWER_VTK"));
2738 case SMESHOp::OpCreateMesh:
2739 case SMESHOp::OpCreateSubMesh:
2740 case SMESHOp::OpEditMeshOrSubMesh:
2741 case SMESHOp::OpEditMesh:
2742 case SMESHOp::OpEditSubMesh:
2743 case SMESHOp::OpCompute:
2744 case SMESHOp::OpComputeSubMesh:
2745 case SMESHOp::OpPreCompute:
2746 case SMESHOp::OpEvaluate:
2747 case SMESHOp::OpMeshOrder:
2748 startOperation( theCommandID );
2750 case SMESHOp::OpCopyMesh:
2752 if (isStudyLocked()) break;
2753 EmitSignalDeactivateDialog();
2754 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2757 case SMESHOp::OpBuildCompoundMesh:
2759 if (isStudyLocked()) break;
2760 EmitSignalDeactivateDialog();
2761 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2765 case SMESHOp::OpDiagonalInversion:
2766 case SMESHOp::OpUnionOfTwoTriangle:
2770 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2774 if ( isStudyLocked() )
2777 /*Standard_Boolean aRes;
2778 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2779 if ( aMesh->_is_nil() )
2781 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2782 tr( "SMESH_BAD_SELECTION" ) );
2786 EmitSignalDeactivateDialog();
2787 if ( theCommandID == SMESHOp::OpDiagonalInversion )
2788 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2790 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2793 case SMESHOp::OpOrientation:
2794 case SMESHOp::OpUnionOfTriangles:
2795 case SMESHOp::OpCuttingOfQuadrangles:
2796 case SMESHOp::OpSplitVolumes:
2800 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2804 if ( isStudyLocked() )
2807 EmitSignalDeactivateDialog();
2808 SMESHGUI_MultiEditDlg* aDlg = NULL;
2809 if ( theCommandID == SMESHOp::OpOrientation )
2810 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2811 else if ( theCommandID == SMESHOp::OpUnionOfTriangles )
2812 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2813 else if ( theCommandID == SMESHOp::OpSplitVolumes )
2814 aDlg = new SMESHGUI_SplitVolumesDlg(this);
2816 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2821 case SMESHOp::OpSmoothing:
2823 if(isStudyLocked()) break;
2825 EmitSignalDeactivateDialog();
2826 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2829 SUIT_MessageBox::warning(desktop(), tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2833 case SMESHOp::OpExtrusion:
2835 if (isStudyLocked()) break;
2837 EmitSignalDeactivateDialog();
2838 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2840 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2844 case SMESHOp::OpExtrusionAlongAPath:
2846 if (isStudyLocked()) break;
2848 EmitSignalDeactivateDialog();
2849 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2851 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2855 case SMESHOp::OpRevolution:
2857 if(isStudyLocked()) break;
2859 EmitSignalDeactivateDialog();
2860 ( new SMESHGUI_RevolutionDlg( this ) )->show();
2863 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2867 case SMESHOp::OpPatternMapping:
2869 if ( isStudyLocked() )
2873 EmitSignalDeactivateDialog();
2874 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2877 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2881 case SMESHOp::OpSplitBiQuadratic:
2882 case SMESHOp::OpConvertMeshToQuadratic:
2883 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
2884 case SMESHOp::OpReorientFaces:
2885 case SMESHOp::OpCreateGeometryGroup:
2887 startOperation( theCommandID );
2890 case SMESHOp::OpCreateGroup:
2894 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2898 if(isStudyLocked()) break;
2899 EmitSignalDeactivateDialog();
2900 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2902 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2903 SALOME_ListIO selected;
2905 aSel->selectedObjects( selected );
2907 int nbSel = selected.Extent();
2909 // check if mesh is selected
2910 aMesh = SMESH::GetMeshByIO( selected.First() );
2912 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2917 case SMESHOp::OpConstructGroup:
2921 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2925 if(isStudyLocked()) break;
2926 EmitSignalDeactivateDialog();
2928 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2929 SALOME_ListIO selected;
2931 aSel->selectedObjects( selected );
2933 int nbSel = selected.Extent();
2935 // check if submesh is selected
2936 Handle(SALOME_InteractiveObject) IObject = selected.First();
2937 if (IObject->hasEntry()) {
2938 _PTR(SObject) aSObj = SMESH::getStudy()->FindObjectID(IObject->getEntry());
2940 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2941 if (!aSubMesh->_is_nil()) {
2943 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2944 // get submesh elements list by types
2945 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2946 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2947 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2948 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2949 // create group for each type o elements
2950 QString aName = IObject->getName();
2951 QStringList anEntryList;
2952 if (aNodes->length() > 0) {
2953 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2954 aGroup->Add(aNodes.inout());
2955 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2956 anEntryList.append( aSObject->GetID().c_str() );
2958 if (aEdges->length() > 0) {
2959 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2960 aGroup->Add(aEdges.inout());
2961 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2962 anEntryList.append( aSObject->GetID().c_str() );
2964 if (aFaces->length() > 0) {
2965 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2966 aGroup->Add(aFaces.inout());
2967 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2968 anEntryList.append( aSObject->GetID().c_str() );
2970 if (aVolumes->length() > 0) {
2971 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2972 aGroup->Add(aVolumes.inout());
2973 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2974 anEntryList.append( aSObject->GetID().c_str() );
2977 anApp->browseObjects( anEntryList );
2979 catch(const SALOME::SALOME_Exception & S_ex){
2980 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2987 SUIT_MessageBox::warning(desktop(),
2988 tr("SMESH_WRN_WARNING"),
2989 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
2994 case SMESHOp::OpEditGroup:
2998 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3002 if(isStudyLocked()) break;
3003 EmitSignalDeactivateDialog();
3005 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3006 SALOME_ListIO selected;
3008 aSel->selectedObjects( selected );
3010 SALOME_ListIteratorOfListIO It (selected);
3011 int nbSelectedGroups = 0;
3012 for ( ; It.More(); It.Next() )
3014 SMESH::SMESH_GroupBase_var aGroup =
3015 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
3016 if (!aGroup->_is_nil()) {
3018 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
3022 if (nbSelectedGroups == 0)
3024 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
3030 case SMESHOp::OpAddElemGroupPopup: // Add elements to group
3032 if(isStudyLocked()) break;
3033 if (myState == 800) {
3034 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3035 if (aDlg) aDlg->onAdd();
3040 case SMESHOp::OpRemoveElemGroupPopup: // Remove elements from group
3042 if(isStudyLocked()) break;
3043 if (myState == 800) {
3044 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3045 if (aDlg) aDlg->onRemove();
3050 case SMESHOp::OpEditGeomGroupAsGroup:
3054 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3058 if(isStudyLocked()) break;
3059 EmitSignalDeactivateDialog();
3061 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3062 SALOME_ListIO selected;
3064 aSel->selectedObjects( selected );
3066 SALOME_ListIteratorOfListIO It (selected);
3067 for ( ; It.More(); It.Next() )
3069 SMESH::SMESH_GroupOnGeom_var aGroup =
3070 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
3071 if (!aGroup->_is_nil()) {
3072 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3077 SMESH::SMESH_GroupOnFilter_var aGroup =
3078 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
3079 if (!aGroup->_is_nil()) {
3080 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3088 case SMESHOp::OpUnionGroups:
3089 case SMESHOp::OpIntersectGroups:
3090 case SMESHOp::OpCutGroups:
3094 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3098 if ( isStudyLocked() )
3101 EmitSignalDeactivateDialog();
3103 SMESHGUI_GroupOpDlg* aDlg = 0;
3104 if ( theCommandID == SMESHOp::OpUnionGroups )
3105 aDlg = new SMESHGUI_UnionGroupsDlg( this );
3106 else if ( theCommandID == SMESHOp::OpIntersectGroups )
3107 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3109 aDlg = new SMESHGUI_CutGroupsDlg( this );
3116 case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
3118 if ( isStudyLocked() )
3121 EmitSignalDeactivateDialog();
3122 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3128 case SMESHOp::OpDeleteGroup: // Delete groups with their contents
3132 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3136 if ( isStudyLocked() )
3139 EmitSignalDeactivateDialog();
3141 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3145 case SMESHOp::OpMeshInformation:
3146 case SMESHOp::OpWhatIs:
3148 int page = theCommandID == SMESHOp::OpMeshInformation ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3149 EmitSignalDeactivateDialog();
3150 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3151 SALOME_ListIO selected;
3153 aSel->selectedObjects( selected );
3155 if ( selected.Extent() > 1 ) { // a dlg for each IO
3156 SALOME_ListIteratorOfListIO It( selected );
3157 for ( ; It.More(); It.Next() ) {
3158 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3159 dlg->showInfo( It.Value() );
3164 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3170 case SMESHOp::OpFindElementByPoint:
3172 startOperation( theCommandID );
3176 case SMESHOp::OpEditHypothesis:
3178 if(isStudyLocked()) break;
3180 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3181 SALOME_ListIO selected;
3183 aSel->selectedObjects( selected );
3185 int nbSel = selected.Extent();
3188 Handle(SALOME_InteractiveObject) anIObject = selected.First();
3189 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3191 if ( !aHypothesis->_is_nil() )
3193 SMESHGUI_GenericHypothesisCreator* aCreator =
3194 SMESH::GetHypothesisCreator( SMESH::toQStr( aHypothesis->GetName() ));
3197 // set geometry of mesh and sub-mesh to aCreator
3198 aSel->selectedObjects( selected, "", /*convertReferences=*/false);
3199 if ( selected.Extent() == 1 )
3201 QString subGeomID, meshGeomID;
3202 Handle(SALOME_InteractiveObject) hypIO = selected.First();
3203 if ( SMESH::GetGeomEntries( hypIO, subGeomID, meshGeomID ))
3205 if ( subGeomID.isEmpty() ) subGeomID = meshGeomID;
3206 aCreator->setShapeEntry( subGeomID );
3207 aCreator->setMainShapeEntry( meshGeomID );
3211 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3221 case SMESHOp::OpUnassign: // REMOVE HYPOTHESIS / ALGORITHMS
3223 if(isStudyLocked()) break;
3224 SUIT_OverrideCursor wc;
3226 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3227 SALOME_ListIO selected;
3229 aSel->selectedObjects( selected, QString::null, false );
3231 SALOME_ListIteratorOfListIO It(selected);
3232 for (int i = 0; It.More(); It.Next(), i++) {
3233 Handle(SALOME_InteractiveObject) IObject = It.Value();
3234 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3237 aSel->setSelectedObjects( l1 );
3242 case SMESHOp::OpElem0D:
3243 case SMESHOp::OpBall:
3244 case SMESHOp::OpEdge:
3245 case SMESHOp::OpTriangle:
3246 case SMESHOp::OpQuadrangle:
3247 case SMESHOp::OpPolygon:
3248 case SMESHOp::OpTetrahedron:
3249 case SMESHOp::OpHexahedron:
3250 case SMESHOp::OpPentahedron:
3251 case SMESHOp::OpPyramid:
3252 case SMESHOp::OpHexagonalPrism:
3254 if(isStudyLocked()) break;
3256 EmitSignalDeactivateDialog();
3257 SMDSAbs_EntityType type = SMDSEntity_Edge;
3258 switch (theCommandID) {
3259 case SMESHOp::OpElem0D: type = SMDSEntity_0D; break;
3260 case SMESHOp::OpBall: type = SMDSEntity_Ball; break;
3261 case SMESHOp::OpTriangle: type = SMDSEntity_Triangle; break;
3262 case SMESHOp::OpQuadrangle: type = SMDSEntity_Quadrangle; break;
3263 case SMESHOp::OpTetrahedron: type = SMDSEntity_Tetra; break;
3264 case SMESHOp::OpPolygon: type = SMDSEntity_Polygon; break;
3265 case SMESHOp::OpHexahedron: type = SMDSEntity_Hexa; break;
3266 case SMESHOp::OpPentahedron: type = SMDSEntity_Penta; break;
3267 case SMESHOp::OpPyramid: type = SMDSEntity_Pyramid; break;
3268 case SMESHOp::OpHexagonalPrism: type = SMDSEntity_Hexagonal_Prism; break;
3271 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3274 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3278 case SMESHOp::OpPolyhedron:
3280 if(isStudyLocked()) break;
3282 EmitSignalDeactivateDialog();
3283 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3286 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3290 case SMESHOp::OpQuadraticEdge:
3291 case SMESHOp::OpQuadraticTriangle:
3292 case SMESHOp::OpBiQuadraticTriangle:
3293 case SMESHOp::OpQuadraticQuadrangle:
3294 case SMESHOp::OpBiQuadraticQuadrangle:
3295 case SMESHOp::OpQuadraticPolygon:
3296 case SMESHOp::OpQuadraticTetrahedron:
3297 case SMESHOp::OpQuadraticPyramid:
3298 case SMESHOp::OpQuadraticPentahedron:
3299 case SMESHOp::OpBiQuadraticPentahedron:
3300 case SMESHOp::OpQuadraticHexahedron:
3301 case SMESHOp::OpTriQuadraticHexahedron:
3303 if(isStudyLocked()) break;
3305 EmitSignalDeactivateDialog();
3306 SMDSAbs_EntityType type = SMDSEntity_Last;
3308 switch (theCommandID) {
3309 case SMESHOp::OpQuadraticEdge: type = SMDSEntity_Quad_Edge; break;
3310 case SMESHOp::OpQuadraticTriangle: type = SMDSEntity_Quad_Triangle; break;
3311 case SMESHOp::OpBiQuadraticTriangle: type = SMDSEntity_BiQuad_Triangle; break;
3312 case SMESHOp::OpQuadraticQuadrangle: type = SMDSEntity_Quad_Quadrangle; break;
3313 case SMESHOp::OpBiQuadraticQuadrangle: type = SMDSEntity_BiQuad_Quadrangle; break;
3314 case SMESHOp::OpQuadraticPolygon: type = SMDSEntity_Quad_Polygon; break;
3315 case SMESHOp::OpQuadraticTetrahedron: type = SMDSEntity_Quad_Tetra; break;
3316 case SMESHOp::OpQuadraticPyramid: type = SMDSEntity_Quad_Pyramid; break;
3317 case SMESHOp::OpQuadraticPentahedron: type = SMDSEntity_Quad_Penta; break;
3318 case SMESHOp::OpBiQuadraticPentahedron: type = SMDSEntity_BiQuad_Penta; break;
3319 case SMESHOp::OpQuadraticHexahedron: type = SMDSEntity_Quad_Hexa; break;
3320 case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
3323 if ( type != SMDSEntity_Last )
3324 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3327 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3328 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3332 case SMESHOp::OpRemoveNodes:
3334 if(isStudyLocked()) break;
3336 EmitSignalDeactivateDialog();
3337 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3340 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3341 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3345 case SMESHOp::OpRemoveElements: // REMOVES ELEMENTS
3347 if(isStudyLocked()) break;
3349 EmitSignalDeactivateDialog();
3350 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3354 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3355 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3359 case SMESHOp::OpClearMesh: {
3361 if(isStudyLocked()) break;
3363 SALOME_ListIO selected;
3364 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3365 aSel->selectedObjects( selected );
3367 SUIT_OverrideCursor wc;
3368 SALOME_ListIteratorOfListIO It (selected);
3369 for ( ; It.More(); It.Next() )
3371 Handle(SALOME_InteractiveObject) IOS = It.Value();
3372 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3373 if ( aMesh->_is_nil()) continue;
3376 if ( aMesh->NbNodes() == 0 ) // imported mesh is not empty
3377 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3378 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3379 // hide groups and submeshes
3380 _PTR(ChildIterator) anIter =
3381 SMESH::getStudy()->NewChildIterator( aMeshSObj );
3382 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3384 _PTR(SObject) so = anIter->Value();
3385 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3388 catch (const SALOME::SALOME_Exception& S_ex){
3390 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3394 SMESH::UpdateView();
3398 case SMESHOp::OpRemoveOrphanNodes:
3400 if(isStudyLocked()) break;
3401 SALOME_ListIO selected;
3402 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3403 aSel->selectedObjects( selected );
3404 if ( selected.Extent() == 1 ) {
3405 Handle(SALOME_InteractiveObject) anIO = selected.First();
3406 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3407 if ( !aMesh->_is_nil() ) {
3408 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3409 tr( "SMESH_WARNING" ),
3410 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3411 SUIT_MessageBox::Yes |
3412 SUIT_MessageBox::No,
3413 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3416 SUIT_OverrideCursor wc;
3417 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3418 int removed = aMeshEditor->RemoveOrphanNodes();
3419 SUIT_MessageBox::information(SMESHGUI::desktop(),
3420 tr("SMESH_INFORMATION"),
3421 tr("NB_NODES_REMOVED").arg(removed));
3422 if ( removed > 0 ) {
3423 SMESH::UpdateView();
3424 SMESHGUI::Modified();
3427 catch (const SALOME::SALOME_Exception& S_ex) {
3428 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3437 case SMESHOp::OpRenumberingNodes:
3439 if(isStudyLocked()) break;
3441 EmitSignalDeactivateDialog();
3442 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3446 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3447 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3451 case SMESHOp::OpRenumberingElements:
3453 if(isStudyLocked()) break;
3455 EmitSignalDeactivateDialog();
3456 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3460 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3461 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3465 case SMESHOp::OpTranslation:
3467 if(isStudyLocked()) break;
3469 EmitSignalDeactivateDialog();
3470 ( new SMESHGUI_TranslationDlg( this ) )->show();
3473 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3474 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3478 case SMESHOp::OpRotation:
3480 if(isStudyLocked()) break;
3482 EmitSignalDeactivateDialog();
3483 ( new SMESHGUI_RotationDlg( this ) )->show();
3486 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3487 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3491 case SMESHOp::OpSymmetry:
3493 if(isStudyLocked()) break;
3495 EmitSignalDeactivateDialog();
3496 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3499 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3500 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3504 case SMESHOp::OpScale:
3506 if(isStudyLocked()) break;
3508 EmitSignalDeactivateDialog();
3509 ( new SMESHGUI_ScaleDlg( this ) )->show();
3512 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3513 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3518 case SMESHOp::OpOffset:
3520 if(isStudyLocked()) break;
3522 EmitSignalDeactivateDialog();
3523 ( new SMESHGUI_OffsetDlg( this ) )->show();
3526 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3527 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3532 case SMESHOp::OpSewing:
3534 if(isStudyLocked()) break;
3536 EmitSignalDeactivateDialog();
3537 ( new SMESHGUI_SewingDlg( this ) )->show();
3540 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3541 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3545 case SMESHOp::OpMergeNodes:
3547 if(isStudyLocked()) break;
3549 EmitSignalDeactivateDialog();
3550 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3553 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3554 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3558 case SMESHOp::OpMergeElements:
3560 if (isStudyLocked()) break;
3562 EmitSignalDeactivateDialog();
3563 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3565 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3566 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3571 case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
3572 startOperation( SMESHOp::OpMoveNode );
3575 case SMESHOp::OpDuplicateNodes:
3577 if(isStudyLocked()) break;
3579 EmitSignalDeactivateDialog();
3580 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3583 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3584 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3589 case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
3590 startOperation( SMESHOp::OpElem0DOnElemNodes );
3593 case SMESHOp::OpSelectFiltersLibrary: // Library of selection filters
3595 static QList<int> aTypes;
3596 if ( aTypes.isEmpty() )
3598 aTypes.append( SMESH::NODE );
3599 aTypes.append( SMESH::EDGE );
3600 aTypes.append( SMESH::FACE );
3601 aTypes.append( SMESH::VOLUME );
3603 if (!myFilterLibraryDlg)
3604 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3605 else if (myFilterLibraryDlg->isHidden())
3606 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3607 myFilterLibraryDlg->raise();
3611 case SMESHOp::OpFreeNode:
3612 case SMESHOp::OpEqualNode:
3613 case SMESHOp::OpNodeConnectivityNb:
3614 case SMESHOp::OpFreeEdge:
3615 case SMESHOp::OpFreeBorder:
3616 case SMESHOp::OpLength:
3617 case SMESHOp::OpConnection:
3618 case SMESHOp::OpEqualEdge:
3619 case SMESHOp::OpFreeFace:
3620 case SMESHOp::OpBareBorderFace:
3621 case SMESHOp::OpOverConstrainedFace:
3622 case SMESHOp::OpLength2D:
3623 case SMESHOp::OpDeflection2D:
3624 case SMESHOp::OpConnection2D:
3625 case SMESHOp::OpArea:
3626 case SMESHOp::OpTaper:
3627 case SMESHOp::OpAspectRatio:
3628 case SMESHOp::OpMinimumAngle:
3629 case SMESHOp::OpWarpingAngle:
3630 case SMESHOp::OpSkew:
3631 case SMESHOp::OpMaxElementLength2D:
3632 case SMESHOp::OpEqualFace:
3633 case SMESHOp::OpAspectRatio3D:
3634 case SMESHOp::OpVolume:
3635 case SMESHOp::OpMaxElementLength3D:
3636 case SMESHOp::OpBareBorderVolume:
3637 case SMESHOp::OpOverConstrainedVolume:
3638 case SMESHOp::OpEqualVolume:
3641 LightApp_SelectionMgr* mgr = selectionMgr();
3642 SALOME_ListIO selected; mgr->selectedObjects( selected );
3644 if( !selected.IsEmpty() ) {
3645 SUIT_OverrideCursor wc;
3646 ::Control( theCommandID );
3649 SUIT_MessageBox::warning(desktop(),
3650 tr( "SMESH_WRN_WARNING" ),
3651 tr( "SMESH_BAD_SELECTION" ) );
3655 SUIT_MessageBox::warning(desktop(),
3656 tr( "SMESH_WRN_WARNING" ),
3657 tr( "NOT_A_VTK_VIEWER" ) );
3660 case SMESHOp::OpOverallMeshQuality:
3661 OverallMeshQuality();
3663 case SMESHOp::OpNumberingNodes:
3665 SUIT_OverrideCursor wc;
3666 LightApp_SelectionMgr* mgr = selectionMgr();
3667 SALOME_ListIO selected; mgr->selectedObjects( selected );
3669 SALOME_ListIteratorOfListIO it(selected);
3670 for( ; it.More(); it.Next()) {
3671 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3672 if(anIObject->hasEntry()) {
3673 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3674 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3680 case SMESHOp::OpNumberingElements:
3682 SUIT_OverrideCursor wc;
3683 LightApp_SelectionMgr* mgr = selectionMgr();
3684 SALOME_ListIO selected; mgr->selectedObjects( selected );
3686 SALOME_ListIteratorOfListIO it(selected);
3687 for( ; it.More(); it.Next()) {
3688 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3689 if(anIObject->hasEntry())
3690 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3691 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3696 case SMESHOp::OpPropertiesLength:
3697 case SMESHOp::OpPropertiesArea:
3698 case SMESHOp::OpPropertiesVolume:
3699 case SMESHOp::OpMinimumDistance:
3700 case SMESHOp::OpBoundingBox:
3702 int page = SMESHGUI_MeasureDlg::MinDistance;
3703 if ( theCommandID == SMESHOp::OpBoundingBox )
3704 page = SMESHGUI_MeasureDlg::BoundingBox;
3705 else if ( theCommandID == SMESHOp::OpPropertiesLength )
3706 page = SMESHGUI_MeasureDlg::Length;
3707 else if ( theCommandID == SMESHOp::OpPropertiesArea )
3708 page = SMESHGUI_MeasureDlg::Area;
3709 else if ( theCommandID == SMESHOp::OpPropertiesVolume )
3710 page = SMESHGUI_MeasureDlg::Volume;
3712 EmitSignalDeactivateDialog();
3713 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3717 case SMESHOp::OpSortChild:
3723 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3724 //updateObjBrowser();
3728 //=============================================================================
3732 //=============================================================================
3733 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3738 //=============================================================================
3742 //=============================================================================
3743 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3748 //=============================================================================
3752 //=============================================================================
3753 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3758 //=============================================================================
3759 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3760 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3762 //=============================================================================
3763 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3764 SUIT_ViewWindow* wnd )
3766 if(theIO->hasEntry()){
3767 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3768 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3772 //=======================================================================
3773 // function : createSMESHAction
3775 //=======================================================================
3776 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3777 const int key, const bool toggle, const QString& shortcutAction )
3780 QWidget* parent = application()->desktop();
3781 SUIT_ResourceMgr* resMgr = resourceMgr();
3783 if ( !icon_id.isEmpty() )
3784 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3786 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3787 if ( !pix.isNull() )
3788 icon = QIcon( pix );
3790 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3791 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3792 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3794 createAction( id, tooltip, icon, menu, status_bar, key, parent,
3795 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3798 //=======================================================================
3799 // function : createPopupItem
3801 //=======================================================================
3802 void SMESHGUI::createPopupItem( const int id,
3803 const QString& clients,
3804 const QString& types,
3805 const QString& theRule,
3808 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3809 popupMgr()->insert( action( id ), pId, 0 );
3811 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3812 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
3813 QString rule = "(%1) and (%2) and (%3)";
3814 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3815 if( clients.isEmpty() )
3816 rule = rule.arg( QString( "true" ) );
3818 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3819 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3822 bool cont = myRules.contains( id );
3824 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3826 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3827 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3830 //=======================================================================
3831 // function : initialize
3833 //=======================================================================
3834 void SMESHGUI::initialize( CAM_Application* app )
3836 SalomeApp_Module::initialize( app );
3838 // SUIT_ResourceMgr* mgr = app->resourceMgr();
3840 /* Automatic Update flag */
3841 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3843 // ----- create actions --------------
3845 //createSMESHAction( SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
3846 createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_I) );
3847 createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
3848 createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL" );
3850 createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
3852 createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
3853 createSMESHAction( SMESHOp::OpImportGMF, "IMPORT_GMF" );
3854 createSMESHAction( SMESHOp::OpPopupImportUNV, "IMPORT_UNV");
3855 createSMESHAction( SMESHOp::OpPopupImportMED, "IMPORT_MED");
3856 createSMESHAction( SMESHOp::OpPopupImportSTL, "IMPORT_STL" );
3858 createSMESHAction( SMESHOp::OpPopupImportCGNS, "IMPORT_CGNS" );
3860 createSMESHAction( SMESHOp::OpPopupImportSAUV, "IMPORT_SAUV" );
3861 createSMESHAction( SMESHOp::OpPopupImportGMF, "IMPORT_GMF" );
3863 createSMESHAction( SMESHOp::OpExportDAT, "DAT" );
3864 createSMESHAction( SMESHOp::OpExportMED, "MED" );
3865 createSMESHAction( SMESHOp::OpExportUNV, "UNV" );
3866 createSMESHAction( SMESHOp::OpExportSTL, "STL" );
3868 createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
3870 createSMESHAction( SMESHOp::OpExportSAUV, "SAUV");
3871 createSMESHAction( SMESHOp::OpExportGMF, "GMF" );
3872 createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
3873 createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
3874 createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
3875 createSMESHAction( SMESHOp::OpPopupExportSTL, "STL" );
3877 createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
3879 createSMESHAction( SMESHOp::OpPopupExportSAUV, "SAUV");
3880 createSMESHAction( SMESHOp::OpPopupExportGMF, "GMF" );
3881 createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
3882 createSMESHAction( SMESHOp::OpDelete, "DELETE", "ICON_DELETE", Qt::Key_Delete );
3883 createSMESHAction( SMESHOp::OpSelectFiltersLibrary, "SEL_FILTER_LIB" );
3884 createSMESHAction( SMESHOp::OpCreateMesh, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
3885 createSMESHAction( SMESHOp::OpCreateSubMesh, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
3886 createSMESHAction( SMESHOp::OpEditMeshOrSubMesh, "EDIT_MESHSUBMESH", "ICON_DLG_EDIT_MESH" );
3887 createSMESHAction( SMESHOp::OpEditMesh, "EDIT_MESH", "ICON_DLG_EDIT_MESH" );
3888 createSMESHAction( SMESHOp::OpEditSubMesh, "EDIT_SUBMESH", "ICON_DLG_EDIT_MESH" );
3889 createSMESHAction( SMESHOp::OpBuildCompoundMesh, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
3890 createSMESHAction( SMESHOp::OpCopyMesh, "COPY_MESH", "ICON_COPY_MESH" );
3891 createSMESHAction( SMESHOp::OpCompute, "COMPUTE", "ICON_COMPUTE" );
3892 createSMESHAction( SMESHOp::OpComputeSubMesh, "COMPUTE_SUBMESH", "ICON_COMPUTE" );
3893 createSMESHAction( SMESHOp::OpPreCompute, "PRECOMPUTE", "ICON_PRECOMPUTE" );
3894 createSMESHAction( SMESHOp::OpEvaluate, "EVALUATE", "ICON_EVALUATE" );
3895 createSMESHAction( SMESHOp::OpMeshOrder, "MESH_ORDER", "ICON_MESH_ORDER");
3896 createSMESHAction( SMESHOp::OpCreateGroup, "CREATE_GROUP", "ICON_CREATE_GROUP" );
3897 createSMESHAction( SMESHOp::OpCreateGeometryGroup, "CREATE_GEO_GROUP", "ICON_CREATE_GEO_GROUP" );
3898 createSMESHAction( SMESHOp::OpConstructGroup, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
3899 createSMESHAction( SMESHOp::OpEditGroup, "EDIT_GROUP", "ICON_EDIT_GROUP" );
3900 createSMESHAction( SMESHOp::OpEditGeomGroupAsGroup, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3901 createSMESHAction( SMESHOp::OpUnionGroups, "UN_GROUP", "ICON_UNION" );
3902 createSMESHAction( SMESHOp::OpIntersectGroups, "INT_GROUP", "ICON_INTERSECT" );
3903 createSMESHAction( SMESHOp::OpCutGroups, "CUT_GROUP", "ICON_CUT" );
3904 createSMESHAction( SMESHOp::OpGroupUnderlyingElem, "UNDERLYING_ELEMS", "ICON_UNDERLYING_ELEMS" );
3905 createSMESHAction( SMESHOp::OpAddElemGroupPopup, "ADD_TO_GROUP" );
3906 createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE_FROM_GROUP" );
3907 createSMESHAction( SMESHOp::OpDeleteGroup, "DEL_GROUP", "ICON_DEL_GROUP" );
3908 createSMESHAction( SMESHOp::OpMeshInformation , "ADV_INFO", "ICON_ADV_INFO" );
3909 //createSMESHAction( SMESHOp::OpStdInfo, "STD_INFO", "ICON_STD_INFO" );
3910 //createSMESHAction( SMESHOp::OpWhatIs, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3911 createSMESHAction( SMESHOp::OpFindElementByPoint, "FIND_ELEM", "ICON_FIND_ELEM" );
3913 createSMESHAction( SMESHOp::OpFreeNode, "FREE_NODE", "ICON_FREE_NODE", 0, true );
3914 createSMESHAction( SMESHOp::OpEqualNode, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
3915 createSMESHAction( SMESHOp::OpNodeConnectivityNb, "NODE_CONNECTIVITY_NB", "ICON_NODE_CONN_NB", 0, true );
3916 createSMESHAction( SMESHOp::OpFreeEdge, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
3917 createSMESHAction( SMESHOp::OpFreeBorder, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
3918 createSMESHAction( SMESHOp::OpLength, "LENGTH", "ICON_LENGTH", 0, true );
3919 createSMESHAction( SMESHOp::OpConnection, "CONNECTION", "ICON_CONNECTION", 0, true );
3920 createSMESHAction( SMESHOp::OpEqualEdge, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
3921 createSMESHAction( SMESHOp::OpFreeFace, "FREE_FACES", "ICON_FREE_FACES", 0, true );
3922 createSMESHAction( SMESHOp::OpBareBorderFace, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
3923 createSMESHAction( SMESHOp::OpOverConstrainedFace, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
3924 createSMESHAction( SMESHOp::OpLength2D, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
3925 createSMESHAction( SMESHOp::OpDeflection2D, "DEFLECTION_2D", "ICON_DEFLECTION_2D", 0, true );
3926 createSMESHAction( SMESHOp::OpConnection2D, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
3927 createSMESHAction( SMESHOp::OpArea, "AREA", "ICON_AREA", 0, true );
3928 createSMESHAction( SMESHOp::OpTaper, "TAPER", "ICON_TAPER", 0, true );
3929 createSMESHAction( SMESHOp::OpAspectRatio, "ASPECT", "ICON_ASPECT", 0, true );
3930 createSMESHAction( SMESHOp::OpMinimumAngle, "MIN_ANG", "ICON_ANGLE", 0, true );
3931 createSMESHAction( SMESHOp::OpWarpingAngle, "WARP", "ICON_WARP", 0, true );
3932 createSMESHAction( SMESHOp::OpSkew, "SKEW", "ICON_SKEW", 0, true );
3933 createSMESHAction( SMESHOp::OpMaxElementLength2D, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
3934 createSMESHAction( SMESHOp::OpEqualFace, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
3935 createSMESHAction( SMESHOp::OpAspectRatio3D, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
3936 createSMESHAction( SMESHOp::OpVolume, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
3937 createSMESHAction( SMESHOp::OpMaxElementLength3D, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
3938 createSMESHAction( SMESHOp::OpBareBorderVolume, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
3939 createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
3940 createSMESHAction( SMESHOp::OpEqualVolume, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
3941 createSMESHAction( SMESHOp::OpOverallMeshQuality, "OVERALL_MESH_QUALITY", "ICON_OVL_MESH_QUALITY" );
3943 createSMESHAction( SMESHOp::OpNode, "NODE", "ICON_DLG_NODE" );
3944 createSMESHAction( SMESHOp::OpElem0D, "ELEM0D", "ICON_DLG_ELEM0D" );
3945 createSMESHAction( SMESHOp::OpElem0DOnElemNodes, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
3946 createSMESHAction( SMESHOp::OpBall, "BALL", "ICON_DLG_BALL" );
3947 createSMESHAction( SMESHOp::OpEdge, "EDGE", "ICON_DLG_EDGE" );
3948 createSMESHAction( SMESHOp::OpTriangle, "TRIANGLE", "ICON_DLG_TRIANGLE" );
3949 createSMESHAction( SMESHOp::OpQuadrangle, "QUAD", "ICON_DLG_QUADRANGLE" );
3950 createSMESHAction( SMESHOp::OpPolygon, "POLYGON", "ICON_DLG_POLYGON" );
3951 createSMESHAction( SMESHOp::OpTetrahedron, "TETRA", "ICON_DLG_TETRAS" );
3952 createSMESHAction( SMESHOp::OpHexahedron, "HEXA", "ICON_DLG_HEXAS" );
3953 createSMESHAction( SMESHOp::OpPentahedron, "PENTA", "ICON_DLG_PENTA" );
3954 createSMESHAction( SMESHOp::OpPyramid , "PYRAMID", "ICON_DLG_PYRAMID" );
3955 createSMESHAction( SMESHOp::OpHexagonalPrism, "OCTA", "ICON_DLG_OCTA" );
3956 createSMESHAction( SMESHOp::OpPolyhedron, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
3957 createSMESHAction( SMESHOp::OpQuadraticEdge, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
3958 createSMESHAction( SMESHOp::OpQuadraticTriangle, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
3959 createSMESHAction( SMESHOp::OpBiQuadraticTriangle, "BIQUADRATIC_TRIANGLE", "ICON_DLG_BIQUADRATIC_TRIANGLE" );
3960 createSMESHAction( SMESHOp::OpQuadraticQuadrangle, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
3961 createSMESHAction( SMESHOp::OpBiQuadraticQuadrangle, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
3962 createSMESHAction( SMESHOp::OpQuadraticPolygon, "QUADRATIC_POLYGON", "ICON_DLG_QUADRATIC_POLYGON" );
3963 createSMESHAction( SMESHOp::OpQuadraticTetrahedron, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
3964 createSMESHAction( SMESHOp::OpQuadraticPyramid, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
3965 createSMESHAction( SMESHOp::OpQuadraticPentahedron, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
3966 createSMESHAction( SMESHOp::OpBiQuadraticPentahedron, "BIQUADRATIC_PENTAHEDRON", "ICON_DLG_BIQUADRATIC_PENTAHEDRON" );
3967 createSMESHAction( SMESHOp::OpQuadraticHexahedron, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
3968 createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
3970 createSMESHAction( SMESHOp::OpRemoveNodes, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
3971 createSMESHAction( SMESHOp::OpRemoveElements, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
3972 createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
3973 createSMESHAction( SMESHOp::OpClearMesh, "CLEAR_MESH", "ICON_CLEAR_MESH" );
3975 //createSMESHAction( SMESHOp::OpRenumberingNodes, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
3976 //createSMESHAction( SMESHOp::OpRenumberingElements, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
3978 createSMESHAction( SMESHOp::OpTranslation, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
3979 createSMESHAction( SMESHOp::OpRotation, "ROT", "ICON_DLG_MESH_ROTATION" );
3980 createSMESHAction( SMESHOp::OpSymmetry, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
3981 createSMESHAction( SMESHOp::OpScale, "SCALE", "ICON_DLG_MESH_SCALE" );
3982 createSMESHAction( SMESHOp::OpOffset, "OFFSET", "ICON_DLG_MESH_OFFSET" );
3983 createSMESHAction( SMESHOp::OpSewing, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
3984 createSMESHAction( SMESHOp::OpMergeNodes, "MERGE", "ICON_SMESH_MERGE_NODES" );
3985 createSMESHAction( SMESHOp::OpMergeElements, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
3986 createSMESHAction( SMESHOp::OpMoveNode, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
3987 createSMESHAction( SMESHOp::OpDuplicateNodes, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
3988 createSMESHAction( SMESHOp::OpDiagonalInversion, "INV", "ICON_DLG_MESH_DIAGONAL" );
3989 createSMESHAction( SMESHOp::OpUnionOfTwoTriangle, "UNION2", "ICON_UNION2TRI" );
3990 createSMESHAction( SMESHOp::OpOrientation, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
3991 createSMESHAction( SMESHOp::OpReorientFaces, "REORIENT_2D", "ICON_REORIENT_2D" );
3992 createSMESHAction( SMESHOp::OpUnionOfTriangles, "UNION", "ICON_UNIONTRI" );
3993 createSMESHAction( SMESHOp::OpCuttingOfQuadrangles, "CUT", "ICON_CUTQUAD" );
3994 createSMESHAction( SMESHOp::OpSplitVolumes, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
3995 createSMESHAction( SMESHOp::OpSplitBiQuadratic, "SPLIT_BIQUAD", "ICON_SPLIT_BIQUAD" );
3996 createSMESHAction( SMESHOp::OpSmoothing, "SMOOTH", "ICON_DLG_SMOOTHING" );
3997 createSMESHAction( SMESHOp::OpExtrusion, "EXTRUSION", "ICON_EXTRUSION" );
3998 createSMESHAction( SMESHOp::OpExtrusionAlongAPath, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
3999 createSMESHAction( SMESHOp::OpRevolution, "REVOLUTION", "ICON_REVOLUTION" );
4000 createSMESHAction( SMESHOp::OpPatternMapping, "MAP", "ICON_MAP" );
4001 createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
4002 createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D", "ICON_2D_FROM_3D" );
4004 createSMESHAction( SMESHOp::OpReset, "RESET" );
4005 createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
4006 createSMESHAction( SMESHOp::OpShowScalarBar, "SHOW_SCALAR_BAR","",0, true );
4007 createSMESHAction( SMESHOp::OpSaveDistribution, "SAVE_DISTRIBUTION" );
4008 createSMESHAction( SMESHOp::OpShowDistribution, "SHOW_DISTRIBUTION","",0, true );
4009 #ifndef DISABLE_PLOT2DVIEWER
4010 createSMESHAction( SMESHOp::OpPlotDistribution, "PLOT_DISTRIBUTION" );
4012 createSMESHAction( SMESHOp::OpDMWireframe, "WIRE", "ICON_WIRE", 0, true );
4013 createSMESHAction( SMESHOp::OpDMShading, "SHADE", "ICON_SHADE", 0, true );
4014 createSMESHAction( SMESHOp::OpDMNodes, "NODES", "ICON_POINTS", 0, true );
4015 createSMESHAction( SMESHOp::OpDMShrink, "SHRINK", "ICON_SHRINK", 0, true );
4016 createSMESHAction( SMESHOp::OpUpdate, "UPDATE", "ICON_UPDATE" );
4017 createSMESHAction( SMESHOp::OpDE0DElements, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
4018 createSMESHAction( SMESHOp::OpDEEdges, "EDGES", "ICON_DLG_EDGE", 0, true );
4019 createSMESHAction( SMESHOp::OpDEFaces, "FACES", "ICON_DLG_TRIANGLE", 0, true );
4020 createSMESHAction( SMESHOp::OpDEVolumes, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
4021 createSMESHAction( SMESHOp::OpDEBalls, "BALLS", "ICON_DLG_BALL", 0, true );
4022 createSMESHAction( SMESHOp::OpDEChoose, "CHOOSE", "ICON_DLG_CHOOSE", 0, false );
4023 createSMESHAction( SMESHOp::OpDEAllEntity, "ALL", "ICON_DLG_CHOOSE_ALL", 0, false );
4024 createSMESHAction( SMESHOp::OpOrientationOnFaces, "FACE_ORIENTATION", "", 0, true );
4026 createSMESHAction( SMESHOp::OpRepresentationLines, "LINE_REPRESENTATION", "", 0, true );
4027 createSMESHAction( SMESHOp::OpRepresentationArcs, "ARC_REPRESENTATION", "", 0, true );
4029 createSMESHAction( SMESHOp::OpEditHypothesis, "EDIT_HYPO" );
4030 createSMESHAction( SMESHOp::OpUnassign, "UNASSIGN" );
4031 createSMESHAction( SMESHOp::OpNumberingNodes, "NUM_NODES", "", 0, true );
4032 createSMESHAction( SMESHOp::OpNumberingElements, "NUM_ELEMENTS", "", 0, true );
4033 createSMESHAction( SMESHOp::OpProperties, "COLORS" );
4034 createSMESHAction( SMESHOp::OpTransparency, "TRANSP" );
4035 createSMESHAction( SMESHOp::OpClipping, "CLIP" );
4036 createSMESHAction( SMESHOp::OpAutoColor, "AUTO_COLOR" );
4037 createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
4039 createSMESHAction( SMESHOp::OpMinimumDistance, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
4040 createSMESHAction( SMESHOp::OpBoundingBox, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
4041 createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH", "ICON_MEASURE_LENGTH" );
4042 createSMESHAction( SMESHOp::OpPropertiesArea, "MEASURE_AREA", "ICON_MEASURE_AREA" );
4043 createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME", "ICON_MEASURE_VOLUME" );
4045 createSMESHAction( SMESHOp::OpHide, "HIDE", "ICON_HIDE" );
4046 createSMESHAction( SMESHOp::OpShow, "SHOW", "ICON_SHOW" );
4047 createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
4049 createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
4051 QList<int> aCtrlActions;
4052 aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode
4053 << SMESHOp::OpNodeConnectivityNb // node controls
4054 << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
4055 << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge // edge controls
4056 << SMESHOp::OpDeflection2D
4057 << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
4058 << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
4059 << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
4060 << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
4061 << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace // face controls
4062 << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
4063 << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
4064 << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume; // volume controls
4065 QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
4066 aCtrlGroup->setExclusive( true );
4067 for( int i = 0; i < aCtrlActions.size(); i++ )
4068 aCtrlGroup->addAction( action( aCtrlActions[i] ) );
4070 // ----- create menu --------------
4071 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
4072 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
4073 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
4074 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
4075 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
4076 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
4077 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
4078 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
4080 createMenu( separator(), fileId );
4082 QMenu* nodeMenu = new QMenu(); QMenu* edgeMenu = new QMenu();
4083 QMenu* faceMenu = new QMenu(); QMenu* volumeMenu = new QMenu();
4084 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
4085 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
4086 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10, -1, nodeMenu ),
4087 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10, -1, edgeMenu ),
4088 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10, -1, faceMenu ),
4089 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10, -1, volumeMenu ),
4090 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
4091 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
4092 //renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
4093 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
4094 basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
4096 //createMenu( SMESHOp::OpImportDAT, importId, -1 );
4097 createMenu( SMESHOp::OpImportUNV, importId, -1 );
4098 createMenu( SMESHOp::OpImportMED, importId, -1 );
4099 createMenu( SMESHOp::OpImportSTL, importId, -1 );
4101 createMenu( SMESHOp::OpImportCGNS, importId, -1 );
4103 createMenu( SMESHOp::OpImportSAUV, importId, -1 );
4104 createMenu( SMESHOp::OpImportGMF, importId, -1 );
4105 createMenu( SMESHOp::OpExportDAT, exportId, -1 );
4106 createMenu( SMESHOp::OpExportMED, exportId, -1 );
4107 createMenu( SMESHOp::OpExportUNV, exportId, -1 );
4108 createMenu( SMESHOp::OpExportSTL, exportId, -1 );
4110 createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
4112 createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
4113 createMenu( SMESHOp::OpExportGMF, exportId, -1 );
4114 createMenu( separator(), fileId, 10 );
4116 createMenu( SMESHOp::OpDelete, editId, -1 );
4118 createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
4120 createMenu( SMESHOp::OpCreateMesh, meshId, -1 ); // "Mesh" menu
4121 createMenu( SMESHOp::OpCreateSubMesh, meshId, -1 );
4122 createMenu( SMESHOp::OpEditMeshOrSubMesh, meshId, -1 );
4123 createMenu( SMESHOp::OpBuildCompoundMesh, meshId, -1 );
4124 createMenu( SMESHOp::OpCopyMesh, meshId, -1 );
4125 createMenu( separator(), meshId, -1 );
4126 createMenu( SMESHOp::OpCompute, meshId, -1 );
4127 createMenu( SMESHOp::OpPreCompute, meshId, -1 );
4128 createMenu( SMESHOp::OpEvaluate, meshId, -1 );
4129 createMenu( SMESHOp::OpMeshOrder, meshId, -1 );
4130 createMenu( separator(), meshId, -1 );
4131 createMenu( SMESHOp::OpCreateGroup, meshId, -1 );
4132 createMenu( SMESHOp::OpCreateGeometryGroup, meshId, -1 );
4133 createMenu( SMESHOp::OpConstructGroup, meshId, -1 );
4134 createMenu( SMESHOp::OpEditGroup, meshId, -1 );
4135 createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4136 createMenu( separator(), meshId, -1 );
4137 createMenu( SMESHOp::OpUnionGroups, meshId, -1 );
4138 createMenu( SMESHOp::OpIntersectGroups, meshId, -1 );
4139 createMenu( SMESHOp::OpCutGroups, meshId, -1 );
4140 createMenu( separator(), meshId, -1 );
4141 createMenu( SMESHOp::OpGroupUnderlyingElem, meshId, -1 );
4142 createMenu( separator(), meshId, -1 );
4143 createMenu( SMESHOp::OpMeshInformation, meshId, -1 );
4144 //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4145 //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4146 createMenu( SMESHOp::OpFindElementByPoint, meshId, -1 );
4147 createMenu( separator(), meshId, -1 );
4149 createMenu( SMESHOp::OpFreeNode, nodeId, -1 );
4150 createMenu( SMESHOp::OpEqualNode, nodeId, -1 );
4151 //createMenu( SMESHOp::OpNodeConnectivityNb, nodeId, -1 );
4152 createMenu( SMESHOp::OpFreeBorder, edgeId, -1 );
4153 createMenu( SMESHOp::OpLength, edgeId, -1 );
4154 createMenu( SMESHOp::OpConnection, edgeId, -1 );
4155 createMenu( SMESHOp::OpEqualEdge, edgeId, -1 );
4156 createMenu( SMESHOp::OpFreeEdge, faceId, -1 );
4157 createMenu( SMESHOp::OpFreeFace, faceId, -1 );
4158 createMenu( SMESHOp::OpBareBorderFace, faceId, -1 );
4159 createMenu( SMESHOp::OpOverConstrainedFace, faceId, -1 );
4160 createMenu( SMESHOp::OpLength2D, faceId, -1 );
4161 createMenu( SMESHOp::OpConnection2D, faceId, -1 );
4162 createMenu( SMESHOp::OpArea, faceId, -1 );
4163 createMenu( SMESHOp::OpTaper, faceId, -1 );
4164 createMenu( SMESHOp::OpAspectRatio, faceId, -1 );
4165 createMenu( SMESHOp::OpMinimumAngle, faceId, -1 );
4166 createMenu( SMESHOp::OpWarpingAngle, faceId, -1 );
4167 createMenu( SMESHOp::OpSkew, faceId, -1 );
4168 createMenu( SMESHOp::OpMaxElementLength2D, faceId, -1 );
4169 createMenu( SMESHOp::OpEqualFace, faceId, -1 );
4170 createMenu( SMESHOp::OpDeflection2D, faceId, -1 );
4171 createMenu( SMESHOp::OpAspectRatio3D, volumeId, -1 );
4172 createMenu( SMESHOp::OpVolume, volumeId, -1 );
4173 createMenu( SMESHOp::OpMaxElementLength3D, volumeId, -1 );
4174 createMenu( SMESHOp::OpBareBorderVolume, volumeId, -1 );
4175 createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4176 createMenu( SMESHOp::OpEqualVolume, volumeId, -1 );
4177 createMenu( separator(), ctrlId, -1 );
4178 createMenu( SMESHOp::OpReset, ctrlId, -1 );
4179 createMenu( separator(), ctrlId, -1 );
4180 createMenu( SMESHOp::OpOverallMeshQuality, ctrlId, -1 );
4182 createMenu( SMESHOp::OpNode, addId, -1 );
4183 createMenu( SMESHOp::OpElem0D, addId, -1 );
4184 createMenu( SMESHOp::OpElem0DOnElemNodes, addId, -1 );
4185 createMenu( SMESHOp::OpBall, addId, -1 );
4186 createMenu( SMESHOp::OpEdge, addId, -1 );
4187 createMenu( SMESHOp::OpTriangle, addId, -1 );
4188 createMenu( SMESHOp::OpQuadrangle, addId, -1 );
4189 createMenu( SMESHOp::OpPolygon, addId, -1 );
4190 createMenu( SMESHOp::OpTetrahedron, addId, -1 );
4191 createMenu( SMESHOp::OpHexahedron, addId, -1 );
4192 createMenu( SMESHOp::OpPentahedron, addId, -1 );
4193 createMenu( SMESHOp::OpPyramid, addId, -1 );
4194 createMenu( SMESHOp::OpHexagonalPrism, addId, -1 );
4195 createMenu( SMESHOp::OpPolyhedron, addId, -1 );
4196 createMenu( separator(), addId, -1 );
4197 createMenu( SMESHOp::OpQuadraticEdge, addId, -1 );
4198 createMenu( SMESHOp::OpQuadraticTriangle, addId, -1 );
4199 createMenu( SMESHOp::OpBiQuadraticTriangle , addId, -1 );
4200 createMenu( SMESHOp::OpQuadraticQuadrangle, addId, -1 );
4201 createMenu( SMESHOp::OpBiQuadraticQuadrangle, addId, -1 );
4202 createMenu( SMESHOp::OpQuadraticPolygon, addId, -1 );
4203 createMenu( SMESHOp::OpQuadraticTetrahedron, addId, -1 );
4204 createMenu( SMESHOp::OpQuadraticPyramid, addId, -1 );
4205 createMenu( SMESHOp::OpQuadraticPentahedron, addId, -1 );
4206 createMenu( SMESHOp::OpBiQuadraticPentahedron, addId, -1 );
4207 createMenu( SMESHOp::OpQuadraticHexahedron, addId, -1 );
4208 createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4210 createMenu( SMESHOp::OpRemoveNodes, removeId, -1 );
4211 createMenu( SMESHOp::OpRemoveElements, removeId, -1 );
4212 createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4213 createMenu( separator(), removeId, -1 );
4214 createMenu( SMESHOp::OpDeleteGroup, removeId, -1 );
4215 createMenu( separator(), removeId, -1 );
4216 createMenu( SMESHOp::OpClearMesh, removeId, -1 );
4218 //createMenu( SMESHOp::OpRenumberingNodes, renumId, -1 );
4219 //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4221 createMenu( SMESHOp::OpMergeNodes, transfId, -1 );
4222 createMenu( SMESHOp::OpMergeElements, transfId, -1 );
4223 createMenu( SMESHOp::OpTranslation, transfId, -1 );
4224 createMenu( SMESHOp::OpRotation, transfId, -1 );
4225 createMenu( SMESHOp::OpSymmetry, transfId, -1 );
4226 createMenu( SMESHOp::OpScale, transfId, -1 );
4227 createMenu( SMESHOp::OpOffset, transfId, -1 );
4228 createMenu( SMESHOp::OpSewing, transfId, -1 );
4229 createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4231 createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4232 createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4233 createMenu( SMESHOp::OpExtrusion, modifyId, -1 );
4234 createMenu( SMESHOp::OpExtrusionAlongAPath, modifyId, -1 );
4235 createMenu( SMESHOp::OpRevolution, modifyId, -1 );
4236 createMenu( SMESHOp::OpOrientation, modifyId, -1 );
4237 createMenu( SMESHOp::OpReorientFaces, modifyId, -1 );
4238 createMenu( SMESHOp::OpMoveNode, modifyId, -1 );
4239 createMenu( SMESHOp::OpDiagonalInversion, modifyId, -1 );
4240 createMenu( SMESHOp::OpUnionOfTwoTriangle, modifyId, -1 );
4241 createMenu( SMESHOp::OpUnionOfTriangles, modifyId, -1 );
4242 createMenu( SMESHOp::OpCuttingOfQuadrangles, modifyId, -1 );
4243 createMenu( SMESHOp::OpSplitVolumes, modifyId, -1 );
4244 createMenu( SMESHOp::OpSplitBiQuadratic, modifyId, -1 );
4245 createMenu( SMESHOp::OpSmoothing, modifyId, -1 );
4246 createMenu( SMESHOp::OpPatternMapping, modifyId, -1 );
4248 createMenu( SMESHOp::OpMinimumDistance, measureId, -1 );
4249 createMenu( SMESHOp::OpBoundingBox, measureId, -1 );
4250 createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4251 createMenu( SMESHOp::OpPropertiesArea, basicPropId, -1 );
4252 createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4253 createMenu( SMESHOp::OpUpdate, viewId, -1 );
4255 connect( nodeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4256 connect( edgeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4257 connect( faceMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4258 connect( volumeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4260 // ----- create toolbars --------------
4261 int meshTb = createTool( tr( "TB_MESH" ), QString( "SMESHMeshToolbar" ) ),
4262 info = createTool( tr( "TB_INFO" ), QString( "SMESHInformationToolbar" ) ),
4263 groupTb = createTool( tr( "TB_GROUP" ), QString( "SMESHGroupToolbar" ) ),
4264 ctrl0dTb = createTool( tr( "TB_CTRL0D" ), QString( "SMESHNodeControlsToolbar" ) ),
4265 ctrl1dTb = createTool( tr( "TB_CTRL1D" ), QString( "SMESHEdgeControlsToolbar" ) ),
4266 ctrl2dTb = createTool( tr( "TB_CTRL2D" ), QString( "SMESHFaceControlsToolbar" ) ),
4267 ctrl3dTb = createTool( tr( "TB_CTRL3D" ), QString( "SMESHVolumeControlsToolbar" ) ),
4268 addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ),
4269 addNonElemTb = createTool( tr( "TB_ADDNON" ), QString( "SMESHAddElementToolbar" ) ),
4270 remTb = createTool( tr( "TB_REM" ), QString( "SMESHRemoveToolbar" ) ),
4271 //renumbTb = createTool( tr( "TB_RENUMBER" ), QString( "SMESHRenumberingToolbar" ) ),
4272 transformTb = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ),
4273 modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ),
4274 measuremTb = createTool( tr( "TB_MEASUREM" ), QString( "SMESHMeasurementsToolbar" ) ),
4275 dispModeTb = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4277 createTool( SMESHOp::OpCreateMesh, meshTb );
4278 createTool( SMESHOp::OpCreateSubMesh, meshTb );
4279 createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4280 createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4281 createTool( SMESHOp::OpCopyMesh, meshTb );
4282 createTool( separator(), meshTb );
4283 createTool( SMESHOp::OpCompute, meshTb );
4284 createTool( SMESHOp::OpPreCompute, meshTb );
4285 createTool( SMESHOp::OpEvaluate, meshTb );
4286 createTool( SMESHOp::OpMeshOrder, meshTb );
4288 createTool( SMESHOp::OpCreateGroup, groupTb );
4289 createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4290 createTool( SMESHOp::OpConstructGroup, groupTb );
4291 createTool( SMESHOp::OpEditGroup, groupTb );
4293 createTool( SMESHOp::OpMeshInformation, info );
4294 //createTool( SMESHOp::OpStdInfo, meshTb );
4295 //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4296 createTool( SMESHOp::OpFindElementByPoint, info );
4298 createTool( SMESHOp::OpFreeNode, ctrl0dTb );
4299 createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4300 //createTool( SMESHOp::OpNodeConnectivityNb, ctrl0dTb );
4302 createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4303 createTool( SMESHOp::OpLength, ctrl1dTb );
4304 createTool( SMESHOp::OpConnection, ctrl1dTb );
4305 createTool( SMESHOp::OpEqualEdge, ctrl1dTb );
4307 createTool( SMESHOp::OpFreeEdge, ctrl2dTb );
4308 createTool( SMESHOp::OpFreeFace, ctrl2dTb );
4309 createTool( SMESHOp::OpBareBorderFace, ctrl2dTb );
4310 createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4311 createTool( SMESHOp::OpLength2D, ctrl2dTb );
4312 createTool( SMESHOp::OpConnection2D, ctrl2dTb );
4313 createTool( SMESHOp::OpArea, ctrl2dTb );
4314 createTool( SMESHOp::OpTaper, ctrl2dTb );
4315 createTool( SMESHOp::OpAspectRatio, ctrl2dTb );
4316 createTool( SMESHOp::OpMinimumAngle, ctrl2dTb );
4317 createTool( SMESHOp::OpWarpingAngle, ctrl2dTb );
4318 createTool( SMESHOp::OpSkew, ctrl2dTb );
4319 createTool( SMESHOp::OpMaxElementLength2D, ctrl2dTb );
4320 createTool( SMESHOp::OpEqualFace, ctrl2dTb );
4321 createTool( SMESHOp::OpDeflection2D, ctrl2dTb );
4323 createTool( SMESHOp::OpAspectRatio3D, ctrl3dTb );
4324 createTool( SMESHOp::OpVolume, ctrl3dTb );
4325 createTool( SMESHOp::OpMaxElementLength3D, ctrl3dTb );
4326 createTool( SMESHOp::OpBareBorderVolume, ctrl3dTb );
4327 createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
4328 createTool( SMESHOp::OpEqualVolume, ctrl3dTb );
4330 createTool( SMESHOp::OpNode, addElemTb );
4331 createTool( SMESHOp::OpElem0D, addElemTb );
4332 createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4333 createTool( SMESHOp::OpBall, addElemTb );
4334 createTool( SMESHOp::OpEdge, addElemTb );
4335 createTool( SMESHOp::OpTriangle, addElemTb );
4336 createTool( SMESHOp::OpQuadrangle, addElemTb );
4337 createTool( SMESHOp::OpPolygon, addElemTb );
4338 createTool( SMESHOp::OpTetrahedron, addElemTb );
4339 createTool( SMESHOp::OpHexahedron, addElemTb );
4340 createTool( SMESHOp::OpPentahedron, addElemTb );
4341 createTool( SMESHOp::OpPyramid, addElemTb );
4342 createTool( SMESHOp::OpHexagonalPrism, addElemTb );
4343 createTool( SMESHOp::OpPolyhedron, addElemTb );
4345 createTool( SMESHOp::OpQuadraticEdge, addNonElemTb );
4346 createTool( SMESHOp::OpQuadraticTriangle, addNonElemTb );
4347 createTool( SMESHOp::OpBiQuadraticTriangle, addNonElemTb );
4348 createTool( SMESHOp::OpQuadraticQuadrangle, addNonElemTb );
4349 createTool( SMESHOp::OpBiQuadraticQuadrangle, addNonElemTb );
4350 createTool( SMESHOp::OpQuadraticPolygon, addNonElemTb );
4351 createTool( SMESHOp::OpQuadraticTetrahedron, addNonElemTb );
4352 createTool( SMESHOp::OpQuadraticPyramid, addNonElemTb );
4353 createTool( SMESHOp::OpQuadraticPentahedron, addNonElemTb );
4354 createTool( SMESHOp::OpBiQuadraticPentahedron, addNonElemTb );
4355 createTool( SMESHOp::OpQuadraticHexahedron, addNonElemTb );
4356 createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4358 createTool( SMESHOp::OpRemoveNodes, remTb );
4359 createTool( SMESHOp::OpRemoveElements, remTb );
4360 createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4361 createTool( SMESHOp::OpClearMesh, remTb );
4363 //createTool( SMESHOp::OpRenumberingNodes, renumbTb );
4364 //createTool( SMESHOp::OpRenumberingElements, renumbTb );
4366 createTool( SMESHOp::OpMergeNodes, transformTb );
4367 createTool( SMESHOp::OpMergeElements, transformTb );
4368 createTool( SMESHOp::OpTranslation, transformTb );
4369 createTool( SMESHOp::OpRotation, transformTb );
4370 createTool( SMESHOp::OpSymmetry, transformTb );
4371 createTool( SMESHOp::OpScale, transformTb );
4372 createTool( SMESHOp::OpOffset, transformTb );
4373 createTool( SMESHOp::OpSewing, transformTb );
4374 createTool( SMESHOp::OpDuplicateNodes, transformTb );
4376 createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4377 createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4378 createTool( SMESHOp::OpExtrusion, modifyTb );
4379 createTool( SMESHOp::OpExtrusionAlongAPath, modifyTb );
4380 createTool( SMESHOp::OpRevolution, modifyTb );
4381 createTool( SMESHOp::OpOrientation, modifyTb );
4382 createTool( SMESHOp::OpReorientFaces, modifyTb );
4383 createTool( SMESHOp::OpMoveNode, modifyTb );
4384 createTool( SMESHOp::OpDiagonalInversion, modifyTb );
4385 createTool( SMESHOp::OpUnionOfTwoTriangle, modifyTb );
4386 createTool( SMESHOp::OpUnionOfTriangles, modifyTb );
4387 createTool( SMESHOp::OpCuttingOfQuadrangles, modifyTb );
4388 createTool( SMESHOp::OpSplitVolumes, modifyTb );
4389 createTool( SMESHOp::OpSplitBiQuadratic, modifyTb );
4390 createTool( SMESHOp::OpSmoothing, modifyTb );
4391 createTool( SMESHOp::OpPatternMapping, modifyTb );
4393 createTool( SMESHOp::OpMinimumDistance, measuremTb );
4395 createTool( SMESHOp::OpUpdate, dispModeTb );
4397 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4398 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4402 OB = "'ObjectBrowser'",
4403 View = "'" + SVTK_Viewer::Type() + "'",
4405 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4406 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4407 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4408 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4409 smesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::COMPONENT ) ),
4410 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4411 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4412 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4413 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4414 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4415 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4416 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4418 mesh_part = mesh + " " + subMesh + " " + group,
4419 mesh_group = mesh + " " + group,
4420 mesh_submesh = mesh + " " + subMesh,
4421 hyp_alg = hypo + " " + algo;
4423 // popup for object browser
4425 isInvisible("not( isVisible )"),
4426 isEmpty("numberOfNodes = 0"),
4427 isNotEmpty("numberOfNodes <> 0"),
4429 // has nodes, edges, etc in VISIBLE! actor
4430 hasNodes("(numberOfNodes > 0 ) && hasActor"),
4431 hasElems("(count( elemTypes ) > 0)"),
4432 hasDifferentElems("(count( elemTypes ) > 1)"),
4433 hasDifferentObjElems("(count( objElemTypes ) > 1)"),
4434 hasBalls("({'BallElem'} in elemTypes)"),
4435 hasElems0d("({'Elem0d'} in elemTypes)"),
4436 hasEdges("({'Edge'} in elemTypes)"),
4437 hasFaces("({'Face'} in elemTypes)"),
4438 hasVolumes("({'Volume'} in elemTypes)"),
4439 hasFacesOrVolumes("(({'Face'} in elemTypes) || ({'Volume'} in elemTypes)) ");
4441 createPopupItem( SMESHOp::OpFileInformation, OB, mesh, "&& selcount=1 && isImported" );
4442 createPopupItem( SMESHOp::OpCreateSubMesh, OB, mesh, "&& hasGeomReference");
4443 createPopupItem( SMESHOp::OpEditMesh, OB, mesh, "&& selcount=1" );
4444 createPopupItem( SMESHOp::OpEditSubMesh, OB, subMesh, "&& selcount=1 && hasGeomReference" );
4445 createPopupItem( SMESHOp::OpEditGroup, OB, group );
4446 createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4448 popupMgr()->insert( separator(), -1, 0 );
4449 createPopupItem( SMESHOp::OpCompute, OB, mesh, "&& selcount=1 && isComputable" );
4450 createPopupItem( SMESHOp::OpComputeSubMesh, OB, subMesh, "&& selcount=1 && isComputable" );
4451 createPopupItem( SMESHOp::OpPreCompute, OB, mesh, "&& selcount=1 && isPreComputable" );
4452 createPopupItem( SMESHOp::OpEvaluate, OB, mesh, "&& selcount=1 && isComputable" );
4453 createPopupItem( SMESHOp::OpMeshOrder, OB, mesh, "&& selcount=1 && isComputable && hasGeomReference" );
4454 createPopupItem( SMESHOp::OpUpdate, OB, mesh_part );
4455 createPopupItem( SMESHOp::OpMeshInformation, OB, mesh_part );
4456 createPopupItem( SMESHOp::OpFindElementByPoint,OB, mesh_group, "&& selcount=1" );
4457 createPopupItem( SMESHOp::OpOverallMeshQuality,OB, mesh_part );
4458 popupMgr()->insert( separator(), -1, 0 );
4459 createPopupItem( SMESHOp::OpCreateGroup, OB, mesh, "&& selcount=1" );
4460 createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh, "&& selcount=1 && hasGeomReference" );
4461 createPopupItem( SMESHOp::OpConstructGroup, OB, subMesh );
4462 popupMgr()->insert( separator(), -1, 0 );
4463 createPopupItem( SMESHOp::OpEditHypothesis, OB, hypo, "&& isEditableHyp");
4464 createPopupItem( SMESHOp::OpUnassign, OB, hyp_alg );
4465 popupMgr()->insert( separator(), -1, 0 );
4466 createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh_submesh );
4467 createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh_group, "&& selcount=1 && dim>=2");
4468 popupMgr()->insert( separator(), -1, 0 );
4469 createPopupItem( SMESHOp::OpClearMesh, OB, mesh );
4470 //popupMgr()->insert( separator(), -1, 0 );
4472 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4473 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4474 QString only_one_2D = only_one_non_empty + " && dim>1";
4476 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4477 createPopupItem( SMESHOp::OpPopupExportMED, OB, mesh_group, multiple_non_empty, anId );
4478 createPopupItem( SMESHOp::OpPopupExportUNV, OB, mesh_group, only_one_non_empty, anId );
4479 createPopupItem( SMESHOp::OpPopupExportSTL, OB, mesh_group, only_one_2D, anId );
4481 createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4483 createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, only_one_non_empty, anId );
4484 createPopupItem( SMESHOp::OpPopupExportGMF, OB, mesh_group, only_one_non_empty, anId );
4485 createPopupItem( SMESHOp::OpPopupExportDAT, OB, mesh_group, only_one_non_empty, anId );
4486 createPopupItem( SMESHOp::OpDelete, OB, mesh_part + " " + hyp_alg );
4487 createPopupItem( SMESHOp::OpDeleteGroup, OB, group );
4489 anId = popupMgr()->insert( tr( "MEN_IMPORT" ), -1, -1 ); // IMPORT submenu
4490 createPopupItem( SMESHOp::OpPopupImportMED, OB, smesh, "", anId );
4491 createPopupItem( SMESHOp::OpPopupImportUNV, OB, smesh, "", anId );
4492 createPopupItem( SMESHOp::OpPopupImportSTL, OB, smesh, "", anId );
4494 createPopupItem( SMESHOp::OpPopupImportCGNS, OB, smesh, "", anId );
4496 createPopupItem( SMESHOp::OpPopupImportSAUV, OB, smesh, "", anId );
4497 createPopupItem( SMESHOp::OpPopupImportGMF, OB, smesh, "", anId );
4498 createPopupItem( SMESHOp::OpPopupImportDAT, OB, smesh, "", anId );
4499 popupMgr()->insert( separator(), -1, 0 );
4502 createPopupItem( SMESHOp::OpEditGroup, View, group );
4503 createPopupItem( SMESHOp::OpAddElemGroupPopup, View, elems, "&& guiState = 800" );
4504 createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems, "&& guiState = 800" );
4506 popupMgr()->insert( separator(), -1, 0 );
4507 createPopupItem( SMESHOp::OpUpdate, View, mesh_part );
4508 createPopupItem( SMESHOp::OpMeshInformation, View, mesh_part );
4509 createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4510 createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh );
4511 popupMgr()->insert( separator(), -1, 0 );
4513 createPopupItem( SMESHOp::OpAutoColor, OB + " " + View, mesh, "&& (not isAutoColor)" );
4514 createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4515 popupMgr()->insert( separator(), -1, 0 );
4517 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4518 QString aType = QString( "%1type in {%2}" ).arg( lc );
4519 aType = aType.arg( mesh_part );
4520 QString aMeshInVTK = aClient + "&&" + aType;
4522 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4523 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4524 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4526 //-------------------------------------------------
4528 //-------------------------------------------------
4529 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4531 popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4532 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4533 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4535 popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4536 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4537 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4539 popupMgr()->insert( separator(), -1, -1 );
4541 //-------------------------------------------------
4543 //-------------------------------------------------
4544 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4546 popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4547 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4548 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4550 popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4551 popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4552 popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4554 popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4555 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4556 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4558 popupMgr()->insert( separator(), anId, -1 );
4560 popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4561 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4562 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4564 //-------------------------------------------------
4566 //-------------------------------------------------
4567 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4569 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4571 popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4572 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4573 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4575 popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4576 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4577 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4579 popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4580 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4581 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4583 popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4584 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4585 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4587 popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4588 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4589 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4591 popupMgr()->insert( separator(), anId, -1 );
4593 popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4594 popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&& $type in {" + mesh + "} &&" + hasDifferentObjElems, QtxPopupMgr::VisibleRule );
4596 popupMgr()->insert( separator(), anId, -1 );
4598 popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4599 popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4602 //-------------------------------------------------
4603 // Representation of the 2D Quadratic elements
4604 //-------------------------------------------------
4605 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4606 popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4607 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "&& isVisible && isQuadratic",QtxPopupMgr::VisibleRule );
4608 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4610 popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4611 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "&& isVisible && isQuadratic", QtxPopupMgr::VisibleRule );
4612 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4614 //-------------------------------------------------
4615 // Orientation of faces
4616 //-------------------------------------------------
4617 popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4618 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4619 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4621 //-------------------------------------------------
4623 //-------------------------------------------------
4624 popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4625 popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4627 //-------------------------------------------------
4629 //-------------------------------------------------
4630 popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4631 popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4633 //-------------------------------------------------
4635 //-------------------------------------------------
4637 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4638 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4639 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4640 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4642 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4644 popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4645 popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4647 popupMgr()->insert( separator(), anId, -1 );
4649 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4651 popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4652 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4653 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4655 popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4656 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4657 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4659 // popupMgr()->insert( action( SMESHOp::OpNodeConnectivityNb ), aSubId, -1 );
4660 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4661 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), "controlMode = 'eNodeConnectivityNb'", QtxPopupMgr::ToggleRule );
4663 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4665 popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4666 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVTK + "&&" + hasEdges + "&&" + hasFacesOrVolumes, QtxPopupMgr::VisibleRule );
4667 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4669 popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4670 popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4671 popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4673 popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4674 popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4675 popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4676 popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4677 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4678 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4680 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4682 popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4683 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4684 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4686 popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4687 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4688 QtxPopupMgr::VisibleRule );
4689 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4691 popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4692 popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4693 popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4695 popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4696 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4697 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4699 popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
4700 popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4701 popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4703 popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
4704 popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4705 popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4707 popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
4708 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4709 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4711 popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
4712 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4713 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4715 popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
4716 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4717 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4719 popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
4720 popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4721 popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4723 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
4724 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4725 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4727 popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
4728 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4729 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4731 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
4732 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4733 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4735 popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
4736 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4737 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4739 popupMgr()->insert ( action( SMESHOp::OpDeflection2D ), aSubId, -1 );
4740 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), aMeshInVtkHasFaces + " && hasGeomReference", QtxPopupMgr::VisibleRule );
4741 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), "controlMode = 'eDeflection2D'", QtxPopupMgr::ToggleRule );
4743 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4745 popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D ), aSubId, -1 );
4746 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4747 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4749 popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
4750 popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4751 popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4753 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
4754 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4755 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4757 popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
4758 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4759 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4761 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
4762 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4763 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4765 popupMgr()->insert ( action( SMESHOp::OpEqualVolume ), aSubId, -1 );
4766 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4767 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4769 popupMgr()->insert( separator(), anId, -1 );
4771 popupMgr()->insert( action( SMESHOp::OpShowScalarBar ), anId, -1 );
4772 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4773 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone' && isScalarBarVisible", QtxPopupMgr::ToggleRule );
4774 popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
4775 popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4777 popupMgr()->insert( separator(), anId, -1 );
4779 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4781 popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
4782 popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4784 popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
4785 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4786 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isScalarBarVisible && isDistributionVisible", QtxPopupMgr::ToggleRule);
4788 #ifndef DISABLE_PLOT2DVIEWER
4789 popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
4790 popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4793 //-------------------------------------------------
4795 //-------------------------------------------------
4796 popupMgr()->insert( separator(), -1, -1 );
4797 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4798 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4799 popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
4800 popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4802 popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
4803 popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4805 popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
4806 popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4808 popupMgr()->insert( separator(), -1, -1 );
4810 //-------------------------------------------------
4812 //-------------------------------------------------
4813 popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
4814 popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4816 popupMgr()->insert( separator(), -1, -1 );
4818 popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
4819 popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
4820 popupMgr()->insert( separator(), -1, -1 );
4822 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4823 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4825 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4826 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4829 //================================================================================
4831 * \brief Return true if SMESH or GEOM objects are selected.
4832 * Is called form LightApp_Module::activateModule() which clear selection if
4833 * not isSelectionCompatible()
4835 //================================================================================
4837 bool SMESHGUI::isSelectionCompatible()
4839 bool isCompatible = true;
4840 SALOME_ListIO selected;
4841 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4842 Sel->selectedObjects( selected );
4844 SALOME_ListIteratorOfListIO It( selected );
4845 for ( ; isCompatible && It.More(); It.Next())
4847 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4848 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4850 return isCompatible;
4854 bool SMESHGUI::reusableOperation( const int id )
4856 // compute, evaluate and precompute are not reusable operations
4857 return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate ) ? false : SalomeApp_Module::reusableOperation( id );
4860 bool SMESHGUI::activateModule( SUIT_Study* study )
4862 bool res = SalomeApp_Module::activateModule( study );
4864 setMenuShown( true );
4865 setToolShown( true );
4867 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4868 PyGILState_STATE gstate = PyGILState_Ensure();
4869 PyObject* pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4870 if ( !pluginsmanager ) {
4874 PyObject* result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toUtf8().data(),tr("SMESH_PLUGINS_OTHER").toUtf8().data());
4879 PyGILState_Release(gstate);
4880 // end of SMESH plugins loading
4882 // Reset actions accelerator keys
4883 action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
4885 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4886 GetSMESHGen()->UpdateStudy();
4888 // get all view currently opened in the study and connect their signals to
4889 // the corresponding slots of the class.
4890 SUIT_Desktop* aDesk = study->application()->desktop();
4892 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4893 SUIT_ViewWindow* wnd;
4894 foreach ( wnd, wndList )
4898 Py_XDECREF(pluginsmanager);
4902 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4904 setMenuShown( false );
4905 setToolShown( false );
4907 EmitSignalCloseAllDialogs();
4909 // Unset actions accelerator keys
4910 action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
4912 return SalomeApp_Module::deactivateModule( study );
4915 void SMESHGUI::studyClosed( SUIT_Study* s )
4919 SMESH::RemoveVisuData();
4920 SalomeApp_Module::studyClosed( s );
4923 void SMESHGUI::OnGUIEvent()
4925 const QObject* obj = sender();
4926 if ( !obj || !obj->inherits( "QAction" ) )
4928 int id = actionId((QAction*)obj);
4933 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4935 if ( CORBA::is_nil( myComponentSMESH ) )
4937 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4938 return aGUI.myComponentSMESH;
4940 return myComponentSMESH;
4943 QString SMESHGUI::engineIOR() const
4945 CORBA::ORB_var anORB = getApp()->orb();
4946 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4947 return QString( anIOR.in() );
4950 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4952 SalomeApp_Module::contextMenuPopup( client, menu, title );
4954 selectionMgr()->selectedObjects( lst );
4955 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4956 Handle(SALOME_InteractiveObject) io = lst.First();
4957 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4958 _PTR(Study) study = appStudy->studyDS();
4959 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4961 QString aName = QString( SMESH::fromUtf8(obj->GetName()) );
4962 while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4963 aName.remove( (aName.length() - 1), 1 );
4969 LightApp_Selection* SMESHGUI::createSelection() const
4971 return new SMESHGUI_Selection();
4974 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4976 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4977 aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
4978 #ifndef DISABLE_PYCONSOLE
4979 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4983 void SMESHGUI::viewManagers( QStringList& list ) const
4985 list.append( SVTK_Viewer::Type() );
4988 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4990 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4991 SMESH::UpdateSelectionProp( this );
4993 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
4994 for(int i = 0; i < aViews.count() ; i++){
4995 SUIT_ViewWindow *sf = aViews[i];
4998 EmitSignalActivatedViewManager();
5002 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
5004 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
5005 myClippingPlaneInfoMap.erase( theViewManager );
5008 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
5010 theActor->AddObserver( SMESH::DeleteActorEvent,
5011 myEventCallbackCommand.GetPointer(),
5015 void SMESHGUI::ProcessEvents( vtkObject* theObject,
5016 unsigned long theEvent,
5017 void* theClientData,
5020 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
5021 if( theObject && (int) theEvent == SMESH::DeleteActorEvent ) {
5022 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
5023 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
5024 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
5025 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
5026 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
5027 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
5028 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
5029 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
5030 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
5031 SMESH::TActorList::iterator anIter3 = anActorList.begin();
5032 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
5033 if( anActor == *anIter3 ) {
5034 anActorList.erase( anIter3 );
5045 void SMESHGUI::createPreferences()
5047 // General tab ------------------------------------------------------------------------
5048 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
5050 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
5051 setPreferenceProperty( autoUpdate, "columns", 2 );
5052 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
5053 setPreferenceProperty( lim, "min", 0 );
5054 setPreferenceProperty( lim, "max", 100000000 );
5055 setPreferenceProperty( lim, "step", 1000 );
5056 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5057 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
5059 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
5060 setPreferenceProperty( dispgroup, "columns", 2 );
5061 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
5063 modes.append( tr("MEN_WIRE") );
5064 modes.append( tr("MEN_SHADE") );
5065 modes.append( tr("MEN_NODES") );
5066 modes.append( tr("MEN_SHRINK") );
5067 QList<QVariant> indices;
5068 indices.append( 0 );
5069 indices.append( 1 );
5070 indices.append( 2 );
5071 indices.append( 3 );
5072 setPreferenceProperty( dispmode, "strings", modes );
5073 setPreferenceProperty( dispmode, "indexes", indices );
5075 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
5076 setPreferenceProperty( arcgroup, "columns", 2 );
5077 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
5078 QStringList quadraticModes;
5079 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
5080 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
5082 indices.append( 0 );
5083 indices.append( 1 );
5084 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
5085 setPreferenceProperty( quadraticmode, "indexes", indices );
5087 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
5088 "SMESH", "max_angle" );
5089 setPreferenceProperty( maxAngle, "min", 1 );
5090 setPreferenceProperty( maxAngle, "max", 90 );
5092 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
5093 setPreferenceProperty( qaGroup, "columns", 2 );
5094 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
5095 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
5096 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
5097 setPreferenceProperty( prec, "min", 0 );
5098 setPreferenceProperty( prec, "max", 100 );
5099 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
5100 setPreferenceProperty( doubleNodesTol, "precision", 10 );
5101 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
5102 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
5103 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
5106 int cinc = addPreference(tr("PREF_CONTROLS_INCREMENT"), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_increment");
5107 setPreferenceProperty( cinc, "min", 0 );
5108 setPreferenceProperty( cinc, "max", 5 );
5111 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
5112 setPreferenceProperty( exportgroup, "columns", 2 );
5113 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
5114 addPreference( tr( "PREF_SHOW_WARN" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "show_warning" );
5115 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
5117 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
5118 setPreferenceProperty( computeGroup, "columns", 2 );
5119 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
5121 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5122 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5123 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5125 indices.append( 0 );
5126 indices.append( 1 );
5127 indices.append( 2 );
5128 setPreferenceProperty( notifyMode, "strings", modes );
5129 setPreferenceProperty( notifyMode, "indexes", indices );
5131 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5132 setPreferenceProperty( infoGroup, "columns", 2 );
5133 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5135 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5136 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5138 indices.append( 0 );
5139 indices.append( 1 );
5140 setPreferenceProperty( elemInfo, "strings", modes );
5141 setPreferenceProperty( elemInfo, "indexes", indices );
5142 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5143 setPreferenceProperty( nodesLim, "min", 0 );
5144 setPreferenceProperty( nodesLim, "max", 10000000 );
5145 setPreferenceProperty( nodesLim, "step", 10000 );
5146 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5147 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5148 setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5149 setPreferenceProperty( ctrlLim, "min", 0 );
5150 setPreferenceProperty( ctrlLim, "max", 10000000 );
5151 setPreferenceProperty( ctrlLim, "step", 1000 );
5152 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5153 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5154 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5155 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5156 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5158 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5159 setPreferenceProperty( segGroup, "columns", 2 );
5160 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5161 "SMESH", "segmentation" );
5162 setPreferenceProperty( segLen, "min", 1 );
5163 setPreferenceProperty( segLen, "max", 10000000 );
5164 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5165 "SMESH", "nb_segments_per_edge" );
5166 setPreferenceProperty( nbSeg, "min", 1 );
5167 setPreferenceProperty( nbSeg, "max", 10000000 );
5169 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5170 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5171 "SMESH", "forget_mesh_on_hyp_modif" );
5174 // Quantities with individual precision settings
5175 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5176 setPreferenceProperty( precGroup, "columns", 2 );
5178 const int nbQuantities = 6;
5179 int precs[nbQuantities], ii = 0;
5180 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5181 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5182 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5183 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5184 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5185 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5186 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5187 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5188 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5189 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5190 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5191 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5193 // Set property for precision value for spinboxes
5194 for ( ii = 0; ii < nbQuantities; ii++ ){
5195 setPreferenceProperty( precs[ii], "min", -14 );
5196 setPreferenceProperty( precs[ii], "max", 14 );
5197 setPreferenceProperty( precs[ii], "precision", 2 );
5200 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5201 setPreferenceProperty( previewGroup, "columns", 2 );
5202 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5203 setPreferenceProperty( chunkSize, "min", 1 );
5204 setPreferenceProperty( chunkSize, "max", 1000 );
5205 setPreferenceProperty( chunkSize, "step", 50 );
5207 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5208 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5210 // Mesh tab ------------------------------------------------------------------------
5211 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5212 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5213 setPreferenceProperty( nodeGroup, "columns", 3 );
5215 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5217 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5219 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5220 QList<QVariant> aMarkerTypeIndicesList;
5221 QList<QVariant> aMarkerTypeIconsList;
5222 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5223 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5224 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5225 aMarkerTypeIndicesList << i;
5226 aMarkerTypeIconsList << pixmap;
5228 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5229 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
5231 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5233 QList<QVariant> aMarkerScaleIndicesList;
5234 QStringList aMarkerScaleValuesList;
5235 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5236 aMarkerScaleIndicesList << i;
5237 //aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5238 aMarkerScaleValuesList << QString::number( i );
5240 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5241 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5243 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5244 //setPreferenceProperty( elemGroup, "columns", 2 );
5246 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5247 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5248 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5249 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5250 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5251 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5252 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5253 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5254 addPreference( tr( "PREF_PREVIEW_COLOR" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5257 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5258 setPreferenceProperty( grpGroup, "columns", 2 );
5260 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5261 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5263 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5264 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5265 /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5266 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5267 double ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5268 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5269 double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5270 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5271 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
5272 LightApp_Preferences::IntSpin, "SMESH", "element_width");
5273 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5274 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5275 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5276 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5278 setPreferenceProperty( size0d, "min", 1 );
5279 setPreferenceProperty( size0d, "max", 10 );
5281 // setPreferenceProperty( ballSize, "min", 1 );
5282 // setPreferenceProperty( ballSize, "max", 10 );
5284 setPreferenceProperty( ballDiameter, "min", 1e-7 );
5285 setPreferenceProperty( ballDiameter, "max", 1e9 );
5286 setPreferenceProperty( ballDiameter, "step", 0.1 );
5288 setPreferenceProperty( ballScale, "min", 1e-2 );
5289 setPreferenceProperty( ballScale, "max", 1e7 );
5290 setPreferenceProperty( ballScale, "step", 0.5 );
5292 setPreferenceProperty( elemW, "min", 1 );
5293 setPreferenceProperty( elemW, "max", 5 );
5295 setPreferenceProperty( outW, "min", 1 );
5296 setPreferenceProperty( outW, "max", 5 );
5298 setPreferenceProperty( shrink, "min", 0 );
5299 setPreferenceProperty( shrink, "max", 100 );
5301 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5302 setPreferenceProperty( numGroup, "columns", 2 );
5304 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5305 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5307 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5308 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5310 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5311 setPreferenceProperty( orientGroup, "columns", 1 );
5313 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5314 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5316 setPreferenceProperty( orientScale, "min", 0.05 );
5317 setPreferenceProperty( orientScale, "max", 0.5 );
5318 setPreferenceProperty( orientScale, "step", 0.05 );
5320 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5322 // Selection tab ------------------------------------------------------------------------
5323 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5325 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5326 setPreferenceProperty( selGroup, "columns", 2 );
5328 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5329 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5331 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5332 setPreferenceProperty( preGroup, "columns", 2 );
5334 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5336 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5337 setPreferenceProperty( precSelGroup, "columns", 2 );
5339 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5340 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5341 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5343 int sinc = addPreference(tr("PREF_SELECTION_INCREMENT"), selTab, LightApp_Preferences::IntSpin, "SMESH", "selection_increment");
5344 setPreferenceProperty( sinc, "min", 0 );
5345 setPreferenceProperty( sinc, "max", 5 );
5347 // Scalar Bar tab ------------------------------------------------------------------------
5348 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5349 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5350 setPreferenceProperty( fontGr, "columns", 2 );
5352 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5353 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5355 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5356 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5358 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5359 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5361 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5362 setPreferenceProperty( numcol, "min", 2 );
5363 setPreferenceProperty( numcol, "max", 256 );
5365 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5366 setPreferenceProperty( numlab, "min", 2 );
5367 setPreferenceProperty( numlab, "max", 65 );
5369 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5370 setPreferenceProperty( orientGr, "columns", 2 );
5371 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5372 QStringList orients;
5373 orients.append( tr( "SMESH_VERTICAL" ) );
5374 orients.append( tr( "SMESH_HORIZONTAL" ) );
5375 indices.clear(); indices.append( 0 ); indices.append( 1 );
5376 setPreferenceProperty( orient, "strings", orients );
5377 setPreferenceProperty( orient, "indexes", indices );
5379 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5380 setPreferenceProperty( posVSizeGr, "columns", 2 );
5381 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5382 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5383 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5384 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5385 setPreferenceProperty( xv, "step", 0.1 );
5386 setPreferenceProperty( xv, "min", 0.0 );
5387 setPreferenceProperty( xv, "max", 1.0 );
5388 setPreferenceProperty( yv, "step", 0.1 );
5389 setPreferenceProperty( yv, "min", 0.0 );
5390 setPreferenceProperty( yv, "max", 1.0 );
5391 setPreferenceProperty( wv, "step", 0.1 );
5392 setPreferenceProperty( wv, "min", 0.0 );
5393 setPreferenceProperty( wv, "max", 1.0 );
5394 setPreferenceProperty( hv, "min", 0.0 );
5395 setPreferenceProperty( hv, "max", 1.0 );
5396 setPreferenceProperty( hv, "step", 0.1 );
5398 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5399 setPreferenceProperty( posHSizeGr, "columns", 2 );
5400 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5401 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5402 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5403 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5404 setPreferenceProperty( xv, "min", 0.0 );
5405 setPreferenceProperty( xv, "max", 1.0 );
5406 setPreferenceProperty( xv, "step", 0.1 );
5407 setPreferenceProperty( xh, "min", 0.0 );
5408 setPreferenceProperty( xh, "max", 1.0 );
5409 setPreferenceProperty( xh, "step", 0.1 );
5410 setPreferenceProperty( yh, "min", 0.0 );
5411 setPreferenceProperty( yh, "max", 1.0 );
5412 setPreferenceProperty( yh, "step", 0.1 );
5413 setPreferenceProperty( wh, "min", 0.0 );
5414 setPreferenceProperty( wh, "max", 1.0 );
5415 setPreferenceProperty( wh, "step", 0.1 );
5416 setPreferenceProperty( hh, "min", 0.0 );
5417 setPreferenceProperty( hh, "max", 1.0 );
5418 setPreferenceProperty( hh, "step", 0.1 );
5420 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5421 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5422 setPreferenceProperty( distributionGr, "columns", 3 );
5424 types.append( tr( "SMESH_MONOCOLOR" ) );
5425 types.append( tr( "SMESH_MULTICOLOR" ) );
5426 indices.clear(); indices.append( 0 ); indices.append( 1 );
5427 setPreferenceProperty( coloringType, "strings", types );
5428 setPreferenceProperty( coloringType, "indexes", indices );
5429 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5433 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5435 if ( sect=="SMESH" ) {
5436 float sbX1 = 0.01, sbY1 = 0.01, sbW = 0.08, sbH = 0.08;
5437 float aTol = 1.00000009999999;
5438 std::string aWarning;
5439 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5441 if ( name== "selection_object_color" ||
5442 name=="selection_element_color" ||
5443 name== "highlight_color" ||
5444 name=="selection_precision_node" ||
5445 name=="selection_precision_element" ||
5446 name=="selection_precision_object" ||
5447 name=="selection_increment")
5449 SMESH::UpdateSelectionProp( this );
5451 else if (name == "scalar_bar_vertical_x" || name == "scalar_bar_vertical_width")
5453 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5454 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5455 if ( sbX1+sbW > aTol ) {
5456 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5459 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5460 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5463 else if (name == "scalar_bar_vertical_y" || name == "scalar_bar_vertical_height" )
5465 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5466 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5467 if ( sbY1 + sbH > aTol ) {
5468 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5469 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5470 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5473 else if (name == "scalar_bar_horizontal_x" || name == "scalar_bar_horizontal_width")
5475 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5476 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5477 if ( sbX1 + sbW > aTol ) {
5478 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5481 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5482 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5485 else if (name == "scalar_bar_horizontal_y" || name == "scalar_bar_horizontal_height")
5487 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5488 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5489 if ( sbY1 + sbH > aTol ) {
5490 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5493 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5494 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5497 else if ( name == "segmentation" )
5499 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5500 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5502 else if ( name == "nb_segments_per_edge" )
5504 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5505 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5507 else if ( name == "historical_python_dump" || name == "forget_mesh_on_hyp_modif" || name == "default_grp_color" )
5509 QString val = aResourceMgr->stringValue( "SMESH", name );
5510 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5512 else if ( name == "numbering_node_color" || name == "numbering_node_font" )
5514 SMESH::UpdateFontProp( this );
5516 else if ( name == "numbering_elem_color" || name == "numbering_elem_font" )
5518 SMESH::UpdateFontProp( this );
5521 if ( aWarning.size() != 0 ) {
5522 aWarning += "The default values are applied instead.";
5523 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5524 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5525 QObject::tr(aWarning.c_str()));
5530 //================================================================================
5532 * \brief Update something in accordance with update flags
5533 * \param theFlags - update flags
5535 * Update viewer or/and object browser etc. in accordance with update flags ( see
5536 * LightApp_UpdateFlags enumeration ).
5538 //================================================================================
5539 void SMESHGUI::update( const int flags )
5541 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5542 SMESH::UpdateView();
5544 SalomeApp_Module::update( flags );
5547 //================================================================================
5549 * \brief Set default selection mode
5551 * SLOT called when operation committed. Sets default selection mode
5553 //================================================================================
5554 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5556 SVTK_ViewWindow* vtkWnd =
5557 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5559 vtkWnd->SetSelectionMode( ActorSelection );
5562 //================================================================================
5564 * \brief Set default selection mode
5566 * SLOT called when operation aborted. Sets default selection mode
5568 //================================================================================
5569 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5571 SVTK_ViewWindow* vtkWnd =
5572 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5574 vtkWnd->SetSelectionMode( ActorSelection );
5577 //================================================================================
5579 * \brief Creates operation with given identifier
5580 * \param id - identifier of operation to be started
5581 * \return Pointer on created operation or NULL if operation is not created
5583 * Virtual method redefined from the base class creates operation with given id.
5584 * It is called called automatically from startOperation method of base class.
5586 //================================================================================
5587 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5589 LightApp_Operation* op = 0;
5590 // to do : create operation here
5593 case SMESHOp::OpSplitBiQuadratic:
5594 op = new SMESHGUI_SplitBiQuadOp();
5596 case SMESHOp::OpConvertMeshToQuadratic:
5597 op = new SMESHGUI_ConvToQuadOp();
5599 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5600 op = new SMESHGUI_Make2DFrom3DOp();
5602 case SMESHOp::OpReorientFaces:
5603 op = new SMESHGUI_ReorientFacesOp();
5605 case SMESHOp::OpCreateMesh:
5606 op = new SMESHGUI_MeshOp( true, true );
5608 case SMESHOp::OpCreateSubMesh:
5609 op = new SMESHGUI_MeshOp( true, false );
5611 case SMESHOp::OpEditMeshOrSubMesh:
5612 case SMESHOp::OpEditMesh:
5613 case SMESHOp::OpEditSubMesh:
5614 op = new SMESHGUI_MeshOp( false );
5616 case SMESHOp::OpCompute:
5617 case SMESHOp::OpComputeSubMesh:
5618 op = new SMESHGUI_ComputeOp();
5620 case SMESHOp::OpPreCompute:
5621 op = new SMESHGUI_PrecomputeOp();
5623 case SMESHOp::OpEvaluate:
5624 op = new SMESHGUI_EvaluateOp();
5626 case SMESHOp::OpMeshOrder:
5627 op = new SMESHGUI_MeshOrderOp();
5629 case SMESHOp::OpCreateGeometryGroup:
5630 op = new SMESHGUI_GroupOnShapeOp();
5632 case SMESHOp::OpFindElementByPoint:
5633 op = new SMESHGUI_FindElemByPointOp();
5635 case SMESHOp::OpMoveNode: // Make mesh pass through point
5636 op = new SMESHGUI_MakeNodeAtPointOp();
5638 case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
5639 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5646 op = SalomeApp_Module::createOperation( id );
5650 //================================================================================
5652 * \brief Stops current operations and starts a given one
5653 * \param id - The id of the operation to start
5655 //================================================================================
5657 void SMESHGUI::switchToOperation(int id)
5659 activeStudy()->abortAllOperations();
5660 startOperation( id );
5663 LightApp_Displayer* SMESHGUI::displayer()
5666 myDisplayer = new SMESHGUI_Displayer( getApp() );
5670 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5673 int aTolerance = 64;
5674 int anIterations = 0;
5680 if( anIterations % aPeriod == 0 )
5683 if( aTolerance < 1 )
5687 aHue = (int)( 360.0 * rand() / RAND_MAX );
5690 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5691 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5692 for( ; it != itEnd; ++it )
5694 SALOMEDS::Color anAutoColor = *it;
5695 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5698 aQColor.getHsv( &h, &s, &v );
5699 if( abs( h - aHue ) < aTolerance )
5711 aColor.setHsv( aHue, 255, 255 );
5713 SALOMEDS::Color aSColor;
5714 aSColor.R = aColor.redF();
5715 aSColor.G = aColor.greenF();
5716 aSColor.B = aColor.blueF();
5721 const char* gSeparator = "_"; // character used to separate parameter names
5722 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5723 const char* gPathSep = "|"; // character used to separate paths
5726 * \brief Store visual parameters
5728 * This method is called just before the study document is saved.
5729 * Store visual parameters in AttributeParameter attribue(s)
5731 void SMESHGUI::storeVisualParameters (int savePoint)
5734 Kernel_Utils::Localizer loc;
5736 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5737 if (!appStudy || !appStudy->studyDS())
5739 _PTR(Study) studyDS = appStudy->studyDS();
5741 // componentName is used for encoding of entries when storing them in IParameters
5742 std::string componentName = myComponentSMESH->ComponentDataType();
5743 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5744 //if (!aSComponent) return;
5747 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5748 componentName.c_str(),
5750 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5752 // store custom markers
5753 if( !myMarkerMap.empty() )
5755 VTK::MarkerMap::const_iterator anIter = myMarkerMap.begin();
5756 for( ; anIter != myMarkerMap.end(); anIter++ )
5758 int anId = anIter->first;
5759 VTK::MarkerData aMarkerData = anIter->second;
5760 std::string aMarkerFileName = aMarkerData.first;
5761 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5762 if( aMarkerTexture.size() < 3 )
5763 continue; // should contain at least width, height and the first value
5765 QString aPropertyName( "texture" );
5766 aPropertyName += gSeparator;
5767 aPropertyName += QString::number( anId );
5769 QString aPropertyValue = aMarkerFileName.c_str();
5770 aPropertyValue += gPathSep;
5772 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5773 ushort aWidth = *aTextureIter++;
5774 ushort aHeight = *aTextureIter++;
5775 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5776 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5777 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5778 aPropertyValue += QString::number( *aTextureIter );
5780 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5784 // viewers counters are used for storing view_numbers in IParameters
5787 // main cycle to store parameters of displayed objects
5788 QList<SUIT_ViewManager*> lst;
5789 QList<SUIT_ViewManager*>::Iterator it;
5790 getApp()->viewManagers(lst);
5791 for (it = lst.begin(); it != lst.end(); it++)
5793 SUIT_ViewManager* vman = *it;
5794 QString vType = vman->getType();
5796 // saving VTK actors properties
5797 if (vType == SVTK_Viewer::Type())
5799 // store the clipping planes attached to the view manager
5800 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5801 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5802 if( anIter != myClippingPlaneInfoMap.end() )
5803 aClippingPlaneInfoList = anIter->second;
5805 if( !aClippingPlaneInfoList.empty() ) {
5806 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5807 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5809 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5810 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5812 QString aPropertyName( "ClippingPlane" );
5813 aPropertyName += gSeparator;
5814 aPropertyName += QString::number( vtkViewers );
5815 aPropertyName += gSeparator;
5816 aPropertyName += QString::number( anId );
5818 QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
5819 aPropertyValue += gDigitsSep;
5820 aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
5821 aPropertyValue += gDigitsSep;
5822 if ( aPlane->PlaneMode == SMESH::Absolute ) {
5823 aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
5824 aPropertyValue += gDigitsSep;
5825 aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
5826 aPropertyValue += gDigitsSep;
5827 aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
5828 aPropertyValue += gDigitsSep;
5829 aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
5830 aPropertyValue += gDigitsSep;
5831 aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
5832 aPropertyValue += gDigitsSep;
5833 aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
5834 aPropertyValue += gDigitsSep;
5835 aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
5837 else if ( aPlane->PlaneMode == SMESH::Relative ) {
5838 aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
5839 aPropertyValue += gDigitsSep;
5840 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5841 aPropertyValue += gDigitsSep;
5842 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5843 aPropertyValue += gDigitsSep;
5844 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5847 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5851 QVector<SUIT_ViewWindow*> views = vman->getViews();
5852 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5854 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5856 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5857 vtkActorCollection* allActors = aCopy.GetActors();
5858 allActors->InitTraversal();
5859 while (vtkActor* actor = allActors->GetNextActor())
5861 if (actor->GetVisibility()) // store only visible actors
5863 SMESH_Actor* aSmeshActor = 0;
5864 if (actor->IsA("SMESH_Actor"))
5865 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5866 if (aSmeshActor && aSmeshActor->hasIO())
5868 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5871 // entry is "encoded" = it does NOT contain component address,
5872 // since it is a subject to change on next component loading
5873 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5875 std::string param, vtkParam = vType.toLatin1().data();
5876 vtkParam += gSeparator;
5877 vtkParam += QString::number(vtkViewers).toLatin1().data();
5878 vtkParam += gSeparator;
5881 param = vtkParam + "Visibility";
5882 ip->setParameter(entry, param, "On");
5885 param = vtkParam + "Representation";
5886 ip->setParameter(entry, param, QString::number
5887 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5890 param = vtkParam + "IsShrunk";
5891 ip->setParameter(entry, param, QString::number
5892 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5894 // Displayed entities
5895 unsigned int aMode = aSmeshActor->GetEntityMode();
5896 bool isE = aMode & SMESH_Actor::eEdges;
5897 bool isF = aMode & SMESH_Actor::eFaces;
5898 bool isV = aMode & SMESH_Actor::eVolumes;
5899 bool is0d = aMode & SMESH_Actor::e0DElements;
5900 bool isB = aMode & SMESH_Actor::eBallElem;
5902 QString modeStr ("e");
5903 modeStr += gDigitsSep; modeStr += QString::number(isE);
5904 modeStr += gDigitsSep; modeStr += "f";
5905 modeStr += gDigitsSep; modeStr += QString::number(isF);
5906 modeStr += gDigitsSep; modeStr += "v";
5907 modeStr += gDigitsSep; modeStr += QString::number(isV);
5908 modeStr += gDigitsSep; modeStr += "0d";
5909 modeStr += gDigitsSep; modeStr += QString::number(is0d);
5910 modeStr += gDigitsSep; modeStr += "b";
5911 modeStr += gDigitsSep; modeStr += QString::number(isB);
5913 param = vtkParam + "Entities";
5914 ip->setParameter(entry, param, modeStr.toLatin1().data());
5920 aSmeshActor->GetSufaceColor(r, g, b, delta);
5921 QStringList colorStr;
5922 colorStr << "surface";
5923 colorStr << QString::number(r);
5924 colorStr << QString::number(g);
5925 colorStr << QString::number(b);
5927 colorStr << "backsurface";
5928 colorStr << QString::number(delta);
5930 aSmeshActor->GetVolumeColor(r, g, b, delta);
5931 colorStr << "volume";
5932 colorStr << QString::number(r);
5933 colorStr << QString::number(g);
5934 colorStr << QString::number(b);
5935 colorStr << QString::number(delta);
5937 aSmeshActor->GetEdgeColor(r, g, b);
5939 colorStr << QString::number(r);
5940 colorStr << QString::number(g);
5941 colorStr << QString::number(b);
5943 aSmeshActor->GetNodeColor(r, g, b);
5945 colorStr << QString::number(r);
5946 colorStr << QString::number(g);
5947 colorStr << QString::number(b);
5949 aSmeshActor->GetOutlineColor(r, g, b);
5950 colorStr << "outline";
5951 colorStr << QString::number(r);
5952 colorStr << QString::number(g);
5953 colorStr << QString::number(b);
5955 aSmeshActor->Get0DColor(r, g, b);
5956 colorStr << "elem0d";
5957 colorStr << QString::number(r);
5958 colorStr << QString::number(g);
5959 colorStr << QString::number(b);
5961 aSmeshActor->GetBallColor(r, g, b);
5963 colorStr << QString::number(r);
5964 colorStr << QString::number(g);
5965 colorStr << QString::number(b);
5967 aSmeshActor->GetFacesOrientationColor(r, g, b);
5968 colorStr << "orientation";
5969 colorStr << QString::number(r);
5970 colorStr << QString::number(g);
5971 colorStr << QString::number(b);
5973 param = vtkParam + "Colors";
5974 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
5977 QStringList sizeStr;
5979 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
5980 sizeStr << "outline";
5981 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
5982 sizeStr << "elem0d";
5983 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
5985 //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
5986 sizeStr << QString::number((double)aSmeshActor->GetBallSize());
5987 sizeStr << QString::number((double)aSmeshActor->GetBallScale());
5988 sizeStr << "shrink";
5989 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
5990 sizeStr << "orientation";
5991 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
5992 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
5994 param = vtkParam + "Sizes";
5995 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
6000 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
6001 if( aMarkerType == VTK::MT_USER ) {
6002 markerStr += "custom";
6003 markerStr += gDigitsSep;
6004 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
6008 markerStr += gDigitsSep;
6009 markerStr += QString::number( (int)aMarkerType );
6010 markerStr += gDigitsSep;
6011 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
6014 param = vtkParam + "PointMarker";
6015 ip->setParameter(entry, param, markerStr.toLatin1().data());
6018 param = vtkParam + "Opacity";
6019 ip->setParameter(entry, param,
6020 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
6023 param = vtkParam + "ClippingPlane";
6025 if( !aClippingPlaneInfoList.empty() ) {
6026 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
6027 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
6029 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
6030 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
6031 SMESH::TActorList::iterator anIter2 = anActorList.begin();
6032 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
6033 if( aSmeshActor == *anIter2 ) {
6034 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
6035 QString::number( anId ).toLatin1().constData() );
6042 ip->setParameter( entry, param, "Off" );
6043 } // if (io->hasEntry())
6044 } // SMESH_Actor && hasIO
6046 } // while.. actors traversal
6050 } // if (SVTK view model)
6051 } // for (viewManagers)
6054 // data structures for clipping planes processing
6058 bool isOpenGLClipping;
6059 vtkIdType RelativeOrientation;
6062 int AbsoluteOrientation;
6063 double X, Y, Z, Dx, Dy, Dz;
6065 typedef std::list<TPlaneData> TPlaneDataList;
6066 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
6068 typedef std::list<vtkActor*> TActorList;
6071 TActorList ActorList;
6072 SUIT_ViewManager* ViewManager;
6074 typedef std::list<TPlaneInfo> TPlaneInfoList;
6075 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
6078 * \brief Restore visual parameters
6080 * This method is called after the study document is opened.
6081 * Restore visual parameters from AttributeParameter attribue(s)
6083 void SMESHGUI::restoreVisualParameters (int savePoint)
6086 Kernel_Utils::Localizer loc;
6088 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6089 if (!appStudy || !appStudy->studyDS())
6091 _PTR(Study) studyDS = appStudy->studyDS();
6093 // componentName is used for encoding of entries when storing them in IParameters
6094 std::string componentName = myComponentSMESH->ComponentDataType();
6095 //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
6096 //if (!aSComponent) return;
6099 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6100 componentName.c_str(),
6102 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6104 // restore custom markers and map of clipping planes
6105 TPlaneDataMap aPlaneDataMap;
6107 std::vector<std::string> properties = ip->getProperties();
6108 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
6110 std::string property = *propIt;
6111 QString aPropertyName( property.c_str() );
6112 QString aPropertyValue( ip->getProperty( property ).c_str() );
6114 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
6115 if( aPropertyNameList.isEmpty() )
6118 QString aPropertyType = aPropertyNameList[0];
6119 if( aPropertyType == "texture" )
6121 if( aPropertyNameList.size() != 2 )
6125 int anId = aPropertyNameList[1].toInt( &ok );
6126 if( !ok || anId < 1 )
6129 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
6130 if( aPropertyValueList.size() != 2 )
6133 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
6134 QString aMarkerTextureString = aPropertyValueList[1];
6135 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
6136 if( aMarkerTextureStringList.size() != 3 )
6140 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6145 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6149 VTK::MarkerTexture aMarkerTexture;
6150 aMarkerTexture.push_back( aWidth );
6151 aMarkerTexture.push_back( aHeight );
6153 QString aMarkerTextureData = aMarkerTextureStringList[2];
6154 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6156 QChar aChar = aMarkerTextureData.at( i );
6157 if( aChar.isDigit() )
6158 aMarkerTexture.push_back( aChar.digitValue() );
6161 myMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6163 else if( aPropertyType == "ClippingPlane" )
6165 if( aPropertyNameList.size() != 3 )
6169 int aViewId = aPropertyNameList[1].toInt( &ok );
6170 if( !ok || aViewId < 0 )
6174 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6175 if( !ok || aClippingPlaneId < 0 )
6178 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6179 if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6182 TPlaneData aPlaneData;
6183 aPlaneData.AbsoluteOrientation = false;
6184 aPlaneData.RelativeOrientation = 0;
6185 aPlaneData.Distance = aPlaneData.Angle[0] = aPlaneData.Angle[1] = 0;
6186 aPlaneData.X = aPlaneData.Y = aPlaneData.Z = 0;
6187 aPlaneData.Dx = aPlaneData.Dy = aPlaneData.Dz = 0;
6189 aPlaneData.Id = aClippingPlaneId;
6192 aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6197 aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6201 if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6204 aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6209 aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6214 aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6219 aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6224 aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6229 aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6234 aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6238 else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6240 aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6245 aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6250 aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6255 aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6260 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6261 aPlaneDataList.push_back( aPlaneData );
6265 TPlaneInfoMap aPlaneInfoMap;
6267 std::vector<std::string> entries = ip->getEntries();
6269 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6271 // entry is a normal entry - it should be "decoded" (setting base address of component)
6272 QString entry (ip->decodeEntry(*entIt).c_str());
6274 // Check that the entry corresponds to a real object in the Study
6275 // as the object may be deleted or modified after the visual state is saved.
6276 _PTR(SObject) so = studyDS->FindObjectID(entry.toUtf8().data());
6277 if (!so) continue; //Skip the not existent entry
6279 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6280 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6282 std::vector<std::string>::iterator namesIt = paramNames.begin();
6283 std::vector<std::string>::iterator valuesIt = paramValues.begin();
6285 // actors are stored in a map after displaying of them for
6286 // quicker access in the future: map < viewID to actor >
6287 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6289 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6291 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6292 // '_' is used as separator and should not be used in viewer type or parameter names.
6293 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6294 if (lst.size() != 3)
6297 QString viewerTypStr = lst[0];
6298 QString viewIndexStr = lst[1];
6299 QString paramNameStr = lst[2];
6302 int viewIndex = viewIndexStr.toUInt(&ok);
6303 if (!ok) // bad conversion of view index to integer
6307 if (viewerTypStr == SVTK_Viewer::Type())
6309 SMESH_Actor* aSmeshActor = 0;
6310 if (vtkActors.IsBound(viewIndex))
6311 aSmeshActor = vtkActors.Find(viewIndex);
6313 QList<SUIT_ViewManager*> lst;
6314 getApp()->viewManagers(viewerTypStr, lst);
6316 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6317 SUIT_ViewManager* vman = NULL;
6318 if (viewIndex >= 0 && viewIndex < lst.count())
6319 vman = lst.at(viewIndex);
6321 if (paramNameStr == "Visibility")
6323 if (!aSmeshActor && displayer() && vman)
6325 SUIT_ViewModel* vmodel = vman->getViewModel();
6326 // SVTK view model can be casted to SALOME_View
6327 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6329 // store displayed actor in a temporary map for quicker
6330 // access later when restoring other parameters
6331 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6332 vtkRenderer* Renderer = vtkView->getRenderer();
6333 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6334 vtkActorCollection* theActors = aCopy.GetActors();
6335 theActors->InitTraversal();
6336 bool isFound = false;
6337 vtkActor *ac = theActors->GetNextActor();
6338 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6339 if (ac->IsA("SMESH_Actor")) {
6340 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6341 if (aGeomAc->hasIO()) {
6342 Handle(SALOME_InteractiveObject) io = aGeomAc->getIO();
6343 if (io->hasEntry() && strcmp(io->getEntry(), entry.toUtf8().data()) == 0) {
6345 vtkActors.Bind(viewIndex, aGeomAc);
6351 } // if (paramNameStr == "Visibility")
6354 // the rest properties "work" with SMESH_Actor
6357 QString val ((*valuesIt).c_str());
6360 if (paramNameStr == "Representation") {
6361 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6364 else if (paramNameStr == "IsShrunk") {
6366 if (!aSmeshActor->IsShrunk())
6367 aSmeshActor->SetShrink();
6370 if (aSmeshActor->IsShrunk())
6371 aSmeshActor->UnShrink();
6374 // Displayed entities
6375 else if (paramNameStr == "Entities") {
6376 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6377 int aEntityMode = SMESH_Actor::eAllEntity;
6378 for ( int i = 0; i < mode.count(); i+=2 ) {
6379 if ( i < mode.count()-1 ) {
6380 QString type = mode[i];
6381 bool val = mode[i+1].toInt();
6382 if ( type == "e" && !val )
6383 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6384 else if ( type == "f" && !val )
6385 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6386 else if ( type == "v" && !val )
6387 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6388 else if ( type == "0d" && !val )
6389 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6390 else if ( type == "b" && !val )
6391 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6394 aSmeshActor->SetEntityMode( aEntityMode );
6397 else if (paramNameStr == "Colors") {
6398 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6405 QColor outlineColor;
6406 QColor orientationColor;
6412 // below lines are required to get default values for delta coefficients
6413 // of backface color for faces and color of reversed volumes
6414 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
6415 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6416 for ( int i = 0; i < colors.count(); i++ ) {
6417 QString type = colors[i];
6418 if ( type == "surface" ) {
6419 // face color is set by 3 values r:g:b, where
6420 // - r,g,b - is rgb color components
6421 if ( i+1 >= colors.count() ) break; // format error
6422 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6423 if ( i+2 >= colors.count() ) break; // format error
6424 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6425 if ( i+3 >= colors.count() ) break; // format error
6426 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6427 faceColor.setRgbF( r, g, b );
6430 else if ( type == "backsurface" ) {
6431 // backface color can be defined in several ways
6432 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6433 // - in latest versions, it is set as delta coefficient
6434 bool rgbOk = false, deltaOk;
6435 if ( i+1 >= colors.count() ) break; // format error
6436 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6437 int delta = colors[i+1].toInt( &deltaOk );
6439 if ( i+1 < colors.count() ) // index is shifted to 1
6440 g = colors[i+1].toDouble( &rgbOk );
6441 if ( rgbOk ) i++; // shift index
6442 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6443 b = colors[i+1].toDouble( &rgbOk );
6445 // - as currently there's no way to set directly backsurface color as it was before,
6446 // we ignore old dump where r,g,b triple was set
6447 // - also we check that delta parameter is set properly
6448 if ( !rgbOk && deltaOk )
6451 else if ( type == "volume" ) {
6452 // volume color is set by 4 values r:g:b:delta, where
6453 // - r,g,b - is a normal volume rgb color components
6454 // - delta - is a reversed volume color delta coefficient
6455 if ( i+1 >= colors.count() ) break; // format error
6456 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6457 if ( i+2 >= colors.count() ) break; // format error
6458 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6459 if ( i+3 >= colors.count() ) break; // format error
6460 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6461 if ( i+4 >= colors.count() ) break; // format error
6462 int delta = colors[i+4].toInt( &bOk );
6463 if ( !bOk ) break; // format error
6464 volumeColor.setRgbF( r, g, b );
6468 else if ( type == "edge" ) {
6469 // edge color is set by 3 values r:g:b, where
6470 // - r,g,b - is rgb color components
6471 if ( i+1 >= colors.count() ) break; // format error
6472 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6473 if ( i+2 >= colors.count() ) break; // format error
6474 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6475 if ( i+3 >= colors.count() ) break; // format error
6476 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6477 edgeColor.setRgbF( r, g, b );
6480 else if ( type == "node" ) {
6481 // node color is set by 3 values r:g:b, where
6482 // - r,g,b - is rgb color components
6483 if ( i+1 >= colors.count() ) break; // format error
6484 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6485 if ( i+2 >= colors.count() ) break; // format error
6486 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6487 if ( i+3 >= colors.count() ) break; // format error
6488 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6489 nodeColor.setRgbF( r, g, b );
6492 else if ( type == "elem0d" ) {
6493 // 0d element color is set by 3 values r:g:b, where
6494 // - r,g,b - is rgb color components
6495 if ( i+1 >= colors.count() ) break; // format error
6496 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6497 if ( i+2 >= colors.count() ) break; // format error
6498 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6499 if ( i+3 >= colors.count() ) break; // format error
6500 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6501 elem0dColor.setRgbF( r, g, b );
6504 else if ( type == "ball" ) {
6505 // ball color is set by 3 values r:g:b, where
6506 // - r,g,b - is rgb color components
6507 if ( i+1 >= colors.count() ) break; // format error
6508 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6509 if ( i+2 >= colors.count() ) break; // format error
6510 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6511 if ( i+3 >= colors.count() ) break; // format error
6512 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6513 ballColor.setRgbF( r, g, b );
6516 else if ( type == "outline" ) {
6517 // outline color is set by 3 values r:g:b, where
6518 // - r,g,b - is rgb color components
6519 if ( i+1 >= colors.count() ) break; // format error
6520 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6521 if ( i+2 >= colors.count() ) break; // format error
6522 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6523 if ( i+3 >= colors.count() ) break; // format error
6524 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6525 outlineColor.setRgbF( r, g, b );
6528 else if ( type == "orientation" ) {
6529 // orientation color is set by 3 values r:g:b, where
6530 // - r,g,b - is rgb color components
6531 if ( i+1 >= colors.count() ) break; // format error
6532 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6533 if ( i+2 >= colors.count() ) break; // format error
6534 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6535 if ( i+3 >= colors.count() ) break; // format error
6536 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6537 orientationColor.setRgbF( r, g, b );
6542 if ( nodeColor.isValid() )
6543 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6545 if ( edgeColor.isValid() )
6546 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6548 if ( faceColor.isValid() )
6549 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6551 if ( volumeColor.isValid() )
6552 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6553 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6554 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6556 if ( elem0dColor.isValid() )
6557 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6559 if ( ballColor.isValid() )
6560 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6562 if ( outlineColor.isValid() )
6563 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6564 // orientation color
6565 if ( orientationColor.isValid() )
6566 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6569 else if (paramNameStr == "Sizes") {
6570 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6573 int outlineWidth = -1;
6574 int elem0dSize = -1;
6575 //int ballSize = -1;
6576 double ballDiameter = -1.0;
6577 double ballScale = -1.0;
6578 double shrinkSize = -1;
6579 double orientationSize = -1;
6580 bool orientation3d = false;
6581 for ( int i = 0; i < sizes.count(); i++ ) {
6582 QString type = sizes[i];
6583 if ( type == "line" ) {
6584 // line (wireframe) width is given as single integer value
6585 if ( i+1 >= sizes.count() ) break; // format error
6586 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6590 if ( type == "outline" ) {
6591 // outline width is given as single integer value
6592 if ( i+1 >= sizes.count() ) break; // format error
6593 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6597 else if ( type == "elem0d" ) {
6598 // 0d element size is given as single integer value
6599 if ( i+1 >= sizes.count() ) break; // format error
6600 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6604 else if ( type == "ball" ) {
6605 // balls are specified by two values: size:scale, where
6606 // - size - is a integer value specifying size
6607 // - scale - is a double value specifying scale factor
6608 if ( i+1 >= sizes.count() ) break; // format error
6609 //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6610 double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6611 if ( i+2 >= sizes.count() ) break; // format error
6612 double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6618 else if ( type == "shrink" ) {
6619 // shrink factor is given as single floating point value
6620 if ( i+1 >= sizes.count() ) break; // format error
6621 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6625 else if ( type == "orientation" ) {
6626 // orientation vectors are specified by two values size:3d, where
6627 // - size - is a floating point value specifying scale factor
6628 // - 3d - is a boolean
6629 if ( i+1 >= sizes.count() ) break; // format error
6630 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6631 if ( i+2 >= sizes.count() ) break; // format error
6632 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6633 orientationSize = v1;
6634 orientation3d = (bool)v2;
6638 // line (wireframe) width
6639 if ( lineWidth > 0 )
6640 aSmeshActor->SetLineWidth( lineWidth );
6642 if ( outlineWidth > 0 )
6643 aSmeshActor->SetOutlineWidth( outlineWidth );
6644 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6645 aSmeshActor->SetOutlineWidth( lineWidth );
6647 if ( elem0dSize > 0 )
6648 aSmeshActor->Set0DSize( elem0dSize );
6650 /*if ( ballSize > 0 )
6651 aSmeshActor->SetBallSize( ballSize );*/
6653 if ( ballDiameter > 0 )
6654 aSmeshActor->SetBallSize( ballDiameter );
6656 if ( ballScale > 0.0 )
6657 aSmeshActor->SetBallScale( ballScale );
6659 if ( shrinkSize > 0 )
6660 aSmeshActor->SetShrinkFactor( shrinkSize );
6661 // orientation vectors
6662 if ( orientationSize > 0 ) {
6663 aSmeshActor->SetFacesOrientationScale( orientationSize );
6664 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6668 else if (paramNameStr == "PointMarker") {
6669 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6670 if( data.count() >= 2 ) {
6672 int aParam1 = data[1].toInt( &ok );
6674 if( data[0] == "std" && data.count() == 3 ) {
6675 int aParam2 = data[2].toInt( &ok );
6676 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6678 else if( data[0] == "custom" ) {
6679 VTK::MarkerMap::const_iterator markerIt = myMarkerMap.find( aParam1 );
6680 if( markerIt != myMarkerMap.end() ) {
6681 VTK::MarkerData aMarkerData = markerIt->second;
6682 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6689 else if (paramNameStr == "Opacity") {
6690 aSmeshActor->SetOpacity(val.toFloat());
6693 else if (paramNameStr.startsWith("ClippingPlane")) {
6694 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6695 // old format - val looks like "Off" or "1:0:0:0.5:0:0"
6696 // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
6697 // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
6698 // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
6699 // new format - val looks like "Off" or "0" (plane id)
6700 // (note: in new format "Off" value is used only for consistency,
6701 // so it is processed together with values in old format)
6702 bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
6703 if( anIsOldFormat ) {
6704 if (paramNameStr == "ClippingPlane1" || val == "Off")
6705 aSmeshActor->RemoveAllClippingPlanes();
6707 QList<SUIT_ViewManager*> lst;
6708 getApp()->viewManagers(viewerTypStr, lst);
6709 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6710 if (viewIndex >= 0 && viewIndex < lst.count()) {
6711 SUIT_ViewManager* vman = lst.at(viewIndex);
6712 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6714 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6716 SMESH::TActorList anActorList;
6717 anActorList.push_back( aSmeshActor );
6718 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
6719 aPlane->myViewWindow = vtkView;
6720 SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
6721 aPlane->PlaneMode = aMode;
6722 bool isOpenGLClipping = ( bool )vals[1].toInt();
6723 aPlane->IsOpenGLClipping = isOpenGLClipping;
6724 if ( aMode == SMESH::Absolute ) {
6725 aPlane->myAbsoluteOrientation = vals[2].toInt();
6726 aPlane->X = vals[3].toFloat();
6727 aPlane->Y = vals[4].toFloat();
6728 aPlane->Z = vals[5].toFloat();
6729 aPlane->Dx = vals[6].toFloat();
6730 aPlane->Dy = vals[7].toFloat();
6731 aPlane->Dz = vals[8].toFloat();
6733 else if ( aMode == SMESH::Relative ) {
6734 aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
6735 aPlane->myDistance = vals[3].toFloat();
6736 aPlane->myAngle[0] = vals[4].toFloat();
6737 aPlane->myAngle[1] = vals[5].toFloat();
6741 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6742 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6743 aClippingPlaneInfo.Plane = aPlane;
6744 aClippingPlaneInfo.ActorList = anActorList;
6745 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6753 int aPlaneId = val.toInt( &ok );
6754 if( ok && aPlaneId >= 0 ) {
6755 bool anIsDefinedPlane = false;
6756 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6757 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6758 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6759 TPlaneInfo& aPlaneInfo = *anIter;
6760 if( aPlaneInfo.PlaneId == aPlaneId ) {
6761 aPlaneInfo.ActorList.push_back( aSmeshActor );
6762 anIsDefinedPlane = true;
6766 if( !anIsDefinedPlane ) {
6767 TPlaneInfo aPlaneInfo;
6768 aPlaneInfo.PlaneId = aPlaneId;
6769 aPlaneInfo.ActorList.push_back( aSmeshActor );
6770 aPlaneInfo.ViewManager = vman;
6772 // to make the list sorted by plane id
6773 anIter = aPlaneInfoList.begin();
6774 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6775 const TPlaneInfo& aPlaneInfoRef = *anIter;
6776 if( aPlaneInfoRef.PlaneId > aPlaneId )
6779 aPlaneInfoList.insert( anIter, aPlaneInfo );
6784 } // if (aSmeshActor)
6785 } // other parameters than Visibility
6787 } // for names/parameters iterator
6788 } // for entries iterator
6790 // take into account planes with empty list of actors referred to them
6791 QList<SUIT_ViewManager*> aVMList;
6792 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6794 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6795 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6796 int aViewId = aPlaneDataIter->first;
6797 if( aViewId >= 0 && aViewId < aVMList.count() ) {
6798 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6800 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6802 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6803 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6804 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6805 const TPlaneData& aPlaneData = *anIter2;
6806 int aPlaneId = aPlaneData.Id;
6808 bool anIsFound = false;
6809 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6810 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6811 const TPlaneInfo& aPlaneInfo = *anIter3;
6812 if( aPlaneInfo.PlaneId == aPlaneId ) {
6819 TPlaneInfo aPlaneInfo; // ActorList field is empty
6820 aPlaneInfo.PlaneId = aPlaneId;
6821 aPlaneInfo.ViewManager = aViewManager;
6823 // to make the list sorted by plane id
6824 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6825 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6826 const TPlaneInfo& aPlaneInfoRef = *anIter4;
6827 if( aPlaneInfoRef.PlaneId > aPlaneId )
6830 aPlaneInfoList.insert( anIter4, aPlaneInfo );
6836 // add clipping planes to actors according to the restored parameters
6837 // and update the clipping plane map
6838 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6839 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6840 int aViewId = anIter1->first;
6841 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6843 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6844 if( anIter2 == aPlaneDataMap.end() )
6846 const TPlaneDataList& aPlaneDataList = anIter2->second;
6848 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6849 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6850 const TPlaneInfo& aPlaneInfo = *anIter3;
6851 int aPlaneId = aPlaneInfo.PlaneId;
6852 const TActorList& anActorList = aPlaneInfo.ActorList;
6853 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6857 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6861 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6863 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6864 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6865 const TPlaneData& aPlaneData = *anIter4;
6866 if( aPlaneData.Id == aPlaneId ) {
6867 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
6868 aPlane->myViewWindow = aViewWindow;
6869 aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
6870 aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
6871 if ( aPlane->PlaneMode == SMESH::Absolute ) {
6872 aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
6873 aPlane->X = aPlaneData.X;
6874 aPlane->Y = aPlaneData.Y;
6875 aPlane->Z = aPlaneData.Z;
6876 aPlane->Dx = aPlaneData.Dx;
6877 aPlane->Dy = aPlaneData.Dy;
6878 aPlane->Dz = aPlaneData.Dz;
6880 else if ( aPlane->PlaneMode == SMESH::Relative ) {
6881 aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
6882 aPlane->myDistance = aPlaneData.Distance;
6883 aPlane->myAngle[0] = aPlaneData.Angle[0];
6884 aPlane->myAngle[1] = aPlaneData.Angle[1];
6887 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6888 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6889 aClippingPlaneInfo.Plane = aPlane;
6890 aClippingPlaneInfo.ActorList = anActorList;
6891 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6902 // update all VTK views
6903 QList<SUIT_ViewManager*> lst;
6904 getApp()->viewManagers(lst);
6905 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6906 SUIT_ViewModel* vmodel = (*it)->getViewModel();
6907 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6908 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6909 // set OpenGL clipping planes
6910 VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
6911 vtkActorCollection* anAllActors = aCopy.GetActors();
6912 anAllActors->InitTraversal();
6913 while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
6914 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
6915 anActor->SetOpenGLClippingPlane();
6917 vtkView->getRenderer()->ResetCameraClippingRange();
6924 \brief Adds preferences for dfont of VTK viewer
6926 \param pIf group identifier
6927 \param param parameter
6928 \return identifier of preferences
6930 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
6932 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6934 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6937 fam.append( tr( "SMESH_FONT_ARIAL" ) );
6938 fam.append( tr( "SMESH_FONT_COURIER" ) );
6939 fam.append( tr( "SMESH_FONT_TIMES" ) );
6941 setPreferenceProperty( tfont, "fonts", fam );
6943 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6944 if ( needSize ) f = f | QtxFontEdit::Size;
6945 setPreferenceProperty( tfont, "features", f );
6951 \brief Actions after hypothesis edition
6952 Updates object browser after hypothesis edition
6954 void SMESHGUI::onHypothesisEdit( int result )
6957 SMESHGUI::Modified();
6958 updateObjBrowser( true );
6962 \brief Actions after choosing menu of control modes
6963 Updates control mode actions according to current selection
6965 void SMESHGUI::onUpdateControlActions()
6967 SALOME_ListIO selected;
6968 if ( LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr() )
6969 aSel->selectedObjects( selected );
6971 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
6972 if ( selected.Extent() ) {
6973 if ( selected.First()->hasEntry() ) {
6974 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( selected.First()->getEntry() )) {
6975 aControl = anActor->GetControlMode();
6976 SALOME_ListIteratorOfListIO it(selected);
6977 for ( it.Next(); it.More(); it.Next() ) {
6978 Handle(SALOME_InteractiveObject) anIO = it.Value();
6979 if ( anIO->hasEntry() ) {
6980 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
6981 if ( aControl != anActor->GetControlMode() ) {
6982 aControl = SMESH_Actor::eNone;
6992 int anAction = ActionToControl( aControl, true );
6994 action( anAction )->setChecked( true );
6996 QMenu* send = (QMenu*)sender();
6997 QList<QAction*> actions = send->actions();
6998 for ( int i = 0; i < actions.size(); i++ )
6999 actions[i]->setChecked( false );
7005 \brief Signal handler closing(SUIT_ViewWindow*) of a view
7006 \param pview view being closed
7008 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
7009 #ifndef DISABLE_PLOT2DVIEWER
7010 //Crear all Plot2d Viewers if need.
7011 SMESH::ClearPlot2Viewers(pview);
7013 EmitSignalCloseView();
7016 void SMESHGUI::message( const QString& msg )
7019 QStringList data = msg.split("/");
7020 if ( data.count() > 0 ) {
7021 if ( data.first() == "mesh_loading" ) {
7023 QString entry = data.count() > 1 ? data[1] : QString();
7024 if ( entry.isEmpty() )
7027 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
7029 _PTR(SObject) obj = study->FindObjectID( entry.toUtf8().constData() );
7032 name = SMESH::fromUtf8(obj->GetName());
7033 if ( name.isEmpty() )
7036 if ( data.last() == "stop" )
7037 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
7039 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
7040 QApplication::processEvents();
7046 \brief Connects or disconnects signals about activating and cloning view on the module slots
7047 \param pview view which is connected/disconnected
7049 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
7053 SUIT_ViewManager* viewMgr = pview->getViewManager();
7055 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7056 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7058 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7059 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7064 \brief Return \c true if object can be renamed
7066 bool SMESHGUI::renameAllowed( const QString& entry) const {
7067 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7071 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7075 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
7080 if(appStudy->isComponent(entry) || obj->isReference())
7083 // check type to prevent renaming of inappropriate objects
7084 int aType = SMESHGUI_Selection::type(qPrintable(entry));
7085 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7086 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7087 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7088 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7089 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
7096 Rename object by entry.
7097 \param entry entry of the object
7098 \param name new name of the object
7099 \brief Return \c true if rename operation finished successfully, \c false otherwise.
7101 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
7103 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7107 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7112 _PTR(Study) aStudy = appStudy->studyDS();
7117 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
7119 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
7124 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
7125 _PTR(GenericAttribute) anAttr;
7126 _PTR(AttributeName) aName;
7128 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
7130 // check type to prevent renaming of inappropriate objects
7131 int aType = SMESHGUI_Selection::type( qPrintable(entry));
7132 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7133 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7134 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7135 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7136 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
7137 if ( !name.isEmpty() ) {
7138 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qUtf8Printable(name) );
7140 // update name of group object and its actor
7141 Handle(SALOME_InteractiveObject) IObject =
7142 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
7144 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
7145 if( !aGroupObject->_is_nil() ) {
7146 aGroupObject->SetName( qUtf8Printable(name) );
7147 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
7148 anActor->setName( qUtf8Printable(name) );
7158 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
7160 static QList<QColor> colors;
7162 if ( colors.isEmpty() ) {
7164 for (int s = 0; s < 2 ; s++)
7166 for (int v = 100; v >= 40; v = v - 20)
7168 for (int h = 0; h < 359 ; h = h + 60)
7170 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
7175 static int currentColor = randomize( colors.size() );
7177 SALOMEDS::Color color;
7178 color.R = (double)colors[currentColor].red() / 255.0;
7179 color.G = (double)colors[currentColor].green() / 255.0;
7180 color.B = (double)colors[currentColor].blue() / 255.0;
7182 currentColor = (currentColor+1) % colors.count();