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 const int objectCountLimit = 30; // PAL23599
1861 int objectCount = 0;
1863 QString aParentComponent = QString::null;
1865 for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1867 Handle(SALOME_InteractiveObject) anIO = anIt.Value();
1868 if ( anIO.IsNull() ) continue;
1870 QString father = "unknown", name;
1872 _PTR(SObject) aSO = aStudy->FindObjectID( anIO->getEntry() );
1874 father = QString::fromStdString( aSO->GetFatherComponent()->ComponentDataType() );
1875 // check if object is reference
1876 _PTR(SObject) aRefSObj;
1877 if ( aSO->ReferencedObject( aRefSObj ) ) {
1878 name = QString::fromStdString ( aRefSObj->GetName() );
1879 father = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1882 name = anIO->getName();
1885 if ( objectCount < objectCountLimit ) { // avoid occupying the whole screen
1886 aNameList.append("\n - ");
1887 aNameList.append( name );
1890 if( aParentComponent.isNull() )
1891 aParentComponent = father;
1892 else if( !aParentComponent.isEmpty() && aParentComponent!=father )
1893 aParentComponent = "";
1895 if ( objectCount >= objectCountLimit )
1896 aNameList.append("\n - ...");
1898 if ( objectCount == 0 )
1899 return; // No Valid Objects Selected
1901 if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
1902 SUIT_MessageBox::warning( SMESHGUI::desktop(),
1903 QObject::tr("ERR_ERROR"),
1904 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
1907 // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
1908 if (SUIT_MessageBox::warning
1909 (SMESHGUI::desktop(),
1910 QObject::tr("SMESH_WRN_WARNING"),
1911 QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
1912 SUIT_MessageBox::Yes | SUIT_MessageBox::No,
1913 SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
1916 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1918 // Put the whole hierarchy of sub-objects of the selected SO's into a list and
1919 // then treat them all starting from the deepest objects (at list back)
1920 std::list< _PTR(SObject) > listSO;
1921 SALOME_ListIteratorOfListIO It(selected);
1922 for( ; It.More(); It.Next()) // loop on selected IO's
1924 Handle(SALOME_InteractiveObject) IObject = It.Value();
1925 if(IObject->hasEntry()) {
1926 _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
1928 // disable removal of "SMESH" component object
1929 if(aSO->FindAttribute(anAttr, "AttributeIOR")){
1931 if ( engineIOR() == anIOR->Value().c_str() )
1934 //Check the referenced object
1935 _PTR(SObject) aRefSObject;
1936 if ( aSO && aSO->ReferencedObject( aRefSObject ) )
1937 aSO = aRefSObject; // Delete main Object instead of reference
1939 listSO.push_back( aSO );
1940 std::list< _PTR(SObject) >::iterator itSO = --listSO.end();
1941 for ( ; itSO != listSO.end(); ++itSO ) {
1942 _PTR(ChildIterator) it = aStudy->NewChildIterator( *itSO );
1943 for (it->InitEx(false); it->More(); it->Next())
1944 listSO.push_back( it->Value() );
1948 // Check if none of objects to delete is referred from outside
1949 std::list< _PTR(SObject) >::reverse_iterator ritSO;
1950 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1952 _PTR(SObject) SO = *ritSO;
1953 if ( !SO ) continue;
1954 std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( *ritSO );
1955 for (size_t i = 0; i < aReferences.size(); i++) {
1956 _PTR(SComponent) aComponent = aReferences[i]->GetFatherComponent();
1957 std::string type = aComponent->ComponentDataType();
1958 if ( type != "SMESH" )
1960 SUIT_MessageBox::warning( anApp->desktop(),
1961 QObject::tr("WRN_WARNING"),
1962 QObject::tr("DEP_OBJECT") );
1963 return; // outside SMESH, there is an object depending on a SMESH object
1968 // Call mesh->Clear() to prevent loading mesh from file caused by hypotheses removal
1969 for( It.Initialize( selected ); It.More(); It.Next()) // loop on selected IO's
1971 Handle(SALOME_InteractiveObject) IObject = It.Value();
1972 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface< SMESH::SMESH_Mesh >( IObject );
1973 if ( !mesh->_is_nil() )
1977 // Treat SO's in the list starting from the back
1978 aStudyBuilder->NewCommand(); // There is a transaction
1979 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1981 _PTR(SObject) SO = *ritSO;
1982 if ( !SO ) continue;
1983 std::string anEntry = SO->GetID();
1985 /** Erase graphical object and remove all its data **/
1986 if(SO->FindAttribute(anAttr, "AttributeIOR")) {
1987 SMESH::RemoveVisualObjectWithActors( anEntry.c_str(), true);
1989 /** Remove an object from data structures **/
1990 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
1991 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
1992 if ( !aGroup->_is_nil() ) { // DELETE GROUP
1993 SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
1994 aMesh->RemoveGroup( aGroup );
1996 else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
1997 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
1998 aMesh->RemoveSubMesh( aSubMesh );
2001 Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
2002 ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
2003 QString objType = CheckTypeObject(IObject);
2004 if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
2005 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
2006 aStudyBuilder->RemoveObjectWithChildren( SO );
2008 else {// default action: remove SObject from the study
2009 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
2010 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
2012 aStudyBuilder->RemoveObjectWithChildren( SO );
2016 } /* listSO back loop */
2018 aStudyBuilder->CommitCommand();
2020 /* Clear any previous selection */
2022 aSel->setSelectedObjects( l1 );
2024 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
2028 SMESHGUI_EXPORT CAM_Module* createModule()
2030 return new SMESHGUI();
2033 SMESHGUI_EXPORT char* getModuleVersion() {
2034 return (char*)SMESH_VERSION_STR;
2038 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
2040 //=============================================================================
2044 //=============================================================================
2045 SMESHGUI::SMESHGUI() :
2046 SalomeApp_Module( "SMESH" )
2048 if ( CORBA::is_nil( myComponentSMESH ) )
2050 CORBA::Boolean anIsEmbeddedMode;
2051 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
2052 //MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
2054 // 0019923: EDF 765 SMESH : default values of hypothesis
2055 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
2056 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
2057 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
2058 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
2059 myComponentSMESH->SetDefaultNbSegments( nbSeg );
2061 const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif", "default_grp_color" };
2062 for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
2063 if ( aResourceMgr->hasValue( "SMESH", options[i] ))
2065 QString val = aResourceMgr->stringValue( "SMESH", options[i] );
2066 myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
2070 myActiveDialogBox = 0;
2071 myFilterLibraryDlg = 0;
2075 myEventCallbackCommand = vtkCallbackCommand::New();
2076 myEventCallbackCommand->Delete();
2077 myEventCallbackCommand->SetClientData( this );
2078 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
2081 /* load resources for all available meshers */
2082 SMESH::InitAvailableHypotheses();
2085 //=============================================================================
2089 //=============================================================================
2090 SMESHGUI::~SMESHGUI()
2094 //=============================================================================
2098 //=============================================================================
2099 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
2101 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2103 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
2108 //=============================================================================
2112 //=============================================================================
2113 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
2115 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2119 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2120 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2121 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2122 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2123 return autoUpdate && !exceeded;
2126 //=============================================================================
2130 //=============================================================================
2131 bool SMESHGUI::automaticUpdate( SMESH::SMESH_IDSource_ptr theMesh,
2132 int* entities, bool* limitExceeded, int* hidden, long* nbElements )
2134 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2138 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2139 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2140 bool incrementalLimit = resMgr->booleanValue( "SMESH", "incremental_limit", false );
2142 SMESH::long_array_var info = theMesh->GetMeshInfo();
2143 long nbOdElems = info[SMDSEntity_0D];
2144 long nbEdges = info[SMDSEntity_Edge] + info[SMDSEntity_Quad_Edge];
2145 long nbFaces = info[SMDSEntity_Triangle] + info[SMDSEntity_Quad_Triangle] + info[SMDSEntity_BiQuad_Triangle] +
2146 info[SMDSEntity_Quadrangle] + info[SMDSEntity_Quad_Quadrangle] + info[SMDSEntity_BiQuad_Quadrangle] +
2147 info[SMDSEntity_Polygon] + info[SMDSEntity_Quad_Polygon];
2148 long nbVolumes = info[SMDSEntity_Tetra] + info[SMDSEntity_Quad_Tetra] +
2149 info[SMDSEntity_Hexa] + info[SMDSEntity_Quad_Hexa] + info[SMDSEntity_TriQuad_Hexa] +
2150 info[SMDSEntity_Pyramid] + info[SMDSEntity_Quad_Pyramid] +
2151 info[SMDSEntity_Penta] + info[SMDSEntity_Quad_Penta] + info[SMDSEntity_BiQuad_Penta] +
2152 info[SMDSEntity_Polyhedra] +
2153 info[SMDSEntity_Hexagonal_Prism];
2154 long nbBalls = info[SMDSEntity_Ball];
2156 long requestedSize = nbOdElems + nbBalls + nbEdges + nbFaces + nbVolumes;
2157 *nbElements = requestedSize;
2159 *entities = SMESH_Actor::eAllEntity;
2162 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2164 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2166 if ( incrementalLimit ) {
2169 if ( nbOdElems > 0 ) {
2170 if ( total + nbOdElems > updateLimit ) {
2171 *entities = *entities & ~SMESH_Actor::e0DElements;
2172 *hidden = *hidden | SMESH_Actor::e0DElements;
2179 if ( nbEdges > 0 ) {
2180 if ( total + nbEdges > updateLimit ) {
2181 *entities = *entities & ~SMESH_Actor::eEdges;
2182 *hidden = *hidden | SMESH_Actor::eEdges;
2189 if ( nbFaces > 0 ) {
2190 if ( total + nbFaces > updateLimit ) {
2191 *entities = *entities & ~SMESH_Actor::eFaces;
2192 *hidden = *hidden | SMESH_Actor::eFaces;
2199 if ( nbVolumes > 0 ) {
2200 if ( total + nbVolumes > updateLimit ) {
2201 *entities = *entities & ~SMESH_Actor::eVolumes;
2202 *hidden = *hidden | SMESH_Actor::eVolumes;
2209 if ( nbBalls > 0 ) {
2210 if ( total + nbBalls > updateLimit ) {
2211 *entities = *entities & ~SMESH_Actor::eBallElem;
2212 *hidden = *hidden | SMESH_Actor::eBallElem;
2220 return autoUpdate && !exceeded;
2223 //=============================================================================
2227 //=============================================================================
2228 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
2230 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
2233 //=============================================================================
2237 //=============================================================================
2238 SMESHGUI* SMESHGUI::GetSMESHGUI()
2240 SMESHGUI* smeshMod = 0;
2241 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
2244 CAM_Module* module = app->module( "Mesh" );
2245 smeshMod = dynamic_cast<SMESHGUI*>( module );
2253 Standard_EXPORT SMESHGUI* GetComponentGUI()
2255 return SMESHGUI::GetSMESHGUI();
2259 //=============================================================================
2263 //=============================================================================
2264 void SMESHGUI::SetState(int aState)
2269 //=============================================================================
2273 //=============================================================================
2274 void SMESHGUI::ResetState()
2279 //=============================================================================
2283 //=============================================================================
2284 void SMESHGUI::EmitSignalDeactivateDialog()
2286 emit SignalDeactivateActiveDialog();
2289 //=============================================================================
2293 //=============================================================================
2294 void SMESHGUI::EmitSignalStudyFrameChanged()
2296 emit SignalStudyFrameChanged();
2299 //=============================================================================
2303 //=============================================================================
2304 void SMESHGUI::EmitSignalCloseAllDialogs()
2306 emit SignalCloseAllDialogs();
2309 //=============================================================================
2313 //=============================================================================
2314 void SMESHGUI::EmitSignalVisibilityChanged()
2316 emit SignalVisibilityChanged();
2319 //=============================================================================
2323 //=============================================================================
2324 void SMESHGUI::EmitSignalCloseView()
2326 emit SignalCloseView();
2329 //=============================================================================
2333 //=============================================================================
2334 void SMESHGUI::EmitSignalActivatedViewManager()
2336 emit SignalActivatedViewManager();
2339 //=============================================================================
2343 //=============================================================================
2344 QDialog *SMESHGUI::GetActiveDialogBox()
2346 return myActiveDialogBox;
2349 //=============================================================================
2353 //=============================================================================
2354 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2356 myActiveDialogBox = (QDialog *) aDlg;
2360 //=============================================================================
2364 //=============================================================================
2365 SUIT_Desktop* SMESHGUI::desktop()
2367 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2369 return app->desktop();
2374 //=============================================================================
2378 //=============================================================================
2379 SalomeApp_Study* SMESHGUI::activeStudy()
2381 SUIT_Application* app = SUIT_Session::session()->activeApplication();
2383 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2388 //=============================================================================
2392 //=============================================================================
2393 void SMESHGUI::Modified( bool theIsUpdateActions )
2395 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2396 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2397 appStudy->Modified();
2398 if( theIsUpdateActions )
2399 app->updateActions();
2404 //=============================================================================
2408 //=============================================================================
2409 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2411 /* Here the position is on the bottom right corner - 10 */
2412 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2414 SUIT_Desktop *PP = desktop();
2415 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2416 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2421 * \brief Verifies whether study of operation is locked
2422 * \param theMess - specifies whether message box must be shown if study is locked
2423 * \return State of study.
2425 * Verifies whether study of operation is locked. If second parameter is TRUE and study
2426 * is locked when corresponding message box appears
2428 bool SMESHGUI::isStudyLocked( bool theMessage )
2430 if ( SMESH::getStudy()->GetProperties()->IsLocked() )
2433 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2434 QObject::tr( "WRN_WARNING" ),
2435 QObject::tr( "WRN_STUDY_LOCKED" ) );
2441 //=============================================================================
2445 //=============================================================================
2446 bool SMESHGUI::OnGUIEvent( int theCommandID )
2448 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2452 SUIT_ResourceMgr* mgr = resourceMgr();
2456 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2457 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2459 //QAction* act = action( theCommandID );
2461 switch (theCommandID) {
2462 case SMESHOp::OpDelete:
2463 if(isStudyLocked()) break;
2466 case SMESHOp::OpImportDAT:
2467 case SMESHOp::OpImportUNV:
2468 case SMESHOp::OpImportMED:
2469 case SMESHOp::OpImportSTL:
2470 case SMESHOp::OpImportCGNS:
2471 case SMESHOp::OpImportSAUV:
2472 case SMESHOp::OpImportGMF:
2473 case SMESHOp::OpPopupImportDAT:
2474 case SMESHOp::OpPopupImportUNV:
2475 case SMESHOp::OpPopupImportMED:
2476 case SMESHOp::OpPopupImportSTL:
2477 case SMESHOp::OpPopupImportCGNS:
2478 case SMESHOp::OpPopupImportSAUV:
2479 case SMESHOp::OpPopupImportGMF:
2481 if(isStudyLocked()) break;
2482 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2486 case SMESHOp::OpFileInformation:
2488 SALOME_ListIO selected;
2489 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2491 aSel->selectedObjects( selected );
2492 if( selected.Extent() )
2494 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2495 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2496 if ( !aMesh->_is_nil() )
2498 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2504 case SMESHOp::OpExportDAT:
2505 case SMESHOp::OpExportMED:
2506 case SMESHOp::OpExportUNV:
2507 case SMESHOp::OpExportSTL:
2508 case SMESHOp::OpExportCGNS:
2509 case SMESHOp::OpExportSAUV:
2510 case SMESHOp::OpExportGMF:
2511 case SMESHOp::OpPopupExportDAT:
2512 case SMESHOp::OpPopupExportMED:
2513 case SMESHOp::OpPopupExportUNV:
2514 case SMESHOp::OpPopupExportSTL:
2515 case SMESHOp::OpPopupExportCGNS:
2516 case SMESHOp::OpPopupExportSAUV:
2517 case SMESHOp::OpPopupExportGMF:
2519 ::ExportMeshToFile(theCommandID);
2523 case SMESHOp::OpReset: // SCALAR BAR
2525 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2526 SALOME_ListIO selected;
2528 aSel->selectedObjects( selected );
2530 SALOME_ListIteratorOfListIO it(selected);
2531 for( ; it.More(); it.Next()) {
2532 Handle(SALOME_InteractiveObject) anIO = it.Value();
2533 if( anIO->hasEntry() ) {
2534 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2535 anActor->SetControlMode( SMESH_Actor::eNone );
2536 #ifndef DISABLE_PLOT2DVIEWER
2537 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2542 SMESH::UpdateView();
2545 case SMESHOp::OpScalarBarProperties:
2547 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2550 case SMESHOp::OpShowScalarBar:
2552 // show/hide scalar bar
2553 ::ShowElement(theCommandID);
2556 case SMESHOp::OpSaveDistribution:
2558 // dump control distribution data to the text file
2559 ::SaveDistribution();
2563 case SMESHOp::OpShowDistribution:
2565 // show/hide distribution
2566 ::ShowElement(theCommandID);
2570 #ifndef DISABLE_PLOT2DVIEWER
2571 case SMESHOp::OpPlotDistribution:
2573 // plot distribution
2574 ::PlotDistribution();
2580 case SMESHOp::OpAutoColor:
2584 case SMESHOp::OpDisableAutoColor:
2585 ::DisableAutoColor();
2588 case SMESHOp::OpClipping:
2589 case SMESHOp::OpTransparency:
2590 case SMESHOp::OpProperties: // Display preferences (colors, shrink size, line width, ...)
2593 case SMESHOp::OpDMWireframe:
2594 case SMESHOp::OpDMShading:
2595 case SMESHOp::OpDMNodes:
2596 case SMESHOp::OpDMShrink:
2597 ::SetDisplayMode(theCommandID, myMarkerMap);
2600 //2D quadratic representation
2601 case SMESHOp::OpRepresentationLines:
2602 case SMESHOp::OpRepresentationArcs:
2603 ::SetDisplayMode(theCommandID, myMarkerMap);
2607 case SMESHOp::OpDE0DElements:
2608 case SMESHOp::OpDEEdges:
2609 case SMESHOp::OpDEFaces:
2610 case SMESHOp::OpDEVolumes:
2611 case SMESHOp::OpDEBalls:
2612 case SMESHOp::OpDEAllEntity:
2613 ::SetDisplayEntity(theCommandID);
2616 // Choose entities to be displayed
2617 case SMESHOp::OpDEChoose:
2619 ( new SMESHGUI_DisplayEntitiesDlg( SMESHGUI::desktop() ) )->exec();
2623 case SMESHOp::OpOrientationOnFaces:
2625 SUIT_OverrideCursor wc;
2626 LightApp_SelectionMgr* mgr = selectionMgr();
2627 SALOME_ListIO selected; mgr->selectedObjects( selected );
2629 SALOME_ListIteratorOfListIO it(selected);
2630 for( ; it.More(); it.Next()) {
2631 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2632 if(anIObject->hasEntry()) {
2633 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2634 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2641 case SMESHOp::OpUpdate:
2643 if(isStudyLocked()) break;
2644 SUIT_OverrideCursor wc;
2647 SMESH::UpdateView();
2649 catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2650 SMESH::OnVisuException();
2652 catch (...) { // PAL16774 (Crash after display of many groups)
2653 SMESH::OnVisuException();
2657 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2658 aSel->selectedObjects( l );
2659 aSel->setSelectedObjects( l );
2663 case SMESHOp::OpHide:
2664 case SMESHOp::OpShow:
2665 case SMESHOp::OpShowOnly:
2667 SUIT_OverrideCursor wc;
2668 SMESH::EDisplaing anAction;
2669 switch (theCommandID) {
2670 case SMESHOp::OpHide: anAction = SMESH::eErase; break;
2671 case SMESHOp::OpShow: anAction = SMESH::eDisplay; break;
2672 case SMESHOp::OpShowOnly: anAction = SMESH::eDisplayOnly; break;
2675 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2676 SALOME_ListIO sel_objects, to_process;
2678 aSel->selectedObjects( sel_objects );
2680 if ( theCommandID==SMESHOp::OpShowOnly )
2682 //MESSAGE("anAction = SMESH::eDisplayOnly");
2683 startOperation( myEraseAll );
2686 extractContainers( sel_objects, to_process );
2691 SALOME_ListIteratorOfListIO It( to_process );
2692 for ( ; It.More(); It.Next())
2694 Handle(SALOME_InteractiveObject) IOS = It.Value();
2695 if ( IOS->hasEntry() )
2697 if ( !SMESH::UpdateView( anAction, IOS->getEntry() )) {
2698 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2699 break; // PAL16774 (Crash after display of many groups)
2701 if (anAction == SMESH::eDisplayOnly)
2702 anAction = SMESH::eDisplay;
2707 // PAL13338 + PAL15161 -->
2708 if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !isStudyLocked()) {
2709 SMESH::UpdateView();
2710 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2712 // PAL13338 + PAL15161 <--
2714 catch (...) { // PAL16774 (Crash after display of many groups)
2715 SMESH::OnVisuException();
2718 if (anAction == SMESH::eErase) {
2720 aSel->setSelectedObjects( l1 );
2723 aSel->setSelectedObjects( to_process );
2728 case SMESHOp::OpNode:
2730 if(isStudyLocked()) break;
2733 EmitSignalDeactivateDialog();
2735 ( new SMESHGUI_NodesDlg( this ) )->show();
2738 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"),tr("SMESH_WRN_VIEWER_VTK"));
2743 case SMESHOp::OpCreateMesh:
2744 case SMESHOp::OpCreateSubMesh:
2745 case SMESHOp::OpEditMeshOrSubMesh:
2746 case SMESHOp::OpEditMesh:
2747 case SMESHOp::OpEditSubMesh:
2748 case SMESHOp::OpCompute:
2749 case SMESHOp::OpComputeSubMesh:
2750 case SMESHOp::OpPreCompute:
2751 case SMESHOp::OpEvaluate:
2752 case SMESHOp::OpMeshOrder:
2753 startOperation( theCommandID );
2755 case SMESHOp::OpCopyMesh:
2757 if (isStudyLocked()) break;
2758 EmitSignalDeactivateDialog();
2759 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2762 case SMESHOp::OpBuildCompoundMesh:
2764 if (isStudyLocked()) break;
2765 EmitSignalDeactivateDialog();
2766 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2770 case SMESHOp::OpDiagonalInversion:
2771 case SMESHOp::OpUnionOfTwoTriangle:
2775 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2779 if ( isStudyLocked() )
2782 /*Standard_Boolean aRes;
2783 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2784 if ( aMesh->_is_nil() )
2786 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2787 tr( "SMESH_BAD_SELECTION" ) );
2791 EmitSignalDeactivateDialog();
2792 if ( theCommandID == SMESHOp::OpDiagonalInversion )
2793 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2795 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2798 case SMESHOp::OpOrientation:
2799 case SMESHOp::OpUnionOfTriangles:
2800 case SMESHOp::OpCuttingOfQuadrangles:
2801 case SMESHOp::OpSplitVolumes:
2805 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2809 if ( isStudyLocked() )
2812 EmitSignalDeactivateDialog();
2813 SMESHGUI_MultiEditDlg* aDlg = NULL;
2814 if ( theCommandID == SMESHOp::OpOrientation )
2815 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2816 else if ( theCommandID == SMESHOp::OpUnionOfTriangles )
2817 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2818 else if ( theCommandID == SMESHOp::OpSplitVolumes )
2819 aDlg = new SMESHGUI_SplitVolumesDlg(this);
2821 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2826 case SMESHOp::OpSmoothing:
2828 if(isStudyLocked()) break;
2830 EmitSignalDeactivateDialog();
2831 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2834 SUIT_MessageBox::warning(desktop(), tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2838 case SMESHOp::OpExtrusion:
2840 if (isStudyLocked()) break;
2842 EmitSignalDeactivateDialog();
2843 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2845 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2849 case SMESHOp::OpExtrusionAlongAPath:
2851 if (isStudyLocked()) break;
2853 EmitSignalDeactivateDialog();
2854 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2856 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2860 case SMESHOp::OpRevolution:
2862 if(isStudyLocked()) break;
2864 EmitSignalDeactivateDialog();
2865 ( new SMESHGUI_RevolutionDlg( this ) )->show();
2868 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2872 case SMESHOp::OpPatternMapping:
2874 if ( isStudyLocked() )
2878 EmitSignalDeactivateDialog();
2879 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2882 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2886 case SMESHOp::OpSplitBiQuadratic:
2887 case SMESHOp::OpConvertMeshToQuadratic:
2888 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
2889 case SMESHOp::OpReorientFaces:
2890 case SMESHOp::OpCreateGeometryGroup:
2892 startOperation( theCommandID );
2895 case SMESHOp::OpCreateGroup:
2899 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2903 if(isStudyLocked()) break;
2904 EmitSignalDeactivateDialog();
2905 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2907 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2908 SALOME_ListIO selected;
2910 aSel->selectedObjects( selected );
2912 int nbSel = selected.Extent();
2914 // check if mesh is selected
2915 aMesh = SMESH::GetMeshByIO( selected.First() );
2917 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2922 case SMESHOp::OpConstructGroup:
2926 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2930 if(isStudyLocked()) break;
2931 EmitSignalDeactivateDialog();
2933 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2934 SALOME_ListIO selected;
2936 aSel->selectedObjects( selected );
2938 int nbSel = selected.Extent();
2940 // check if submesh is selected
2941 Handle(SALOME_InteractiveObject) IObject = selected.First();
2942 if (IObject->hasEntry()) {
2943 _PTR(SObject) aSObj = SMESH::getStudy()->FindObjectID(IObject->getEntry());
2945 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2946 if (!aSubMesh->_is_nil()) {
2948 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2949 // get submesh elements list by types
2950 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2951 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2952 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2953 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2954 // create group for each type o elements
2955 QString aName = IObject->getName();
2956 QStringList anEntryList;
2957 if (aNodes->length() > 0) {
2958 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2959 aGroup->Add(aNodes.inout());
2960 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2961 anEntryList.append( aSObject->GetID().c_str() );
2963 if (aEdges->length() > 0) {
2964 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2965 aGroup->Add(aEdges.inout());
2966 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2967 anEntryList.append( aSObject->GetID().c_str() );
2969 if (aFaces->length() > 0) {
2970 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2971 aGroup->Add(aFaces.inout());
2972 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2973 anEntryList.append( aSObject->GetID().c_str() );
2975 if (aVolumes->length() > 0) {
2976 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2977 aGroup->Add(aVolumes.inout());
2978 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2979 anEntryList.append( aSObject->GetID().c_str() );
2982 anApp->browseObjects( anEntryList );
2984 catch(const SALOME::SALOME_Exception & S_ex){
2985 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2992 SUIT_MessageBox::warning(desktop(),
2993 tr("SMESH_WRN_WARNING"),
2994 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
2999 case SMESHOp::OpEditGroup:
3003 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3007 if(isStudyLocked()) break;
3008 EmitSignalDeactivateDialog();
3010 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3011 SALOME_ListIO selected;
3013 aSel->selectedObjects( selected );
3015 SALOME_ListIteratorOfListIO It (selected);
3016 int nbSelectedGroups = 0;
3017 for ( ; It.More(); It.Next() )
3019 SMESH::SMESH_GroupBase_var aGroup =
3020 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
3021 if (!aGroup->_is_nil()) {
3023 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
3027 if (nbSelectedGroups == 0)
3029 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
3035 case SMESHOp::OpAddElemGroupPopup: // Add elements to group
3037 if(isStudyLocked()) break;
3038 if (myState == 800) {
3039 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3040 if (aDlg) aDlg->onAdd();
3045 case SMESHOp::OpRemoveElemGroupPopup: // Remove elements from group
3047 if(isStudyLocked()) break;
3048 if (myState == 800) {
3049 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3050 if (aDlg) aDlg->onRemove();
3055 case SMESHOp::OpEditGeomGroupAsGroup:
3059 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3063 if(isStudyLocked()) break;
3064 EmitSignalDeactivateDialog();
3066 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3067 SALOME_ListIO selected;
3069 aSel->selectedObjects( selected );
3071 SALOME_ListIteratorOfListIO It (selected);
3072 for ( ; It.More(); It.Next() )
3074 SMESH::SMESH_GroupOnGeom_var aGroup =
3075 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
3076 if (!aGroup->_is_nil()) {
3077 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3082 SMESH::SMESH_GroupOnFilter_var aGroup =
3083 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
3084 if (!aGroup->_is_nil()) {
3085 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3093 case SMESHOp::OpUnionGroups:
3094 case SMESHOp::OpIntersectGroups:
3095 case SMESHOp::OpCutGroups:
3099 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3103 if ( isStudyLocked() )
3106 EmitSignalDeactivateDialog();
3108 SMESHGUI_GroupOpDlg* aDlg = 0;
3109 if ( theCommandID == SMESHOp::OpUnionGroups )
3110 aDlg = new SMESHGUI_UnionGroupsDlg( this );
3111 else if ( theCommandID == SMESHOp::OpIntersectGroups )
3112 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3114 aDlg = new SMESHGUI_CutGroupsDlg( this );
3121 case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
3123 if ( isStudyLocked() )
3126 EmitSignalDeactivateDialog();
3127 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3133 case SMESHOp::OpDeleteGroup: // Delete groups with their contents
3137 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3141 if ( isStudyLocked() )
3144 EmitSignalDeactivateDialog();
3146 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3150 case SMESHOp::OpMeshInformation:
3151 case SMESHOp::OpWhatIs:
3153 int page = theCommandID == SMESHOp::OpMeshInformation ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3154 EmitSignalDeactivateDialog();
3155 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3156 SALOME_ListIO selected;
3158 aSel->selectedObjects( selected );
3160 if ( selected.Extent() > 1 ) { // a dlg for each IO
3161 SALOME_ListIteratorOfListIO It( selected );
3162 for ( ; It.More(); It.Next() ) {
3163 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3164 dlg->showInfo( It.Value() );
3169 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3175 case SMESHOp::OpFindElementByPoint:
3177 startOperation( theCommandID );
3181 case SMESHOp::OpEditHypothesis:
3183 if(isStudyLocked()) break;
3185 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3186 SALOME_ListIO selected;
3188 aSel->selectedObjects( selected );
3190 int nbSel = selected.Extent();
3193 Handle(SALOME_InteractiveObject) anIObject = selected.First();
3194 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3196 if ( !aHypothesis->_is_nil() )
3198 SMESHGUI_GenericHypothesisCreator* aCreator =
3199 SMESH::GetHypothesisCreator( SMESH::toQStr( aHypothesis->GetName() ));
3202 // set geometry of mesh and sub-mesh to aCreator
3203 aSel->selectedObjects( selected, "", /*convertReferences=*/false);
3204 if ( selected.Extent() == 1 )
3206 QString subGeomID, meshGeomID;
3207 Handle(SALOME_InteractiveObject) hypIO = selected.First();
3208 if ( SMESH::GetGeomEntries( hypIO, subGeomID, meshGeomID ))
3210 if ( subGeomID.isEmpty() ) subGeomID = meshGeomID;
3211 aCreator->setShapeEntry( subGeomID );
3212 aCreator->setMainShapeEntry( meshGeomID );
3216 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3226 case SMESHOp::OpUnassign: // REMOVE HYPOTHESIS / ALGORITHMS
3228 if(isStudyLocked()) break;
3229 SUIT_OverrideCursor wc;
3231 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3232 SALOME_ListIO selected;
3234 aSel->selectedObjects( selected, QString::null, false );
3236 SALOME_ListIteratorOfListIO It(selected);
3237 for (int i = 0; It.More(); It.Next(), i++) {
3238 Handle(SALOME_InteractiveObject) IObject = It.Value();
3239 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3242 aSel->setSelectedObjects( l1 );
3247 case SMESHOp::OpElem0D:
3248 case SMESHOp::OpBall:
3249 case SMESHOp::OpEdge:
3250 case SMESHOp::OpTriangle:
3251 case SMESHOp::OpQuadrangle:
3252 case SMESHOp::OpPolygon:
3253 case SMESHOp::OpTetrahedron:
3254 case SMESHOp::OpHexahedron:
3255 case SMESHOp::OpPentahedron:
3256 case SMESHOp::OpPyramid:
3257 case SMESHOp::OpHexagonalPrism:
3259 if(isStudyLocked()) break;
3261 EmitSignalDeactivateDialog();
3262 SMDSAbs_EntityType type = SMDSEntity_Edge;
3263 switch (theCommandID) {
3264 case SMESHOp::OpElem0D: type = SMDSEntity_0D; break;
3265 case SMESHOp::OpBall: type = SMDSEntity_Ball; break;
3266 case SMESHOp::OpTriangle: type = SMDSEntity_Triangle; break;
3267 case SMESHOp::OpQuadrangle: type = SMDSEntity_Quadrangle; break;
3268 case SMESHOp::OpTetrahedron: type = SMDSEntity_Tetra; break;
3269 case SMESHOp::OpPolygon: type = SMDSEntity_Polygon; break;
3270 case SMESHOp::OpHexahedron: type = SMDSEntity_Hexa; break;
3271 case SMESHOp::OpPentahedron: type = SMDSEntity_Penta; break;
3272 case SMESHOp::OpPyramid: type = SMDSEntity_Pyramid; break;
3273 case SMESHOp::OpHexagonalPrism: type = SMDSEntity_Hexagonal_Prism; break;
3276 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3279 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3283 case SMESHOp::OpPolyhedron:
3285 if(isStudyLocked()) break;
3287 EmitSignalDeactivateDialog();
3288 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3291 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3295 case SMESHOp::OpQuadraticEdge:
3296 case SMESHOp::OpQuadraticTriangle:
3297 case SMESHOp::OpBiQuadraticTriangle:
3298 case SMESHOp::OpQuadraticQuadrangle:
3299 case SMESHOp::OpBiQuadraticQuadrangle:
3300 case SMESHOp::OpQuadraticPolygon:
3301 case SMESHOp::OpQuadraticTetrahedron:
3302 case SMESHOp::OpQuadraticPyramid:
3303 case SMESHOp::OpQuadraticPentahedron:
3304 case SMESHOp::OpBiQuadraticPentahedron:
3305 case SMESHOp::OpQuadraticHexahedron:
3306 case SMESHOp::OpTriQuadraticHexahedron:
3308 if(isStudyLocked()) break;
3310 EmitSignalDeactivateDialog();
3311 SMDSAbs_EntityType type = SMDSEntity_Last;
3313 switch (theCommandID) {
3314 case SMESHOp::OpQuadraticEdge: type = SMDSEntity_Quad_Edge; break;
3315 case SMESHOp::OpQuadraticTriangle: type = SMDSEntity_Quad_Triangle; break;
3316 case SMESHOp::OpBiQuadraticTriangle: type = SMDSEntity_BiQuad_Triangle; break;
3317 case SMESHOp::OpQuadraticQuadrangle: type = SMDSEntity_Quad_Quadrangle; break;
3318 case SMESHOp::OpBiQuadraticQuadrangle: type = SMDSEntity_BiQuad_Quadrangle; break;
3319 case SMESHOp::OpQuadraticPolygon: type = SMDSEntity_Quad_Polygon; break;
3320 case SMESHOp::OpQuadraticTetrahedron: type = SMDSEntity_Quad_Tetra; break;
3321 case SMESHOp::OpQuadraticPyramid: type = SMDSEntity_Quad_Pyramid; break;
3322 case SMESHOp::OpQuadraticPentahedron: type = SMDSEntity_Quad_Penta; break;
3323 case SMESHOp::OpBiQuadraticPentahedron: type = SMDSEntity_BiQuad_Penta; break;
3324 case SMESHOp::OpQuadraticHexahedron: type = SMDSEntity_Quad_Hexa; break;
3325 case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
3328 if ( type != SMDSEntity_Last )
3329 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3332 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3333 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3337 case SMESHOp::OpRemoveNodes:
3339 if(isStudyLocked()) break;
3341 EmitSignalDeactivateDialog();
3342 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3345 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3346 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3350 case SMESHOp::OpRemoveElements: // REMOVES ELEMENTS
3352 if(isStudyLocked()) break;
3354 EmitSignalDeactivateDialog();
3355 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3359 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3360 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3364 case SMESHOp::OpClearMesh: {
3366 if(isStudyLocked()) break;
3368 SALOME_ListIO selected;
3369 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3370 aSel->selectedObjects( selected );
3372 SUIT_OverrideCursor wc;
3373 SALOME_ListIteratorOfListIO It (selected);
3374 for ( ; It.More(); It.Next() )
3376 Handle(SALOME_InteractiveObject) IOS = It.Value();
3377 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3378 if ( aMesh->_is_nil()) continue;
3381 if ( aMesh->NbNodes() == 0 ) // imported mesh is not empty
3382 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3383 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3384 // hide groups and submeshes
3385 _PTR(ChildIterator) anIter =
3386 SMESH::getStudy()->NewChildIterator( aMeshSObj );
3387 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3389 _PTR(SObject) so = anIter->Value();
3390 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3393 catch (const SALOME::SALOME_Exception& S_ex){
3395 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3399 SMESH::UpdateView();
3403 case SMESHOp::OpRemoveOrphanNodes:
3405 if(isStudyLocked()) break;
3406 SALOME_ListIO selected;
3407 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3408 aSel->selectedObjects( selected );
3409 if ( selected.Extent() == 1 ) {
3410 Handle(SALOME_InteractiveObject) anIO = selected.First();
3411 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3412 if ( !aMesh->_is_nil() ) {
3413 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3414 tr( "SMESH_WARNING" ),
3415 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3416 SUIT_MessageBox::Yes |
3417 SUIT_MessageBox::No,
3418 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3421 SUIT_OverrideCursor wc;
3422 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3423 int removed = aMeshEditor->RemoveOrphanNodes();
3424 SUIT_MessageBox::information(SMESHGUI::desktop(),
3425 tr("SMESH_INFORMATION"),
3426 tr("NB_NODES_REMOVED").arg(removed));
3427 if ( removed > 0 ) {
3428 SMESH::UpdateView();
3429 SMESHGUI::Modified();
3432 catch (const SALOME::SALOME_Exception& S_ex) {
3433 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3442 case SMESHOp::OpRenumberingNodes:
3444 if(isStudyLocked()) break;
3446 EmitSignalDeactivateDialog();
3447 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3451 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3452 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3456 case SMESHOp::OpRenumberingElements:
3458 if(isStudyLocked()) break;
3460 EmitSignalDeactivateDialog();
3461 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3465 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3466 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3470 case SMESHOp::OpTranslation:
3472 if(isStudyLocked()) break;
3474 EmitSignalDeactivateDialog();
3475 ( new SMESHGUI_TranslationDlg( this ) )->show();
3478 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3479 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3483 case SMESHOp::OpRotation:
3485 if(isStudyLocked()) break;
3487 EmitSignalDeactivateDialog();
3488 ( new SMESHGUI_RotationDlg( this ) )->show();
3491 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3492 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3496 case SMESHOp::OpSymmetry:
3498 if(isStudyLocked()) break;
3500 EmitSignalDeactivateDialog();
3501 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3504 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3505 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3509 case SMESHOp::OpScale:
3511 if(isStudyLocked()) break;
3513 EmitSignalDeactivateDialog();
3514 ( new SMESHGUI_ScaleDlg( this ) )->show();
3517 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3518 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3523 case SMESHOp::OpOffset:
3525 if(isStudyLocked()) break;
3527 EmitSignalDeactivateDialog();
3528 ( new SMESHGUI_OffsetDlg( this ) )->show();
3531 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3532 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3537 case SMESHOp::OpSewing:
3539 if(isStudyLocked()) break;
3541 EmitSignalDeactivateDialog();
3542 ( new SMESHGUI_SewingDlg( this ) )->show();
3545 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3546 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3550 case SMESHOp::OpMergeNodes:
3552 if(isStudyLocked()) break;
3554 EmitSignalDeactivateDialog();
3555 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3558 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3559 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3563 case SMESHOp::OpMergeElements:
3565 if (isStudyLocked()) break;
3567 EmitSignalDeactivateDialog();
3568 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3570 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3571 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3576 case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
3577 startOperation( SMESHOp::OpMoveNode );
3580 case SMESHOp::OpDuplicateNodes:
3582 if(isStudyLocked()) break;
3584 EmitSignalDeactivateDialog();
3585 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3588 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3589 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3594 case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
3595 startOperation( SMESHOp::OpElem0DOnElemNodes );
3598 case SMESHOp::OpSelectFiltersLibrary: // Library of selection filters
3600 static QList<int> aTypes;
3601 if ( aTypes.isEmpty() )
3603 aTypes.append( SMESH::NODE );
3604 aTypes.append( SMESH::EDGE );
3605 aTypes.append( SMESH::FACE );
3606 aTypes.append( SMESH::VOLUME );
3608 if (!myFilterLibraryDlg)
3609 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3610 else if (myFilterLibraryDlg->isHidden())
3611 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3612 myFilterLibraryDlg->raise();
3616 case SMESHOp::OpFreeNode:
3617 case SMESHOp::OpEqualNode:
3618 case SMESHOp::OpNodeConnectivityNb:
3619 case SMESHOp::OpFreeEdge:
3620 case SMESHOp::OpFreeBorder:
3621 case SMESHOp::OpLength:
3622 case SMESHOp::OpConnection:
3623 case SMESHOp::OpEqualEdge:
3624 case SMESHOp::OpFreeFace:
3625 case SMESHOp::OpBareBorderFace:
3626 case SMESHOp::OpOverConstrainedFace:
3627 case SMESHOp::OpLength2D:
3628 case SMESHOp::OpDeflection2D:
3629 case SMESHOp::OpConnection2D:
3630 case SMESHOp::OpArea:
3631 case SMESHOp::OpTaper:
3632 case SMESHOp::OpAspectRatio:
3633 case SMESHOp::OpMinimumAngle:
3634 case SMESHOp::OpWarpingAngle:
3635 case SMESHOp::OpSkew:
3636 case SMESHOp::OpMaxElementLength2D:
3637 case SMESHOp::OpEqualFace:
3638 case SMESHOp::OpAspectRatio3D:
3639 case SMESHOp::OpVolume:
3640 case SMESHOp::OpMaxElementLength3D:
3641 case SMESHOp::OpBareBorderVolume:
3642 case SMESHOp::OpOverConstrainedVolume:
3643 case SMESHOp::OpEqualVolume:
3646 LightApp_SelectionMgr* mgr = selectionMgr();
3647 SALOME_ListIO selected; mgr->selectedObjects( selected );
3649 if( !selected.IsEmpty() ) {
3650 SUIT_OverrideCursor wc;
3651 ::Control( theCommandID );
3654 SUIT_MessageBox::warning(desktop(),
3655 tr( "SMESH_WRN_WARNING" ),
3656 tr( "SMESH_BAD_SELECTION" ) );
3660 SUIT_MessageBox::warning(desktop(),
3661 tr( "SMESH_WRN_WARNING" ),
3662 tr( "NOT_A_VTK_VIEWER" ) );
3665 case SMESHOp::OpOverallMeshQuality:
3666 OverallMeshQuality();
3668 case SMESHOp::OpNumberingNodes:
3670 SUIT_OverrideCursor wc;
3671 LightApp_SelectionMgr* mgr = selectionMgr();
3672 SALOME_ListIO selected; mgr->selectedObjects( selected );
3674 SALOME_ListIteratorOfListIO it(selected);
3675 for( ; it.More(); it.Next()) {
3676 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3677 if(anIObject->hasEntry()) {
3678 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3679 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3685 case SMESHOp::OpNumberingElements:
3687 SUIT_OverrideCursor wc;
3688 LightApp_SelectionMgr* mgr = selectionMgr();
3689 SALOME_ListIO selected; mgr->selectedObjects( selected );
3691 SALOME_ListIteratorOfListIO it(selected);
3692 for( ; it.More(); it.Next()) {
3693 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3694 if(anIObject->hasEntry())
3695 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3696 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3701 case SMESHOp::OpPropertiesLength:
3702 case SMESHOp::OpPropertiesArea:
3703 case SMESHOp::OpPropertiesVolume:
3704 case SMESHOp::OpMinimumDistance:
3705 case SMESHOp::OpBoundingBox:
3707 int page = SMESHGUI_MeasureDlg::MinDistance;
3708 if ( theCommandID == SMESHOp::OpBoundingBox )
3709 page = SMESHGUI_MeasureDlg::BoundingBox;
3710 else if ( theCommandID == SMESHOp::OpPropertiesLength )
3711 page = SMESHGUI_MeasureDlg::Length;
3712 else if ( theCommandID == SMESHOp::OpPropertiesArea )
3713 page = SMESHGUI_MeasureDlg::Area;
3714 else if ( theCommandID == SMESHOp::OpPropertiesVolume )
3715 page = SMESHGUI_MeasureDlg::Volume;
3717 EmitSignalDeactivateDialog();
3718 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3722 case SMESHOp::OpSortChild:
3728 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3729 //updateObjBrowser();
3733 //=============================================================================
3737 //=============================================================================
3738 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3743 //=============================================================================
3747 //=============================================================================
3748 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3753 //=============================================================================
3757 //=============================================================================
3758 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3763 //=============================================================================
3764 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3765 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3767 //=============================================================================
3768 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3769 SUIT_ViewWindow* wnd )
3771 if(theIO->hasEntry()){
3772 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3773 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3777 //=======================================================================
3778 // function : createSMESHAction
3780 //=======================================================================
3781 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3782 const int key, const bool toggle, const QString& shortcutAction )
3785 QWidget* parent = application()->desktop();
3786 SUIT_ResourceMgr* resMgr = resourceMgr();
3788 if ( !icon_id.isEmpty() )
3789 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3791 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3792 if ( !pix.isNull() )
3793 icon = QIcon( pix );
3795 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3796 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3797 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3799 createAction( id, tooltip, icon, menu, status_bar, key, parent,
3800 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3803 //=======================================================================
3804 // function : createPopupItem
3806 //=======================================================================
3807 void SMESHGUI::createPopupItem( const int id,
3808 const QString& clients,
3809 const QString& types,
3810 const QString& theRule,
3813 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3814 popupMgr()->insert( action( id ), pId, 0 );
3816 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3817 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
3818 QString rule = "(%1) and (%2) and (%3)";
3819 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3820 if( clients.isEmpty() )
3821 rule = rule.arg( QString( "true" ) );
3823 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3824 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3827 bool cont = myRules.contains( id );
3829 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3831 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3832 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3835 //=======================================================================
3836 // function : initialize
3838 //=======================================================================
3839 void SMESHGUI::initialize( CAM_Application* app )
3841 SalomeApp_Module::initialize( app );
3843 // SUIT_ResourceMgr* mgr = app->resourceMgr();
3845 /* Automatic Update flag */
3846 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3848 // ----- create actions --------------
3850 //createSMESHAction( SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
3851 createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_I) );
3852 createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
3853 createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL" );
3855 createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
3857 createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
3858 createSMESHAction( SMESHOp::OpImportGMF, "IMPORT_GMF" );
3859 createSMESHAction( SMESHOp::OpPopupImportUNV, "IMPORT_UNV");
3860 createSMESHAction( SMESHOp::OpPopupImportMED, "IMPORT_MED");
3861 createSMESHAction( SMESHOp::OpPopupImportSTL, "IMPORT_STL" );
3863 createSMESHAction( SMESHOp::OpPopupImportCGNS, "IMPORT_CGNS" );
3865 createSMESHAction( SMESHOp::OpPopupImportSAUV, "IMPORT_SAUV" );
3866 createSMESHAction( SMESHOp::OpPopupImportGMF, "IMPORT_GMF" );
3868 createSMESHAction( SMESHOp::OpExportDAT, "DAT" );
3869 createSMESHAction( SMESHOp::OpExportMED, "MED" );
3870 createSMESHAction( SMESHOp::OpExportUNV, "UNV" );
3871 createSMESHAction( SMESHOp::OpExportSTL, "STL" );
3873 createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
3875 createSMESHAction( SMESHOp::OpExportSAUV, "SAUV");
3876 createSMESHAction( SMESHOp::OpExportGMF, "GMF" );
3877 createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
3878 createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
3879 createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
3880 createSMESHAction( SMESHOp::OpPopupExportSTL, "STL" );
3882 createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
3884 createSMESHAction( SMESHOp::OpPopupExportSAUV, "SAUV");
3885 createSMESHAction( SMESHOp::OpPopupExportGMF, "GMF" );
3886 createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
3887 createSMESHAction( SMESHOp::OpDelete, "DELETE", "ICON_DELETE", Qt::Key_Delete );
3888 createSMESHAction( SMESHOp::OpSelectFiltersLibrary, "SEL_FILTER_LIB" );
3889 createSMESHAction( SMESHOp::OpCreateMesh, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
3890 createSMESHAction( SMESHOp::OpCreateSubMesh, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
3891 createSMESHAction( SMESHOp::OpEditMeshOrSubMesh, "EDIT_MESHSUBMESH", "ICON_DLG_EDIT_MESH" );
3892 createSMESHAction( SMESHOp::OpEditMesh, "EDIT_MESH", "ICON_DLG_EDIT_MESH" );
3893 createSMESHAction( SMESHOp::OpEditSubMesh, "EDIT_SUBMESH", "ICON_DLG_EDIT_MESH" );
3894 createSMESHAction( SMESHOp::OpBuildCompoundMesh, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
3895 createSMESHAction( SMESHOp::OpCopyMesh, "COPY_MESH", "ICON_COPY_MESH" );
3896 createSMESHAction( SMESHOp::OpCompute, "COMPUTE", "ICON_COMPUTE" );
3897 createSMESHAction( SMESHOp::OpComputeSubMesh, "COMPUTE_SUBMESH", "ICON_COMPUTE" );
3898 createSMESHAction( SMESHOp::OpPreCompute, "PRECOMPUTE", "ICON_PRECOMPUTE" );
3899 createSMESHAction( SMESHOp::OpEvaluate, "EVALUATE", "ICON_EVALUATE" );
3900 createSMESHAction( SMESHOp::OpMeshOrder, "MESH_ORDER", "ICON_MESH_ORDER");
3901 createSMESHAction( SMESHOp::OpCreateGroup, "CREATE_GROUP", "ICON_CREATE_GROUP" );
3902 createSMESHAction( SMESHOp::OpCreateGeometryGroup, "CREATE_GEO_GROUP", "ICON_CREATE_GEO_GROUP" );
3903 createSMESHAction( SMESHOp::OpConstructGroup, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
3904 createSMESHAction( SMESHOp::OpEditGroup, "EDIT_GROUP", "ICON_EDIT_GROUP" );
3905 createSMESHAction( SMESHOp::OpEditGeomGroupAsGroup, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3906 createSMESHAction( SMESHOp::OpUnionGroups, "UN_GROUP", "ICON_UNION" );
3907 createSMESHAction( SMESHOp::OpIntersectGroups, "INT_GROUP", "ICON_INTERSECT" );
3908 createSMESHAction( SMESHOp::OpCutGroups, "CUT_GROUP", "ICON_CUT" );
3909 createSMESHAction( SMESHOp::OpGroupUnderlyingElem, "UNDERLYING_ELEMS", "ICON_UNDERLYING_ELEMS" );
3910 createSMESHAction( SMESHOp::OpAddElemGroupPopup, "ADD_TO_GROUP" );
3911 createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE_FROM_GROUP" );
3912 createSMESHAction( SMESHOp::OpDeleteGroup, "DEL_GROUP", "ICON_DEL_GROUP" );
3913 createSMESHAction( SMESHOp::OpMeshInformation , "ADV_INFO", "ICON_ADV_INFO" );
3914 //createSMESHAction( SMESHOp::OpStdInfo, "STD_INFO", "ICON_STD_INFO" );
3915 //createSMESHAction( SMESHOp::OpWhatIs, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3916 createSMESHAction( SMESHOp::OpFindElementByPoint, "FIND_ELEM", "ICON_FIND_ELEM" );
3918 createSMESHAction( SMESHOp::OpFreeNode, "FREE_NODE", "ICON_FREE_NODE", 0, true );
3919 createSMESHAction( SMESHOp::OpEqualNode, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
3920 createSMESHAction( SMESHOp::OpNodeConnectivityNb, "NODE_CONNECTIVITY_NB", "ICON_NODE_CONN_NB", 0, true );
3921 createSMESHAction( SMESHOp::OpFreeEdge, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
3922 createSMESHAction( SMESHOp::OpFreeBorder, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
3923 createSMESHAction( SMESHOp::OpLength, "LENGTH", "ICON_LENGTH", 0, true );
3924 createSMESHAction( SMESHOp::OpConnection, "CONNECTION", "ICON_CONNECTION", 0, true );
3925 createSMESHAction( SMESHOp::OpEqualEdge, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
3926 createSMESHAction( SMESHOp::OpFreeFace, "FREE_FACES", "ICON_FREE_FACES", 0, true );
3927 createSMESHAction( SMESHOp::OpBareBorderFace, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
3928 createSMESHAction( SMESHOp::OpOverConstrainedFace, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
3929 createSMESHAction( SMESHOp::OpLength2D, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
3930 createSMESHAction( SMESHOp::OpDeflection2D, "DEFLECTION_2D", "ICON_DEFLECTION_2D", 0, true );
3931 createSMESHAction( SMESHOp::OpConnection2D, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
3932 createSMESHAction( SMESHOp::OpArea, "AREA", "ICON_AREA", 0, true );
3933 createSMESHAction( SMESHOp::OpTaper, "TAPER", "ICON_TAPER", 0, true );
3934 createSMESHAction( SMESHOp::OpAspectRatio, "ASPECT", "ICON_ASPECT", 0, true );
3935 createSMESHAction( SMESHOp::OpMinimumAngle, "MIN_ANG", "ICON_ANGLE", 0, true );
3936 createSMESHAction( SMESHOp::OpWarpingAngle, "WARP", "ICON_WARP", 0, true );
3937 createSMESHAction( SMESHOp::OpSkew, "SKEW", "ICON_SKEW", 0, true );
3938 createSMESHAction( SMESHOp::OpMaxElementLength2D, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
3939 createSMESHAction( SMESHOp::OpEqualFace, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
3940 createSMESHAction( SMESHOp::OpAspectRatio3D, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
3941 createSMESHAction( SMESHOp::OpVolume, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
3942 createSMESHAction( SMESHOp::OpMaxElementLength3D, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
3943 createSMESHAction( SMESHOp::OpBareBorderVolume, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
3944 createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
3945 createSMESHAction( SMESHOp::OpEqualVolume, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
3946 createSMESHAction( SMESHOp::OpOverallMeshQuality, "OVERALL_MESH_QUALITY", "ICON_OVL_MESH_QUALITY" );
3948 createSMESHAction( SMESHOp::OpNode, "NODE", "ICON_DLG_NODE" );
3949 createSMESHAction( SMESHOp::OpElem0D, "ELEM0D", "ICON_DLG_ELEM0D" );
3950 createSMESHAction( SMESHOp::OpElem0DOnElemNodes, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
3951 createSMESHAction( SMESHOp::OpBall, "BALL", "ICON_DLG_BALL" );
3952 createSMESHAction( SMESHOp::OpEdge, "EDGE", "ICON_DLG_EDGE" );
3953 createSMESHAction( SMESHOp::OpTriangle, "TRIANGLE", "ICON_DLG_TRIANGLE" );
3954 createSMESHAction( SMESHOp::OpQuadrangle, "QUAD", "ICON_DLG_QUADRANGLE" );
3955 createSMESHAction( SMESHOp::OpPolygon, "POLYGON", "ICON_DLG_POLYGON" );
3956 createSMESHAction( SMESHOp::OpTetrahedron, "TETRA", "ICON_DLG_TETRAS" );
3957 createSMESHAction( SMESHOp::OpHexahedron, "HEXA", "ICON_DLG_HEXAS" );
3958 createSMESHAction( SMESHOp::OpPentahedron, "PENTA", "ICON_DLG_PENTA" );
3959 createSMESHAction( SMESHOp::OpPyramid , "PYRAMID", "ICON_DLG_PYRAMID" );
3960 createSMESHAction( SMESHOp::OpHexagonalPrism, "OCTA", "ICON_DLG_OCTA" );
3961 createSMESHAction( SMESHOp::OpPolyhedron, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
3962 createSMESHAction( SMESHOp::OpQuadraticEdge, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
3963 createSMESHAction( SMESHOp::OpQuadraticTriangle, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
3964 createSMESHAction( SMESHOp::OpBiQuadraticTriangle, "BIQUADRATIC_TRIANGLE", "ICON_DLG_BIQUADRATIC_TRIANGLE" );
3965 createSMESHAction( SMESHOp::OpQuadraticQuadrangle, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
3966 createSMESHAction( SMESHOp::OpBiQuadraticQuadrangle, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
3967 createSMESHAction( SMESHOp::OpQuadraticPolygon, "QUADRATIC_POLYGON", "ICON_DLG_QUADRATIC_POLYGON" );
3968 createSMESHAction( SMESHOp::OpQuadraticTetrahedron, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
3969 createSMESHAction( SMESHOp::OpQuadraticPyramid, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
3970 createSMESHAction( SMESHOp::OpQuadraticPentahedron, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
3971 createSMESHAction( SMESHOp::OpBiQuadraticPentahedron, "BIQUADRATIC_PENTAHEDRON", "ICON_DLG_BIQUADRATIC_PENTAHEDRON" );
3972 createSMESHAction( SMESHOp::OpQuadraticHexahedron, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
3973 createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
3975 createSMESHAction( SMESHOp::OpRemoveNodes, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
3976 createSMESHAction( SMESHOp::OpRemoveElements, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
3977 createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
3978 createSMESHAction( SMESHOp::OpClearMesh, "CLEAR_MESH", "ICON_CLEAR_MESH" );
3980 //createSMESHAction( SMESHOp::OpRenumberingNodes, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
3981 //createSMESHAction( SMESHOp::OpRenumberingElements, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
3983 createSMESHAction( SMESHOp::OpTranslation, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
3984 createSMESHAction( SMESHOp::OpRotation, "ROT", "ICON_DLG_MESH_ROTATION" );
3985 createSMESHAction( SMESHOp::OpSymmetry, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
3986 createSMESHAction( SMESHOp::OpScale, "SCALE", "ICON_DLG_MESH_SCALE" );
3987 createSMESHAction( SMESHOp::OpOffset, "OFFSET", "ICON_DLG_MESH_OFFSET" );
3988 createSMESHAction( SMESHOp::OpSewing, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
3989 createSMESHAction( SMESHOp::OpMergeNodes, "MERGE", "ICON_SMESH_MERGE_NODES" );
3990 createSMESHAction( SMESHOp::OpMergeElements, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
3991 createSMESHAction( SMESHOp::OpMoveNode, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
3992 createSMESHAction( SMESHOp::OpDuplicateNodes, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
3993 createSMESHAction( SMESHOp::OpDiagonalInversion, "INV", "ICON_DLG_MESH_DIAGONAL" );
3994 createSMESHAction( SMESHOp::OpUnionOfTwoTriangle, "UNION2", "ICON_UNION2TRI" );
3995 createSMESHAction( SMESHOp::OpOrientation, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
3996 createSMESHAction( SMESHOp::OpReorientFaces, "REORIENT_2D", "ICON_REORIENT_2D" );
3997 createSMESHAction( SMESHOp::OpUnionOfTriangles, "UNION", "ICON_UNIONTRI" );
3998 createSMESHAction( SMESHOp::OpCuttingOfQuadrangles, "CUT", "ICON_CUTQUAD" );
3999 createSMESHAction( SMESHOp::OpSplitVolumes, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
4000 createSMESHAction( SMESHOp::OpSplitBiQuadratic, "SPLIT_BIQUAD", "ICON_SPLIT_BIQUAD" );
4001 createSMESHAction( SMESHOp::OpSmoothing, "SMOOTH", "ICON_DLG_SMOOTHING" );
4002 createSMESHAction( SMESHOp::OpExtrusion, "EXTRUSION", "ICON_EXTRUSION" );
4003 createSMESHAction( SMESHOp::OpExtrusionAlongAPath, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
4004 createSMESHAction( SMESHOp::OpRevolution, "REVOLUTION", "ICON_REVOLUTION" );
4005 createSMESHAction( SMESHOp::OpPatternMapping, "MAP", "ICON_MAP" );
4006 createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
4007 createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D", "ICON_2D_FROM_3D" );
4009 createSMESHAction( SMESHOp::OpReset, "RESET" );
4010 createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
4011 createSMESHAction( SMESHOp::OpShowScalarBar, "SHOW_SCALAR_BAR","",0, true );
4012 createSMESHAction( SMESHOp::OpSaveDistribution, "SAVE_DISTRIBUTION" );
4013 createSMESHAction( SMESHOp::OpShowDistribution, "SHOW_DISTRIBUTION","",0, true );
4014 #ifndef DISABLE_PLOT2DVIEWER
4015 createSMESHAction( SMESHOp::OpPlotDistribution, "PLOT_DISTRIBUTION" );
4017 createSMESHAction( SMESHOp::OpDMWireframe, "WIRE", "ICON_WIRE", 0, true );
4018 createSMESHAction( SMESHOp::OpDMShading, "SHADE", "ICON_SHADE", 0, true );
4019 createSMESHAction( SMESHOp::OpDMNodes, "NODES", "ICON_POINTS", 0, true );
4020 createSMESHAction( SMESHOp::OpDMShrink, "SHRINK", "ICON_SHRINK", 0, true );
4021 createSMESHAction( SMESHOp::OpUpdate, "UPDATE", "ICON_UPDATE" );
4022 createSMESHAction( SMESHOp::OpDE0DElements, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
4023 createSMESHAction( SMESHOp::OpDEEdges, "EDGES", "ICON_DLG_EDGE", 0, true );
4024 createSMESHAction( SMESHOp::OpDEFaces, "FACES", "ICON_DLG_TRIANGLE", 0, true );
4025 createSMESHAction( SMESHOp::OpDEVolumes, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
4026 createSMESHAction( SMESHOp::OpDEBalls, "BALLS", "ICON_DLG_BALL", 0, true );
4027 createSMESHAction( SMESHOp::OpDEChoose, "CHOOSE", "ICON_DLG_CHOOSE", 0, false );
4028 createSMESHAction( SMESHOp::OpDEAllEntity, "ALL", "ICON_DLG_CHOOSE_ALL", 0, false );
4029 createSMESHAction( SMESHOp::OpOrientationOnFaces, "FACE_ORIENTATION", "", 0, true );
4031 createSMESHAction( SMESHOp::OpRepresentationLines, "LINE_REPRESENTATION", "", 0, true );
4032 createSMESHAction( SMESHOp::OpRepresentationArcs, "ARC_REPRESENTATION", "", 0, true );
4034 createSMESHAction( SMESHOp::OpEditHypothesis, "EDIT_HYPO" );
4035 createSMESHAction( SMESHOp::OpUnassign, "UNASSIGN" );
4036 createSMESHAction( SMESHOp::OpNumberingNodes, "NUM_NODES", "", 0, true );
4037 createSMESHAction( SMESHOp::OpNumberingElements, "NUM_ELEMENTS", "", 0, true );
4038 createSMESHAction( SMESHOp::OpProperties, "COLORS" );
4039 createSMESHAction( SMESHOp::OpTransparency, "TRANSP" );
4040 createSMESHAction( SMESHOp::OpClipping, "CLIP" );
4041 createSMESHAction( SMESHOp::OpAutoColor, "AUTO_COLOR" );
4042 createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
4044 createSMESHAction( SMESHOp::OpMinimumDistance, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
4045 createSMESHAction( SMESHOp::OpBoundingBox, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
4046 createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH", "ICON_MEASURE_LENGTH" );
4047 createSMESHAction( SMESHOp::OpPropertiesArea, "MEASURE_AREA", "ICON_MEASURE_AREA" );
4048 createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME", "ICON_MEASURE_VOLUME" );
4050 createSMESHAction( SMESHOp::OpHide, "HIDE", "ICON_HIDE" );
4051 createSMESHAction( SMESHOp::OpShow, "SHOW", "ICON_SHOW" );
4052 createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
4054 createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
4056 QList<int> aCtrlActions;
4057 aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode
4058 << SMESHOp::OpNodeConnectivityNb // node controls
4059 << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
4060 << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge // edge controls
4061 << SMESHOp::OpDeflection2D
4062 << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
4063 << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
4064 << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
4065 << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
4066 << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace // face controls
4067 << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
4068 << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
4069 << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume; // volume controls
4070 QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
4071 aCtrlGroup->setExclusive( true );
4072 for( int i = 0; i < aCtrlActions.size(); i++ )
4073 aCtrlGroup->addAction( action( aCtrlActions[i] ) );
4075 // ----- create menu --------------
4076 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
4077 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
4078 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
4079 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
4080 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
4081 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
4082 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
4083 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
4085 createMenu( separator(), fileId );
4087 QMenu* nodeMenu = new QMenu(); QMenu* edgeMenu = new QMenu();
4088 QMenu* faceMenu = new QMenu(); QMenu* volumeMenu = new QMenu();
4089 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
4090 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
4091 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10, -1, nodeMenu ),
4092 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10, -1, edgeMenu ),
4093 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10, -1, faceMenu ),
4094 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10, -1, volumeMenu ),
4095 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
4096 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
4097 //renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
4098 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
4099 basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
4101 //createMenu( SMESHOp::OpImportDAT, importId, -1 );
4102 createMenu( SMESHOp::OpImportUNV, importId, -1 );
4103 createMenu( SMESHOp::OpImportMED, importId, -1 );
4104 createMenu( SMESHOp::OpImportSTL, importId, -1 );
4106 createMenu( SMESHOp::OpImportCGNS, importId, -1 );
4108 createMenu( SMESHOp::OpImportSAUV, importId, -1 );
4109 createMenu( SMESHOp::OpImportGMF, importId, -1 );
4110 createMenu( SMESHOp::OpExportDAT, exportId, -1 );
4111 createMenu( SMESHOp::OpExportMED, exportId, -1 );
4112 createMenu( SMESHOp::OpExportUNV, exportId, -1 );
4113 createMenu( SMESHOp::OpExportSTL, exportId, -1 );
4115 createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
4117 createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
4118 createMenu( SMESHOp::OpExportGMF, exportId, -1 );
4119 createMenu( separator(), fileId, 10 );
4121 createMenu( SMESHOp::OpDelete, editId, -1 );
4123 createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
4125 createMenu( SMESHOp::OpCreateMesh, meshId, -1 ); // "Mesh" menu
4126 createMenu( SMESHOp::OpCreateSubMesh, meshId, -1 );
4127 createMenu( SMESHOp::OpEditMeshOrSubMesh, meshId, -1 );
4128 createMenu( SMESHOp::OpBuildCompoundMesh, meshId, -1 );
4129 createMenu( SMESHOp::OpCopyMesh, meshId, -1 );
4130 createMenu( separator(), meshId, -1 );
4131 createMenu( SMESHOp::OpCompute, meshId, -1 );
4132 createMenu( SMESHOp::OpPreCompute, meshId, -1 );
4133 createMenu( SMESHOp::OpEvaluate, meshId, -1 );
4134 createMenu( SMESHOp::OpMeshOrder, meshId, -1 );
4135 createMenu( separator(), meshId, -1 );
4136 createMenu( SMESHOp::OpCreateGroup, meshId, -1 );
4137 createMenu( SMESHOp::OpCreateGeometryGroup, meshId, -1 );
4138 createMenu( SMESHOp::OpConstructGroup, meshId, -1 );
4139 createMenu( SMESHOp::OpEditGroup, meshId, -1 );
4140 createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4141 createMenu( separator(), meshId, -1 );
4142 createMenu( SMESHOp::OpUnionGroups, meshId, -1 );
4143 createMenu( SMESHOp::OpIntersectGroups, meshId, -1 );
4144 createMenu( SMESHOp::OpCutGroups, meshId, -1 );
4145 createMenu( separator(), meshId, -1 );
4146 createMenu( SMESHOp::OpGroupUnderlyingElem, meshId, -1 );
4147 createMenu( separator(), meshId, -1 );
4148 createMenu( SMESHOp::OpMeshInformation, meshId, -1 );
4149 //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4150 //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4151 createMenu( SMESHOp::OpFindElementByPoint, meshId, -1 );
4152 createMenu( separator(), meshId, -1 );
4154 createMenu( SMESHOp::OpFreeNode, nodeId, -1 );
4155 createMenu( SMESHOp::OpEqualNode, nodeId, -1 );
4156 //createMenu( SMESHOp::OpNodeConnectivityNb, nodeId, -1 );
4157 createMenu( SMESHOp::OpFreeBorder, edgeId, -1 );
4158 createMenu( SMESHOp::OpLength, edgeId, -1 );
4159 createMenu( SMESHOp::OpConnection, edgeId, -1 );
4160 createMenu( SMESHOp::OpEqualEdge, edgeId, -1 );
4161 createMenu( SMESHOp::OpFreeEdge, faceId, -1 );
4162 createMenu( SMESHOp::OpFreeFace, faceId, -1 );
4163 createMenu( SMESHOp::OpBareBorderFace, faceId, -1 );
4164 createMenu( SMESHOp::OpOverConstrainedFace, faceId, -1 );
4165 createMenu( SMESHOp::OpLength2D, faceId, -1 );
4166 createMenu( SMESHOp::OpConnection2D, faceId, -1 );
4167 createMenu( SMESHOp::OpArea, faceId, -1 );
4168 createMenu( SMESHOp::OpTaper, faceId, -1 );
4169 createMenu( SMESHOp::OpAspectRatio, faceId, -1 );
4170 createMenu( SMESHOp::OpMinimumAngle, faceId, -1 );
4171 createMenu( SMESHOp::OpWarpingAngle, faceId, -1 );
4172 createMenu( SMESHOp::OpSkew, faceId, -1 );
4173 createMenu( SMESHOp::OpMaxElementLength2D, faceId, -1 );
4174 createMenu( SMESHOp::OpEqualFace, faceId, -1 );
4175 createMenu( SMESHOp::OpDeflection2D, faceId, -1 );
4176 createMenu( SMESHOp::OpAspectRatio3D, volumeId, -1 );
4177 createMenu( SMESHOp::OpVolume, volumeId, -1 );
4178 createMenu( SMESHOp::OpMaxElementLength3D, volumeId, -1 );
4179 createMenu( SMESHOp::OpBareBorderVolume, volumeId, -1 );
4180 createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4181 createMenu( SMESHOp::OpEqualVolume, volumeId, -1 );
4182 createMenu( separator(), ctrlId, -1 );
4183 createMenu( SMESHOp::OpReset, ctrlId, -1 );
4184 createMenu( separator(), ctrlId, -1 );
4185 createMenu( SMESHOp::OpOverallMeshQuality, ctrlId, -1 );
4187 createMenu( SMESHOp::OpNode, addId, -1 );
4188 createMenu( SMESHOp::OpElem0D, addId, -1 );
4189 createMenu( SMESHOp::OpElem0DOnElemNodes, addId, -1 );
4190 createMenu( SMESHOp::OpBall, addId, -1 );
4191 createMenu( SMESHOp::OpEdge, addId, -1 );
4192 createMenu( SMESHOp::OpTriangle, addId, -1 );
4193 createMenu( SMESHOp::OpQuadrangle, addId, -1 );
4194 createMenu( SMESHOp::OpPolygon, addId, -1 );
4195 createMenu( SMESHOp::OpTetrahedron, addId, -1 );
4196 createMenu( SMESHOp::OpHexahedron, addId, -1 );
4197 createMenu( SMESHOp::OpPentahedron, addId, -1 );
4198 createMenu( SMESHOp::OpPyramid, addId, -1 );
4199 createMenu( SMESHOp::OpHexagonalPrism, addId, -1 );
4200 createMenu( SMESHOp::OpPolyhedron, addId, -1 );
4201 createMenu( separator(), addId, -1 );
4202 createMenu( SMESHOp::OpQuadraticEdge, addId, -1 );
4203 createMenu( SMESHOp::OpQuadraticTriangle, addId, -1 );
4204 createMenu( SMESHOp::OpBiQuadraticTriangle , addId, -1 );
4205 createMenu( SMESHOp::OpQuadraticQuadrangle, addId, -1 );
4206 createMenu( SMESHOp::OpBiQuadraticQuadrangle, addId, -1 );
4207 createMenu( SMESHOp::OpQuadraticPolygon, addId, -1 );
4208 createMenu( SMESHOp::OpQuadraticTetrahedron, addId, -1 );
4209 createMenu( SMESHOp::OpQuadraticPyramid, addId, -1 );
4210 createMenu( SMESHOp::OpQuadraticPentahedron, addId, -1 );
4211 createMenu( SMESHOp::OpBiQuadraticPentahedron, addId, -1 );
4212 createMenu( SMESHOp::OpQuadraticHexahedron, addId, -1 );
4213 createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4215 createMenu( SMESHOp::OpRemoveNodes, removeId, -1 );
4216 createMenu( SMESHOp::OpRemoveElements, removeId, -1 );
4217 createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4218 createMenu( separator(), removeId, -1 );
4219 createMenu( SMESHOp::OpDeleteGroup, removeId, -1 );
4220 createMenu( separator(), removeId, -1 );
4221 createMenu( SMESHOp::OpClearMesh, removeId, -1 );
4223 //createMenu( SMESHOp::OpRenumberingNodes, renumId, -1 );
4224 //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4226 createMenu( SMESHOp::OpMergeNodes, transfId, -1 );
4227 createMenu( SMESHOp::OpMergeElements, transfId, -1 );
4228 createMenu( SMESHOp::OpTranslation, transfId, -1 );
4229 createMenu( SMESHOp::OpRotation, transfId, -1 );
4230 createMenu( SMESHOp::OpSymmetry, transfId, -1 );
4231 createMenu( SMESHOp::OpScale, transfId, -1 );
4232 createMenu( SMESHOp::OpOffset, transfId, -1 );
4233 createMenu( SMESHOp::OpSewing, transfId, -1 );
4234 createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4236 createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4237 createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4238 createMenu( SMESHOp::OpExtrusion, modifyId, -1 );
4239 createMenu( SMESHOp::OpExtrusionAlongAPath, modifyId, -1 );
4240 createMenu( SMESHOp::OpRevolution, modifyId, -1 );
4241 createMenu( SMESHOp::OpOrientation, modifyId, -1 );
4242 createMenu( SMESHOp::OpReorientFaces, modifyId, -1 );
4243 createMenu( SMESHOp::OpMoveNode, modifyId, -1 );
4244 createMenu( SMESHOp::OpDiagonalInversion, modifyId, -1 );
4245 createMenu( SMESHOp::OpUnionOfTwoTriangle, modifyId, -1 );
4246 createMenu( SMESHOp::OpUnionOfTriangles, modifyId, -1 );
4247 createMenu( SMESHOp::OpCuttingOfQuadrangles, modifyId, -1 );
4248 createMenu( SMESHOp::OpSplitVolumes, modifyId, -1 );
4249 createMenu( SMESHOp::OpSplitBiQuadratic, modifyId, -1 );
4250 createMenu( SMESHOp::OpSmoothing, modifyId, -1 );
4251 createMenu( SMESHOp::OpPatternMapping, modifyId, -1 );
4253 createMenu( SMESHOp::OpMinimumDistance, measureId, -1 );
4254 createMenu( SMESHOp::OpBoundingBox, measureId, -1 );
4255 createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4256 createMenu( SMESHOp::OpPropertiesArea, basicPropId, -1 );
4257 createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4258 createMenu( SMESHOp::OpUpdate, viewId, -1 );
4260 connect( nodeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4261 connect( edgeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4262 connect( faceMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4263 connect( volumeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4265 // ----- create toolbars --------------
4266 int meshTb = createTool( tr( "TB_MESH" ), QString( "SMESHMeshToolbar" ) ),
4267 info = createTool( tr( "TB_INFO" ), QString( "SMESHInformationToolbar" ) ),
4268 groupTb = createTool( tr( "TB_GROUP" ), QString( "SMESHGroupToolbar" ) ),
4269 ctrl0dTb = createTool( tr( "TB_CTRL0D" ), QString( "SMESHNodeControlsToolbar" ) ),
4270 ctrl1dTb = createTool( tr( "TB_CTRL1D" ), QString( "SMESHEdgeControlsToolbar" ) ),
4271 ctrl2dTb = createTool( tr( "TB_CTRL2D" ), QString( "SMESHFaceControlsToolbar" ) ),
4272 ctrl3dTb = createTool( tr( "TB_CTRL3D" ), QString( "SMESHVolumeControlsToolbar" ) ),
4273 addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ),
4274 addNonElemTb = createTool( tr( "TB_ADDNON" ), QString( "SMESHAddElementToolbar" ) ),
4275 remTb = createTool( tr( "TB_REM" ), QString( "SMESHRemoveToolbar" ) ),
4276 //renumbTb = createTool( tr( "TB_RENUMBER" ), QString( "SMESHRenumberingToolbar" ) ),
4277 transformTb = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ),
4278 modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ),
4279 measuremTb = createTool( tr( "TB_MEASUREM" ), QString( "SMESHMeasurementsToolbar" ) ),
4280 dispModeTb = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4282 createTool( SMESHOp::OpCreateMesh, meshTb );
4283 createTool( SMESHOp::OpCreateSubMesh, meshTb );
4284 createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4285 createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4286 createTool( SMESHOp::OpCopyMesh, meshTb );
4287 createTool( separator(), meshTb );
4288 createTool( SMESHOp::OpCompute, meshTb );
4289 createTool( SMESHOp::OpPreCompute, meshTb );
4290 createTool( SMESHOp::OpEvaluate, meshTb );
4291 createTool( SMESHOp::OpMeshOrder, meshTb );
4293 createTool( SMESHOp::OpCreateGroup, groupTb );
4294 createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4295 createTool( SMESHOp::OpConstructGroup, groupTb );
4296 createTool( SMESHOp::OpEditGroup, groupTb );
4298 createTool( SMESHOp::OpMeshInformation, info );
4299 //createTool( SMESHOp::OpStdInfo, meshTb );
4300 //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4301 createTool( SMESHOp::OpFindElementByPoint, info );
4303 createTool( SMESHOp::OpFreeNode, ctrl0dTb );
4304 createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4305 //createTool( SMESHOp::OpNodeConnectivityNb, ctrl0dTb );
4307 createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4308 createTool( SMESHOp::OpLength, ctrl1dTb );
4309 createTool( SMESHOp::OpConnection, ctrl1dTb );
4310 createTool( SMESHOp::OpEqualEdge, ctrl1dTb );
4312 createTool( SMESHOp::OpFreeEdge, ctrl2dTb );
4313 createTool( SMESHOp::OpFreeFace, ctrl2dTb );
4314 createTool( SMESHOp::OpBareBorderFace, ctrl2dTb );
4315 createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4316 createTool( SMESHOp::OpLength2D, ctrl2dTb );
4317 createTool( SMESHOp::OpConnection2D, ctrl2dTb );
4318 createTool( SMESHOp::OpArea, ctrl2dTb );
4319 createTool( SMESHOp::OpTaper, ctrl2dTb );
4320 createTool( SMESHOp::OpAspectRatio, ctrl2dTb );
4321 createTool( SMESHOp::OpMinimumAngle, ctrl2dTb );
4322 createTool( SMESHOp::OpWarpingAngle, ctrl2dTb );
4323 createTool( SMESHOp::OpSkew, ctrl2dTb );
4324 createTool( SMESHOp::OpMaxElementLength2D, ctrl2dTb );
4325 createTool( SMESHOp::OpEqualFace, ctrl2dTb );
4326 createTool( SMESHOp::OpDeflection2D, ctrl2dTb );
4328 createTool( SMESHOp::OpAspectRatio3D, ctrl3dTb );
4329 createTool( SMESHOp::OpVolume, ctrl3dTb );
4330 createTool( SMESHOp::OpMaxElementLength3D, ctrl3dTb );
4331 createTool( SMESHOp::OpBareBorderVolume, ctrl3dTb );
4332 createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
4333 createTool( SMESHOp::OpEqualVolume, ctrl3dTb );
4335 createTool( SMESHOp::OpNode, addElemTb );
4336 createTool( SMESHOp::OpElem0D, addElemTb );
4337 createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4338 createTool( SMESHOp::OpBall, addElemTb );
4339 createTool( SMESHOp::OpEdge, addElemTb );
4340 createTool( SMESHOp::OpTriangle, addElemTb );
4341 createTool( SMESHOp::OpQuadrangle, addElemTb );
4342 createTool( SMESHOp::OpPolygon, addElemTb );
4343 createTool( SMESHOp::OpTetrahedron, addElemTb );
4344 createTool( SMESHOp::OpHexahedron, addElemTb );
4345 createTool( SMESHOp::OpPentahedron, addElemTb );
4346 createTool( SMESHOp::OpPyramid, addElemTb );
4347 createTool( SMESHOp::OpHexagonalPrism, addElemTb );
4348 createTool( SMESHOp::OpPolyhedron, addElemTb );
4350 createTool( SMESHOp::OpQuadraticEdge, addNonElemTb );
4351 createTool( SMESHOp::OpQuadraticTriangle, addNonElemTb );
4352 createTool( SMESHOp::OpBiQuadraticTriangle, addNonElemTb );
4353 createTool( SMESHOp::OpQuadraticQuadrangle, addNonElemTb );
4354 createTool( SMESHOp::OpBiQuadraticQuadrangle, addNonElemTb );
4355 createTool( SMESHOp::OpQuadraticPolygon, addNonElemTb );
4356 createTool( SMESHOp::OpQuadraticTetrahedron, addNonElemTb );
4357 createTool( SMESHOp::OpQuadraticPyramid, addNonElemTb );
4358 createTool( SMESHOp::OpQuadraticPentahedron, addNonElemTb );
4359 createTool( SMESHOp::OpBiQuadraticPentahedron, addNonElemTb );
4360 createTool( SMESHOp::OpQuadraticHexahedron, addNonElemTb );
4361 createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4363 createTool( SMESHOp::OpRemoveNodes, remTb );
4364 createTool( SMESHOp::OpRemoveElements, remTb );
4365 createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4366 createTool( SMESHOp::OpClearMesh, remTb );
4368 //createTool( SMESHOp::OpRenumberingNodes, renumbTb );
4369 //createTool( SMESHOp::OpRenumberingElements, renumbTb );
4371 createTool( SMESHOp::OpMergeNodes, transformTb );
4372 createTool( SMESHOp::OpMergeElements, transformTb );
4373 createTool( SMESHOp::OpTranslation, transformTb );
4374 createTool( SMESHOp::OpRotation, transformTb );
4375 createTool( SMESHOp::OpSymmetry, transformTb );
4376 createTool( SMESHOp::OpScale, transformTb );
4377 createTool( SMESHOp::OpOffset, transformTb );
4378 createTool( SMESHOp::OpSewing, transformTb );
4379 createTool( SMESHOp::OpDuplicateNodes, transformTb );
4381 createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4382 createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4383 createTool( SMESHOp::OpExtrusion, modifyTb );
4384 createTool( SMESHOp::OpExtrusionAlongAPath, modifyTb );
4385 createTool( SMESHOp::OpRevolution, modifyTb );
4386 createTool( SMESHOp::OpOrientation, modifyTb );
4387 createTool( SMESHOp::OpReorientFaces, modifyTb );
4388 createTool( SMESHOp::OpMoveNode, modifyTb );
4389 createTool( SMESHOp::OpDiagonalInversion, modifyTb );
4390 createTool( SMESHOp::OpUnionOfTwoTriangle, modifyTb );
4391 createTool( SMESHOp::OpUnionOfTriangles, modifyTb );
4392 createTool( SMESHOp::OpCuttingOfQuadrangles, modifyTb );
4393 createTool( SMESHOp::OpSplitVolumes, modifyTb );
4394 createTool( SMESHOp::OpSplitBiQuadratic, modifyTb );
4395 createTool( SMESHOp::OpSmoothing, modifyTb );
4396 createTool( SMESHOp::OpPatternMapping, modifyTb );
4398 createTool( SMESHOp::OpMinimumDistance, measuremTb );
4400 createTool( SMESHOp::OpUpdate, dispModeTb );
4402 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4403 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4407 OB = "'ObjectBrowser'",
4408 View = "'" + SVTK_Viewer::Type() + "'",
4410 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4411 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4412 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4413 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4414 smesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::COMPONENT ) ),
4415 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4416 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4417 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4418 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4419 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4420 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4421 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4423 mesh_part = mesh + " " + subMesh + " " + group,
4424 mesh_group = mesh + " " + group,
4425 mesh_submesh = mesh + " " + subMesh,
4426 hyp_alg = hypo + " " + algo;
4428 // popup for object browser
4430 isInvisible("not( isVisible )"),
4431 isEmpty("numberOfNodes = 0"),
4432 isNotEmpty("numberOfNodes <> 0"),
4434 // has nodes, edges, etc in VISIBLE! actor
4435 hasNodes("(numberOfNodes > 0 ) && hasActor"),
4436 hasElems("(count( elemTypes ) > 0)"),
4437 hasDifferentElems("(count( elemTypes ) > 1)"),
4438 hasDifferentObjElems("(count( objElemTypes ) > 1)"),
4439 hasBalls("({'BallElem'} in elemTypes)"),
4440 hasElems0d("({'Elem0d'} in elemTypes)"),
4441 hasEdges("({'Edge'} in elemTypes)"),
4442 hasFaces("({'Face'} in elemTypes)"),
4443 hasVolumes("({'Volume'} in elemTypes)"),
4444 hasFacesOrVolumes("(({'Face'} in elemTypes) || ({'Volume'} in elemTypes)) ");
4446 createPopupItem( SMESHOp::OpFileInformation, OB, mesh, "&& selcount=1 && isImported" );
4447 createPopupItem( SMESHOp::OpCreateSubMesh, OB, mesh, "&& hasGeomReference");
4448 createPopupItem( SMESHOp::OpEditMesh, OB, mesh, "&& selcount=1" );
4449 createPopupItem( SMESHOp::OpEditSubMesh, OB, subMesh, "&& selcount=1 && hasGeomReference" );
4450 createPopupItem( SMESHOp::OpEditGroup, OB, group );
4451 createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4453 popupMgr()->insert( separator(), -1, 0 );
4454 createPopupItem( SMESHOp::OpCompute, OB, mesh, "&& selcount=1 && isComputable" );
4455 createPopupItem( SMESHOp::OpComputeSubMesh, OB, subMesh, "&& selcount=1 && isComputable" );
4456 createPopupItem( SMESHOp::OpPreCompute, OB, mesh, "&& selcount=1 && isPreComputable" );
4457 createPopupItem( SMESHOp::OpEvaluate, OB, mesh, "&& selcount=1 && isComputable" );
4458 createPopupItem( SMESHOp::OpMeshOrder, OB, mesh, "&& selcount=1 && isComputable && hasGeomReference" );
4459 createPopupItem( SMESHOp::OpUpdate, OB, mesh_part );
4460 createPopupItem( SMESHOp::OpMeshInformation, OB, mesh_part );
4461 createPopupItem( SMESHOp::OpFindElementByPoint,OB, mesh_group, "&& selcount=1" );
4462 createPopupItem( SMESHOp::OpOverallMeshQuality,OB, mesh_part );
4463 popupMgr()->insert( separator(), -1, 0 );
4464 createPopupItem( SMESHOp::OpCreateGroup, OB, mesh, "&& selcount=1" );
4465 createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh, "&& selcount=1 && hasGeomReference" );
4466 createPopupItem( SMESHOp::OpConstructGroup, OB, subMesh );
4467 popupMgr()->insert( separator(), -1, 0 );
4468 createPopupItem( SMESHOp::OpEditHypothesis, OB, hypo, "&& isEditableHyp");
4469 createPopupItem( SMESHOp::OpUnassign, OB, hyp_alg );
4470 popupMgr()->insert( separator(), -1, 0 );
4471 createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh_submesh );
4472 createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh_group, "&& selcount=1 && dim>=2");
4473 popupMgr()->insert( separator(), -1, 0 );
4474 createPopupItem( SMESHOp::OpClearMesh, OB, mesh );
4475 //popupMgr()->insert( separator(), -1, 0 );
4477 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4478 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4479 QString only_one_2D = only_one_non_empty + " && dim>1";
4481 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4482 createPopupItem( SMESHOp::OpPopupExportMED, OB, mesh_group, multiple_non_empty, anId );
4483 createPopupItem( SMESHOp::OpPopupExportUNV, OB, mesh_group, only_one_non_empty, anId );
4484 createPopupItem( SMESHOp::OpPopupExportSTL, OB, mesh_group, only_one_2D, anId );
4486 createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4488 createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, only_one_non_empty, anId );
4489 createPopupItem( SMESHOp::OpPopupExportGMF, OB, mesh_group, only_one_non_empty, anId );
4490 createPopupItem( SMESHOp::OpPopupExportDAT, OB, mesh_group, only_one_non_empty, anId );
4491 createPopupItem( SMESHOp::OpDelete, OB, mesh_part + " " + hyp_alg );
4492 createPopupItem( SMESHOp::OpDeleteGroup, OB, group );
4494 anId = popupMgr()->insert( tr( "MEN_IMPORT" ), -1, -1 ); // IMPORT submenu
4495 createPopupItem( SMESHOp::OpPopupImportMED, OB, smesh, "", anId );
4496 createPopupItem( SMESHOp::OpPopupImportUNV, OB, smesh, "", anId );
4497 createPopupItem( SMESHOp::OpPopupImportSTL, OB, smesh, "", anId );
4499 createPopupItem( SMESHOp::OpPopupImportCGNS, OB, smesh, "", anId );
4501 createPopupItem( SMESHOp::OpPopupImportSAUV, OB, smesh, "", anId );
4502 createPopupItem( SMESHOp::OpPopupImportGMF, OB, smesh, "", anId );
4503 createPopupItem( SMESHOp::OpPopupImportDAT, OB, smesh, "", anId );
4504 popupMgr()->insert( separator(), -1, 0 );
4507 createPopupItem( SMESHOp::OpEditGroup, View, group );
4508 createPopupItem( SMESHOp::OpAddElemGroupPopup, View, elems, "&& guiState = 800" );
4509 createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems, "&& guiState = 800" );
4511 popupMgr()->insert( separator(), -1, 0 );
4512 createPopupItem( SMESHOp::OpUpdate, View, mesh_part );
4513 createPopupItem( SMESHOp::OpMeshInformation, View, mesh_part );
4514 createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4515 createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh );
4516 popupMgr()->insert( separator(), -1, 0 );
4518 createPopupItem( SMESHOp::OpAutoColor, OB + " " + View, mesh, "&& (not isAutoColor)" );
4519 createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4520 popupMgr()->insert( separator(), -1, 0 );
4522 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4523 QString aType = QString( "%1type in {%2}" ).arg( lc );
4524 aType = aType.arg( mesh_part );
4525 QString aMeshInVTK = aClient + "&&" + aType;
4527 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4528 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4529 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4531 //-------------------------------------------------
4533 //-------------------------------------------------
4534 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4536 popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4537 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4538 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4540 popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4541 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4542 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4544 popupMgr()->insert( separator(), -1, -1 );
4546 //-------------------------------------------------
4548 //-------------------------------------------------
4549 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4551 popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4552 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4553 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4555 popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4556 popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4557 popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4559 popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4560 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4561 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4563 popupMgr()->insert( separator(), anId, -1 );
4565 popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4566 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4567 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4569 //-------------------------------------------------
4571 //-------------------------------------------------
4572 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4574 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4576 popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4577 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4578 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4580 popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4581 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4582 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4584 popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4585 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4586 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4588 popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4589 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4590 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4592 popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4593 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4594 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4596 popupMgr()->insert( separator(), anId, -1 );
4598 popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4599 popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&& $type in {" + mesh + "} &&" + hasDifferentObjElems, QtxPopupMgr::VisibleRule );
4601 popupMgr()->insert( separator(), anId, -1 );
4603 popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4604 popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4607 //-------------------------------------------------
4608 // Representation of the 2D Quadratic elements
4609 //-------------------------------------------------
4610 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4611 popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4612 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "&& isVisible && isQuadratic",QtxPopupMgr::VisibleRule );
4613 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4615 popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4616 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "&& isVisible && isQuadratic", QtxPopupMgr::VisibleRule );
4617 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4619 //-------------------------------------------------
4620 // Orientation of faces
4621 //-------------------------------------------------
4622 popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4623 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4624 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4626 //-------------------------------------------------
4628 //-------------------------------------------------
4629 popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4630 popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4632 //-------------------------------------------------
4634 //-------------------------------------------------
4635 popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4636 popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4638 //-------------------------------------------------
4640 //-------------------------------------------------
4642 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4643 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4644 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4645 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4647 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4649 popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4650 popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4652 popupMgr()->insert( separator(), anId, -1 );
4654 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4656 popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4657 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4658 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4660 popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4661 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4662 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4664 // popupMgr()->insert( action( SMESHOp::OpNodeConnectivityNb ), aSubId, -1 );
4665 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4666 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), "controlMode = 'eNodeConnectivityNb'", QtxPopupMgr::ToggleRule );
4668 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4670 popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4671 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVTK + "&&" + hasEdges + "&&" + hasFacesOrVolumes, QtxPopupMgr::VisibleRule );
4672 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4674 popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4675 popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4676 popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4678 popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4679 popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4680 popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4681 popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4682 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4683 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4685 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4687 popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4688 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4689 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4691 popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4692 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4693 QtxPopupMgr::VisibleRule );
4694 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4696 popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4697 popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4698 popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4700 popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4701 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4702 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4704 popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
4705 popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4706 popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4708 popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
4709 popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4710 popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4712 popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
4713 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4714 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4716 popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
4717 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4718 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4720 popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
4721 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4722 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4724 popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
4725 popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4726 popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4728 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
4729 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4730 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4732 popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
4733 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4734 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4736 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
4737 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4738 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4740 popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
4741 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4742 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4744 popupMgr()->insert ( action( SMESHOp::OpDeflection2D ), aSubId, -1 );
4745 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), aMeshInVtkHasFaces + " && hasGeomReference", QtxPopupMgr::VisibleRule );
4746 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), "controlMode = 'eDeflection2D'", QtxPopupMgr::ToggleRule );
4748 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4750 popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D ), aSubId, -1 );
4751 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4752 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4754 popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
4755 popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4756 popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4758 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
4759 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4760 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4762 popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
4763 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4764 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4766 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
4767 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4768 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4770 popupMgr()->insert ( action( SMESHOp::OpEqualVolume ), aSubId, -1 );
4771 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4772 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4774 popupMgr()->insert( separator(), anId, -1 );
4776 popupMgr()->insert( action( SMESHOp::OpShowScalarBar ), anId, -1 );
4777 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4778 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone' && isScalarBarVisible", QtxPopupMgr::ToggleRule );
4779 popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
4780 popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4782 popupMgr()->insert( separator(), anId, -1 );
4784 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4786 popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
4787 popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4789 popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
4790 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4791 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isScalarBarVisible && isDistributionVisible", QtxPopupMgr::ToggleRule);
4793 #ifndef DISABLE_PLOT2DVIEWER
4794 popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
4795 popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4798 //-------------------------------------------------
4800 //-------------------------------------------------
4801 popupMgr()->insert( separator(), -1, -1 );
4802 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4803 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4804 popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
4805 popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4807 popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
4808 popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4810 popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
4811 popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4813 popupMgr()->insert( separator(), -1, -1 );
4815 //-------------------------------------------------
4817 //-------------------------------------------------
4818 popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
4819 popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4821 popupMgr()->insert( separator(), -1, -1 );
4823 popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
4824 popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
4825 popupMgr()->insert( separator(), -1, -1 );
4827 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4828 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4830 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4831 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4834 //================================================================================
4836 * \brief Return true if SMESH or GEOM objects are selected.
4837 * Is called form LightApp_Module::activateModule() which clear selection if
4838 * not isSelectionCompatible()
4840 //================================================================================
4842 bool SMESHGUI::isSelectionCompatible()
4844 bool isCompatible = true;
4845 SALOME_ListIO selected;
4846 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4847 Sel->selectedObjects( selected );
4849 SALOME_ListIteratorOfListIO It( selected );
4850 for ( ; isCompatible && It.More(); It.Next())
4852 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4853 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4855 return isCompatible;
4859 bool SMESHGUI::reusableOperation( const int id )
4861 // compute, evaluate and precompute are not reusable operations
4862 return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate ) ? false : SalomeApp_Module::reusableOperation( id );
4865 bool SMESHGUI::activateModule( SUIT_Study* study )
4867 bool res = SalomeApp_Module::activateModule( study );
4869 setMenuShown( true );
4870 setToolShown( true );
4872 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4873 PyGILState_STATE gstate = PyGILState_Ensure();
4874 PyObject* pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4875 if ( !pluginsmanager ) {
4879 PyObject* result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toUtf8().data(),tr("SMESH_PLUGINS_OTHER").toUtf8().data());
4884 PyGILState_Release(gstate);
4885 // end of SMESH plugins loading
4887 // Reset actions accelerator keys
4888 action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
4890 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4891 GetSMESHGen()->UpdateStudy();
4893 // get all view currently opened in the study and connect their signals to
4894 // the corresponding slots of the class.
4895 SUIT_Desktop* aDesk = study->application()->desktop();
4897 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4898 SUIT_ViewWindow* wnd;
4899 foreach ( wnd, wndList )
4903 Py_XDECREF(pluginsmanager);
4907 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4909 setMenuShown( false );
4910 setToolShown( false );
4912 EmitSignalCloseAllDialogs();
4914 // Unset actions accelerator keys
4915 action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
4917 return SalomeApp_Module::deactivateModule( study );
4920 void SMESHGUI::studyClosed( SUIT_Study* s )
4924 SMESH::RemoveVisuData();
4925 SalomeApp_Module::studyClosed( s );
4928 void SMESHGUI::OnGUIEvent()
4930 const QObject* obj = sender();
4931 if ( !obj || !obj->inherits( "QAction" ) )
4933 int id = actionId((QAction*)obj);
4938 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4940 if ( CORBA::is_nil( myComponentSMESH ) )
4942 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4943 return aGUI.myComponentSMESH;
4945 return myComponentSMESH;
4948 QString SMESHGUI::engineIOR() const
4950 CORBA::ORB_var anORB = getApp()->orb();
4951 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4952 return QString( anIOR.in() );
4955 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4957 SalomeApp_Module::contextMenuPopup( client, menu, title );
4959 selectionMgr()->selectedObjects( lst );
4960 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4961 Handle(SALOME_InteractiveObject) io = lst.First();
4962 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4963 _PTR(Study) study = appStudy->studyDS();
4964 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4966 QString aName = QString( SMESH::fromUtf8(obj->GetName()) );
4967 while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4968 aName.remove( (aName.length() - 1), 1 );
4974 LightApp_Selection* SMESHGUI::createSelection() const
4976 return new SMESHGUI_Selection();
4979 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4981 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4982 aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
4983 #ifndef DISABLE_PYCONSOLE
4984 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4988 void SMESHGUI::viewManagers( QStringList& list ) const
4990 list.append( SVTK_Viewer::Type() );
4993 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4995 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4996 SMESH::UpdateSelectionProp( this );
4998 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
4999 for(int i = 0; i < aViews.count() ; i++){
5000 SUIT_ViewWindow *sf = aViews[i];
5003 EmitSignalActivatedViewManager();
5007 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
5009 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
5010 myClippingPlaneInfoMap.erase( theViewManager );
5013 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
5015 theActor->AddObserver( SMESH::DeleteActorEvent,
5016 myEventCallbackCommand.GetPointer(),
5020 void SMESHGUI::ProcessEvents( vtkObject* theObject,
5021 unsigned long theEvent,
5022 void* theClientData,
5025 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
5026 if( theObject && (int) theEvent == SMESH::DeleteActorEvent ) {
5027 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
5028 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
5029 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
5030 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
5031 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
5032 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
5033 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
5034 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
5035 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
5036 SMESH::TActorList::iterator anIter3 = anActorList.begin();
5037 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
5038 if( anActor == *anIter3 ) {
5039 anActorList.erase( anIter3 );
5050 void SMESHGUI::createPreferences()
5052 // General tab ------------------------------------------------------------------------
5053 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
5055 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
5056 setPreferenceProperty( autoUpdate, "columns", 2 );
5057 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
5058 setPreferenceProperty( lim, "min", 0 );
5059 setPreferenceProperty( lim, "max", 100000000 );
5060 setPreferenceProperty( lim, "step", 1000 );
5061 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5062 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
5064 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
5065 setPreferenceProperty( dispgroup, "columns", 2 );
5066 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
5068 modes.append( tr("MEN_WIRE") );
5069 modes.append( tr("MEN_SHADE") );
5070 modes.append( tr("MEN_NODES") );
5071 modes.append( tr("MEN_SHRINK") );
5072 QList<QVariant> indices;
5073 indices.append( 0 );
5074 indices.append( 1 );
5075 indices.append( 2 );
5076 indices.append( 3 );
5077 setPreferenceProperty( dispmode, "strings", modes );
5078 setPreferenceProperty( dispmode, "indexes", indices );
5080 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
5081 setPreferenceProperty( arcgroup, "columns", 2 );
5082 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
5083 QStringList quadraticModes;
5084 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
5085 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
5087 indices.append( 0 );
5088 indices.append( 1 );
5089 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
5090 setPreferenceProperty( quadraticmode, "indexes", indices );
5092 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
5093 "SMESH", "max_angle" );
5094 setPreferenceProperty( maxAngle, "min", 1 );
5095 setPreferenceProperty( maxAngle, "max", 90 );
5097 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
5098 setPreferenceProperty( qaGroup, "columns", 2 );
5099 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
5100 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
5101 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
5102 setPreferenceProperty( prec, "min", 0 );
5103 setPreferenceProperty( prec, "max", 100 );
5104 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
5105 setPreferenceProperty( doubleNodesTol, "precision", 10 );
5106 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
5107 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
5108 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
5111 int cinc = addPreference(tr("PREF_CONTROLS_INCREMENT"), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_increment");
5112 setPreferenceProperty( cinc, "min", 0 );
5113 setPreferenceProperty( cinc, "max", 5 );
5116 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
5117 setPreferenceProperty( exportgroup, "columns", 2 );
5118 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
5119 addPreference( tr( "PREF_SHOW_WARN" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "show_warning" );
5120 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
5122 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
5123 setPreferenceProperty( computeGroup, "columns", 2 );
5124 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
5126 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5127 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5128 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5130 indices.append( 0 );
5131 indices.append( 1 );
5132 indices.append( 2 );
5133 setPreferenceProperty( notifyMode, "strings", modes );
5134 setPreferenceProperty( notifyMode, "indexes", indices );
5136 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5137 setPreferenceProperty( infoGroup, "columns", 2 );
5138 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5140 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5141 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5143 indices.append( 0 );
5144 indices.append( 1 );
5145 setPreferenceProperty( elemInfo, "strings", modes );
5146 setPreferenceProperty( elemInfo, "indexes", indices );
5147 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5148 setPreferenceProperty( nodesLim, "min", 0 );
5149 setPreferenceProperty( nodesLim, "max", 10000000 );
5150 setPreferenceProperty( nodesLim, "step", 10000 );
5151 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5152 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5153 setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5154 setPreferenceProperty( ctrlLim, "min", 0 );
5155 setPreferenceProperty( ctrlLim, "max", 10000000 );
5156 setPreferenceProperty( ctrlLim, "step", 1000 );
5157 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5158 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5159 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5160 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5161 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5163 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5164 setPreferenceProperty( segGroup, "columns", 2 );
5165 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5166 "SMESH", "segmentation" );
5167 setPreferenceProperty( segLen, "min", 1 );
5168 setPreferenceProperty( segLen, "max", 10000000 );
5169 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5170 "SMESH", "nb_segments_per_edge" );
5171 setPreferenceProperty( nbSeg, "min", 1 );
5172 setPreferenceProperty( nbSeg, "max", 10000000 );
5174 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5175 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5176 "SMESH", "forget_mesh_on_hyp_modif" );
5179 // Quantities with individual precision settings
5180 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5181 setPreferenceProperty( precGroup, "columns", 2 );
5183 const int nbQuantities = 6;
5184 int precs[nbQuantities], ii = 0;
5185 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5186 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5187 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5188 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5189 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5190 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5191 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5192 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5193 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5194 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5195 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5196 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5198 // Set property for precision value for spinboxes
5199 for ( ii = 0; ii < nbQuantities; ii++ ){
5200 setPreferenceProperty( precs[ii], "min", -14 );
5201 setPreferenceProperty( precs[ii], "max", 14 );
5202 setPreferenceProperty( precs[ii], "precision", 2 );
5205 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5206 setPreferenceProperty( previewGroup, "columns", 2 );
5207 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5208 setPreferenceProperty( chunkSize, "min", 1 );
5209 setPreferenceProperty( chunkSize, "max", 1000 );
5210 setPreferenceProperty( chunkSize, "step", 50 );
5212 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5213 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5215 // Mesh tab ------------------------------------------------------------------------
5216 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5217 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5218 setPreferenceProperty( nodeGroup, "columns", 3 );
5220 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5222 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5224 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5225 QList<QVariant> aMarkerTypeIndicesList;
5226 QList<QVariant> aMarkerTypeIconsList;
5227 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5228 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5229 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5230 aMarkerTypeIndicesList << i;
5231 aMarkerTypeIconsList << pixmap;
5233 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5234 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
5236 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5238 QList<QVariant> aMarkerScaleIndicesList;
5239 QStringList aMarkerScaleValuesList;
5240 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5241 aMarkerScaleIndicesList << i;
5242 //aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5243 aMarkerScaleValuesList << QString::number( i );
5245 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5246 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5248 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5249 //setPreferenceProperty( elemGroup, "columns", 2 );
5251 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5252 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5253 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5254 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5255 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5256 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5257 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5258 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5259 addPreference( tr( "PREF_PREVIEW_COLOR" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5262 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5263 setPreferenceProperty( grpGroup, "columns", 2 );
5265 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5266 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5268 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5269 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5270 /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5271 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5272 double ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5273 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5274 double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5275 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5276 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
5277 LightApp_Preferences::IntSpin, "SMESH", "element_width");
5278 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5279 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5280 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5281 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5283 setPreferenceProperty( size0d, "min", 1 );
5284 setPreferenceProperty( size0d, "max", 10 );
5286 // setPreferenceProperty( ballSize, "min", 1 );
5287 // setPreferenceProperty( ballSize, "max", 10 );
5289 setPreferenceProperty( ballDiameter, "min", 1e-7 );
5290 setPreferenceProperty( ballDiameter, "max", 1e9 );
5291 setPreferenceProperty( ballDiameter, "step", 0.1 );
5293 setPreferenceProperty( ballScale, "min", 1e-2 );
5294 setPreferenceProperty( ballScale, "max", 1e7 );
5295 setPreferenceProperty( ballScale, "step", 0.5 );
5297 setPreferenceProperty( elemW, "min", 1 );
5298 setPreferenceProperty( elemW, "max", 5 );
5300 setPreferenceProperty( outW, "min", 1 );
5301 setPreferenceProperty( outW, "max", 5 );
5303 setPreferenceProperty( shrink, "min", 0 );
5304 setPreferenceProperty( shrink, "max", 100 );
5306 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5307 setPreferenceProperty( numGroup, "columns", 2 );
5309 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5310 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5312 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5313 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5315 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5316 setPreferenceProperty( orientGroup, "columns", 1 );
5318 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5319 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5321 setPreferenceProperty( orientScale, "min", 0.05 );
5322 setPreferenceProperty( orientScale, "max", 0.5 );
5323 setPreferenceProperty( orientScale, "step", 0.05 );
5325 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5327 // Selection tab ------------------------------------------------------------------------
5328 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5330 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5331 setPreferenceProperty( selGroup, "columns", 2 );
5333 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5334 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5336 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5337 setPreferenceProperty( preGroup, "columns", 2 );
5339 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5341 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5342 setPreferenceProperty( precSelGroup, "columns", 2 );
5344 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5345 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5346 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5348 int sinc = addPreference(tr("PREF_SELECTION_INCREMENT"), selTab, LightApp_Preferences::IntSpin, "SMESH", "selection_increment");
5349 setPreferenceProperty( sinc, "min", 0 );
5350 setPreferenceProperty( sinc, "max", 5 );
5352 // Scalar Bar tab ------------------------------------------------------------------------
5353 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5354 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5355 setPreferenceProperty( fontGr, "columns", 2 );
5357 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5358 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5360 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5361 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5363 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5364 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5366 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5367 setPreferenceProperty( numcol, "min", 2 );
5368 setPreferenceProperty( numcol, "max", 256 );
5370 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5371 setPreferenceProperty( numlab, "min", 2 );
5372 setPreferenceProperty( numlab, "max", 65 );
5374 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5375 setPreferenceProperty( orientGr, "columns", 2 );
5376 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5377 QStringList orients;
5378 orients.append( tr( "SMESH_VERTICAL" ) );
5379 orients.append( tr( "SMESH_HORIZONTAL" ) );
5380 indices.clear(); indices.append( 0 ); indices.append( 1 );
5381 setPreferenceProperty( orient, "strings", orients );
5382 setPreferenceProperty( orient, "indexes", indices );
5384 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5385 setPreferenceProperty( posVSizeGr, "columns", 2 );
5386 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5387 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5388 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5389 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5390 setPreferenceProperty( xv, "step", 0.1 );
5391 setPreferenceProperty( xv, "min", 0.0 );
5392 setPreferenceProperty( xv, "max", 1.0 );
5393 setPreferenceProperty( yv, "step", 0.1 );
5394 setPreferenceProperty( yv, "min", 0.0 );
5395 setPreferenceProperty( yv, "max", 1.0 );
5396 setPreferenceProperty( wv, "step", 0.1 );
5397 setPreferenceProperty( wv, "min", 0.0 );
5398 setPreferenceProperty( wv, "max", 1.0 );
5399 setPreferenceProperty( hv, "min", 0.0 );
5400 setPreferenceProperty( hv, "max", 1.0 );
5401 setPreferenceProperty( hv, "step", 0.1 );
5403 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5404 setPreferenceProperty( posHSizeGr, "columns", 2 );
5405 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5406 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5407 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5408 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5409 setPreferenceProperty( xv, "min", 0.0 );
5410 setPreferenceProperty( xv, "max", 1.0 );
5411 setPreferenceProperty( xv, "step", 0.1 );
5412 setPreferenceProperty( xh, "min", 0.0 );
5413 setPreferenceProperty( xh, "max", 1.0 );
5414 setPreferenceProperty( xh, "step", 0.1 );
5415 setPreferenceProperty( yh, "min", 0.0 );
5416 setPreferenceProperty( yh, "max", 1.0 );
5417 setPreferenceProperty( yh, "step", 0.1 );
5418 setPreferenceProperty( wh, "min", 0.0 );
5419 setPreferenceProperty( wh, "max", 1.0 );
5420 setPreferenceProperty( wh, "step", 0.1 );
5421 setPreferenceProperty( hh, "min", 0.0 );
5422 setPreferenceProperty( hh, "max", 1.0 );
5423 setPreferenceProperty( hh, "step", 0.1 );
5425 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5426 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5427 setPreferenceProperty( distributionGr, "columns", 3 );
5429 types.append( tr( "SMESH_MONOCOLOR" ) );
5430 types.append( tr( "SMESH_MULTICOLOR" ) );
5431 indices.clear(); indices.append( 0 ); indices.append( 1 );
5432 setPreferenceProperty( coloringType, "strings", types );
5433 setPreferenceProperty( coloringType, "indexes", indices );
5434 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5438 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5440 if ( sect=="SMESH" ) {
5441 float sbX1 = 0.01, sbY1 = 0.01, sbW = 0.08, sbH = 0.08;
5442 float aTol = 1.00000009999999;
5443 std::string aWarning;
5444 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5446 if ( name== "selection_object_color" ||
5447 name=="selection_element_color" ||
5448 name== "highlight_color" ||
5449 name=="selection_precision_node" ||
5450 name=="selection_precision_element" ||
5451 name=="selection_precision_object" ||
5452 name=="selection_increment")
5454 SMESH::UpdateSelectionProp( this );
5456 else if (name == "scalar_bar_vertical_x" || name == "scalar_bar_vertical_width")
5458 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5459 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5460 if ( sbX1+sbW > aTol ) {
5461 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5464 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5465 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5468 else if (name == "scalar_bar_vertical_y" || name == "scalar_bar_vertical_height" )
5470 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5471 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5472 if ( sbY1 + sbH > aTol ) {
5473 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5474 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5475 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5478 else if (name == "scalar_bar_horizontal_x" || name == "scalar_bar_horizontal_width")
5480 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5481 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5482 if ( sbX1 + sbW > aTol ) {
5483 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5486 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5487 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5490 else if (name == "scalar_bar_horizontal_y" || name == "scalar_bar_horizontal_height")
5492 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5493 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5494 if ( sbY1 + sbH > aTol ) {
5495 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5498 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5499 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5502 else if ( name == "segmentation" )
5504 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5505 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5507 else if ( name == "nb_segments_per_edge" )
5509 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5510 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5512 else if ( name == "historical_python_dump" || name == "forget_mesh_on_hyp_modif" || name == "default_grp_color" )
5514 QString val = aResourceMgr->stringValue( "SMESH", name );
5515 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5517 else if ( name == "numbering_node_color" || name == "numbering_node_font" )
5519 SMESH::UpdateFontProp( this );
5521 else if ( name == "numbering_elem_color" || name == "numbering_elem_font" )
5523 SMESH::UpdateFontProp( this );
5526 if ( aWarning.size() != 0 ) {
5527 aWarning += "The default values are applied instead.";
5528 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5529 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5530 QObject::tr(aWarning.c_str()));
5535 //================================================================================
5537 * \brief Update something in accordance with update flags
5538 * \param theFlags - update flags
5540 * Update viewer or/and object browser etc. in accordance with update flags ( see
5541 * LightApp_UpdateFlags enumeration ).
5543 //================================================================================
5544 void SMESHGUI::update( const int flags )
5546 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5547 SMESH::UpdateView();
5549 SalomeApp_Module::update( flags );
5552 //================================================================================
5554 * \brief Set default selection mode
5556 * SLOT called when operation committed. Sets default selection mode
5558 //================================================================================
5559 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5561 SVTK_ViewWindow* vtkWnd =
5562 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5564 vtkWnd->SetSelectionMode( ActorSelection );
5567 //================================================================================
5569 * \brief Set default selection mode
5571 * SLOT called when operation aborted. Sets default selection mode
5573 //================================================================================
5574 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5576 SVTK_ViewWindow* vtkWnd =
5577 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5579 vtkWnd->SetSelectionMode( ActorSelection );
5582 //================================================================================
5584 * \brief Creates operation with given identifier
5585 * \param id - identifier of operation to be started
5586 * \return Pointer on created operation or NULL if operation is not created
5588 * Virtual method redefined from the base class creates operation with given id.
5589 * It is called called automatically from startOperation method of base class.
5591 //================================================================================
5592 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5594 LightApp_Operation* op = 0;
5595 // to do : create operation here
5598 case SMESHOp::OpSplitBiQuadratic:
5599 op = new SMESHGUI_SplitBiQuadOp();
5601 case SMESHOp::OpConvertMeshToQuadratic:
5602 op = new SMESHGUI_ConvToQuadOp();
5604 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5605 op = new SMESHGUI_Make2DFrom3DOp();
5607 case SMESHOp::OpReorientFaces:
5608 op = new SMESHGUI_ReorientFacesOp();
5610 case SMESHOp::OpCreateMesh:
5611 op = new SMESHGUI_MeshOp( true, true );
5613 case SMESHOp::OpCreateSubMesh:
5614 op = new SMESHGUI_MeshOp( true, false );
5616 case SMESHOp::OpEditMeshOrSubMesh:
5617 case SMESHOp::OpEditMesh:
5618 case SMESHOp::OpEditSubMesh:
5619 op = new SMESHGUI_MeshOp( false );
5621 case SMESHOp::OpCompute:
5622 case SMESHOp::OpComputeSubMesh:
5623 op = new SMESHGUI_ComputeOp();
5625 case SMESHOp::OpPreCompute:
5626 op = new SMESHGUI_PrecomputeOp();
5628 case SMESHOp::OpEvaluate:
5629 op = new SMESHGUI_EvaluateOp();
5631 case SMESHOp::OpMeshOrder:
5632 op = new SMESHGUI_MeshOrderOp();
5634 case SMESHOp::OpCreateGeometryGroup:
5635 op = new SMESHGUI_GroupOnShapeOp();
5637 case SMESHOp::OpFindElementByPoint:
5638 op = new SMESHGUI_FindElemByPointOp();
5640 case SMESHOp::OpMoveNode: // Make mesh pass through point
5641 op = new SMESHGUI_MakeNodeAtPointOp();
5643 case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
5644 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5651 op = SalomeApp_Module::createOperation( id );
5655 //================================================================================
5657 * \brief Stops current operations and starts a given one
5658 * \param id - The id of the operation to start
5660 //================================================================================
5662 void SMESHGUI::switchToOperation(int id)
5664 activeStudy()->abortAllOperations();
5665 startOperation( id );
5668 LightApp_Displayer* SMESHGUI::displayer()
5671 myDisplayer = new SMESHGUI_Displayer( getApp() );
5675 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5678 int aTolerance = 64;
5679 int anIterations = 0;
5685 if( anIterations % aPeriod == 0 )
5688 if( aTolerance < 1 )
5692 aHue = (int)( 360.0 * rand() / RAND_MAX );
5695 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5696 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5697 for( ; it != itEnd; ++it )
5699 SALOMEDS::Color anAutoColor = *it;
5700 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5703 aQColor.getHsv( &h, &s, &v );
5704 if( abs( h - aHue ) < aTolerance )
5716 aColor.setHsv( aHue, 255, 255 );
5718 SALOMEDS::Color aSColor;
5719 aSColor.R = aColor.redF();
5720 aSColor.G = aColor.greenF();
5721 aSColor.B = aColor.blueF();
5726 const char* gSeparator = "_"; // character used to separate parameter names
5727 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5728 const char* gPathSep = "|"; // character used to separate paths
5731 * \brief Store visual parameters
5733 * This method is called just before the study document is saved.
5734 * Store visual parameters in AttributeParameter attribue(s)
5736 void SMESHGUI::storeVisualParameters (int savePoint)
5739 Kernel_Utils::Localizer loc;
5741 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5742 if (!appStudy || !appStudy->studyDS())
5744 _PTR(Study) studyDS = appStudy->studyDS();
5746 // componentName is used for encoding of entries when storing them in IParameters
5747 std::string componentName = myComponentSMESH->ComponentDataType();
5748 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5749 //if (!aSComponent) return;
5752 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5753 componentName.c_str(),
5755 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5757 // store custom markers
5758 if( !myMarkerMap.empty() )
5760 VTK::MarkerMap::const_iterator anIter = myMarkerMap.begin();
5761 for( ; anIter != myMarkerMap.end(); anIter++ )
5763 int anId = anIter->first;
5764 VTK::MarkerData aMarkerData = anIter->second;
5765 std::string aMarkerFileName = aMarkerData.first;
5766 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5767 if( aMarkerTexture.size() < 3 )
5768 continue; // should contain at least width, height and the first value
5770 QString aPropertyName( "texture" );
5771 aPropertyName += gSeparator;
5772 aPropertyName += QString::number( anId );
5774 QString aPropertyValue = aMarkerFileName.c_str();
5775 aPropertyValue += gPathSep;
5777 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5778 ushort aWidth = *aTextureIter++;
5779 ushort aHeight = *aTextureIter++;
5780 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5781 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5782 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5783 aPropertyValue += QString::number( *aTextureIter );
5785 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5789 // viewers counters are used for storing view_numbers in IParameters
5792 // main cycle to store parameters of displayed objects
5793 QList<SUIT_ViewManager*> lst;
5794 QList<SUIT_ViewManager*>::Iterator it;
5795 getApp()->viewManagers(lst);
5796 for (it = lst.begin(); it != lst.end(); it++)
5798 SUIT_ViewManager* vman = *it;
5799 QString vType = vman->getType();
5801 // saving VTK actors properties
5802 if (vType == SVTK_Viewer::Type())
5804 // store the clipping planes attached to the view manager
5805 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5806 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5807 if( anIter != myClippingPlaneInfoMap.end() )
5808 aClippingPlaneInfoList = anIter->second;
5810 if( !aClippingPlaneInfoList.empty() ) {
5811 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5812 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5814 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5815 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5817 QString aPropertyName( "ClippingPlane" );
5818 aPropertyName += gSeparator;
5819 aPropertyName += QString::number( vtkViewers );
5820 aPropertyName += gSeparator;
5821 aPropertyName += QString::number( anId );
5823 QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
5824 aPropertyValue += gDigitsSep;
5825 aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
5826 aPropertyValue += gDigitsSep;
5827 if ( aPlane->PlaneMode == SMESH::Absolute ) {
5828 aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
5829 aPropertyValue += gDigitsSep;
5830 aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
5831 aPropertyValue += gDigitsSep;
5832 aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
5833 aPropertyValue += gDigitsSep;
5834 aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
5835 aPropertyValue += gDigitsSep;
5836 aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
5837 aPropertyValue += gDigitsSep;
5838 aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
5839 aPropertyValue += gDigitsSep;
5840 aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
5842 else if ( aPlane->PlaneMode == SMESH::Relative ) {
5843 aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
5844 aPropertyValue += gDigitsSep;
5845 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5846 aPropertyValue += gDigitsSep;
5847 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5848 aPropertyValue += gDigitsSep;
5849 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5852 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5856 QVector<SUIT_ViewWindow*> views = vman->getViews();
5857 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5859 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5861 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5862 vtkActorCollection* allActors = aCopy.GetActors();
5863 allActors->InitTraversal();
5864 while (vtkActor* actor = allActors->GetNextActor())
5866 if (actor->GetVisibility()) // store only visible actors
5868 SMESH_Actor* aSmeshActor = 0;
5869 if (actor->IsA("SMESH_Actor"))
5870 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5871 if (aSmeshActor && aSmeshActor->hasIO())
5873 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5876 // entry is "encoded" = it does NOT contain component address,
5877 // since it is a subject to change on next component loading
5878 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5880 std::string param, vtkParam = vType.toLatin1().data();
5881 vtkParam += gSeparator;
5882 vtkParam += QString::number(vtkViewers).toLatin1().data();
5883 vtkParam += gSeparator;
5886 param = vtkParam + "Visibility";
5887 ip->setParameter(entry, param, "On");
5890 param = vtkParam + "Representation";
5891 ip->setParameter(entry, param, QString::number
5892 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5895 param = vtkParam + "IsShrunk";
5896 ip->setParameter(entry, param, QString::number
5897 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5899 // Displayed entities
5900 unsigned int aMode = aSmeshActor->GetEntityMode();
5901 bool isE = aMode & SMESH_Actor::eEdges;
5902 bool isF = aMode & SMESH_Actor::eFaces;
5903 bool isV = aMode & SMESH_Actor::eVolumes;
5904 bool is0d = aMode & SMESH_Actor::e0DElements;
5905 bool isB = aMode & SMESH_Actor::eBallElem;
5907 QString modeStr ("e");
5908 modeStr += gDigitsSep; modeStr += QString::number(isE);
5909 modeStr += gDigitsSep; modeStr += "f";
5910 modeStr += gDigitsSep; modeStr += QString::number(isF);
5911 modeStr += gDigitsSep; modeStr += "v";
5912 modeStr += gDigitsSep; modeStr += QString::number(isV);
5913 modeStr += gDigitsSep; modeStr += "0d";
5914 modeStr += gDigitsSep; modeStr += QString::number(is0d);
5915 modeStr += gDigitsSep; modeStr += "b";
5916 modeStr += gDigitsSep; modeStr += QString::number(isB);
5918 param = vtkParam + "Entities";
5919 ip->setParameter(entry, param, modeStr.toLatin1().data());
5925 aSmeshActor->GetSufaceColor(r, g, b, delta);
5926 QStringList colorStr;
5927 colorStr << "surface";
5928 colorStr << QString::number(r);
5929 colorStr << QString::number(g);
5930 colorStr << QString::number(b);
5932 colorStr << "backsurface";
5933 colorStr << QString::number(delta);
5935 aSmeshActor->GetVolumeColor(r, g, b, delta);
5936 colorStr << "volume";
5937 colorStr << QString::number(r);
5938 colorStr << QString::number(g);
5939 colorStr << QString::number(b);
5940 colorStr << QString::number(delta);
5942 aSmeshActor->GetEdgeColor(r, g, b);
5944 colorStr << QString::number(r);
5945 colorStr << QString::number(g);
5946 colorStr << QString::number(b);
5948 aSmeshActor->GetNodeColor(r, g, b);
5950 colorStr << QString::number(r);
5951 colorStr << QString::number(g);
5952 colorStr << QString::number(b);
5954 aSmeshActor->GetOutlineColor(r, g, b);
5955 colorStr << "outline";
5956 colorStr << QString::number(r);
5957 colorStr << QString::number(g);
5958 colorStr << QString::number(b);
5960 aSmeshActor->Get0DColor(r, g, b);
5961 colorStr << "elem0d";
5962 colorStr << QString::number(r);
5963 colorStr << QString::number(g);
5964 colorStr << QString::number(b);
5966 aSmeshActor->GetBallColor(r, g, b);
5968 colorStr << QString::number(r);
5969 colorStr << QString::number(g);
5970 colorStr << QString::number(b);
5972 aSmeshActor->GetFacesOrientationColor(r, g, b);
5973 colorStr << "orientation";
5974 colorStr << QString::number(r);
5975 colorStr << QString::number(g);
5976 colorStr << QString::number(b);
5978 param = vtkParam + "Colors";
5979 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
5982 QStringList sizeStr;
5984 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
5985 sizeStr << "outline";
5986 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
5987 sizeStr << "elem0d";
5988 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
5990 //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
5991 sizeStr << QString::number((double)aSmeshActor->GetBallSize());
5992 sizeStr << QString::number((double)aSmeshActor->GetBallScale());
5993 sizeStr << "shrink";
5994 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
5995 sizeStr << "orientation";
5996 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
5997 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
5999 param = vtkParam + "Sizes";
6000 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
6005 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
6006 if( aMarkerType == VTK::MT_USER ) {
6007 markerStr += "custom";
6008 markerStr += gDigitsSep;
6009 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
6013 markerStr += gDigitsSep;
6014 markerStr += QString::number( (int)aMarkerType );
6015 markerStr += gDigitsSep;
6016 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
6019 param = vtkParam + "PointMarker";
6020 ip->setParameter(entry, param, markerStr.toLatin1().data());
6023 param = vtkParam + "Opacity";
6024 ip->setParameter(entry, param,
6025 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
6028 param = vtkParam + "ClippingPlane";
6030 if( !aClippingPlaneInfoList.empty() ) {
6031 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
6032 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
6034 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
6035 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
6036 SMESH::TActorList::iterator anIter2 = anActorList.begin();
6037 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
6038 if( aSmeshActor == *anIter2 ) {
6039 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
6040 QString::number( anId ).toLatin1().constData() );
6047 ip->setParameter( entry, param, "Off" );
6048 } // if (io->hasEntry())
6049 } // SMESH_Actor && hasIO
6051 } // while.. actors traversal
6055 } // if (SVTK view model)
6056 } // for (viewManagers)
6059 // data structures for clipping planes processing
6063 bool isOpenGLClipping;
6064 vtkIdType RelativeOrientation;
6067 int AbsoluteOrientation;
6068 double X, Y, Z, Dx, Dy, Dz;
6070 typedef std::list<TPlaneData> TPlaneDataList;
6071 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
6073 typedef std::list<vtkActor*> TActorList;
6076 TActorList ActorList;
6077 SUIT_ViewManager* ViewManager;
6079 typedef std::list<TPlaneInfo> TPlaneInfoList;
6080 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
6083 * \brief Restore visual parameters
6085 * This method is called after the study document is opened.
6086 * Restore visual parameters from AttributeParameter attribue(s)
6088 void SMESHGUI::restoreVisualParameters (int savePoint)
6091 Kernel_Utils::Localizer loc;
6093 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6094 if (!appStudy || !appStudy->studyDS())
6096 _PTR(Study) studyDS = appStudy->studyDS();
6098 // componentName is used for encoding of entries when storing them in IParameters
6099 std::string componentName = myComponentSMESH->ComponentDataType();
6100 //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
6101 //if (!aSComponent) return;
6104 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6105 componentName.c_str(),
6107 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6109 // restore custom markers and map of clipping planes
6110 TPlaneDataMap aPlaneDataMap;
6112 std::vector<std::string> properties = ip->getProperties();
6113 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
6115 std::string property = *propIt;
6116 QString aPropertyName( property.c_str() );
6117 QString aPropertyValue( ip->getProperty( property ).c_str() );
6119 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
6120 if( aPropertyNameList.isEmpty() )
6123 QString aPropertyType = aPropertyNameList[0];
6124 if( aPropertyType == "texture" )
6126 if( aPropertyNameList.size() != 2 )
6130 int anId = aPropertyNameList[1].toInt( &ok );
6131 if( !ok || anId < 1 )
6134 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
6135 if( aPropertyValueList.size() != 2 )
6138 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
6139 QString aMarkerTextureString = aPropertyValueList[1];
6140 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
6141 if( aMarkerTextureStringList.size() != 3 )
6145 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6150 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6154 VTK::MarkerTexture aMarkerTexture;
6155 aMarkerTexture.push_back( aWidth );
6156 aMarkerTexture.push_back( aHeight );
6158 QString aMarkerTextureData = aMarkerTextureStringList[2];
6159 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6161 QChar aChar = aMarkerTextureData.at( i );
6162 if( aChar.isDigit() )
6163 aMarkerTexture.push_back( aChar.digitValue() );
6166 myMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6168 else if( aPropertyType == "ClippingPlane" )
6170 if( aPropertyNameList.size() != 3 )
6174 int aViewId = aPropertyNameList[1].toInt( &ok );
6175 if( !ok || aViewId < 0 )
6179 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6180 if( !ok || aClippingPlaneId < 0 )
6183 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6184 if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6187 TPlaneData aPlaneData;
6188 aPlaneData.AbsoluteOrientation = false;
6189 aPlaneData.RelativeOrientation = 0;
6190 aPlaneData.Distance = aPlaneData.Angle[0] = aPlaneData.Angle[1] = 0;
6191 aPlaneData.X = aPlaneData.Y = aPlaneData.Z = 0;
6192 aPlaneData.Dx = aPlaneData.Dy = aPlaneData.Dz = 0;
6194 aPlaneData.Id = aClippingPlaneId;
6197 aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6202 aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6206 if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6209 aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6214 aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6219 aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6224 aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6229 aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6234 aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6239 aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6243 else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6245 aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6250 aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6255 aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6260 aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6265 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6266 aPlaneDataList.push_back( aPlaneData );
6270 TPlaneInfoMap aPlaneInfoMap;
6272 std::vector<std::string> entries = ip->getEntries();
6274 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6276 // entry is a normal entry - it should be "decoded" (setting base address of component)
6277 QString entry (ip->decodeEntry(*entIt).c_str());
6279 // Check that the entry corresponds to a real object in the Study
6280 // as the object may be deleted or modified after the visual state is saved.
6281 _PTR(SObject) so = studyDS->FindObjectID(entry.toUtf8().data());
6282 if (!so) continue; //Skip the not existent entry
6284 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6285 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6287 std::vector<std::string>::iterator namesIt = paramNames.begin();
6288 std::vector<std::string>::iterator valuesIt = paramValues.begin();
6290 // actors are stored in a map after displaying of them for
6291 // quicker access in the future: map < viewID to actor >
6292 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6294 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6296 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6297 // '_' is used as separator and should not be used in viewer type or parameter names.
6298 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6299 if (lst.size() != 3)
6302 QString viewerTypStr = lst[0];
6303 QString viewIndexStr = lst[1];
6304 QString paramNameStr = lst[2];
6307 int viewIndex = viewIndexStr.toUInt(&ok);
6308 if (!ok) // bad conversion of view index to integer
6312 if (viewerTypStr == SVTK_Viewer::Type())
6314 SMESH_Actor* aSmeshActor = 0;
6315 if (vtkActors.IsBound(viewIndex))
6316 aSmeshActor = vtkActors.Find(viewIndex);
6318 QList<SUIT_ViewManager*> lst;
6319 getApp()->viewManagers(viewerTypStr, lst);
6321 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6322 SUIT_ViewManager* vman = NULL;
6323 if (viewIndex >= 0 && viewIndex < lst.count())
6324 vman = lst.at(viewIndex);
6326 if (paramNameStr == "Visibility")
6328 if (!aSmeshActor && displayer() && vman)
6330 SUIT_ViewModel* vmodel = vman->getViewModel();
6331 // SVTK view model can be casted to SALOME_View
6332 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6334 // store displayed actor in a temporary map for quicker
6335 // access later when restoring other parameters
6336 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6337 vtkRenderer* Renderer = vtkView->getRenderer();
6338 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6339 vtkActorCollection* theActors = aCopy.GetActors();
6340 theActors->InitTraversal();
6341 bool isFound = false;
6342 vtkActor *ac = theActors->GetNextActor();
6343 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6344 if (ac->IsA("SMESH_Actor")) {
6345 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6346 if (aGeomAc->hasIO()) {
6347 Handle(SALOME_InteractiveObject) io = aGeomAc->getIO();
6348 if (io->hasEntry() && strcmp(io->getEntry(), entry.toUtf8().data()) == 0) {
6350 vtkActors.Bind(viewIndex, aGeomAc);
6356 } // if (paramNameStr == "Visibility")
6359 // the rest properties "work" with SMESH_Actor
6362 QString val ((*valuesIt).c_str());
6365 if (paramNameStr == "Representation") {
6366 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6369 else if (paramNameStr == "IsShrunk") {
6371 if (!aSmeshActor->IsShrunk())
6372 aSmeshActor->SetShrink();
6375 if (aSmeshActor->IsShrunk())
6376 aSmeshActor->UnShrink();
6379 // Displayed entities
6380 else if (paramNameStr == "Entities") {
6381 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6382 int aEntityMode = SMESH_Actor::eAllEntity;
6383 for ( int i = 0; i < mode.count(); i+=2 ) {
6384 if ( i < mode.count()-1 ) {
6385 QString type = mode[i];
6386 bool val = mode[i+1].toInt();
6387 if ( type == "e" && !val )
6388 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6389 else if ( type == "f" && !val )
6390 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6391 else if ( type == "v" && !val )
6392 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6393 else if ( type == "0d" && !val )
6394 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6395 else if ( type == "b" && !val )
6396 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6399 aSmeshActor->SetEntityMode( aEntityMode );
6402 else if (paramNameStr == "Colors") {
6403 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6410 QColor outlineColor;
6411 QColor orientationColor;
6417 // below lines are required to get default values for delta coefficients
6418 // of backface color for faces and color of reversed volumes
6419 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
6420 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6421 for ( int i = 0; i < colors.count(); i++ ) {
6422 QString type = colors[i];
6423 if ( type == "surface" ) {
6424 // face color is set by 3 values r:g:b, where
6425 // - r,g,b - is rgb color components
6426 if ( i+1 >= colors.count() ) break; // format error
6427 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6428 if ( i+2 >= colors.count() ) break; // format error
6429 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6430 if ( i+3 >= colors.count() ) break; // format error
6431 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6432 faceColor.setRgbF( r, g, b );
6435 else if ( type == "backsurface" ) {
6436 // backface color can be defined in several ways
6437 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6438 // - in latest versions, it is set as delta coefficient
6439 bool rgbOk = false, deltaOk;
6440 if ( i+1 >= colors.count() ) break; // format error
6441 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6442 int delta = colors[i+1].toInt( &deltaOk );
6444 if ( i+1 < colors.count() ) // index is shifted to 1
6445 g = colors[i+1].toDouble( &rgbOk );
6446 if ( rgbOk ) i++; // shift index
6447 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6448 b = colors[i+1].toDouble( &rgbOk );
6450 // - as currently there's no way to set directly backsurface color as it was before,
6451 // we ignore old dump where r,g,b triple was set
6452 // - also we check that delta parameter is set properly
6453 if ( !rgbOk && deltaOk )
6456 else if ( type == "volume" ) {
6457 // volume color is set by 4 values r:g:b:delta, where
6458 // - r,g,b - is a normal volume rgb color components
6459 // - delta - is a reversed volume color delta coefficient
6460 if ( i+1 >= colors.count() ) break; // format error
6461 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6462 if ( i+2 >= colors.count() ) break; // format error
6463 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6464 if ( i+3 >= colors.count() ) break; // format error
6465 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6466 if ( i+4 >= colors.count() ) break; // format error
6467 int delta = colors[i+4].toInt( &bOk );
6468 if ( !bOk ) break; // format error
6469 volumeColor.setRgbF( r, g, b );
6473 else if ( type == "edge" ) {
6474 // edge color is set by 3 values r:g:b, where
6475 // - r,g,b - is rgb color components
6476 if ( i+1 >= colors.count() ) break; // format error
6477 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6478 if ( i+2 >= colors.count() ) break; // format error
6479 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6480 if ( i+3 >= colors.count() ) break; // format error
6481 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6482 edgeColor.setRgbF( r, g, b );
6485 else if ( type == "node" ) {
6486 // node color is set by 3 values r:g:b, where
6487 // - r,g,b - is rgb color components
6488 if ( i+1 >= colors.count() ) break; // format error
6489 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6490 if ( i+2 >= colors.count() ) break; // format error
6491 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6492 if ( i+3 >= colors.count() ) break; // format error
6493 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6494 nodeColor.setRgbF( r, g, b );
6497 else if ( type == "elem0d" ) {
6498 // 0d element color is set by 3 values r:g:b, where
6499 // - r,g,b - is rgb color components
6500 if ( i+1 >= colors.count() ) break; // format error
6501 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6502 if ( i+2 >= colors.count() ) break; // format error
6503 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6504 if ( i+3 >= colors.count() ) break; // format error
6505 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6506 elem0dColor.setRgbF( r, g, b );
6509 else if ( type == "ball" ) {
6510 // ball color is set by 3 values r:g:b, where
6511 // - r,g,b - is rgb color components
6512 if ( i+1 >= colors.count() ) break; // format error
6513 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6514 if ( i+2 >= colors.count() ) break; // format error
6515 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6516 if ( i+3 >= colors.count() ) break; // format error
6517 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6518 ballColor.setRgbF( r, g, b );
6521 else if ( type == "outline" ) {
6522 // outline color is set by 3 values r:g:b, where
6523 // - r,g,b - is rgb color components
6524 if ( i+1 >= colors.count() ) break; // format error
6525 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6526 if ( i+2 >= colors.count() ) break; // format error
6527 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6528 if ( i+3 >= colors.count() ) break; // format error
6529 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6530 outlineColor.setRgbF( r, g, b );
6533 else if ( type == "orientation" ) {
6534 // orientation color is set by 3 values r:g:b, where
6535 // - r,g,b - is rgb color components
6536 if ( i+1 >= colors.count() ) break; // format error
6537 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6538 if ( i+2 >= colors.count() ) break; // format error
6539 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6540 if ( i+3 >= colors.count() ) break; // format error
6541 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6542 orientationColor.setRgbF( r, g, b );
6547 if ( nodeColor.isValid() )
6548 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6550 if ( edgeColor.isValid() )
6551 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6553 if ( faceColor.isValid() )
6554 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6556 if ( volumeColor.isValid() )
6557 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6558 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6559 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6561 if ( elem0dColor.isValid() )
6562 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6564 if ( ballColor.isValid() )
6565 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6567 if ( outlineColor.isValid() )
6568 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6569 // orientation color
6570 if ( orientationColor.isValid() )
6571 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6574 else if (paramNameStr == "Sizes") {
6575 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6578 int outlineWidth = -1;
6579 int elem0dSize = -1;
6580 //int ballSize = -1;
6581 double ballDiameter = -1.0;
6582 double ballScale = -1.0;
6583 double shrinkSize = -1;
6584 double orientationSize = -1;
6585 bool orientation3d = false;
6586 for ( int i = 0; i < sizes.count(); i++ ) {
6587 QString type = sizes[i];
6588 if ( type == "line" ) {
6589 // line (wireframe) width is given as single integer value
6590 if ( i+1 >= sizes.count() ) break; // format error
6591 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6595 if ( type == "outline" ) {
6596 // outline width is given as single integer value
6597 if ( i+1 >= sizes.count() ) break; // format error
6598 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6602 else if ( type == "elem0d" ) {
6603 // 0d element size is given as single integer value
6604 if ( i+1 >= sizes.count() ) break; // format error
6605 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6609 else if ( type == "ball" ) {
6610 // balls are specified by two values: size:scale, where
6611 // - size - is a integer value specifying size
6612 // - scale - is a double value specifying scale factor
6613 if ( i+1 >= sizes.count() ) break; // format error
6614 //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6615 double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6616 if ( i+2 >= sizes.count() ) break; // format error
6617 double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6623 else if ( type == "shrink" ) {
6624 // shrink factor is given as single floating point value
6625 if ( i+1 >= sizes.count() ) break; // format error
6626 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6630 else if ( type == "orientation" ) {
6631 // orientation vectors are specified by two values size:3d, where
6632 // - size - is a floating point value specifying scale factor
6633 // - 3d - is a boolean
6634 if ( i+1 >= sizes.count() ) break; // format error
6635 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6636 if ( i+2 >= sizes.count() ) break; // format error
6637 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6638 orientationSize = v1;
6639 orientation3d = (bool)v2;
6643 // line (wireframe) width
6644 if ( lineWidth > 0 )
6645 aSmeshActor->SetLineWidth( lineWidth );
6647 if ( outlineWidth > 0 )
6648 aSmeshActor->SetOutlineWidth( outlineWidth );
6649 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6650 aSmeshActor->SetOutlineWidth( lineWidth );
6652 if ( elem0dSize > 0 )
6653 aSmeshActor->Set0DSize( elem0dSize );
6655 /*if ( ballSize > 0 )
6656 aSmeshActor->SetBallSize( ballSize );*/
6658 if ( ballDiameter > 0 )
6659 aSmeshActor->SetBallSize( ballDiameter );
6661 if ( ballScale > 0.0 )
6662 aSmeshActor->SetBallScale( ballScale );
6664 if ( shrinkSize > 0 )
6665 aSmeshActor->SetShrinkFactor( shrinkSize );
6666 // orientation vectors
6667 if ( orientationSize > 0 ) {
6668 aSmeshActor->SetFacesOrientationScale( orientationSize );
6669 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6673 else if (paramNameStr == "PointMarker") {
6674 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6675 if( data.count() >= 2 ) {
6677 int aParam1 = data[1].toInt( &ok );
6679 if( data[0] == "std" && data.count() == 3 ) {
6680 int aParam2 = data[2].toInt( &ok );
6681 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6683 else if( data[0] == "custom" ) {
6684 VTK::MarkerMap::const_iterator markerIt = myMarkerMap.find( aParam1 );
6685 if( markerIt != myMarkerMap.end() ) {
6686 VTK::MarkerData aMarkerData = markerIt->second;
6687 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6694 else if (paramNameStr == "Opacity") {
6695 aSmeshActor->SetOpacity(val.toFloat());
6698 else if (paramNameStr.startsWith("ClippingPlane")) {
6699 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6700 // old format - val looks like "Off" or "1:0:0:0.5:0:0"
6701 // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
6702 // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
6703 // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
6704 // new format - val looks like "Off" or "0" (plane id)
6705 // (note: in new format "Off" value is used only for consistency,
6706 // so it is processed together with values in old format)
6707 bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
6708 if( anIsOldFormat ) {
6709 if (paramNameStr == "ClippingPlane1" || val == "Off")
6710 aSmeshActor->RemoveAllClippingPlanes();
6712 QList<SUIT_ViewManager*> lst;
6713 getApp()->viewManagers(viewerTypStr, lst);
6714 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6715 if (viewIndex >= 0 && viewIndex < lst.count()) {
6716 SUIT_ViewManager* vman = lst.at(viewIndex);
6717 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6719 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6721 SMESH::TActorList anActorList;
6722 anActorList.push_back( aSmeshActor );
6723 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
6724 aPlane->myViewWindow = vtkView;
6725 SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
6726 aPlane->PlaneMode = aMode;
6727 bool isOpenGLClipping = ( bool )vals[1].toInt();
6728 aPlane->IsOpenGLClipping = isOpenGLClipping;
6729 if ( aMode == SMESH::Absolute ) {
6730 aPlane->myAbsoluteOrientation = vals[2].toInt();
6731 aPlane->X = vals[3].toFloat();
6732 aPlane->Y = vals[4].toFloat();
6733 aPlane->Z = vals[5].toFloat();
6734 aPlane->Dx = vals[6].toFloat();
6735 aPlane->Dy = vals[7].toFloat();
6736 aPlane->Dz = vals[8].toFloat();
6738 else if ( aMode == SMESH::Relative ) {
6739 aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
6740 aPlane->myDistance = vals[3].toFloat();
6741 aPlane->myAngle[0] = vals[4].toFloat();
6742 aPlane->myAngle[1] = vals[5].toFloat();
6746 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6747 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6748 aClippingPlaneInfo.Plane = aPlane;
6749 aClippingPlaneInfo.ActorList = anActorList;
6750 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6758 int aPlaneId = val.toInt( &ok );
6759 if( ok && aPlaneId >= 0 ) {
6760 bool anIsDefinedPlane = false;
6761 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6762 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6763 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6764 TPlaneInfo& aPlaneInfo = *anIter;
6765 if( aPlaneInfo.PlaneId == aPlaneId ) {
6766 aPlaneInfo.ActorList.push_back( aSmeshActor );
6767 anIsDefinedPlane = true;
6771 if( !anIsDefinedPlane ) {
6772 TPlaneInfo aPlaneInfo;
6773 aPlaneInfo.PlaneId = aPlaneId;
6774 aPlaneInfo.ActorList.push_back( aSmeshActor );
6775 aPlaneInfo.ViewManager = vman;
6777 // to make the list sorted by plane id
6778 anIter = aPlaneInfoList.begin();
6779 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6780 const TPlaneInfo& aPlaneInfoRef = *anIter;
6781 if( aPlaneInfoRef.PlaneId > aPlaneId )
6784 aPlaneInfoList.insert( anIter, aPlaneInfo );
6789 } // if (aSmeshActor)
6790 } // other parameters than Visibility
6792 } // for names/parameters iterator
6793 } // for entries iterator
6795 // take into account planes with empty list of actors referred to them
6796 QList<SUIT_ViewManager*> aVMList;
6797 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6799 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6800 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6801 int aViewId = aPlaneDataIter->first;
6802 if( aViewId >= 0 && aViewId < aVMList.count() ) {
6803 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6805 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6807 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6808 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6809 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6810 const TPlaneData& aPlaneData = *anIter2;
6811 int aPlaneId = aPlaneData.Id;
6813 bool anIsFound = false;
6814 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6815 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6816 const TPlaneInfo& aPlaneInfo = *anIter3;
6817 if( aPlaneInfo.PlaneId == aPlaneId ) {
6824 TPlaneInfo aPlaneInfo; // ActorList field is empty
6825 aPlaneInfo.PlaneId = aPlaneId;
6826 aPlaneInfo.ViewManager = aViewManager;
6828 // to make the list sorted by plane id
6829 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6830 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6831 const TPlaneInfo& aPlaneInfoRef = *anIter4;
6832 if( aPlaneInfoRef.PlaneId > aPlaneId )
6835 aPlaneInfoList.insert( anIter4, aPlaneInfo );
6841 // add clipping planes to actors according to the restored parameters
6842 // and update the clipping plane map
6843 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6844 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6845 int aViewId = anIter1->first;
6846 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6848 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6849 if( anIter2 == aPlaneDataMap.end() )
6851 const TPlaneDataList& aPlaneDataList = anIter2->second;
6853 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6854 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6855 const TPlaneInfo& aPlaneInfo = *anIter3;
6856 int aPlaneId = aPlaneInfo.PlaneId;
6857 const TActorList& anActorList = aPlaneInfo.ActorList;
6858 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6862 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6866 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6868 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6869 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6870 const TPlaneData& aPlaneData = *anIter4;
6871 if( aPlaneData.Id == aPlaneId ) {
6872 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
6873 aPlane->myViewWindow = aViewWindow;
6874 aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
6875 aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
6876 if ( aPlane->PlaneMode == SMESH::Absolute ) {
6877 aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
6878 aPlane->X = aPlaneData.X;
6879 aPlane->Y = aPlaneData.Y;
6880 aPlane->Z = aPlaneData.Z;
6881 aPlane->Dx = aPlaneData.Dx;
6882 aPlane->Dy = aPlaneData.Dy;
6883 aPlane->Dz = aPlaneData.Dz;
6885 else if ( aPlane->PlaneMode == SMESH::Relative ) {
6886 aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
6887 aPlane->myDistance = aPlaneData.Distance;
6888 aPlane->myAngle[0] = aPlaneData.Angle[0];
6889 aPlane->myAngle[1] = aPlaneData.Angle[1];
6892 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6893 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6894 aClippingPlaneInfo.Plane = aPlane;
6895 aClippingPlaneInfo.ActorList = anActorList;
6896 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6907 // update all VTK views
6908 QList<SUIT_ViewManager*> lst;
6909 getApp()->viewManagers(lst);
6910 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6911 SUIT_ViewModel* vmodel = (*it)->getViewModel();
6912 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6913 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6914 // set OpenGL clipping planes
6915 VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
6916 vtkActorCollection* anAllActors = aCopy.GetActors();
6917 anAllActors->InitTraversal();
6918 while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
6919 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
6920 anActor->SetOpenGLClippingPlane();
6922 vtkView->getRenderer()->ResetCameraClippingRange();
6929 \brief Adds preferences for dfont of VTK viewer
6931 \param pIf group identifier
6932 \param param parameter
6933 \return identifier of preferences
6935 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
6937 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6939 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6942 fam.append( tr( "SMESH_FONT_ARIAL" ) );
6943 fam.append( tr( "SMESH_FONT_COURIER" ) );
6944 fam.append( tr( "SMESH_FONT_TIMES" ) );
6946 setPreferenceProperty( tfont, "fonts", fam );
6948 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6949 if ( needSize ) f = f | QtxFontEdit::Size;
6950 setPreferenceProperty( tfont, "features", f );
6956 \brief Actions after hypothesis edition
6957 Updates object browser after hypothesis edition
6959 void SMESHGUI::onHypothesisEdit( int result )
6962 SMESHGUI::Modified();
6963 updateObjBrowser( true );
6967 \brief Actions after choosing menu of control modes
6968 Updates control mode actions according to current selection
6970 void SMESHGUI::onUpdateControlActions()
6972 SALOME_ListIO selected;
6973 if ( LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr() )
6974 aSel->selectedObjects( selected );
6976 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
6977 if ( selected.Extent() ) {
6978 if ( selected.First()->hasEntry() ) {
6979 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( selected.First()->getEntry() )) {
6980 aControl = anActor->GetControlMode();
6981 SALOME_ListIteratorOfListIO it(selected);
6982 for ( it.Next(); it.More(); it.Next() ) {
6983 Handle(SALOME_InteractiveObject) anIO = it.Value();
6984 if ( anIO->hasEntry() ) {
6985 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
6986 if ( aControl != anActor->GetControlMode() ) {
6987 aControl = SMESH_Actor::eNone;
6997 int anAction = ActionToControl( aControl, true );
6999 action( anAction )->setChecked( true );
7001 QMenu* send = (QMenu*)sender();
7002 QList<QAction*> actions = send->actions();
7003 for ( int i = 0; i < actions.size(); i++ )
7004 actions[i]->setChecked( false );
7010 \brief Signal handler closing(SUIT_ViewWindow*) of a view
7011 \param pview view being closed
7013 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
7014 #ifndef DISABLE_PLOT2DVIEWER
7015 //Crear all Plot2d Viewers if need.
7016 SMESH::ClearPlot2Viewers(pview);
7018 EmitSignalCloseView();
7021 void SMESHGUI::message( const QString& msg )
7024 QStringList data = msg.split("/");
7025 if ( data.count() > 0 ) {
7026 if ( data.first() == "mesh_loading" ) {
7028 QString entry = data.count() > 1 ? data[1] : QString();
7029 if ( entry.isEmpty() )
7032 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
7034 _PTR(SObject) obj = study->FindObjectID( entry.toUtf8().constData() );
7037 name = SMESH::fromUtf8(obj->GetName());
7038 if ( name.isEmpty() )
7041 if ( data.last() == "stop" )
7042 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
7044 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
7045 QApplication::processEvents();
7051 \brief Connects or disconnects signals about activating and cloning view on the module slots
7052 \param pview view which is connected/disconnected
7054 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
7058 SUIT_ViewManager* viewMgr = pview->getViewManager();
7060 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7061 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7063 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7064 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7069 \brief Return \c true if object can be renamed
7071 bool SMESHGUI::renameAllowed( const QString& entry) const {
7072 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7076 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7080 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
7085 if(appStudy->isComponent(entry) || obj->isReference())
7088 // check type to prevent renaming of inappropriate objects
7089 int aType = SMESHGUI_Selection::type(qPrintable(entry));
7090 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7091 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7092 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7093 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7094 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
7101 Rename object by entry.
7102 \param entry entry of the object
7103 \param name new name of the object
7104 \brief Return \c true if rename operation finished successfully, \c false otherwise.
7106 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
7108 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7112 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7117 _PTR(Study) aStudy = appStudy->studyDS();
7122 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
7124 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
7129 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
7130 _PTR(GenericAttribute) anAttr;
7131 _PTR(AttributeName) aName;
7133 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
7135 // check type to prevent renaming of inappropriate objects
7136 int aType = SMESHGUI_Selection::type( qPrintable(entry));
7137 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7138 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7139 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7140 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7141 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
7142 if ( !name.isEmpty() ) {
7143 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qUtf8Printable(name) );
7145 // update name of group object and its actor
7146 Handle(SALOME_InteractiveObject) IObject =
7147 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
7149 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
7150 if( !aGroupObject->_is_nil() ) {
7151 aGroupObject->SetName( qUtf8Printable(name) );
7152 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
7153 anActor->setName( qUtf8Printable(name) );
7163 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
7165 static QList<QColor> colors;
7167 if ( colors.isEmpty() ) {
7169 for (int s = 0; s < 2 ; s++)
7171 for (int v = 100; v >= 40; v = v - 20)
7173 for (int h = 0; h < 359 ; h = h + 60)
7175 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
7180 static int currentColor = randomize( colors.size() );
7182 SALOMEDS::Color color;
7183 color.R = (double)colors[currentColor].red() / 255.0;
7184 color.G = (double)colors[currentColor].green() / 255.0;
7185 color.B = (double)colors[currentColor].blue() / 255.0;
7187 currentColor = (currentColor+1) % colors.count();