1 // Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
3 // Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
6 // This library is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU Lesser General Public
8 // License as published by the Free Software Foundation; either
9 // version 2.1 of the License, or (at your option) any later version.
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 // Lesser General Public License for more details.
16 // You should have received a copy of the GNU Lesser General Public
17 // License along with this library; if not, write to the Free Software
18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
22 // File : SMESHGUI.cxx
23 // Author : Nicolas REJNERI, Open CASCADE S.A.S.
25 #include <Standard_math.hxx> // E.A. must be included before Python.h to fix compilation on windows
27 #undef HAVE_FINITE // VSR: avoid compilation warning on Linux : "HAVE_FINITE" redefined
33 #include "SMESHGUI_Add0DElemsOnAllNodesDlg.h"
34 #include "SMESHGUI_AddMeshElementDlg.h"
35 #include "SMESHGUI_AddQuadraticElementDlg.h"
36 #include "SMESHGUI_BuildCompoundDlg.h"
37 #include "SMESHGUI_ClippingDlg.h"
38 #include "SMESHGUI_ComputeDlg.h"
39 #include "SMESHGUI_ConvToQuadOp.h"
40 #include "SMESHGUI_CopyMeshDlg.h"
41 #include "SMESHGUI_CreatePolyhedralVolumeDlg.h"
42 #include "SMESHGUI_DeleteGroupDlg.h"
43 #include "SMESHGUI_Displayer.h"
44 #include "SMESHGUI_DuplicateNodesDlg.h"
45 #include "SMESHGUI_ExtrusionAlongPathDlg.h"
46 #include "SMESHGUI_ExtrusionDlg.h"
47 #include "SMESHGUI_FieldSelectorWdg.h"
48 #include "SMESHGUI_FileInfoDlg.h"
49 #include "SMESHGUI_FileValidator.h"
50 #include "SMESHGUI_FilterDlg.h"
51 #include "SMESHGUI_FilterLibraryDlg.h"
52 #include "SMESHGUI_FindElemByPointDlg.h"
53 #include "SMESHGUI_GroupDlg.h"
54 #include "SMESHGUI_GroupOnShapeDlg.h"
55 #include "SMESHGUI_GroupOpDlg.h"
56 #include "SMESHGUI_Hypotheses.h"
57 #include "SMESHGUI_Make2DFrom3DOp.h"
58 #include "SMESHGUI_MakeNodeAtPointDlg.h"
59 #include "SMESHGUI_Measurements.h"
60 #include "SMESHGUI_MergeDlg.h"
61 #include "SMESHGUI_MeshInfo.h"
62 #include "SMESHGUI_MeshOp.h"
63 #include "SMESHGUI_MeshOrderOp.h"
64 #include "SMESHGUI_MeshPatternDlg.h"
65 #include "SMESHGUI_MultiEditDlg.h"
66 #include "SMESHGUI_NodesDlg.h"
67 #include "SMESHGUI_Operations.h"
68 #include "SMESHGUI_Preferences_ScalarBarDlg.h"
69 #include "SMESHGUI_PropertiesDlg.h"
70 #include "SMESHGUI_RemoveElementsDlg.h"
71 #include "SMESHGUI_RemoveNodesDlg.h"
72 #include "SMESHGUI_RenumberingDlg.h"
73 #include "SMESHGUI_ReorientFacesDlg.h"
74 #include "SMESHGUI_RevolutionDlg.h"
75 #include "SMESHGUI_RotationDlg.h"
76 #include "SMESHGUI_ScaleDlg.h"
77 #include "SMESHGUI_Selection.h"
78 #include "SMESHGUI_SewingDlg.h"
79 #include "SMESHGUI_SingleEditDlg.h"
80 #include "SMESHGUI_SmoothingDlg.h"
81 #include "SMESHGUI_SymmetryDlg.h"
82 #include "SMESHGUI_TranslationDlg.h"
83 #include "SMESHGUI_TransparencyDlg.h"
84 #include "SMESHGUI_DisplayEntitiesDlg.h"
85 #include "SMESHGUI_SplitBiQuad.h"
87 #include "SMESHGUI_FilterUtils.h"
88 #include "SMESHGUI_GEOMGenUtils.h"
89 #include "SMESHGUI_GroupUtils.h"
90 #include "SMESHGUI_HypothesesUtils.h"
91 #include "SMESHGUI_MeshUtils.h"
92 #include "SMESHGUI_PatternUtils.h"
93 #include "SMESHGUI_Utils.h"
94 #include "SMESHGUI_VTKUtils.h"
96 #include "SMESH_version.h"
98 #include "SMESH_ControlsDef.hxx"
99 #include "SMESH_Actor.h"
100 #include "SMESH_ActorUtils.h"
101 #include "SMESH_Client.hxx"
102 #include "SMESH_ScalarBarActor.h"
103 #include "SMESH_TypeFilter.hxx"
105 // SALOME GUI includes
106 #include <SalomeApp_Application.h>
107 #include <SalomeApp_CheckFileDlg.h>
108 #include <SalomeApp_DataObject.h>
109 #include <SalomeApp_Study.h>
110 #include <SalomeApp_Tools.h>
112 #include <LightApp_DataOwner.h>
113 #include <LightApp_NameDlg.h>
114 #include <LightApp_Preferences.h>
115 #include <LightApp_SelectionMgr.h>
116 #include <LightApp_UpdateFlags.h>
118 #include <SVTK_ViewManager.h>
119 #include <SVTK_ViewModel.h>
120 #include <SVTK_ViewWindow.h>
122 #include <VTKViewer_Algorithm.h>
124 #include <SUIT_Desktop.h>
125 #include <SUIT_FileDlg.h>
126 #include <SUIT_MessageBox.h>
127 #include <SUIT_OverrideCursor.h>
128 #include <SUIT_ResourceMgr.h>
129 #include <SUIT_Session.h>
131 #include <QtxPopupMgr.h>
132 #include <QtxFontEdit.h>
134 #include <SALOME_ListIO.hxx>
136 #ifndef DISABLE_PLOT2DVIEWER
137 #include <SPlot2d_ViewModel.h>
138 #include <SPlot2d_Histogram.h>
142 #include <SALOMEconfig.h>
143 #include CORBA_CLIENT_HEADER(SALOMEDS_Attributes)
144 #include CORBA_CLIENT_HEADER(SMESH_MeshEditor)
145 #include CORBA_CLIENT_HEADER(SMESH_Measurements)
146 #include CORBA_CLIENT_HEADER(SMESH_Mesh)
149 // #define INCLUDE_MENUITEM_DEF // VSR commented ????????
150 #include <QApplication>
152 #include <QTextStream>
157 #include <QDialogButtonBox>
160 #include <boost/shared_ptr.hpp>
163 #include <vtkCallbackCommand.h>
164 #include <vtkCamera.h>
165 #include <vtkLookupTable.h>
166 #include <vtkPlane.h>
167 #include <vtkRenderer.h>
169 // SALOME KERNEL includes
170 #include <SALOMEDSClient_ClientFactory.hxx>
171 #include <SALOMEDSClient_IParameters.hxx>
172 #include <SALOMEDSClient_SComponent.hxx>
173 #include <SALOMEDSClient_StudyBuilder.hxx>
174 #include <SALOMEDS_Study.hxx>
175 #include <SALOMEDS_SObject.hxx>
176 #include "utilities.h"
179 #include <Standard_ErrorHandler.hxx>
180 #include <NCollection_DataMap.hxx>
181 #include <NCollection_DoubleMap.hxx>
183 #include <Basics_Utils.hxx>
185 // Below macro, when uncommented, switches on simplified (more performant) algorithm
186 // of auto-color picking up
187 #define SIMPLE_AUTOCOLOR
192 //=============================================================
193 void ImportMeshesFromFile(SMESH::SMESH_Gen_ptr theComponentMesh,
196 void ExportMeshToFile(int theCommandID);
198 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap);
200 void SetDisplayEntity(int theCommandID);
202 int ActionToControl( int theID, bool theReversed = false );
204 void Control( int theCommandID );
207 //================================================================================
209 * \brief Reads meshes from file
211 //================================================================================
213 void ImportMeshesFromFile( SMESH::SMESH_Gen_ptr theComponentMesh,
217 std::string myExtension;
219 if ( theCommandID == SMESHOp::OpImportMED ||
220 theCommandID == SMESHOp::OpPopupImportMED ) {
221 filter.append( QObject::tr( "MED_FILES_FILTER" ) + " (*.*med)" );
222 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
224 else if ( theCommandID == SMESHOp::OpImportUNV ||
225 theCommandID == SMESHOp::OpPopupImportUNV ) {
226 filter.append( QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)" );
228 else if ( theCommandID == SMESHOp::OpImportDAT ||
229 theCommandID == SMESHOp::OpPopupImportDAT ) {
230 filter.append( QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)" );
232 else if ( theCommandID == SMESHOp::OpImportSTL ||
233 theCommandID == SMESHOp::OpPopupImportSTL ) {
234 filter.append( QObject::tr( "STL_FILES_FILTER" ) + " (*.stl)" );
236 else if ( theCommandID == SMESHOp::OpImportCGNS ||
237 theCommandID == SMESHOp::OpPopupImportCGNS ) {
238 filter.append( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
240 else if ( theCommandID == SMESHOp::OpImportSAUV ||
241 theCommandID == SMESHOp::OpPopupImportSAUV ) {
242 filter.append( QObject::tr( "SAUV files (*.sauv*)" ) );
243 filter.append( QObject::tr( "All files (*)" ) );
245 else if ( theCommandID == SMESHOp::OpImportGMF ||
246 theCommandID == SMESHOp::OpPopupImportGMF ) {
247 filter.append( QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" );
248 filter.append( QObject::tr( "GMF_BINARY_FILES_FILTER") + " (*.meshb)" );
251 QString anInitialPath = "";
252 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
253 anInitialPath = QDir::currentPath();
255 QStringList filenames;
256 bool toCreateGroups = true;
258 // if ( theCommandID == SMESHOp::OpImportGMF ) { // GMF
259 // SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg
260 // ( SMESHGUI::desktop(), true, QObject::tr("SMESH_REQUIRED_GROUPS"), true, true );
261 // fd->setWindowTitle( QObject::tr( "SMESH_IMPORT_MESH" ) );
262 // fd->setNameFilters( filter );
263 // fd->SetChecked( true );
265 // filenames << fd->selectedFile();
266 // toCreateGroups = fd->IsChecked();
272 filenames = SUIT_FileDlg::getOpenFileNames( SMESHGUI::desktop(),
275 QObject::tr( "SMESH_IMPORT_MESH" ) );
277 if ( filenames.count() > 0 )
279 SUIT_OverrideCursor wc;
280 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
283 QStringList anEntryList;
284 bool isEmpty = false;
285 for ( QStringList::ConstIterator it = filenames.begin(); it != filenames.end(); ++it )
287 QString filename = *it;
288 SMESH::mesh_array_var aMeshes = new SMESH::mesh_array;
290 switch ( theCommandID ) {
291 case SMESHOp::OpImportDAT:
292 case SMESHOp::OpPopupImportDAT:
294 // DAT format (currently unsupported)
295 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
296 arg( QObject::tr( "SMESH_ERR_NOT_SUPPORTED_FORMAT" ) ) );
299 case SMESHOp::OpImportUNV:
300 case SMESHOp::OpPopupImportUNV:
303 aMeshes->length( 1 );
304 aMeshes[0] = theComponentMesh->CreateMeshesFromUNV( filename.toUtf8().constData() );
305 if ( aMeshes[0]->_is_nil() )
306 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
307 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
310 case SMESHOp::OpImportMED:
311 case SMESHOp::OpPopupImportMED:
314 SMESH::DriverMED_ReadStatus res;
315 aMeshes = theComponentMesh->CreateMeshesFromMED( filename.toUtf8().constData(), res );
316 if ( res != SMESH::DRS_OK ) {
317 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
318 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
322 case SMESHOp::OpImportSTL:
323 case SMESHOp::OpPopupImportSTL:
326 aMeshes->length( 1 );
327 aMeshes[0] = theComponentMesh->CreateMeshesFromSTL( filename.toUtf8().constData() );
328 if ( aMeshes[0]->_is_nil() ) {
329 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
330 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
334 case SMESHOp::OpImportCGNS:
335 case SMESHOp::OpPopupImportCGNS:
338 SMESH::DriverMED_ReadStatus res;
339 aMeshes = theComponentMesh->CreateMeshesFromCGNS( filename.toUtf8().constData(), res );
340 if ( res != SMESH::DRS_OK ) {
341 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
342 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
346 case SMESHOp::OpImportSAUV:
347 case SMESHOp::OpPopupImportSAUV:
350 SMESH::DriverMED_ReadStatus res;
351 aMeshes = theComponentMesh->CreateMeshesFromSAUV( filename.toUtf8().constData(), res );
352 if ( res != SMESH::DRS_OK ) {
353 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
354 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
358 case SMESHOp::OpImportGMF:
359 case SMESHOp::OpPopupImportGMF:
362 SMESH::ComputeError_var res;
363 aMeshes->length( 1 );
364 aMeshes[0] = theComponentMesh->CreateMeshesFromGMF( filename.toUtf8().constData(),
367 if ( res->code != SMESH::DRS_OK ) {
368 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
369 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res->code ).toLatin1().data() ) ) );
370 if ( strlen( res->comment.in() ) > 0 ) {
371 errors.back() += ": ";
372 errors.back() += res->comment.in();
379 catch ( const SALOME::SALOME_Exception& S_ex ) {
380 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
381 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
384 for ( int i = 0, iEnd = aMeshes->length(); i < iEnd; i++ )
386 _PTR(SObject) aMeshSO = SMESH::FindSObject( aMeshes[i] );
388 _PTR(StudyBuilder) aBuilder = aStudy->NewBuilder();
389 _PTR(AttributePixMap) aPixmap = aBuilder->FindOrCreateAttribute( aMeshSO, "AttributePixMap" );
390 aPixmap->SetPixMap( "ICON_SMESH_TREE_MESH_IMPORTED" );
391 if ( theCommandID == SMESHOp::OpImportUNV ) // mesh names aren't taken from the file for UNV import
392 SMESH::SetName( aMeshSO, QFileInfo(filename).fileName() );
394 anEntryList.append( aMeshSO->GetID().c_str() );
402 // update Object browser
403 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
405 // browse to the published meshes
406 if( LightApp_Application* anApp =
407 dynamic_cast<LightApp_Application*>( SUIT_Session::session()->activeApplication() ) )
408 anApp->browseObjects( anEntryList );
410 // show Error message box if there were errors
411 if ( errors.count() > 0 ) {
412 SUIT_MessageBox::critical( SMESHGUI::desktop(),
413 QObject::tr( "SMESH_ERROR" ),
414 QObject::tr( "SMESH_IMPORT_ERRORS" ) + "\n" + errors.join( "\n" ) );
417 // show warning message box, if some imported mesh is empty
419 SUIT_MessageBox::warning( SMESHGUI::desktop(),
420 QObject::tr( "SMESH_WRN_WARNING" ),
421 QObject::tr( "SMESH_DRS_SOME_EMPTY" ) );
426 //================================================================================
428 * \brief Export selected meshes or groups into a file
430 //================================================================================
432 void ExportMeshToFile( int theCommandID )
434 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
435 SALOME_ListIO selected;
437 aSel->selectedObjects( selected );
439 const bool isDAT = ( theCommandID == SMESHOp::OpExportDAT ||
440 theCommandID == SMESHOp::OpPopupExportDAT );
441 const bool isMED = ( theCommandID == SMESHOp::OpExportMED ||
442 theCommandID == SMESHOp::OpPopupExportMED );
443 const bool isUNV = ( theCommandID == SMESHOp::OpExportUNV ||
444 theCommandID == SMESHOp::OpPopupExportUNV );
445 const bool isSTL = ( theCommandID == SMESHOp::OpExportSTL ||
446 theCommandID == SMESHOp::OpPopupExportSTL );
447 const bool isCGNS= ( theCommandID == SMESHOp::OpExportCGNS ||
448 theCommandID == SMESHOp::OpPopupExportCGNS );
449 const bool isSAUV= ( theCommandID == SMESHOp::OpExportSAUV ||
450 theCommandID == SMESHOp::OpPopupExportSAUV );
451 const bool isGMF = ( theCommandID == SMESHOp::OpExportGMF ||
452 theCommandID == SMESHOp::OpPopupExportGMF );
454 const bool multiMeshSupported = ( isMED || isCGNS ); // file can hold several meshes
455 if ( selected.Extent() == 0 || ( selected.Extent() > 1 && !multiMeshSupported ))
457 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
458 bool aCheckWarn = true;
460 aCheckWarn = resMgr->booleanValue( "SMESH", "show_warning", false );
461 // get mesh object from selection and check duplication of their names
462 bool hasDuplicatedMeshNames = false;
463 QList< QPair< SMESH::SMESH_IDSource_var, QString > > aMeshList;
464 QList< QPair< SMESH::SMESH_IDSource_var, QString > >::iterator aMeshIter;
465 SALOME_ListIteratorOfListIO It( selected );
466 for( ; It.More(); It.Next() )
468 Handle(SALOME_InteractiveObject) anIObject = It.Value();
469 SMESH::SMESH_IDSource_var aMeshItem =
470 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIObject);
471 if ( aMeshItem->_is_nil() ) {
472 SUIT_MessageBox::warning( SMESHGUI::desktop(),
473 QObject::tr( "SMESH_WRN_WARNING" ),
474 QObject::tr( "SMESH_BAD_MESH_SELECTION" ));
477 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( aMeshItem );
478 if ( aCheckWarn && !aGroup->_is_nil() )
480 QMessageBox msgBox(SUIT_MessageBox::Warning,
481 QObject::tr("SMESH_WRN_WARNING"),
482 QObject::tr("SMESH_EXPORT_ONLY_GPOUP"),
483 QMessageBox::StandardButton::NoButton,
484 SMESHGUI::desktop());
485 QCheckBox dontShowCheckBox(QObject::tr("SMESH_WRN_SHOW_DLG_CHECKBOX"));
486 msgBox.addButton(QMessageBox::Ok);
487 msgBox.addButton(QMessageBox::Cancel);
488 msgBox.setDefaultButton(QMessageBox::Cancel);
489 QGridLayout* lt = qobject_cast<QGridLayout*>(msgBox.layout());
490 QDialogButtonBox* btnbox = msgBox.findChild<QDialogButtonBox*>();
491 lt->addWidget(&dontShowCheckBox, lt->rowCount(), lt->columnCount()-1, lt->rowCount(), lt->columnCount());
492 lt->addWidget(btnbox, lt->rowCount(), 0, lt->rowCount(), lt->columnCount());
493 if(msgBox.exec() == QMessageBox::Ok)
495 if(dontShowCheckBox.checkState() == Qt::Checked)
498 resMgr->setValue( "SMESH", "show_warning", false);
506 QString aMeshName = anIObject->getName();
508 // check for name duplications
509 if ( !hasDuplicatedMeshNames )
510 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
511 if( aMeshName == (*aMeshIter).second ) {
512 hasDuplicatedMeshNames = true;
517 aMeshList.append( QPair< SMESH::SMESH_IDSource_var, QString >( aMeshItem, aMeshName ) );
520 if( hasDuplicatedMeshNames && isMED ) {
521 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
522 QObject::tr("SMESH_WRN_WARNING"),
523 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_MESH_NAMES"),
524 QObject::tr("SMESH_BUT_YES"),
525 QObject::tr("SMESH_BUT_NO"), 0, 1);
530 aMeshIter = aMeshList.begin();
531 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
532 SMESH::SMESH_Mesh_var aMesh = aMeshOrGroup->GetMesh();
533 QString aMeshName = (*aMeshIter).second;
535 if ( isMED || isCGNS || isSAUV ) // formats where group names must be unique
537 // check for equal group names within each mesh
538 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
539 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
540 if ( !aMeshItem->_is_nil() && aMeshItem->HasDuplicatedGroupNamesMED()) {
541 int aRet = SUIT_MessageBox::warning
542 (SMESHGUI::desktop(),
543 QObject::tr("SMESH_WRN_WARNING"),
544 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_GRP").arg((*aMeshIter).second),
545 QObject::tr("SMESH_BUT_YES"),
546 QObject::tr("SMESH_BUT_NO"), 0, 1);
553 // Warn the user about presence of not supported elements
555 std::vector< SMESH::EntityType > notSupportedElemTypes, presentNotSupported;
559 notSupportedElemTypes.push_back( SMESH::Entity_0D );
560 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
565 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
566 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
567 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
568 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
569 notSupportedElemTypes.push_back( SMESH::Entity_Pyramid );
570 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
571 notSupportedElemTypes.push_back( SMESH::Entity_0D );
572 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
577 notSupportedElemTypes.push_back( SMESH::Entity_Edge );
578 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Edge );
579 notSupportedElemTypes.push_back( SMESH::Entity_0D );
580 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
585 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
590 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
591 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Triangle );
592 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Quadrangle );
593 notSupportedElemTypes.push_back( SMESH::Entity_TriQuad_Hexa );
594 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
595 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
596 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
597 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
602 notSupportedElemTypes.push_back( SMESH::Entity_0D );
603 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
604 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
605 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Pyramid );
606 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Penta );
607 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Penta );
608 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
609 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
610 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
611 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
613 if ( ! notSupportedElemTypes.empty() )
615 SMESH::long_array_var nbElems = aMeshOrGroup->GetMeshInfo();
616 for ( size_t iType = 0; iType < notSupportedElemTypes.size(); ++iType )
617 if ( nbElems[ notSupportedElemTypes[ iType ]] > 0 )
618 presentNotSupported.push_back( notSupportedElemTypes[ iType ]);
620 if ( !presentNotSupported.empty() )
623 const char* typeMsg[] = {
624 "SMESH_NODES", "SMESH_ELEMS0D","SMESH_EDGES","SMESH_QUADRATIC_EDGES",
625 "SMESH_TRIANGLES", "SMESH_QUADRATIC_TRIANGLES", "SMESH_BIQUADRATIC_TRIANGLES",
626 "SMESH_QUADRANGLES","SMESH_QUADRATIC_QUADRANGLES", "SMESH_BIQUADRATIC_QUADRANGLES",
627 "SMESH_POLYGONS","SMESH_QUADRATIC_POLYGONS",
628 "SMESH_TETRAHEDRA","SMESH_QUADRATIC_TETRAHEDRONS","SMESH_PYRAMIDS",
629 "SMESH_QUADRATIC_PYRAMIDS","SMESH_HEXAHEDRA","SMESH_QUADRATIC_HEXAHEDRONS",
630 "SMESH_TRIQUADRATIC_HEXAHEDRONS","SMESH_PENTAHEDRA","SMESH_QUADRATIC_PENTAHEDRONS",
631 "SMESH_BIQUADRATIC_PENTAHEDRONS",
632 "SMESH_OCTAHEDRA","SMESH_POLYEDRONS","SMESH_QUADRATIC_POLYEDRONS","SMESH_BALLS"
634 // is typeMsg complete? (compilation failure mains that enum SMDSAbs_EntityType changed)
635 const int nbTypes = sizeof( typeMsg ) / sizeof( const char* );
636 int _assert[( nbTypes == SMESH::Entity_Last ) ? 2 : -1 ]; _assert[0]=_assert[1]=0;
638 QString andStr = " " + QObject::tr("SMESH_AND") + " ", comma(", ");
639 for ( size_t iType = 0; iType < presentNotSupported.size(); ++iType ) {
640 typeNames += QObject::tr( typeMsg[ presentNotSupported[ iType ]]);
641 if ( iType != presentNotSupported.size() - 1 )
642 typeNames += ( iType == presentNotSupported.size() - 2 ) ? andStr : comma;
644 int aRet = SUIT_MessageBox::warning
645 (SMESHGUI::desktop(),
646 QObject::tr("SMESH_WRN_WARNING"),
647 QObject::tr("EXPORT_NOT_SUPPORTED").arg(aMeshName).arg(format).arg(typeNames),
648 QObject::tr("SMESH_BUT_YES"),
649 QObject::tr("SMESH_BUT_NO"), 0, 1);
654 // Get parameters of export operation
657 SMESH::MED_VERSION aFormat = SMESH::MED_LATEST;
658 // Init the parameters with the default values
659 bool aIsASCII_STL = true;
660 bool toCreateGroups = false;
662 toCreateGroups = resMgr->booleanValue( "SMESH", "auto_groups", false );
663 bool toOverwrite = true;
664 bool toFindOutDim = true;
666 QString aFilter, aTitle = QObject::tr("SMESH_EXPORT_MESH");
667 QString anInitialPath = "";
668 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
669 anInitialPath = QDir::currentPath();
671 QList< QPair< GEOM::ListOfFields_var, QString > > aFieldList;
673 // Get a file name to write in and additional otions
674 if ( isUNV || isDAT || isGMF ) // Export w/o options
677 aFilter = QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)";
679 aFilter = QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)";
681 aFilter = QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" +
682 ";;" + QObject::tr( "GMF_BINARY_FILES_FILTER" ) + " (*.meshb)";
683 if ( anInitialPath.isEmpty() ) anInitialPath = SUIT_FileDlg::getLastVisitedPath();
684 aFilename = SUIT_FileDlg::getFileName(SMESHGUI::desktop(),
685 anInitialPath + QString("/") + aMeshName,
686 aFilter, aTitle, false);
688 else if ( isCGNS )// Export to CGNS
690 const char* theByTypeResource = "cgns_group_elems_by_type";
691 toCreateGroups = SMESHGUI::resourceMgr()->booleanValue( "SMESH", theByTypeResource, false );
693 QStringList checkBoxes;
694 checkBoxes << QObject::tr("CGNS_EXPORT_ELEMS_BY_TYPE");
696 SalomeApp_CheckFileDlg* fd =
697 new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true );
698 fd->setWindowTitle( aTitle );
699 fd->setNameFilter( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
700 if ( !anInitialPath.isEmpty() )
701 fd->setDirectory( anInitialPath );
702 fd->selectFile(aMeshName);
703 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
704 fd->setValidator( fv );
705 fd->SetChecked( toCreateGroups, 0 );
708 aFilename = fd->selectedFile();
709 toOverwrite = fv->isOverwrite();
710 toCreateGroups = fd->IsChecked(0);
711 SMESHGUI::resourceMgr()->setValue("SMESH", theByTypeResource, toCreateGroups );
715 else if ( isSTL ) // Export to STL
717 QMap<QString, int> aFilterMap;
718 aFilterMap.insert( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)", 1 );
719 aFilterMap.insert( QObject::tr( "STL_BIN_FILES_FILTER" ) + " (*.stl)", 0 );
722 QMap<QString, int>::const_iterator it = aFilterMap.begin();
723 for ( ; it != aFilterMap.end(); ++it )
724 filters.push_back( it.key() );
726 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
727 fd->setWindowTitle( aTitle );
728 fd->setNameFilters( filters );
729 fd->selectNameFilter( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
730 if ( !anInitialPath.isEmpty() )
731 fd->setDirectory( anInitialPath );
732 fd->selectFile(aMeshName);
736 aFilename = fd->selectedFile();
737 aIsASCII_STL = (aFilterMap[fd->selectedNameFilter()]) == 1 ? true: false;
742 else if ( isMED || isSAUV ) // Export to MED or SAUV
744 QMap<QString, SMESH::MED_VERSION> aFilterMap;
746 QString v22 (aMesh->GetVersionString(SMESH::MED_V2_2, 2));
747 aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v22 ) + " (*.med)", SMESH::MED_V2_2 );
748 int minor = v22.split(".").last().toInt();
749 int vv= int(SMESH::MED_MINOR_0); // add all minor from 0 to current
750 for (int ii=0; ii<minor; ii++)
752 QString vs = aMesh->GetVersionString(SMESH::MED_VERSION(vv), 2);
753 aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( vs ) + " (*.med)", SMESH::MED_VERSION(vv));
758 aFilterMap.insert("All files (*)", SMESH::MED_V2_1 );
759 aFilterMap.insert("SAUV files (*.sauv)", SMESH::MED_V2_2 );
760 aFilterMap.insert("SAUV files (*.sauve)", SMESH::MED_V2_1 );
764 QString aDefaultFilter;
765 QMap<QString, SMESH::MED_VERSION>::const_iterator it = aFilterMap.begin();
766 for ( ; it != aFilterMap.end(); ++it ) {
767 filters.push_back( it.key() );
768 if (it.value() == SMESH::MED_V2_2)
769 aDefaultFilter = it.key();
771 QStringList checkBoxes;
772 checkBoxes << QObject::tr("SMESH_AUTO_GROUPS") << QObject::tr("SMESH_AUTO_DIM");
774 SMESHGUI_FieldSelectorWdg* fieldSelWdg = new SMESHGUI_FieldSelectorWdg();
775 QList< QWidget* > wdgList;
776 if ( fieldSelWdg->GetAllFields( aMeshList, aFieldList ))
777 wdgList.append( fieldSelWdg );
779 SalomeApp_CheckFileDlg* fd =
780 new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true, wdgList );
781 fd->setWindowTitle( aTitle );
782 fd->setNameFilters( filters );
783 fd->selectNameFilter( aDefaultFilter );
784 fd->SetChecked( toCreateGroups, 0 );
785 fd->SetChecked( toFindOutDim, 1 );
786 if ( !anInitialPath.isEmpty() )
787 fd->setDirectory( anInitialPath );
788 fd->selectFile(aMeshName);
791 QListView *lview = fd->findChild<QListView*>("listView");
793 lview->setMinimumHeight(200);
795 QTreeView *tview = fd->findChild<QTreeView*>("treeView");
797 tview->setMinimumHeight(200);
800 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
801 fd->setValidator( fv );
806 aFilename = fd->selectedFile();
808 aFilename = QString::null;
811 aFormat = aFilterMap[fd->selectedNameFilter()];
812 toOverwrite = fv->isOverwrite();
814 if ( !aFilename.isEmpty() ) {
815 // med-2.1 does not support poly elements
816 if ( aFormat==SMESH::MED_V2_1 )
817 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
818 SMESH::SMESH_IDSource_var aMeshItem = (*aMeshIter).first;
819 SMESH::long_array_var nbElems = aMeshItem->GetMeshInfo();
820 if ( nbElems[ SMESH::Entity_Polygon ] + nbElems[ SMESH::Entity_Quad_Polygon ] +
821 nbElems[ SMESH::Entity_Polyhedra ] + nbElems[ SMESH::Entity_Quad_Polyhedra ])
823 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
824 QObject::tr("SMESH_WRN_WARNING"),
825 QObject::tr("SMESH_EXPORT_MED_V2_1").arg((*aMeshIter).second),
826 QObject::tr("SMESH_BUT_YES"),
827 QObject::tr("SMESH_BUT_NO"), 0, 1);
835 // can't append to an existing using other format
836 SMESH::MED_VERSION aVersion = aFormat; //SMESH::MED_V2_1;
837 bool isVersionOk = SMESHGUI::GetSMESHGen()->GetMEDVersion( aFilename.toUtf8().constData(), aVersion );
838 if( !isVersionOk || aVersion != aFormat ) {
839 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
840 QObject::tr("SMESH_WRN_WARNING"),
841 QObject::tr("SMESH_EXPORT_MED_VERSION_COLLISION").arg(aFilename),
842 QObject::tr("SMESH_BUT_YES"),
843 QObject::tr("SMESH_BUT_NO"), 0, 1);
850 QStringList aMeshNamesCollisionList;
851 SMESH::string_array_var aMeshNames = SMESHGUI::GetSMESHGen()->GetMeshNames( aFilename.toUtf8().constData() );
852 for( int i = 0, n = aMeshNames->length(); i < n; i++ ) {
853 QString anExistingMeshName( aMeshNames[ i ] );
854 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
855 QString anExportMeshName = (*aMeshIter).second;
856 if( anExportMeshName == anExistingMeshName ) {
857 aMeshNamesCollisionList.append( anExportMeshName );
862 if( !aMeshNamesCollisionList.isEmpty() ) {
863 QString aMeshNamesCollisionString = aMeshNamesCollisionList.join( ", " );
864 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
865 QObject::tr("SMESH_WRN_WARNING"),
866 QObject::tr("SMESH_EXPORT_MED_MESH_NAMES_COLLISION").arg(aMeshNamesCollisionString),
867 QObject::tr("SMESH_BUT_YES"),
868 QObject::tr("SMESH_BUT_NO"),
869 QObject::tr("SMESH_BUT_CANCEL"), 0, 2);
878 toCreateGroups = fd->IsChecked(0);
879 toFindOutDim = fd->IsChecked(1);
880 fieldSelWdg->GetSelectedFields();
881 if ( !fieldSelWdg->parent() )
892 if ( !aFilename.isEmpty() ) {
893 // Check whether the file already exists and delete it if yes
894 QFile aFile( aFilename );
895 if ( aFile.exists() && toOverwrite )
897 SUIT_OverrideCursor wc;
900 // Renumbering is not needed since SMDS redesign in V6.2.0 (Nov 2010)
901 // bool Renumber = false;
902 // // PAL 14172 : Check of we have to renumber or not from the preferences before export
904 // Renumber= resMgr->booleanValue("renumbering");
906 // SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
907 // aMeshEditor->RenumberNodes();
908 // aMeshEditor->RenumberElements();
909 // if ( SMESHGUI::automaticUpdate() )
910 // SMESH::UpdateView();
914 aMeshIter = aMeshList.begin();
915 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
917 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
918 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
919 const GEOM::ListOfFields& fields = aFieldList[ aMeshIndex ].first.in();
920 const QString& geoAssFields = aFieldList[ aMeshIndex ].second;
921 const bool hasFields = ( fields.length() || !geoAssFields.isEmpty() );
922 if ( !hasFields && aMeshOrGroup->_is_equivalent( aMeshItem ))
923 aMeshItem->ExportToMEDX( aFilename.toUtf8().data(), toCreateGroups,
924 aFormat, toOverwrite && aMeshIndex == 0, toFindOutDim );
926 aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups,
927 aFormat, toOverwrite && aMeshIndex == 0, toFindOutDim,
928 fields, geoAssFields.toLatin1().data() );
933 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ )
935 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
936 if( !aMeshItem->_is_nil() )
937 aMeshItem->ExportSAUV( aFilename.toUtf8().data(), toCreateGroups );
942 if ( aMeshOrGroup->_is_equivalent( aMesh ))
943 aMesh->ExportDAT( aFilename.toUtf8().data() );
945 aMesh->ExportPartToDAT( aMeshOrGroup, aFilename.toUtf8().data() );
949 if ( aMeshOrGroup->_is_equivalent( aMesh ))
950 aMesh->ExportUNV( aFilename.toUtf8().data() );
952 aMesh->ExportPartToUNV( aMeshOrGroup, aFilename.toUtf8().data() );
956 if ( aMeshOrGroup->_is_equivalent( aMesh ))
957 aMesh->ExportSTL( aFilename.toUtf8().data(), aIsASCII_STL );
959 aMesh->ExportPartToSTL( aMeshOrGroup, aFilename.toUtf8().data(), aIsASCII_STL );
963 aMeshIter = aMeshList.begin();
964 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
966 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
967 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
968 aMeshItem->ExportCGNS( aMeshOrGroup,
969 aFilename.toUtf8().data(),
970 toOverwrite && aMeshIndex == 0,
976 toCreateGroups = true;
977 aMesh->ExportGMF( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups );
980 catch (const SALOME::SALOME_Exception& S_ex){
982 SUIT_MessageBox::warning(SMESHGUI::desktop(),
983 QObject::tr("SMESH_WRN_WARNING"),
984 QObject::tr("SMESH_EXPORT_FAILED"));
990 inline void InverseEntityMode(unsigned int& theOutputMode,
991 unsigned int theMode)
993 bool anIsNotPresent = ~theOutputMode & theMode;
995 theOutputMode |= theMode;
997 theOutputMode &= ~theMode;
1000 void SetDisplayEntity(int theCommandID)
1002 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1003 SALOME_ListIO selected;
1005 aSel->selectedObjects( selected );
1007 if ( selected.Extent() >= 1 ) {
1008 SUIT_OverrideCursor wc;
1009 SALOME_ListIteratorOfListIO It( selected );
1010 for( ; It.More(); It.Next()){
1011 Handle(SALOME_InteractiveObject) IObject = It.Value();
1012 if(IObject->hasEntry()){
1013 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1014 unsigned int aMode = anActor->GetEntityMode();
1015 switch(theCommandID){
1016 case SMESHOp::OpDE0DElements: InverseEntityMode(aMode,SMESH_Actor::e0DElements); break;
1017 case SMESHOp::OpDEEdges: InverseEntityMode(aMode,SMESH_Actor::eEdges); break;
1018 case SMESHOp::OpDEFaces: InverseEntityMode(aMode,SMESH_Actor::eFaces); break;
1019 case SMESHOp::OpDEVolumes: InverseEntityMode(aMode,SMESH_Actor::eVolumes); break;
1020 case SMESHOp::OpDEBalls: InverseEntityMode(aMode,SMESH_Actor::eBallElem); break;
1021 case SMESHOp::OpDEAllEntity: aMode = SMESH_Actor::eAllEntity; break;
1024 anActor->SetEntityMode(aMode);
1033 SalomeApp_Application* app =
1034 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1038 LightApp_SelectionMgr* aSel = app->selectionMgr();
1039 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1040 if ( !aSel || !appStudy )
1043 SALOME_ListIO selected;
1044 aSel->selectedObjects( selected );
1045 if ( selected.IsEmpty() )
1048 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1050 _PTR(Study) aStudy = appStudy->studyDS();
1051 _PTR(SObject) aMainSObject = aStudy->FindObjectID( anIObject->getEntry() );
1052 SMESH::SMESH_Mesh_var aMainObject = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1053 if ( aMainObject->_is_nil() )
1056 SUIT_OverrideCursor wc;
1058 aMainObject->SetAutoColor( true ); // mesh groups are re-colored here
1060 QList<SALOMEDS::Color> aReservedColors;
1062 SMESH::ListOfGroups aListOfGroups = *aMainObject->GetGroups();
1063 for ( int i = 0, n = aListOfGroups.length(); i < n; i++ )
1065 SMESH::SMESH_GroupBase_var aGroupObject = aListOfGroups[i];
1067 #ifdef SIMPLE_AUTOCOLOR // simplified algorithm for auto-colors
1068 SALOMEDS::Color aColor = SMESHGUI::getPredefinedUniqueColor();
1069 #else // old algorithm for auto-colors
1070 SALOMEDS::Color aColor = SMESHGUI::getUniqueColor( aReservedColors );
1071 aReservedColors.append( aColor );
1072 #endif // SIMPLE_AUTOCOLOR
1073 aGroupObject->SetColor( aColor );
1075 _PTR(SObject) aGroupSObject = SMESH::FindSObject(aGroupObject);
1076 if ( aGroupSObject ) {
1079 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry(aGroupSObject->GetID().c_str())) {
1080 switch ( aGroupObject->GetType ()) {
1082 anActor->SetNodeColor( aColor.R, aColor.G, aColor.B ); break;
1084 anActor->SetEdgeColor( aColor.R, aColor.G, aColor.B ); break;
1086 anActor->Set0DColor( aColor.R, aColor.G, aColor.B ); break;
1088 anActor->SetBallColor( aColor.R, aColor.G, aColor.B ); break;
1090 SMESH::GetColor("SMESH", "volume_color", c, delta, "255,0,170|-100");
1091 anActor->SetVolumeColor( aColor.R, aColor.G, aColor.B, delta ); break;
1094 SMESH::GetColor("SMESH", "fill_color", c, delta, "0,170,255|-100");
1095 anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B, delta );
1101 SMESH::RepaintCurrentView();
1104 void OverallMeshQuality()
1106 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1107 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1108 SALOME_ListIO selected;
1110 aSel->selectedObjects( selected );
1112 if ( selected.IsEmpty() ) return;
1113 SALOME_ListIteratorOfListIO It( selected );
1114 for ( ; It.More(); It.Next() ) {
1115 SMESHGUI_CtrlInfoDlg* ctrlDlg = new SMESHGUI_CtrlInfoDlg( SMESHGUI::desktop() );
1116 ctrlDlg->showInfo( It.Value() );
1121 QString functorToString( SMESH::Controls::FunctorPtr f )
1123 QString type = QObject::tr( "UNKNOWN_CONTROL" );
1124 if ( dynamic_cast< SMESH::Controls::Volume* >( f.get() ) )
1125 type = QObject::tr( "VOLUME_3D_ELEMENTS" );
1126 else if ( dynamic_cast< SMESH::Controls::MaxElementLength2D* >( f.get() ) )
1127 type = QObject::tr( "MAX_ELEMENT_LENGTH_2D" );
1128 else if ( dynamic_cast< SMESH::Controls::MaxElementLength3D* >( f.get() ) )
1129 type = QObject::tr( "MAX_ELEMENT_LENGTH_3D" );
1130 else if ( dynamic_cast< SMESH::Controls::MinimumAngle* >( f.get() ) )
1131 type = QObject::tr( "MINIMUMANGLE_ELEMENTS" );
1132 else if ( dynamic_cast< SMESH::Controls::AspectRatio* >( f.get() ) )
1133 type = QObject::tr( "ASPECTRATIO_ELEMENTS" );
1134 else if ( dynamic_cast< SMESH::Controls::AspectRatio3D* >( f.get() ) )
1135 type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" );
1136 else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) )
1137 type = QObject::tr( "WARP_ELEMENTS" );
1138 else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) )
1139 type = QObject::tr( "TAPER_ELEMENTS" );
1140 else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) )
1141 type = QObject::tr( "SKEW_ELEMENTS" );
1142 else if ( dynamic_cast< SMESH::Controls::Area* >( f.get() ) )
1143 type = QObject::tr( "AREA_ELEMENTS" );
1144 else if ( dynamic_cast< SMESH::Controls::Length* >( f.get() ) )
1145 type = QObject::tr( "LENGTH_EDGES" );
1146 else if ( dynamic_cast< SMESH::Controls::Length2D* >( f.get() ) )
1147 type = QObject::tr( "LENGTH2D_EDGES" );
1148 else if ( dynamic_cast< SMESH::Controls::MultiConnection* >( f.get() ) )
1149 type = QObject::tr( "MULTI_BORDERS" );
1150 else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) )
1151 type = QObject::tr( "MULTI2D_BORDERS" );
1152 else if ( dynamic_cast< SMESH::Controls::FreeNodes* >( f.get() ) )
1153 type = QObject::tr( "FREE_NODES" );
1154 else if ( dynamic_cast< SMESH::Controls::FreeEdges* >( f.get() ) )
1155 type = QObject::tr( "FREE_EDGES" );
1156 else if ( dynamic_cast< SMESH::Controls::FreeBorders* >( f.get() ) )
1157 type = QObject::tr( "FREE_BORDERS" );
1158 else if ( dynamic_cast< SMESH::Controls::FreeFaces* >( f.get() ) )
1159 type = QObject::tr( "FREE_FACES" );
1160 else if ( dynamic_cast< SMESH::Controls::BareBorderVolume* >( f.get() ) )
1161 type = QObject::tr( "BARE_BORDER_VOLUME" );
1162 else if ( dynamic_cast< SMESH::Controls::BareBorderFace* >( f.get() ) )
1163 type = QObject::tr( "BARE_BORDER_FACE" );
1164 else if ( dynamic_cast< SMESH::Controls::OverConstrainedVolume* >( f.get() ) )
1165 type = QObject::tr( "OVER_CONSTRAINED_VOLUME" );
1166 else if ( dynamic_cast< SMESH::Controls::OverConstrainedFace* >( f.get() ) )
1167 type = QObject::tr( "OVER_CONSTRAINED_FACE" );
1168 else if ( dynamic_cast< SMESH::Controls::CoincidentNodes* >( f.get() ) )
1169 type = QObject::tr( "EQUAL_NODE" );
1170 else if ( dynamic_cast< SMESH::Controls::CoincidentElements1D* >( f.get() ) )
1171 type = QObject::tr( "EQUAL_EDGE" );
1172 else if ( dynamic_cast< SMESH::Controls::CoincidentElements2D* >( f.get() ) )
1173 type = QObject::tr( "EQUAL_FACE" );
1174 else if ( dynamic_cast< SMESH::Controls::CoincidentElements3D* >( f.get() ) )
1175 type = QObject::tr( "EQUAL_VOLUME" );
1176 else if ( dynamic_cast< SMESH::Controls::NodeConnectivityNumber* >( f.get() ) )
1177 type = QObject::tr( "NODE_CONNECTIVITY_NB" );
1181 void SaveDistribution()
1183 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1184 SALOME_ListIO selected;
1186 aSel->selectedObjects( selected );
1188 if ( selected.Extent() == 1 ) {
1189 Handle(SALOME_InteractiveObject) anIO = selected.First();
1190 if ( anIO->hasEntry() ) {
1191 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1193 anActor->GetScalarBarActor() &&
1194 anActor->GetControlMode() != SMESH_Actor::eNone )
1196 SMESH_ScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor();
1197 SMESH::Controls::FunctorPtr aFunctor = anActor->GetFunctor();
1198 if ( aScalarBarActor && aFunctor ) {
1199 SMESH::Controls::NumericalFunctor* aNumFun =
1200 dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
1202 std::vector<int> elements;
1203 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
1204 if ( mesh->_is_nil() ) {
1205 SMESH::SMESH_IDSource_var idSource =
1206 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
1207 if ( !idSource->_is_nil() )
1209 SMESH::long_array_var ids = idSource->GetIDs();
1210 elements.resize( ids->length() );
1211 for ( unsigned i = 0; i < elements.size(); ++i )
1212 elements[i] = ids[i];
1215 int nbIntervals = aScalarBarActor->GetMaximumNumberOfColors();
1216 vtkLookupTable* lookupTable =
1217 static_cast<vtkLookupTable*>(aScalarBarActor->GetLookupTable());
1218 double * minmax = lookupTable->GetRange();
1219 bool isLogarithmic = lookupTable->GetScale() == VTK_SCALE_LOG10;
1220 std::vector<int> nbEvents;
1221 std::vector<double> funValues;
1222 aNumFun->GetHistogram( nbIntervals, nbEvents, funValues,
1223 elements, minmax, isLogarithmic );
1224 QString anInitialPath = "";
1225 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
1226 anInitialPath = QDir::currentPath();
1227 QString aMeshName = anIO->getName();
1229 filter.append( QObject::tr( "TEXT_FILES_FILTER" ) + " (*.txt)" );
1230 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
1231 QString aFilename = anInitialPath + "/" + aMeshName + "_" +
1232 functorToString( aFunctor ).toLower().simplified().replace( QRegExp( " |-" ), "_" ) + ".txt";
1233 aFilename = SUIT_FileDlg::getFileName( SMESHGUI::desktop(),
1236 QObject::tr( "SMESH_SAVE_DISTRIBUTION" ),
1238 if ( !aFilename.isEmpty() ) {
1239 QFile f( aFilename );
1240 if ( f.open( QFile::WriteOnly | QFile::Truncate ) ) {
1241 QTextStream out( &f );
1242 out << "# Mesh: " << aMeshName << endl;
1243 out << "# Control: " << functorToString( aFunctor ) << endl;
1245 out.setFieldWidth( 10 );
1246 for ( int i = 0; i < (int)qMin( nbEvents.size(), funValues.size()-1 ); i++ )
1247 out << funValues[i] << "\t" << funValues[i+1] << "\t" << nbEvents[i] << endl;
1258 void ShowElement( int theCommandID )
1260 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1261 SALOME_ListIO selected;
1263 aSel->selectedObjects( selected );
1265 if ( selected.Extent() == 1 ) {
1266 Handle(SALOME_InteractiveObject) anIO = selected.First();
1267 if ( anIO->hasEntry() ) {
1268 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1270 anActor->GetScalarBarActor() &&
1271 anActor->GetControlMode() != SMESH_Actor::eNone )
1273 SMESH_ScalarBarActor *aScalarBarActor = anActor->GetScalarBarActor();
1274 if ( theCommandID == SMESHOp::OpShowDistribution ) {
1275 aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility());
1277 else if ( theCommandID == SMESHOp::OpShowScalarBar ) {
1278 aScalarBarActor->SetVisibility( !aScalarBarActor->GetVisibility());
1285 #ifndef DISABLE_PLOT2DVIEWER
1286 void PlotDistribution()
1288 SalomeApp_Application* app =
1289 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1293 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1294 SALOME_ListIO selected;
1296 aSel->selectedObjects( selected );
1298 if ( selected.Extent() == 1 ) {
1299 Handle(SALOME_InteractiveObject) anIO = selected.First();
1300 if ( anIO->hasEntry() ) {
1301 //Find Actor by entry before getting Plot2d viewer,
1302 //because after call getViewManager( Plot2d_Viewer::Type(), true ) active window is Plot2d Viewer
1303 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1305 SUIT_ViewManager* aViewManager =
1306 app->getViewManager( Plot2d_Viewer::Type(), true ); // create if necessary
1310 SPlot2d_Viewer* aView = dynamic_cast<SPlot2d_Viewer*>(aViewManager->getViewModel());
1314 Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
1318 if ( anActor && anActor->GetControlMode() != SMESH_Actor::eNone )
1320 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1321 QString functorName = functorToString( anActor->GetFunctor());
1322 QString aHistogramName("%1 : %2");
1323 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1324 aHistogram->setName(aHistogramName);
1325 aHistogram->setHorTitle(functorName);
1326 aHistogram->setVerTitle(QObject::tr("DISTRIBUTION_NB_ENT"));
1327 aPlot->displayObject(aHistogram, true);
1332 #endif //DISABLE_PLOT2DVIEWER
1334 void DisableAutoColor()
1336 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1337 SALOME_ListIO selected;
1339 aSel->selectedObjects( selected );
1341 if ( selected.Extent() ) {
1342 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1343 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1344 if ( !aMesh->_is_nil() ) {
1345 aMesh->SetAutoColor( false );
1352 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1353 SALOME_ListIO selected;
1355 aSel->selectedObjects( selected );
1356 if ( selected.Extent() )
1358 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1359 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1360 _PTR(SObject) aSObj = aStudy->FindObjectID(anIObject->getEntry());
1362 if ( aStudy->GetUseCaseBuilder()->SortChildren( aSObj, true/*AscendingOrder*/ ) ) {
1363 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1370 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap)
1372 SALOME_ListIO selected;
1373 SalomeApp_Application* app =
1374 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1378 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1379 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1380 if ( !aSel || !appStudy )
1383 if ( theCommandID == SMESHOp::OpClipping ) { // Clipping dialog can be activated without selection
1384 if ( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
1385 aModule->EmitSignalDeactivateDialog();
1386 if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
1387 (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
1392 _PTR(Study) aStudy = appStudy->studyDS();
1394 aSel->selectedObjects( selected );
1396 if ( selected.Extent() >= 1 )
1398 switch ( theCommandID ) {
1399 case SMESHOp::OpTransparency:
1401 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1402 (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
1405 case SMESHOp::OpProperties:
1408 QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
1409 QColor orientationColor, outlineColor, volumeColor;
1410 int deltaF = 0, deltaV = 0;
1413 double ballScale = 1.0;
1415 int outlineWidth = 1;
1416 double shrinkCoef = 0.0;
1417 double orientationScale = 0.0;
1418 bool orientation3d = false;
1419 VTK::MarkerType markerType = VTK::MT_NONE;
1420 VTK::MarkerScale markerScale = VTK::MS_NONE;
1422 bool hasNodes = false;
1423 int presentEntities = 0;
1424 bool firstTime = true;
1426 SALOME_ListIteratorOfListIO It( selected );
1427 for ( ; It.More(); It.Next() ) {
1428 Handle(SALOME_InteractiveObject) IObject = It.Value();
1429 if ( !IObject->hasEntry() ) continue;
1430 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1431 if ( !anActor || !anActor->GetObject() ) continue;
1434 // nodes: color, marker
1435 anActor->GetNodeColor( color[0], color[1], color[2] );
1436 nodeColor.setRgbF( color[0], color[1], color[2] );
1437 markerType = anActor->GetMarkerType();
1438 markerScale = anActor->GetMarkerScale();
1439 markerId = anActor->GetMarkerTexture();
1440 // edges: color, width
1441 anActor->GetEdgeColor( color[0], color[1], color[2] );
1442 edgeColor.setRgbF( color[0], color[1], color[2] );
1443 edgeWidth = qMax( (int)anActor->GetLineWidth(), 1 ); // minimum allowed width is 1
1444 // faces: front color, back color (delta)
1445 anActor->GetSufaceColor( color[0], color[1], color[2], deltaF );
1446 faceColor.setRgbF( color[0], color[1], color[2] );
1447 // faces: front color, back color (delta)
1448 anActor->GetVolumeColor( color[0], color[1], color[2], deltaV );
1449 volumeColor.setRgbF( color[0], color[1], color[2] );
1450 // 0d elements: color, size
1451 anActor->Get0DColor( color[0], color[1], color[2] );
1452 elem0dColor.setRgbF( color[0], color[1], color[2] );
1453 elem0dSize = qMax( (int)anActor->Get0DSize(), 1 ); // minimum allowed size is 1
1454 // balls: color, size
1455 anActor->GetBallColor( color[0], color[1], color[2] );
1456 ballColor.setRgbF( color[0], color[1], color[2] );
1457 //ballSize = qMax( (int)anActor->GetBallSize(), 1 ); // minimum allowed size is 1
1458 ballScale = qMax( (double)anActor->GetBallScale(), 1e-2 ); // minimum allowed scale is 1e-2
1460 anActor->GetOutlineColor( color[0], color[1], color[2] );
1461 outlineColor.setRgbF( color[0], color[1], color[2] );
1462 outlineWidth = qMax( (int)anActor->GetOutlineWidth(), 1 ); // minimum allowed width is 1
1463 // orientation vectors: color, scale, 3d flag
1464 anActor->GetFacesOrientationColor( color[0], color[1], color[2] );
1465 orientationColor.setRgbF( color[0], color[1], color[2] );
1466 orientationScale = anActor->GetFacesOrientationScale();
1467 orientation3d = anActor->GetFacesOrientation3DVectors();
1469 shrinkCoef = anActor->GetShrinkFactor();
1472 firstTime = false; // we only take properties from first object (for performance reasons)
1475 hasNodes = anActor->GetObject()->GetNbEntities( SMDSAbs_Node );
1476 if ( !(presentEntities & SMESH_Actor::eEdges) && anActor->GetObject()->GetNbEntities( SMDSAbs_Edge ) )
1477 presentEntities = presentEntities | SMESH_Actor::eEdges;
1478 if ( !(presentEntities & SMESH_Actor::eFaces) && anActor->GetObject()->GetNbEntities( SMDSAbs_Face ) )
1479 presentEntities = presentEntities | SMESH_Actor::eFaces;
1480 if ( !(presentEntities & SMESH_Actor::eVolumes) && anActor->GetObject()->GetNbEntities( SMDSAbs_Volume ) )
1481 presentEntities = presentEntities | SMESH_Actor::eVolumes;
1482 if ( !(presentEntities & SMESH_Actor::e0DElements) && anActor->GetObject()->GetNbEntities( SMDSAbs_0DElement ) )
1483 presentEntities = presentEntities | SMESH_Actor::e0DElements;
1484 if ( !(presentEntities & SMESH_Actor::eBallElem) && anActor->GetObject()->GetNbEntities( SMDSAbs_Ball ) )
1485 presentEntities = presentEntities | SMESH_Actor::eBallElem;
1487 // as we know that all types of elements are present, we can exit the loop
1488 if ( presentEntities == SMESH_Actor::eAllEntity )
1492 SMESHGUI_PropertiesDlg dlg( theMarkerMap[ aStudy->StudyId() ], SMESHGUI::desktop() );
1493 // nodes: color, marker
1494 dlg.setNodeColor( nodeColor );
1495 if( markerType != VTK::MT_USER )
1496 dlg.setNodeMarker( markerType, markerScale );
1498 dlg.setNodeCustomMarker( markerId );
1499 // edges: color, line width
1500 dlg.setEdgeColor( edgeColor );
1501 dlg.setEdgeWidth( edgeWidth );
1502 // faces: front color, back color
1503 dlg.setFaceColor( faceColor, deltaF );
1504 // volumes: normal color, reversed color
1505 dlg.setVolumeColor( volumeColor, deltaV );
1506 // outlines: color, line width
1507 dlg.setOutlineColor( outlineColor );
1508 dlg.setOutlineWidth( outlineWidth );
1509 // 0d elements: color, size
1510 dlg.setElem0dColor( elem0dColor );
1511 dlg.setElem0dSize( elem0dSize );
1512 // balls: color, size
1513 dlg.setBallColor( ballColor );
1514 //dlg.setBallSize( ballSize );
1515 dlg.setBallScale( ballScale );
1516 // orientation: color, scale, 3d flag
1517 dlg.setOrientationColor( orientationColor );
1518 dlg.setOrientationSize( int( orientationScale * 100. ) );
1519 dlg.setOrientation3d( orientation3d );
1520 // shrink: scale factor
1521 dlg.setShrinkCoef( int( shrinkCoef * 100. ) );
1522 // hide unused controls
1523 dlg.showControls( presentEntities, hasNodes );
1526 nodeColor = dlg.nodeColor();
1527 markerType = dlg.nodeMarkerType();
1528 markerScale = dlg.nodeMarkerScale();
1529 markerId = dlg.nodeMarkerId();
1530 edgeColor = dlg.edgeColor();
1531 edgeWidth = dlg.edgeWidth();
1532 faceColor = dlg.faceColor();
1533 deltaF = dlg.faceColorDelta();
1534 volumeColor = dlg.volumeColor();
1535 deltaV = dlg.volumeColorDelta();
1536 outlineColor = dlg.outlineColor();
1537 outlineWidth = dlg.outlineWidth();
1538 elem0dColor = dlg.elem0dColor();
1539 elem0dSize = dlg.elem0dSize();
1540 ballColor = dlg.ballColor();
1541 // ballSize = dlg.ballSize();
1542 ballScale = dlg.ballScale();
1543 orientationColor = dlg.orientationColor();
1544 orientationScale = dlg.orientationSize() / 100.;
1545 orientation3d = dlg.orientation3d();
1546 shrinkCoef = dlg.shrinkCoef() / 100.;
1548 // store point markers map that might be changed by the user
1549 theMarkerMap[ aStudy->StudyId() ] = dlg.customMarkers();
1551 // set properties from dialog box to the presentations
1552 SALOME_ListIteratorOfListIO It( selected );
1553 for ( ; It.More(); It.Next() ) {
1554 Handle(SALOME_InteractiveObject) IObject = It.Value();
1555 if ( !IObject->hasEntry() ) continue;
1556 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1557 if ( !anActor ) continue;
1559 // nodes: color, marker
1560 anActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
1561 if ( markerType != VTK::MT_USER ) {
1562 anActor->SetMarkerStd( markerType, markerScale );
1565 const VTK::MarkerMap& markerMap = theMarkerMap[ aStudy->StudyId() ];
1566 VTK::MarkerMap::const_iterator iter = markerMap.find( markerId );
1567 if ( iter != markerMap.end() )
1568 anActor->SetMarkerTexture( markerId, iter->second.second );
1570 // volumes: normal color, reversed color (delta)
1571 anActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
1572 // faces: front color, back color (delta)
1573 anActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
1574 // edges: color, width
1575 anActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
1576 anActor->SetLineWidth( edgeWidth );
1578 anActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
1579 anActor->SetOutlineWidth( outlineWidth );
1580 // 0D elements: color, size
1581 anActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
1582 anActor->Set0DSize( elem0dSize );
1583 // balls: color, size
1584 anActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
1585 // anActor->SetBallSize( ballSize );
1586 anActor->SetBallScale( ballScale );
1587 // orientation: color, scale, 3d flag
1588 anActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
1589 anActor->SetFacesOrientationScale( orientationScale );
1590 anActor->SetFacesOrientation3DVectors( orientation3d );
1592 anActor->SetShrinkFactor( shrinkCoef );
1594 // for groups, set also proper color
1595 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1596 if ( !aGroupObject->_is_nil() ) {
1597 SMESH::ElementType anElementType = aGroupObject->GetType();
1599 switch( anElementType ) {
1601 aColor = nodeColor; break;
1603 aColor = edgeColor; break;
1605 aColor = faceColor; break;
1607 aColor = volumeColor; break;
1609 aColor = elem0dColor; break;
1611 aColor = ballColor; break;
1615 if ( aColor.isValid() ) {
1616 SALOMEDS::Color aGroupColor;
1617 aGroupColor.R = aColor.redF();
1618 aGroupColor.G = aColor.greenF();
1619 aGroupColor.B = aColor.blueF();
1620 aGroupObject->SetColor( aGroupColor );
1622 } // if ( !aGroupObject->_is_nil() )
1623 } // for ( ; It.More(); It.Next() )
1624 SMESH::RepaintCurrentView();
1625 } // if ( dlg.exec() )
1627 } // case SMESHOp::OpProperties:
1628 } // switch(theCommandID)
1629 SUIT_OverrideCursor wc;
1630 SALOME_ListIteratorOfListIO It( selected );
1631 for( ; It.More(); It.Next()){
1632 Handle(SALOME_InteractiveObject) IObject = It.Value();
1633 if(IObject->hasEntry()){
1634 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1635 switch(theCommandID){
1636 case SMESHOp::OpDMWireframe:
1637 anActor->SetRepresentation(SMESH_Actor::eEdge);
1639 case SMESHOp::OpDMShading:
1640 anActor->SetRepresentation(SMESH_Actor::eSurface);
1642 case SMESHOp::OpDMShrink:
1643 if(anActor->IsShrunk())
1644 anActor->UnShrink();
1646 anActor->SetShrink();
1648 case SMESHOp::OpDMNodes:
1649 anActor->SetRepresentation(SMESH_Actor::ePoint);
1651 case SMESHOp::OpRepresentationLines:
1652 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1653 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1655 case SMESHOp::OpRepresentationArcs:
1656 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1657 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1663 SMESH::RepaintCurrentView();
1667 int ActionToControl( int theID, bool theReversed )
1669 NCollection_DoubleMap<int,int> ActionControl;
1670 ActionControl.Bind( 0, SMESH_Actor::eNone );
1671 ActionControl.Bind( SMESHOp::OpFreeNode, SMESH_Actor::eFreeNodes );
1672 ActionControl.Bind( SMESHOp::OpEqualNode, SMESH_Actor::eCoincidentNodes );
1673 ActionControl.Bind( SMESHOp::OpNodeConnectivityNb, SMESH_Actor::eNodeConnectivityNb );
1674 ActionControl.Bind( SMESHOp::OpFreeEdge, SMESH_Actor::eFreeEdges );
1675 ActionControl.Bind( SMESHOp::OpFreeBorder, SMESH_Actor::eFreeBorders );
1676 ActionControl.Bind( SMESHOp::OpLength, SMESH_Actor::eLength );
1677 ActionControl.Bind( SMESHOp::OpConnection, SMESH_Actor::eMultiConnection );
1678 ActionControl.Bind( SMESHOp::OpEqualEdge, SMESH_Actor::eCoincidentElems1D );
1679 ActionControl.Bind( SMESHOp::OpFreeFace, SMESH_Actor::eFreeFaces );
1680 ActionControl.Bind( SMESHOp::OpBareBorderFace, SMESH_Actor::eBareBorderFace );
1681 ActionControl.Bind( SMESHOp::OpOverConstrainedFace, SMESH_Actor::eOverConstrainedFace );
1682 ActionControl.Bind( SMESHOp::OpLength2D, SMESH_Actor::eLength2D );
1683 ActionControl.Bind( SMESHOp::OpConnection2D, SMESH_Actor::eMultiConnection2D );
1684 ActionControl.Bind( SMESHOp::OpArea, SMESH_Actor::eArea );
1685 ActionControl.Bind( SMESHOp::OpTaper, SMESH_Actor::eTaper );
1686 ActionControl.Bind( SMESHOp::OpAspectRatio, SMESH_Actor::eAspectRatio );
1687 ActionControl.Bind( SMESHOp::OpMinimumAngle, SMESH_Actor::eMinimumAngle );
1688 ActionControl.Bind( SMESHOp::OpWarpingAngle, SMESH_Actor::eWarping );
1689 ActionControl.Bind( SMESHOp::OpSkew, SMESH_Actor::eSkew );
1690 ActionControl.Bind( SMESHOp::OpMaxElementLength2D, SMESH_Actor::eMaxElementLength2D );
1691 ActionControl.Bind( SMESHOp::OpEqualFace, SMESH_Actor::eCoincidentElems2D );
1692 ActionControl.Bind( SMESHOp::OpAspectRatio3D, SMESH_Actor::eAspectRatio3D );
1693 ActionControl.Bind( SMESHOp::OpVolume, SMESH_Actor::eVolume3D );
1694 ActionControl.Bind( SMESHOp::OpMaxElementLength3D, SMESH_Actor::eMaxElementLength3D );
1695 ActionControl.Bind( SMESHOp::OpBareBorderVolume, SMESH_Actor::eBareBorderVolume );
1696 ActionControl.Bind( SMESHOp::OpOverConstrainedVolume, SMESH_Actor::eOverConstrainedVolume );
1697 ActionControl.Bind( SMESHOp::OpEqualVolume, SMESH_Actor::eCoincidentElems3D );
1699 return theReversed ? ActionControl.Find2( theID ) : ActionControl.Find1( theID );
1702 void Control( int theCommandID )
1704 SMESH_Actor::eControl aControl = SMESH_Actor::eControl( ActionToControl( theCommandID ));
1705 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1707 SALOME_ListIO selected;
1708 if ( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
1709 aSel->selectedObjects( selected );
1711 if ( !selected.IsEmpty() ) {
1712 SALOME_ListIteratorOfListIO It(selected);
1713 for ( ; It.More(); It.Next())
1715 Handle(SALOME_InteractiveObject) anIO = It.Value();
1716 if ( !anIO.IsNull() ) {
1717 _PTR(SObject) SO = aStudy->FindObjectID( It.Value()->getEntry() );
1719 CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
1720 SMESH::SMESH_IDSource_var anIDSrc = SMESH::SMESH_IDSource::_narrow( aObject );
1721 if ( !anIDSrc->_is_nil() ) {
1722 SMESH_Actor *anActor = SMESH::FindActorByEntry( anIO->getEntry());
1723 if (( !anActor && selected.Extent() == 1 ) &&
1724 ( anActor = SMESH::CreateActor( aStudy, anIO->getEntry() )))
1726 anActor->SetControlMode( aControl );
1727 SMESH::DisplayActor( SMESH::GetCurrentVtkView(), anActor );
1728 SMESH::UpdateView ( SMESH::eDisplay, anIO->getEntry() );
1732 if ( anActor->GetControlMode() != aControl )
1733 anActor->SetControlMode( aControl );
1734 QString functorName = functorToString( anActor->GetFunctor() );
1735 int anEntitiesCount = anActor->GetNumberControlEntities();
1736 if (anEntitiesCount >= 0)
1737 functorName = functorName + ": " + QString::number(anEntitiesCount);
1738 anActor->GetScalarBarActor()->SetTitle( functorName.toLatin1().constData() );
1739 SMESH::RepaintCurrentView();
1740 #ifndef DISABLE_PLOT2DVIEWER
1741 if ( anActor->GetPlot2Histogram() ) {
1742 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1743 QString aHistogramName("%1 : %2");
1744 aHistogramName = aHistogramName.arg( anIO->getName() ).arg( functorName );
1745 aHistogram->setName( aHistogramName );
1746 aHistogram->setHorTitle( functorName );
1747 SMESH::ProcessIn2DViewers( anActor );
1759 bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1760 SMESH::MeshObjectType theType,
1761 const QString theInTypeName,
1762 QString & theOutTypeName)
1764 SMESH_TypeFilter aTypeFilter( theType );
1766 if ( !theIO.IsNull() )
1768 entry = theIO->getEntry();
1769 LightApp_DataOwner owner( entry );
1770 if ( aTypeFilter.isOk( &owner )) {
1771 theOutTypeName = theInTypeName;
1779 QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1781 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1782 _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1784 _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1785 CORBA::String_var anID = aSComp->GetID().c_str();
1786 if ( !strcmp(anID.in(),theIO->getEntry()) )
1792 CheckOIType ( theIO, SMESH::HYPOTHESIS, "Hypothesis", aTypeName ) ||
1793 CheckOIType ( theIO, SMESH::ALGORITHM, "Algorithm", aTypeName ) ||
1794 CheckOIType ( theIO, SMESH::MESH, "Mesh", aTypeName ) ||
1795 CheckOIType ( theIO, SMESH::SUBMESH, "SubMesh", aTypeName ) ||
1796 CheckOIType ( theIO, SMESH::GROUP, "Group", aTypeName )
1804 // QString CheckHomogeneousSelection()
1806 // LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1807 // SALOME_ListIO selected;
1809 // aSel->selectedObjects( selected );
1811 // QString RefType = CheckTypeObject(selected.First());
1812 // SALOME_ListIteratorOfListIO It(selected);
1813 // for ( ; It.More(); It.Next())
1815 // Handle(SALOME_InteractiveObject) IObject = It.Value();
1816 // QString Type = CheckTypeObject(IObject);
1817 // if ( Type.compare(RefType) != 0 )
1818 // return "Heterogeneous Selection";
1824 uint randomize( uint size )
1826 static bool initialized = false;
1827 if ( !initialized ) {
1828 qsrand( QDateTime::currentDateTime().toTime_t() );
1832 v = uint( (double)( v ) / RAND_MAX * size );
1833 v = qMax( uint(0), qMin ( v, size-1 ) );
1839 void SMESHGUI::OnEditDelete()
1841 // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1842 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1843 SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1845 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1846 _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1847 _PTR(GenericAttribute) anAttr;
1848 _PTR(AttributeIOR) anIOR;
1850 int objectCount = 0;
1852 QString aParentComponent = QString::null;
1853 Handle(SALOME_InteractiveObject) anIO;
1854 for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1856 anIO = anIt.Value();
1857 QString cur = anIO->getComponentDataType();
1858 _PTR(SObject) aSO = aStudy->FindObjectID(anIO->getEntry());
1860 // check if object is reference
1861 _PTR(SObject) aRefSObj;
1862 aNameList.append("\n - ");
1863 if ( aSO->ReferencedObject( aRefSObj ) ) {
1864 QString aRefName = QString::fromStdString ( aRefSObj->GetName() );
1865 aNameList.append( aRefName );
1866 cur = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1869 aNameList.append(anIO->getName());
1873 if( aParentComponent.isNull() )
1874 aParentComponent = cur;
1875 else if( !aParentComponent.isEmpty() && aParentComponent!=cur )
1876 aParentComponent = "";
1879 if ( objectCount == 0 )
1880 return; // No Valid Objects Selected
1882 if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
1883 SUIT_MessageBox::warning( SMESHGUI::desktop(),
1884 QObject::tr("ERR_ERROR"),
1885 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
1888 // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
1889 if (SUIT_MessageBox::warning
1890 (SMESHGUI::desktop(),
1891 QObject::tr("SMESH_WRN_WARNING"),
1892 QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
1893 SUIT_MessageBox::Yes | SUIT_MessageBox::No,
1894 SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
1897 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1899 // Put the whole hierarchy of sub-objects of the selected SO's into a list and
1900 // then treat them all starting from the deepest objects (at list back)
1901 std::list< _PTR(SObject) > listSO;
1902 SALOME_ListIteratorOfListIO It(selected);
1903 for( ; It.More(); It.Next()) // loop on selected IO's
1905 Handle(SALOME_InteractiveObject) IObject = It.Value();
1906 if(IObject->hasEntry()) {
1907 _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
1909 // disable removal of "SMESH" component object
1910 if(aSO->FindAttribute(anAttr, "AttributeIOR")){
1912 if ( engineIOR() == anIOR->Value().c_str() )
1915 //Check the referenced object
1916 _PTR(SObject) aRefSObject;
1917 if ( aSO && aSO->ReferencedObject( aRefSObject ) )
1918 aSO = aRefSObject; // Delete main Object instead of reference
1920 listSO.push_back( aSO );
1921 std::list< _PTR(SObject) >::iterator itSO = --listSO.end();
1922 for ( ; itSO != listSO.end(); ++itSO ) {
1923 _PTR(ChildIterator) it = aStudy->NewChildIterator( *itSO );
1924 for (it->InitEx(false); it->More(); it->Next())
1925 listSO.push_back( it->Value() );
1929 // Check if none of objects to delete is referred from outside
1930 std::list< _PTR(SObject) >::reverse_iterator ritSO;
1931 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1933 _PTR(SObject) SO = *ritSO;
1934 if ( !SO ) continue;
1935 std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( *ritSO );
1936 for (size_t i = 0; i < aReferences.size(); i++) {
1937 _PTR(SComponent) aComponent = aReferences[i]->GetFatherComponent();
1938 std::string type = aComponent->ComponentDataType();
1939 if ( type != "SMESH" )
1941 SUIT_MessageBox::warning( anApp->desktop(),
1942 QObject::tr("WRN_WARNING"),
1943 QObject::tr("DEP_OBJECT") );
1944 return; // outside SMESH, there is an object depending on a SMESH object
1949 // Call mesh->Clear() to prevent loading mesh from file caused by hypotheses removal
1950 for( It.Initialize( selected ); It.More(); It.Next()) // loop on selected IO's
1952 Handle(SALOME_InteractiveObject) IObject = It.Value();
1953 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface< SMESH::SMESH_Mesh >( IObject );
1954 if ( !mesh->_is_nil() )
1958 // Treat SO's in the list starting from the back
1959 aStudyBuilder->NewCommand(); // There is a transaction
1960 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1962 _PTR(SObject) SO = *ritSO;
1963 if ( !SO ) continue;
1964 std::string anEntry = SO->GetID();
1966 /** Erase graphical object and remove all its data **/
1967 if(SO->FindAttribute(anAttr, "AttributeIOR")) {
1968 SMESH::RemoveVisualObjectWithActors( anEntry.c_str(), true);
1970 /** Remove an object from data structures **/
1971 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
1972 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
1973 if ( !aGroup->_is_nil() ) { // DELETE GROUP
1974 SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
1975 aMesh->RemoveGroup( aGroup );
1977 else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
1978 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
1979 aMesh->RemoveSubMesh( aSubMesh );
1981 _PTR(SObject) aMeshSO = SMESH::FindSObject(aMesh);
1983 SMESH::ModifiedMesh(aMeshSO, false, aMesh->NbNodes()==0);
1986 Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
1987 ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
1988 QString objType = CheckTypeObject(IObject);
1989 if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
1990 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
1991 aStudyBuilder->RemoveObjectWithChildren( SO );
1993 else {// default action: remove SObject from the study
1994 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
1995 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
1997 aStudyBuilder->RemoveObjectWithChildren( SO );
2001 } /* listSO back loop */
2003 aStudyBuilder->CommitCommand();
2005 /* Clear any previous selection */
2007 aSel->setSelectedObjects( l1 );
2009 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
2013 SMESHGUI_EXPORT CAM_Module* createModule()
2015 return new SMESHGUI();
2018 SMESHGUI_EXPORT char* getModuleVersion() {
2019 return (char*)SMESH_VERSION_STR;
2023 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
2025 //=============================================================================
2029 //=============================================================================
2030 SMESHGUI::SMESHGUI() :
2031 SalomeApp_Module( "SMESH" )
2033 if ( CORBA::is_nil( myComponentSMESH ) )
2035 CORBA::Boolean anIsEmbeddedMode;
2036 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
2037 //MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
2039 // 0019923: EDF 765 SMESH : default values of hypothesis
2040 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
2041 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
2042 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
2043 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
2044 myComponentSMESH->SetDefaultNbSegments( nbSeg );
2046 const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif", "default_grp_color" };
2047 for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
2048 if ( aResourceMgr->hasValue( "SMESH", options[i] ))
2050 QString val = aResourceMgr->stringValue( "SMESH", options[i] );
2051 myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
2055 myActiveDialogBox = 0;
2056 myFilterLibraryDlg = 0;
2060 myEventCallbackCommand = vtkCallbackCommand::New();
2061 myEventCallbackCommand->Delete();
2062 myEventCallbackCommand->SetClientData( this );
2063 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
2066 /* load resources for all available meshers */
2067 SMESH::InitAvailableHypotheses();
2070 //=============================================================================
2074 //=============================================================================
2075 SMESHGUI::~SMESHGUI()
2079 //=============================================================================
2083 //=============================================================================
2084 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
2086 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2088 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
2093 //=============================================================================
2097 //=============================================================================
2098 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
2100 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2104 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2105 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2106 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2107 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2108 return autoUpdate && !exceeded;
2111 //=============================================================================
2115 //=============================================================================
2116 bool SMESHGUI::automaticUpdate( SMESH::SMESH_IDSource_ptr theMesh,
2117 int* entities, bool* limitExceeded, int* hidden, long* nbElements )
2119 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2123 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2124 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2125 bool incrementalLimit = resMgr->booleanValue( "SMESH", "incremental_limit", false );
2127 SMESH::long_array_var info = theMesh->GetMeshInfo();
2128 long nbOdElems = info[SMDSEntity_0D];
2129 long nbEdges = info[SMDSEntity_Edge] + info[SMDSEntity_Quad_Edge];
2130 long nbFaces = info[SMDSEntity_Triangle] + info[SMDSEntity_Quad_Triangle] + info[SMDSEntity_BiQuad_Triangle] +
2131 info[SMDSEntity_Quadrangle] + info[SMDSEntity_Quad_Quadrangle] + info[SMDSEntity_BiQuad_Quadrangle] +
2132 info[SMDSEntity_Polygon] + info[SMDSEntity_Quad_Polygon];
2133 long nbVolumes = info[SMDSEntity_Tetra] + info[SMDSEntity_Quad_Tetra] +
2134 info[SMDSEntity_Hexa] + info[SMDSEntity_Quad_Hexa] + info[SMDSEntity_TriQuad_Hexa] +
2135 info[SMDSEntity_Pyramid] + info[SMDSEntity_Quad_Pyramid] +
2136 info[SMDSEntity_Penta] + info[SMDSEntity_Quad_Penta] + info[SMDSEntity_BiQuad_Penta] +
2137 info[SMDSEntity_Polyhedra] +
2138 info[SMDSEntity_Hexagonal_Prism];
2139 long nbBalls = info[SMDSEntity_Ball];
2141 long requestedSize = nbOdElems + nbBalls + nbEdges + nbFaces + nbVolumes;
2142 *nbElements = requestedSize;
2144 *entities = SMESH_Actor::eAllEntity;
2147 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2149 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2151 if ( incrementalLimit ) {
2154 if ( nbOdElems > 0 ) {
2155 if ( total + nbOdElems > updateLimit ) {
2156 *entities = *entities & ~SMESH_Actor::e0DElements;
2157 *hidden = *hidden | SMESH_Actor::e0DElements;
2164 if ( nbEdges > 0 ) {
2165 if ( total + nbEdges > updateLimit ) {
2166 *entities = *entities & ~SMESH_Actor::eEdges;
2167 *hidden = *hidden | SMESH_Actor::eEdges;
2174 if ( nbFaces > 0 ) {
2175 if ( total + nbFaces > updateLimit ) {
2176 *entities = *entities & ~SMESH_Actor::eFaces;
2177 *hidden = *hidden | SMESH_Actor::eFaces;
2184 if ( nbVolumes > 0 ) {
2185 if ( total + nbVolumes > updateLimit ) {
2186 *entities = *entities & ~SMESH_Actor::eVolumes;
2187 *hidden = *hidden | SMESH_Actor::eVolumes;
2194 if ( nbBalls > 0 ) {
2195 if ( total + nbBalls > updateLimit ) {
2196 *entities = *entities & ~SMESH_Actor::eBallElem;
2197 *hidden = *hidden | SMESH_Actor::eBallElem;
2205 return autoUpdate && !exceeded;
2208 //=============================================================================
2212 //=============================================================================
2213 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
2215 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
2218 //=============================================================================
2222 //=============================================================================
2223 SMESHGUI* SMESHGUI::GetSMESHGUI()
2225 SMESHGUI* smeshMod = 0;
2226 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
2229 CAM_Module* module = app->module( "Mesh" );
2230 smeshMod = dynamic_cast<SMESHGUI*>( module );
2233 if ( smeshMod && smeshMod->application() && smeshMod->application()->activeStudy() )
2235 SalomeApp_Study* study = dynamic_cast<SalomeApp_Study*>( smeshMod->application()->activeStudy() );
2238 _PTR(Study) aStudy = study->studyDS();
2240 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
2249 Standard_EXPORT SMESHGUI* GetComponentGUI()
2251 return SMESHGUI::GetSMESHGUI();
2255 //=============================================================================
2259 //=============================================================================
2260 void SMESHGUI::SetState(int aState)
2265 //=============================================================================
2269 //=============================================================================
2270 void SMESHGUI::ResetState()
2275 //=============================================================================
2279 //=============================================================================
2280 void SMESHGUI::EmitSignalDeactivateDialog()
2282 emit SignalDeactivateActiveDialog();
2285 //=============================================================================
2289 //=============================================================================
2290 void SMESHGUI::EmitSignalStudyFrameChanged()
2292 emit SignalStudyFrameChanged();
2295 //=============================================================================
2299 //=============================================================================
2300 void SMESHGUI::EmitSignalCloseAllDialogs()
2302 emit SignalCloseAllDialogs();
2305 //=============================================================================
2309 //=============================================================================
2310 void SMESHGUI::EmitSignalVisibilityChanged()
2312 emit SignalVisibilityChanged();
2315 //=============================================================================
2319 //=============================================================================
2320 void SMESHGUI::EmitSignalCloseView()
2322 emit SignalCloseView();
2325 //=============================================================================
2329 //=============================================================================
2330 void SMESHGUI::EmitSignalActivatedViewManager()
2332 emit SignalActivatedViewManager();
2335 //=============================================================================
2339 //=============================================================================
2340 QDialog *SMESHGUI::GetActiveDialogBox()
2342 return myActiveDialogBox;
2345 //=============================================================================
2349 //=============================================================================
2350 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2352 myActiveDialogBox = (QDialog *) aDlg;
2356 //=============================================================================
2360 //=============================================================================
2361 SUIT_Desktop* SMESHGUI::desktop()
2363 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2365 return app->desktop();
2370 //=============================================================================
2374 //=============================================================================
2375 SalomeApp_Study* SMESHGUI::activeStudy()
2377 SUIT_Application* app = SUIT_Session::session()->activeApplication();
2379 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2384 //=============================================================================
2388 //=============================================================================
2389 void SMESHGUI::Modified( bool theIsUpdateActions )
2391 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2392 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2393 appStudy->Modified();
2394 if( theIsUpdateActions )
2395 app->updateActions();
2400 //=============================================================================
2404 //=============================================================================
2405 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2407 /* Here the position is on the bottom right corner - 10 */
2408 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2410 SUIT_Desktop *PP = desktop();
2411 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2412 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2416 //=============================================================================
2420 //=============================================================================
2421 static int isStudyLocked(_PTR(Study) theStudy){
2422 return theStudy->GetProperties()->IsLocked();
2425 static bool checkLock(_PTR(Study) theStudy) {
2426 if (isStudyLocked(theStudy)) {
2427 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2428 QObject::tr("WRN_WARNING"),
2429 QObject::tr("WRN_STUDY_LOCKED") );
2435 //=======================================================================
2436 //function : CheckActiveStudyLocked
2438 //=======================================================================
2440 bool SMESHGUI::isActiveStudyLocked()
2442 _PTR(Study) aStudy = activeStudy()->studyDS();
2443 return checkLock( aStudy );
2446 //=============================================================================
2450 //=============================================================================
2451 bool SMESHGUI::OnGUIEvent( int theCommandID )
2453 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2457 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
2458 SUIT_ResourceMgr* mgr = resourceMgr();
2462 if (CORBA::is_nil(GetSMESHGen()->GetCurrentStudy())) {
2463 GetSMESHGen()->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
2466 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2467 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2469 //QAction* act = action( theCommandID );
2471 switch (theCommandID) {
2472 case SMESHOp::OpDelete:
2473 if(checkLock(aStudy)) break;
2476 case SMESHOp::OpImportDAT:
2477 case SMESHOp::OpImportUNV:
2478 case SMESHOp::OpImportMED:
2479 case SMESHOp::OpImportSTL:
2480 case SMESHOp::OpImportCGNS:
2481 case SMESHOp::OpImportSAUV:
2482 case SMESHOp::OpImportGMF:
2483 case SMESHOp::OpPopupImportDAT:
2484 case SMESHOp::OpPopupImportUNV:
2485 case SMESHOp::OpPopupImportMED:
2486 case SMESHOp::OpPopupImportSTL:
2487 case SMESHOp::OpPopupImportCGNS:
2488 case SMESHOp::OpPopupImportSAUV:
2489 case SMESHOp::OpPopupImportGMF:
2491 if(checkLock(aStudy)) break;
2492 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2496 case SMESHOp::OpFileInformation:
2498 SALOME_ListIO selected;
2499 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2501 aSel->selectedObjects( selected );
2502 if( selected.Extent() )
2504 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2505 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2506 if ( !aMesh->_is_nil() )
2508 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2514 case SMESHOp::OpExportDAT:
2515 case SMESHOp::OpExportMED:
2516 case SMESHOp::OpExportUNV:
2517 case SMESHOp::OpExportSTL:
2518 case SMESHOp::OpExportCGNS:
2519 case SMESHOp::OpExportSAUV:
2520 case SMESHOp::OpExportGMF:
2521 case SMESHOp::OpPopupExportDAT:
2522 case SMESHOp::OpPopupExportMED:
2523 case SMESHOp::OpPopupExportUNV:
2524 case SMESHOp::OpPopupExportSTL:
2525 case SMESHOp::OpPopupExportCGNS:
2526 case SMESHOp::OpPopupExportSAUV:
2527 case SMESHOp::OpPopupExportGMF:
2529 ::ExportMeshToFile(theCommandID);
2533 case SMESHOp::OpReset: // SCALAR BAR
2535 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2536 SALOME_ListIO selected;
2538 aSel->selectedObjects( selected );
2540 SALOME_ListIteratorOfListIO it(selected);
2541 for( ; it.More(); it.Next()) {
2542 Handle(SALOME_InteractiveObject) anIO = it.Value();
2543 if( anIO->hasEntry() ) {
2544 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2545 anActor->SetControlMode( SMESH_Actor::eNone );
2546 #ifndef DISABLE_PLOT2DVIEWER
2547 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2552 SMESH::UpdateView();
2555 case SMESHOp::OpScalarBarProperties:
2557 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2560 case SMESHOp::OpShowScalarBar:
2562 // show/hide scalar bar
2563 ::ShowElement(theCommandID);
2566 case SMESHOp::OpSaveDistribution:
2568 // dump control distribution data to the text file
2569 ::SaveDistribution();
2573 case SMESHOp::OpShowDistribution:
2575 // show/hide distribution
2576 ::ShowElement(theCommandID);
2580 #ifndef DISABLE_PLOT2DVIEWER
2581 case SMESHOp::OpPlotDistribution:
2583 // plot distribution
2584 ::PlotDistribution();
2590 case SMESHOp::OpAutoColor:
2594 case SMESHOp::OpDisableAutoColor:
2595 ::DisableAutoColor();
2598 case SMESHOp::OpClipping:
2599 case SMESHOp::OpTransparency:
2600 case SMESHOp::OpProperties: // Display preferences (colors, shrink size, line width, ...)
2603 case SMESHOp::OpDMWireframe:
2604 case SMESHOp::OpDMShading:
2605 case SMESHOp::OpDMNodes:
2606 case SMESHOp::OpDMShrink:
2607 ::SetDisplayMode(theCommandID, myMarkerMap);
2610 //2D quadratic representation
2611 case SMESHOp::OpRepresentationLines:
2612 case SMESHOp::OpRepresentationArcs:
2613 ::SetDisplayMode(theCommandID, myMarkerMap);
2617 case SMESHOp::OpDE0DElements:
2618 case SMESHOp::OpDEEdges:
2619 case SMESHOp::OpDEFaces:
2620 case SMESHOp::OpDEVolumes:
2621 case SMESHOp::OpDEBalls:
2622 case SMESHOp::OpDEAllEntity:
2623 ::SetDisplayEntity(theCommandID);
2626 // Choose entities to be displayed
2627 case SMESHOp::OpDEChoose:
2629 ( new SMESHGUI_DisplayEntitiesDlg( SMESHGUI::desktop() ) )->exec();
2633 case SMESHOp::OpOrientationOnFaces:
2635 SUIT_OverrideCursor wc;
2636 LightApp_SelectionMgr* mgr = selectionMgr();
2637 SALOME_ListIO selected; mgr->selectedObjects( selected );
2639 SALOME_ListIteratorOfListIO it(selected);
2640 for( ; it.More(); it.Next()) {
2641 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2642 if(anIObject->hasEntry()) {
2643 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2644 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2651 case SMESHOp::OpUpdate:
2653 if(checkLock(aStudy)) break;
2654 SUIT_OverrideCursor wc;
2657 SMESH::UpdateView();
2659 catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2660 SMESH::OnVisuException();
2662 catch (...) { // PAL16774 (Crash after display of many groups)
2663 SMESH::OnVisuException();
2667 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2668 aSel->selectedObjects( l );
2669 aSel->setSelectedObjects( l );
2673 case SMESHOp::OpHide:
2674 case SMESHOp::OpShow:
2675 case SMESHOp::OpShowOnly:
2677 SUIT_OverrideCursor wc;
2678 SMESH::EDisplaing anAction;
2679 switch (theCommandID) {
2680 case SMESHOp::OpHide: anAction = SMESH::eErase; break;
2681 case SMESHOp::OpShow: anAction = SMESH::eDisplay; break;
2682 case SMESHOp::OpShowOnly: anAction = SMESH::eDisplayOnly; break;
2685 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2686 SALOME_ListIO sel_objects, to_process;
2688 aSel->selectedObjects( sel_objects );
2690 if ( theCommandID==SMESHOp::OpShowOnly )
2692 //MESSAGE("anAction = SMESH::eDisplayOnly");
2693 startOperation( myEraseAll );
2696 extractContainers( sel_objects, to_process );
2701 SALOME_ListIteratorOfListIO It( to_process );
2702 for ( ; It.More(); It.Next())
2704 Handle(SALOME_InteractiveObject) IOS = It.Value();
2705 if ( IOS->hasEntry() )
2707 if ( !SMESH::UpdateView( anAction, IOS->getEntry() )) {
2708 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2709 break; // PAL16774 (Crash after display of many groups)
2711 if (anAction == SMESH::eDisplayOnly)
2712 anAction = SMESH::eDisplay;
2717 // PAL13338 + PAL15161 -->
2718 if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !checkLock(aStudy)) {
2719 SMESH::UpdateView();
2720 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2722 // PAL13338 + PAL15161 <--
2724 catch (...) { // PAL16774 (Crash after display of many groups)
2725 SMESH::OnVisuException();
2728 if (anAction == SMESH::eErase) {
2730 aSel->setSelectedObjects( l1 );
2733 aSel->setSelectedObjects( to_process );
2738 case SMESHOp::OpNode:
2740 if(checkLock(aStudy)) break;
2743 EmitSignalDeactivateDialog();
2745 ( new SMESHGUI_NodesDlg( this ) )->show();
2748 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"),tr("SMESH_WRN_VIEWER_VTK"));
2753 case SMESHOp::OpCreateMesh:
2754 case SMESHOp::OpCreateSubMesh:
2755 case SMESHOp::OpEditMeshOrSubMesh:
2756 case SMESHOp::OpEditMesh:
2757 case SMESHOp::OpEditSubMesh:
2758 case SMESHOp::OpCompute:
2759 case SMESHOp::OpComputeSubMesh:
2760 case SMESHOp::OpPreCompute:
2761 case SMESHOp::OpEvaluate:
2762 case SMESHOp::OpMeshOrder:
2763 startOperation( theCommandID );
2765 case SMESHOp::OpCopyMesh:
2767 if (checkLock(aStudy)) break;
2768 EmitSignalDeactivateDialog();
2769 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2772 case SMESHOp::OpBuildCompoundMesh:
2774 if (checkLock(aStudy)) break;
2775 EmitSignalDeactivateDialog();
2776 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2780 case SMESHOp::OpDiagonalInversion:
2781 case SMESHOp::OpUnionOfTwoTriangle:
2785 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2789 if ( checkLock( aStudy ) )
2792 /*Standard_Boolean aRes;
2793 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2794 if ( aMesh->_is_nil() )
2796 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2797 tr( "SMESH_BAD_SELECTION" ) );
2801 EmitSignalDeactivateDialog();
2802 if ( theCommandID == SMESHOp::OpDiagonalInversion )
2803 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2805 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2808 case SMESHOp::OpOrientation:
2809 case SMESHOp::OpUnionOfTriangles:
2810 case SMESHOp::OpCuttingOfQuadrangles:
2811 case SMESHOp::OpSplitVolumes:
2815 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2819 if ( checkLock( aStudy ) )
2822 EmitSignalDeactivateDialog();
2823 SMESHGUI_MultiEditDlg* aDlg = NULL;
2824 if ( theCommandID == SMESHOp::OpOrientation )
2825 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2826 else if ( theCommandID == SMESHOp::OpUnionOfTriangles )
2827 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2828 else if ( theCommandID == SMESHOp::OpSplitVolumes )
2829 aDlg = new SMESHGUI_SplitVolumesDlg(this);
2831 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2836 case SMESHOp::OpSmoothing:
2838 if(checkLock(aStudy)) break;
2840 EmitSignalDeactivateDialog();
2841 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2844 SUIT_MessageBox::warning(desktop(), tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2848 case SMESHOp::OpExtrusion:
2850 if (checkLock(aStudy)) break;
2852 EmitSignalDeactivateDialog();
2853 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2855 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2859 case SMESHOp::OpExtrusionAlongAPath:
2861 if (checkLock(aStudy)) break;
2863 EmitSignalDeactivateDialog();
2864 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2866 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2870 case SMESHOp::OpRevolution:
2872 if(checkLock(aStudy)) break;
2874 EmitSignalDeactivateDialog();
2875 ( new SMESHGUI_RevolutionDlg( this ) )->show();
2878 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2882 case SMESHOp::OpPatternMapping:
2884 if ( checkLock( aStudy ) )
2888 EmitSignalDeactivateDialog();
2889 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2892 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2896 case SMESHOp::OpSplitBiQuadratic:
2897 case SMESHOp::OpConvertMeshToQuadratic:
2898 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
2899 case SMESHOp::OpReorientFaces:
2900 case SMESHOp::OpCreateGeometryGroup:
2902 startOperation( theCommandID );
2905 case SMESHOp::OpCreateGroup:
2909 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2913 if(checkLock(aStudy)) break;
2914 EmitSignalDeactivateDialog();
2915 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2917 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2918 SALOME_ListIO selected;
2920 aSel->selectedObjects( selected );
2922 int nbSel = selected.Extent();
2924 // check if mesh is selected
2925 aMesh = SMESH::GetMeshByIO( selected.First() );
2927 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2932 case SMESHOp::OpConstructGroup:
2936 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2940 if(checkLock(aStudy)) break;
2941 EmitSignalDeactivateDialog();
2943 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2944 SALOME_ListIO selected;
2946 aSel->selectedObjects( selected );
2948 int nbSel = selected.Extent();
2950 // check if submesh is selected
2951 Handle(SALOME_InteractiveObject) IObject = selected.First();
2952 if (IObject->hasEntry()) {
2953 _PTR(SObject) aSObj = aStudy->FindObjectID(IObject->getEntry());
2955 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2956 if (!aSubMesh->_is_nil()) {
2958 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2959 // get submesh elements list by types
2960 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2961 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2962 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2963 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2964 // create group for each type o elements
2965 QString aName = IObject->getName();
2966 QStringList anEntryList;
2967 if (aNodes->length() > 0) {
2968 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2969 aGroup->Add(aNodes.inout());
2970 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2971 anEntryList.append( aSObject->GetID().c_str() );
2973 if (aEdges->length() > 0) {
2974 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2975 aGroup->Add(aEdges.inout());
2976 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2977 anEntryList.append( aSObject->GetID().c_str() );
2979 if (aFaces->length() > 0) {
2980 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2981 aGroup->Add(aFaces.inout());
2982 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2983 anEntryList.append( aSObject->GetID().c_str() );
2985 if (aVolumes->length() > 0) {
2986 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2987 aGroup->Add(aVolumes.inout());
2988 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2989 anEntryList.append( aSObject->GetID().c_str() );
2992 anApp->browseObjects( anEntryList );
2994 catch(const SALOME::SALOME_Exception & S_ex){
2995 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3002 SUIT_MessageBox::warning(desktop(),
3003 tr("SMESH_WRN_WARNING"),
3004 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
3009 case SMESHOp::OpEditGroup:
3013 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3017 if(checkLock(aStudy)) break;
3018 EmitSignalDeactivateDialog();
3020 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3021 SALOME_ListIO selected;
3023 aSel->selectedObjects( selected );
3025 SALOME_ListIteratorOfListIO It (selected);
3026 int nbSelectedGroups = 0;
3027 for ( ; It.More(); It.Next() )
3029 SMESH::SMESH_GroupBase_var aGroup =
3030 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
3031 if (!aGroup->_is_nil()) {
3033 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
3037 if (nbSelectedGroups == 0)
3039 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
3045 case SMESHOp::OpAddElemGroupPopup: // Add elements to group
3047 if(checkLock(aStudy)) break;
3048 if (myState == 800) {
3049 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3050 if (aDlg) aDlg->onAdd();
3055 case SMESHOp::OpRemoveElemGroupPopup: // Remove elements from group
3057 if(checkLock(aStudy)) break;
3058 if (myState == 800) {
3059 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3060 if (aDlg) aDlg->onRemove();
3065 case SMESHOp::OpEditGeomGroupAsGroup:
3069 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3073 if(checkLock(aStudy)) break;
3074 EmitSignalDeactivateDialog();
3076 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3077 SALOME_ListIO selected;
3079 aSel->selectedObjects( selected );
3081 SALOME_ListIteratorOfListIO It (selected);
3082 for ( ; It.More(); It.Next() )
3084 SMESH::SMESH_GroupOnGeom_var aGroup =
3085 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
3086 if (!aGroup->_is_nil()) {
3087 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3092 SMESH::SMESH_GroupOnFilter_var aGroup =
3093 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
3094 if (!aGroup->_is_nil()) {
3095 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3103 case SMESHOp::OpUnionGroups:
3104 case SMESHOp::OpIntersectGroups:
3105 case SMESHOp::OpCutGroups:
3109 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3113 if ( checkLock( aStudy ) )
3116 EmitSignalDeactivateDialog();
3118 SMESHGUI_GroupOpDlg* aDlg = 0;
3119 if ( theCommandID == SMESHOp::OpUnionGroups )
3120 aDlg = new SMESHGUI_UnionGroupsDlg( this );
3121 else if ( theCommandID == SMESHOp::OpIntersectGroups )
3122 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3124 aDlg = new SMESHGUI_CutGroupsDlg( this );
3131 case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
3133 if ( checkLock( aStudy ) )
3136 EmitSignalDeactivateDialog();
3137 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3143 case SMESHOp::OpDeleteGroup: // Delete groups with their contents
3147 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3151 if ( checkLock( aStudy ) )
3154 EmitSignalDeactivateDialog();
3156 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3160 case SMESHOp::OpMeshInformation:
3161 case SMESHOp::OpWhatIs:
3163 int page = theCommandID == SMESHOp::OpMeshInformation ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3164 EmitSignalDeactivateDialog();
3165 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3166 SALOME_ListIO selected;
3168 aSel->selectedObjects( selected );
3170 if ( selected.Extent() > 1 ) { // a dlg for each IO
3171 SALOME_ListIteratorOfListIO It( selected );
3172 for ( ; It.More(); It.Next() ) {
3173 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3174 dlg->showInfo( It.Value() );
3179 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3185 case SMESHOp::OpFindElementByPoint:
3187 startOperation( theCommandID );
3191 case SMESHOp::OpEditHypothesis:
3193 if(checkLock(aStudy)) break;
3195 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3196 SALOME_ListIO selected;
3198 aSel->selectedObjects( selected );
3200 int nbSel = selected.Extent();
3203 Handle(SALOME_InteractiveObject) anIObject = selected.First();
3204 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3206 if ( !aHypothesis->_is_nil() )
3208 SMESHGUI_GenericHypothesisCreator* aCreator =
3209 SMESH::GetHypothesisCreator( SMESH::toQStr( aHypothesis->GetName() ));
3212 // set geometry of mesh and sub-mesh to aCreator
3213 aSel->selectedObjects( selected, "", /*convertReferences=*/false);
3214 if ( selected.Extent() == 1 )
3216 QString subGeomID, meshGeomID;
3217 Handle(SALOME_InteractiveObject) hypIO = selected.First();
3218 if ( SMESH::GetGeomEntries( hypIO, subGeomID, meshGeomID ))
3220 if ( subGeomID.isEmpty() ) subGeomID = meshGeomID;
3221 aCreator->setShapeEntry( subGeomID );
3222 aCreator->setMainShapeEntry( meshGeomID );
3226 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3236 case SMESHOp::OpUnassign: // REMOVE HYPOTHESIS / ALGORITHMS
3238 if(checkLock(aStudy)) break;
3239 SUIT_OverrideCursor wc;
3241 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3242 SALOME_ListIO selected;
3244 aSel->selectedObjects( selected, QString::null, false );
3246 SALOME_ListIteratorOfListIO It(selected);
3247 for (int i = 0; It.More(); It.Next(), i++) {
3248 Handle(SALOME_InteractiveObject) IObject = It.Value();
3249 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3252 aSel->setSelectedObjects( l1 );
3257 case SMESHOp::OpElem0D:
3258 case SMESHOp::OpBall:
3259 case SMESHOp::OpEdge:
3260 case SMESHOp::OpTriangle:
3261 case SMESHOp::OpQuadrangle:
3262 case SMESHOp::OpPolygon:
3263 case SMESHOp::OpTetrahedron:
3264 case SMESHOp::OpHexahedron:
3265 case SMESHOp::OpPentahedron:
3266 case SMESHOp::OpPyramid:
3267 case SMESHOp::OpHexagonalPrism:
3269 if(checkLock(aStudy)) break;
3271 EmitSignalDeactivateDialog();
3272 SMDSAbs_EntityType type = SMDSEntity_Edge;
3273 switch (theCommandID) {
3274 case SMESHOp::OpElem0D: type = SMDSEntity_0D; break;
3275 case SMESHOp::OpBall: type = SMDSEntity_Ball; break;
3276 case SMESHOp::OpTriangle: type = SMDSEntity_Triangle; break;
3277 case SMESHOp::OpQuadrangle: type = SMDSEntity_Quadrangle; break;
3278 case SMESHOp::OpTetrahedron: type = SMDSEntity_Tetra; break;
3279 case SMESHOp::OpPolygon: type = SMDSEntity_Polygon; break;
3280 case SMESHOp::OpHexahedron: type = SMDSEntity_Hexa; break;
3281 case SMESHOp::OpPentahedron: type = SMDSEntity_Penta; break;
3282 case SMESHOp::OpPyramid: type = SMDSEntity_Pyramid; break;
3283 case SMESHOp::OpHexagonalPrism: type = SMDSEntity_Hexagonal_Prism; break;
3286 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3289 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3293 case SMESHOp::OpPolyhedron:
3295 if(checkLock(aStudy)) break;
3297 EmitSignalDeactivateDialog();
3298 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3301 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3305 case SMESHOp::OpQuadraticEdge:
3306 case SMESHOp::OpQuadraticTriangle:
3307 case SMESHOp::OpBiQuadraticTriangle:
3308 case SMESHOp::OpQuadraticQuadrangle:
3309 case SMESHOp::OpBiQuadraticQuadrangle:
3310 case SMESHOp::OpQuadraticPolygon:
3311 case SMESHOp::OpQuadraticTetrahedron:
3312 case SMESHOp::OpQuadraticPyramid:
3313 case SMESHOp::OpQuadraticPentahedron:
3314 case SMESHOp::OpBiQuadraticPentahedron:
3315 case SMESHOp::OpQuadraticHexahedron:
3316 case SMESHOp::OpTriQuadraticHexahedron:
3318 if(checkLock(aStudy)) break;
3320 EmitSignalDeactivateDialog();
3321 SMDSAbs_EntityType type = SMDSEntity_Last;
3323 switch (theCommandID) {
3324 case SMESHOp::OpQuadraticEdge: type = SMDSEntity_Quad_Edge; break;
3325 case SMESHOp::OpQuadraticTriangle: type = SMDSEntity_Quad_Triangle; break;
3326 case SMESHOp::OpBiQuadraticTriangle: type = SMDSEntity_BiQuad_Triangle; break;
3327 case SMESHOp::OpQuadraticQuadrangle: type = SMDSEntity_Quad_Quadrangle; break;
3328 case SMESHOp::OpBiQuadraticQuadrangle: type = SMDSEntity_BiQuad_Quadrangle; break;
3329 case SMESHOp::OpQuadraticPolygon: type = SMDSEntity_Quad_Polygon; break;
3330 case SMESHOp::OpQuadraticTetrahedron: type = SMDSEntity_Quad_Tetra; break;
3331 case SMESHOp::OpQuadraticPyramid: type = SMDSEntity_Quad_Pyramid; break;
3332 case SMESHOp::OpQuadraticPentahedron: type = SMDSEntity_Quad_Penta; break;
3333 case SMESHOp::OpBiQuadraticPentahedron: type = SMDSEntity_BiQuad_Penta; break;
3334 case SMESHOp::OpQuadraticHexahedron: type = SMDSEntity_Quad_Hexa; break;
3335 case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
3338 if ( type != SMDSEntity_Last )
3339 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3342 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3343 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3347 case SMESHOp::OpRemoveNodes:
3349 if(checkLock(aStudy)) break;
3351 EmitSignalDeactivateDialog();
3352 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3355 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3356 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3360 case SMESHOp::OpRemoveElements: // REMOVES ELEMENTS
3362 if(checkLock(aStudy)) break;
3364 EmitSignalDeactivateDialog();
3365 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3369 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3370 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3374 case SMESHOp::OpClearMesh: {
3376 if(checkLock(aStudy)) break;
3378 SALOME_ListIO selected;
3379 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3380 aSel->selectedObjects( selected );
3382 SUIT_OverrideCursor wc;
3383 SALOME_ListIteratorOfListIO It (selected);
3384 for ( ; It.More(); It.Next() )
3386 Handle(SALOME_InteractiveObject) IOS = It.Value();
3387 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3388 if ( aMesh->_is_nil()) continue;
3391 if ( aMesh->NbNodes() == 0 ) // imported mesh is not empty
3392 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3393 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3394 SMESH::ModifiedMesh( aMeshSObj, false, true);
3395 // hide groups and submeshes
3396 _PTR(ChildIterator) anIter =
3397 SMESH::GetActiveStudyDocument()->NewChildIterator( aMeshSObj );
3398 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3400 _PTR(SObject) so = anIter->Value();
3401 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3404 catch (const SALOME::SALOME_Exception& S_ex){
3406 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3410 SMESH::UpdateView();
3414 case SMESHOp::OpRemoveOrphanNodes:
3416 if(checkLock(aStudy)) break;
3417 SALOME_ListIO selected;
3418 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3419 aSel->selectedObjects( selected );
3420 if ( selected.Extent() == 1 ) {
3421 Handle(SALOME_InteractiveObject) anIO = selected.First();
3422 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3423 if ( !aMesh->_is_nil() ) {
3424 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3425 tr( "SMESH_WARNING" ),
3426 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3427 SUIT_MessageBox::Yes |
3428 SUIT_MessageBox::No,
3429 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3432 SUIT_OverrideCursor wc;
3433 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3434 int removed = aMeshEditor->RemoveOrphanNodes();
3435 SUIT_MessageBox::information(SMESHGUI::desktop(),
3436 tr("SMESH_INFORMATION"),
3437 tr("NB_NODES_REMOVED").arg(removed));
3438 if ( removed > 0 ) {
3439 SMESH::UpdateView();
3440 SMESHGUI::Modified();
3443 catch (const SALOME::SALOME_Exception& S_ex) {
3444 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3453 case SMESHOp::OpRenumberingNodes:
3455 if(checkLock(aStudy)) break;
3457 EmitSignalDeactivateDialog();
3458 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3462 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3463 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3467 case SMESHOp::OpRenumberingElements:
3469 if(checkLock(aStudy)) break;
3471 EmitSignalDeactivateDialog();
3472 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3476 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3477 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3481 case SMESHOp::OpTranslation:
3483 if(checkLock(aStudy)) break;
3485 EmitSignalDeactivateDialog();
3486 ( new SMESHGUI_TranslationDlg( this ) )->show();
3489 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3490 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3494 case SMESHOp::OpRotation:
3496 if(checkLock(aStudy)) break;
3498 EmitSignalDeactivateDialog();
3499 ( new SMESHGUI_RotationDlg( this ) )->show();
3502 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3503 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3507 case SMESHOp::OpSymmetry:
3509 if(checkLock(aStudy)) break;
3511 EmitSignalDeactivateDialog();
3512 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3515 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3516 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3520 case SMESHOp::OpScale:
3522 if(checkLock(aStudy)) break;
3524 EmitSignalDeactivateDialog();
3525 ( new SMESHGUI_ScaleDlg( this ) )->show();
3528 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3529 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3534 case SMESHOp::OpSewing:
3536 if(checkLock(aStudy)) break;
3538 EmitSignalDeactivateDialog();
3539 ( new SMESHGUI_SewingDlg( this ) )->show();
3542 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3543 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3547 case SMESHOp::OpMergeNodes:
3549 if(checkLock(aStudy)) break;
3551 EmitSignalDeactivateDialog();
3552 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3555 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3556 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3560 case SMESHOp::OpMergeElements:
3562 if (checkLock(aStudy)) break;
3564 EmitSignalDeactivateDialog();
3565 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3567 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3568 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3573 case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
3574 startOperation( SMESHOp::OpMoveNode );
3577 case SMESHOp::OpDuplicateNodes:
3579 if(checkLock(aStudy)) break;
3581 EmitSignalDeactivateDialog();
3582 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3585 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3586 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3591 case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
3592 startOperation( SMESHOp::OpElem0DOnElemNodes );
3595 case SMESHOp::OpSelectFiltersLibrary: // Library of selection filters
3597 static QList<int> aTypes;
3598 if ( aTypes.isEmpty() )
3600 aTypes.append( SMESH::NODE );
3601 aTypes.append( SMESH::EDGE );
3602 aTypes.append( SMESH::FACE );
3603 aTypes.append( SMESH::VOLUME );
3605 if (!myFilterLibraryDlg)
3606 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3607 else if (myFilterLibraryDlg->isHidden())
3608 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3609 myFilterLibraryDlg->raise();
3613 case SMESHOp::OpFreeNode:
3614 case SMESHOp::OpEqualNode:
3615 case SMESHOp::OpNodeConnectivityNb:
3616 case SMESHOp::OpFreeEdge:
3617 case SMESHOp::OpFreeBorder:
3618 case SMESHOp::OpLength:
3619 case SMESHOp::OpConnection:
3620 case SMESHOp::OpEqualEdge:
3621 case SMESHOp::OpFreeFace:
3622 case SMESHOp::OpBareBorderFace:
3623 case SMESHOp::OpOverConstrainedFace:
3624 case SMESHOp::OpLength2D:
3625 case SMESHOp::OpConnection2D:
3626 case SMESHOp::OpArea:
3627 case SMESHOp::OpTaper:
3628 case SMESHOp::OpAspectRatio:
3629 case SMESHOp::OpMinimumAngle:
3630 case SMESHOp::OpWarpingAngle:
3631 case SMESHOp::OpSkew:
3632 case SMESHOp::OpMaxElementLength2D:
3633 case SMESHOp::OpEqualFace:
3634 case SMESHOp::OpAspectRatio3D:
3635 case SMESHOp::OpVolume:
3636 case SMESHOp::OpMaxElementLength3D:
3637 case SMESHOp::OpBareBorderVolume:
3638 case SMESHOp::OpOverConstrainedVolume:
3639 case SMESHOp::OpEqualVolume:
3642 LightApp_SelectionMgr* mgr = selectionMgr();
3643 SALOME_ListIO selected; mgr->selectedObjects( selected );
3645 if( !selected.IsEmpty() ) {
3646 SUIT_OverrideCursor wc;
3647 ::Control( theCommandID );
3650 SUIT_MessageBox::warning(desktop(),
3651 tr( "SMESH_WRN_WARNING" ),
3652 tr( "SMESH_BAD_SELECTION" ) );
3656 SUIT_MessageBox::warning(desktop(),
3657 tr( "SMESH_WRN_WARNING" ),
3658 tr( "NOT_A_VTK_VIEWER" ) );
3661 case SMESHOp::OpOverallMeshQuality:
3662 OverallMeshQuality();
3664 case SMESHOp::OpNumberingNodes:
3666 SUIT_OverrideCursor wc;
3667 LightApp_SelectionMgr* mgr = selectionMgr();
3668 SALOME_ListIO selected; mgr->selectedObjects( selected );
3670 SALOME_ListIteratorOfListIO it(selected);
3671 for( ; it.More(); it.Next()) {
3672 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3673 if(anIObject->hasEntry()) {
3674 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3675 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3681 case SMESHOp::OpNumberingElements:
3683 SUIT_OverrideCursor wc;
3684 LightApp_SelectionMgr* mgr = selectionMgr();
3685 SALOME_ListIO selected; mgr->selectedObjects( selected );
3687 SALOME_ListIteratorOfListIO it(selected);
3688 for( ; it.More(); it.Next()) {
3689 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3690 if(anIObject->hasEntry())
3691 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3692 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3697 case SMESHOp::OpPropertiesLength:
3698 case SMESHOp::OpPropertiesArea:
3699 case SMESHOp::OpPropertiesVolume:
3700 case SMESHOp::OpMinimumDistance:
3701 case SMESHOp::OpBoundingBox:
3703 int page = SMESHGUI_MeasureDlg::MinDistance;
3704 if ( theCommandID == SMESHOp::OpBoundingBox )
3705 page = SMESHGUI_MeasureDlg::BoundingBox;
3706 else if ( theCommandID == SMESHOp::OpPropertiesLength )
3707 page = SMESHGUI_MeasureDlg::Length;
3708 else if ( theCommandID == SMESHOp::OpPropertiesArea )
3709 page = SMESHGUI_MeasureDlg::Area;
3710 else if ( theCommandID == SMESHOp::OpPropertiesVolume )
3711 page = SMESHGUI_MeasureDlg::Volume;
3713 EmitSignalDeactivateDialog();
3714 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3718 case SMESHOp::OpSortChild:
3724 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3725 //updateObjBrowser();
3729 //=============================================================================
3733 //=============================================================================
3734 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3739 //=============================================================================
3743 //=============================================================================
3744 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3749 //=============================================================================
3753 //=============================================================================
3754 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3759 //=============================================================================
3760 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3761 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3763 //=============================================================================
3764 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3765 SUIT_ViewWindow* wnd )
3767 if(theIO->hasEntry()){
3768 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3769 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3773 //=======================================================================
3774 // function : createSMESHAction
3776 //=======================================================================
3777 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3778 const int key, const bool toggle, const QString& shortcutAction )
3781 QWidget* parent = application()->desktop();
3782 SUIT_ResourceMgr* resMgr = resourceMgr();
3784 if ( !icon_id.isEmpty() )
3785 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3787 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3788 if ( !pix.isNull() )
3789 icon = QIcon( pix );
3791 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3792 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3793 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3795 createAction( id, tooltip, icon, menu, status_bar, key, parent,
3796 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3799 //=======================================================================
3800 // function : createPopupItem
3802 //=======================================================================
3803 void SMESHGUI::createPopupItem( const int id,
3804 const QString& clients,
3805 const QString& types,
3806 const QString& theRule,
3809 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3810 popupMgr()->insert( action( id ), pId, 0 );
3812 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3813 QString dc = "selcount"; // VSR : insetad of QtxPopupSelection::defSelCountParam()
3814 QString rule = "(%1) and (%2) and (%3)";
3815 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3816 if( clients.isEmpty() )
3817 rule = rule.arg( QString( "true" ) );
3819 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3820 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3823 bool cont = myRules.contains( id );
3825 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3827 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3828 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3831 //=======================================================================
3832 // function : initialize
3834 //=======================================================================
3835 void SMESHGUI::initialize( CAM_Application* app )
3837 SalomeApp_Module::initialize( app );
3839 // SUIT_ResourceMgr* mgr = app->resourceMgr();
3841 /* Automatic Update flag */
3842 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3844 // ----- create actions --------------
3846 //createSMESHAction( SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
3847 createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_I) );
3848 createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
3849 createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL" );
3851 createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
3853 createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
3854 createSMESHAction( SMESHOp::OpImportGMF, "IMPORT_GMF" );
3855 createSMESHAction( SMESHOp::OpPopupImportUNV, "IMPORT_UNV");
3856 createSMESHAction( SMESHOp::OpPopupImportMED, "IMPORT_MED");
3857 createSMESHAction( SMESHOp::OpPopupImportSTL, "IMPORT_STL" );
3859 createSMESHAction( SMESHOp::OpPopupImportCGNS, "IMPORT_CGNS" );
3861 createSMESHAction( SMESHOp::OpPopupImportSAUV, "IMPORT_SAUV" );
3862 createSMESHAction( SMESHOp::OpPopupImportGMF, "IMPORT_GMF" );
3864 createSMESHAction( SMESHOp::OpExportDAT, "DAT" );
3865 createSMESHAction( SMESHOp::OpExportMED, "MED" );
3866 createSMESHAction( SMESHOp::OpExportUNV, "UNV" );
3867 createSMESHAction( SMESHOp::OpExportSTL, "STL" );
3869 createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
3871 createSMESHAction( SMESHOp::OpExportSAUV, "SAUV");
3872 createSMESHAction( SMESHOp::OpExportGMF, "GMF" );
3873 createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
3874 createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
3875 createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
3876 createSMESHAction( SMESHOp::OpPopupExportSTL, "STL" );
3878 createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
3880 createSMESHAction( SMESHOp::OpPopupExportSAUV, "SAUV");
3881 createSMESHAction( SMESHOp::OpPopupExportGMF, "GMF" );
3882 createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
3883 createSMESHAction( SMESHOp::OpDelete, "DELETE", "ICON_DELETE", Qt::Key_Delete );
3884 createSMESHAction( SMESHOp::OpSelectFiltersLibrary, "SEL_FILTER_LIB" );
3885 createSMESHAction( SMESHOp::OpCreateMesh, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
3886 createSMESHAction( SMESHOp::OpCreateSubMesh, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
3887 createSMESHAction( SMESHOp::OpEditMeshOrSubMesh, "EDIT_MESHSUBMESH", "ICON_DLG_EDIT_MESH" );
3888 createSMESHAction( SMESHOp::OpEditMesh, "EDIT_MESH", "ICON_DLG_EDIT_MESH" );
3889 createSMESHAction( SMESHOp::OpEditSubMesh, "EDIT_SUBMESH", "ICON_DLG_EDIT_MESH" );
3890 createSMESHAction( SMESHOp::OpBuildCompoundMesh, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
3891 createSMESHAction( SMESHOp::OpCopyMesh, "COPY_MESH", "ICON_COPY_MESH" );
3892 createSMESHAction( SMESHOp::OpCompute, "COMPUTE", "ICON_COMPUTE" );
3893 createSMESHAction( SMESHOp::OpComputeSubMesh, "COMPUTE_SUBMESH", "ICON_COMPUTE" );
3894 createSMESHAction( SMESHOp::OpPreCompute, "PRECOMPUTE", "ICON_PRECOMPUTE" );
3895 createSMESHAction( SMESHOp::OpEvaluate, "EVALUATE", "ICON_EVALUATE" );
3896 createSMESHAction( SMESHOp::OpMeshOrder, "MESH_ORDER", "ICON_MESH_ORDER");
3897 createSMESHAction( SMESHOp::OpCreateGroup, "CREATE_GROUP", "ICON_CREATE_GROUP" );
3898 createSMESHAction( SMESHOp::OpCreateGeometryGroup, "CREATE_GEO_GROUP", "ICON_CREATE_GEO_GROUP" );
3899 createSMESHAction( SMESHOp::OpConstructGroup, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
3900 createSMESHAction( SMESHOp::OpEditGroup, "EDIT_GROUP", "ICON_EDIT_GROUP" );
3901 createSMESHAction( SMESHOp::OpEditGeomGroupAsGroup, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3902 createSMESHAction( SMESHOp::OpUnionGroups, "UN_GROUP", "ICON_UNION" );
3903 createSMESHAction( SMESHOp::OpIntersectGroups, "INT_GROUP", "ICON_INTERSECT" );
3904 createSMESHAction( SMESHOp::OpCutGroups, "CUT_GROUP", "ICON_CUT" );
3905 createSMESHAction( SMESHOp::OpGroupUnderlyingElem, "UNDERLYING_ELEMS", "ICON_UNDERLYING_ELEMS" );
3906 createSMESHAction( SMESHOp::OpAddElemGroupPopup, "ADD_TO_GROUP" );
3907 createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE_FROM_GROUP" );
3908 createSMESHAction( SMESHOp::OpDeleteGroup, "DEL_GROUP", "ICON_DEL_GROUP" );
3909 createSMESHAction( SMESHOp::OpMeshInformation , "ADV_INFO", "ICON_ADV_INFO" );
3910 //createSMESHAction( SMESHOp::OpStdInfo, "STD_INFO", "ICON_STD_INFO" );
3911 //createSMESHAction( SMESHOp::OpWhatIs, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3912 createSMESHAction( SMESHOp::OpFindElementByPoint, "FIND_ELEM", "ICON_FIND_ELEM" );
3914 createSMESHAction( SMESHOp::OpFreeNode, "FREE_NODE", "ICON_FREE_NODE", 0, true );
3915 createSMESHAction( SMESHOp::OpEqualNode, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
3916 createSMESHAction( SMESHOp::OpNodeConnectivityNb, "NODE_CONNECTIVITY_NB", "ICON_NODE_CONN_NB", 0, true );
3917 createSMESHAction( SMESHOp::OpFreeEdge, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
3918 createSMESHAction( SMESHOp::OpFreeBorder, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
3919 createSMESHAction( SMESHOp::OpLength, "LENGTH", "ICON_LENGTH", 0, true );
3920 createSMESHAction( SMESHOp::OpConnection, "CONNECTION", "ICON_CONNECTION", 0, true );
3921 createSMESHAction( SMESHOp::OpEqualEdge, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
3922 createSMESHAction( SMESHOp::OpFreeFace, "FREE_FACES", "ICON_FREE_FACES", 0, true );
3923 createSMESHAction( SMESHOp::OpBareBorderFace, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
3924 createSMESHAction( SMESHOp::OpOverConstrainedFace, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
3925 createSMESHAction( SMESHOp::OpLength2D, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
3926 createSMESHAction( SMESHOp::OpConnection2D, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
3927 createSMESHAction( SMESHOp::OpArea, "AREA", "ICON_AREA", 0, true );
3928 createSMESHAction( SMESHOp::OpTaper, "TAPER", "ICON_TAPER", 0, true );
3929 createSMESHAction( SMESHOp::OpAspectRatio, "ASPECT", "ICON_ASPECT", 0, true );
3930 createSMESHAction( SMESHOp::OpMinimumAngle, "MIN_ANG", "ICON_ANGLE", 0, true );
3931 createSMESHAction( SMESHOp::OpWarpingAngle, "WARP", "ICON_WARP", 0, true );
3932 createSMESHAction( SMESHOp::OpSkew, "SKEW", "ICON_SKEW", 0, true );
3933 createSMESHAction( SMESHOp::OpMaxElementLength2D, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
3934 createSMESHAction( SMESHOp::OpEqualFace, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
3935 createSMESHAction( SMESHOp::OpAspectRatio3D, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
3936 createSMESHAction( SMESHOp::OpVolume, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
3937 createSMESHAction( SMESHOp::OpMaxElementLength3D, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
3938 createSMESHAction( SMESHOp::OpBareBorderVolume, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
3939 createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
3940 createSMESHAction( SMESHOp::OpEqualVolume, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
3941 createSMESHAction( SMESHOp::OpOverallMeshQuality, "OVERALL_MESH_QUALITY", "ICON_OVL_MESH_QUALITY" );
3943 createSMESHAction( SMESHOp::OpNode, "NODE", "ICON_DLG_NODE" );
3944 createSMESHAction( SMESHOp::OpElem0D, "ELEM0D", "ICON_DLG_ELEM0D" );
3945 createSMESHAction( SMESHOp::OpElem0DOnElemNodes, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
3946 createSMESHAction( SMESHOp::OpBall, "BALL", "ICON_DLG_BALL" );
3947 createSMESHAction( SMESHOp::OpEdge, "EDGE", "ICON_DLG_EDGE" );
3948 createSMESHAction( SMESHOp::OpTriangle, "TRIANGLE", "ICON_DLG_TRIANGLE" );
3949 createSMESHAction( SMESHOp::OpQuadrangle, "QUAD", "ICON_DLG_QUADRANGLE" );
3950 createSMESHAction( SMESHOp::OpPolygon, "POLYGON", "ICON_DLG_POLYGON" );
3951 createSMESHAction( SMESHOp::OpTetrahedron, "TETRA", "ICON_DLG_TETRAS" );
3952 createSMESHAction( SMESHOp::OpHexahedron, "HEXA", "ICON_DLG_HEXAS" );
3953 createSMESHAction( SMESHOp::OpPentahedron, "PENTA", "ICON_DLG_PENTA" );
3954 createSMESHAction( SMESHOp::OpPyramid , "PYRAMID", "ICON_DLG_PYRAMID" );
3955 createSMESHAction( SMESHOp::OpHexagonalPrism, "OCTA", "ICON_DLG_OCTA" );
3956 createSMESHAction( SMESHOp::OpPolyhedron, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
3957 createSMESHAction( SMESHOp::OpQuadraticEdge, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
3958 createSMESHAction( SMESHOp::OpQuadraticTriangle, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
3959 createSMESHAction( SMESHOp::OpBiQuadraticTriangle, "BIQUADRATIC_TRIANGLE", "ICON_DLG_BIQUADRATIC_TRIANGLE" );
3960 createSMESHAction( SMESHOp::OpQuadraticQuadrangle, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
3961 createSMESHAction( SMESHOp::OpBiQuadraticQuadrangle, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
3962 createSMESHAction( SMESHOp::OpQuadraticPolygon, "QUADRATIC_POLYGON", "ICON_DLG_QUADRATIC_POLYGON" );
3963 createSMESHAction( SMESHOp::OpQuadraticTetrahedron, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
3964 createSMESHAction( SMESHOp::OpQuadraticPyramid, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
3965 createSMESHAction( SMESHOp::OpQuadraticPentahedron, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
3966 createSMESHAction( SMESHOp::OpBiQuadraticPentahedron, "BIQUADRATIC_PENTAHEDRON", "ICON_DLG_BIQUADRATIC_PENTAHEDRON" );
3967 createSMESHAction( SMESHOp::OpQuadraticHexahedron, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
3968 createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
3970 createSMESHAction( SMESHOp::OpRemoveNodes, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
3971 createSMESHAction( SMESHOp::OpRemoveElements, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
3972 createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
3973 createSMESHAction( SMESHOp::OpClearMesh, "CLEAR_MESH", "ICON_CLEAR_MESH" );
3975 //createSMESHAction( SMESHOp::OpRenumberingNodes, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
3976 //createSMESHAction( SMESHOp::OpRenumberingElements, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
3978 createSMESHAction( SMESHOp::OpTranslation, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
3979 createSMESHAction( SMESHOp::OpRotation, "ROT", "ICON_DLG_MESH_ROTATION" );
3980 createSMESHAction( SMESHOp::OpSymmetry, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
3981 createSMESHAction( SMESHOp::OpScale, "SCALE", "ICON_DLG_MESH_SCALE" );
3982 createSMESHAction( SMESHOp::OpSewing, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
3983 createSMESHAction( SMESHOp::OpMergeNodes, "MERGE", "ICON_SMESH_MERGE_NODES" );
3984 createSMESHAction( SMESHOp::OpMergeElements, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
3985 createSMESHAction( SMESHOp::OpMoveNode, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
3986 createSMESHAction( SMESHOp::OpDuplicateNodes, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
3987 createSMESHAction( SMESHOp::OpDiagonalInversion, "INV", "ICON_DLG_MESH_DIAGONAL" );
3988 createSMESHAction( SMESHOp::OpUnionOfTwoTriangle, "UNION2", "ICON_UNION2TRI" );
3989 createSMESHAction( SMESHOp::OpOrientation, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
3990 createSMESHAction( SMESHOp::OpReorientFaces, "REORIENT_2D", "ICON_REORIENT_2D" );
3991 createSMESHAction( SMESHOp::OpUnionOfTriangles, "UNION", "ICON_UNIONTRI" );
3992 createSMESHAction( SMESHOp::OpCuttingOfQuadrangles, "CUT", "ICON_CUTQUAD" );
3993 createSMESHAction( SMESHOp::OpSplitVolumes, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
3994 createSMESHAction( SMESHOp::OpSplitBiQuadratic, "SPLIT_BIQUAD", "ICON_SPLIT_BIQUAD" );
3995 createSMESHAction( SMESHOp::OpSmoothing, "SMOOTH", "ICON_DLG_SMOOTHING" );
3996 createSMESHAction( SMESHOp::OpExtrusion, "EXTRUSION", "ICON_EXTRUSION" );
3997 createSMESHAction( SMESHOp::OpExtrusionAlongAPath, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
3998 createSMESHAction( SMESHOp::OpRevolution, "REVOLUTION", "ICON_REVOLUTION" );
3999 createSMESHAction( SMESHOp::OpPatternMapping, "MAP", "ICON_MAP" );
4000 createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
4001 createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D", "ICON_2D_FROM_3D" );
4003 createSMESHAction( SMESHOp::OpReset, "RESET" );
4004 createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
4005 createSMESHAction( SMESHOp::OpShowScalarBar, "SHOW_SCALAR_BAR","",0, true );
4006 createSMESHAction( SMESHOp::OpSaveDistribution, "SAVE_DISTRIBUTION" );
4007 createSMESHAction( SMESHOp::OpShowDistribution, "SHOW_DISTRIBUTION","",0, true );
4008 #ifndef DISABLE_PLOT2DVIEWER
4009 createSMESHAction( SMESHOp::OpPlotDistribution, "PLOT_DISTRIBUTION" );
4011 createSMESHAction( SMESHOp::OpDMWireframe, "WIRE", "ICON_WIRE", 0, true );
4012 createSMESHAction( SMESHOp::OpDMShading, "SHADE", "ICON_SHADE", 0, true );
4013 createSMESHAction( SMESHOp::OpDMNodes, "NODES", "ICON_POINTS", 0, true );
4014 createSMESHAction( SMESHOp::OpDMShrink, "SHRINK", "ICON_SHRINK", 0, true );
4015 createSMESHAction( SMESHOp::OpUpdate, "UPDATE", "ICON_UPDATE" );
4016 createSMESHAction( SMESHOp::OpDE0DElements, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
4017 createSMESHAction( SMESHOp::OpDEEdges, "EDGES", "ICON_DLG_EDGE", 0, true );
4018 createSMESHAction( SMESHOp::OpDEFaces, "FACES", "ICON_DLG_TRIANGLE", 0, true );
4019 createSMESHAction( SMESHOp::OpDEVolumes, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
4020 createSMESHAction( SMESHOp::OpDEBalls, "BALLS", "ICON_DLG_BALL", 0, true );
4021 createSMESHAction( SMESHOp::OpDEChoose, "CHOOSE", "ICON_DLG_CHOOSE", 0, false );
4022 createSMESHAction( SMESHOp::OpDEAllEntity, "ALL", "ICON_DLG_CHOOSE_ALL", 0, false );
4023 createSMESHAction( SMESHOp::OpOrientationOnFaces, "FACE_ORIENTATION", "", 0, true );
4025 createSMESHAction( SMESHOp::OpRepresentationLines, "LINE_REPRESENTATION", "", 0, true );
4026 createSMESHAction( SMESHOp::OpRepresentationArcs, "ARC_REPRESENTATION", "", 0, true );
4028 createSMESHAction( SMESHOp::OpEditHypothesis, "EDIT_HYPO" );
4029 createSMESHAction( SMESHOp::OpUnassign, "UNASSIGN" );
4030 createSMESHAction( SMESHOp::OpNumberingNodes, "NUM_NODES", "", 0, true );
4031 createSMESHAction( SMESHOp::OpNumberingElements, "NUM_ELEMENTS", "", 0, true );
4032 createSMESHAction( SMESHOp::OpProperties, "COLORS" );
4033 createSMESHAction( SMESHOp::OpTransparency, "TRANSP" );
4034 createSMESHAction( SMESHOp::OpClipping, "CLIP" );
4035 createSMESHAction( SMESHOp::OpAutoColor, "AUTO_COLOR" );
4036 createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
4038 createSMESHAction( SMESHOp::OpMinimumDistance, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
4039 createSMESHAction( SMESHOp::OpBoundingBox, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
4040 createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH", "ICON_MEASURE_LENGTH" );
4041 createSMESHAction( SMESHOp::OpPropertiesArea, "MEASURE_AREA", "ICON_MEASURE_AREA" );
4042 createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME", "ICON_MEASURE_VOLUME" );
4044 createSMESHAction( SMESHOp::OpHide, "HIDE", "ICON_HIDE" );
4045 createSMESHAction( SMESHOp::OpShow, "SHOW", "ICON_SHOW" );
4046 createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
4048 createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
4050 QList<int> aCtrlActions;
4051 aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode
4052 << SMESHOp::OpNodeConnectivityNb // node controls
4053 << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
4054 << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge // edge controls
4055 << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
4056 << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
4057 << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
4058 << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
4059 << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace // face controls
4060 << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
4061 << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
4062 << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume; // volume controls
4063 QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
4064 aCtrlGroup->setExclusive( true );
4065 for( int i = 0; i < aCtrlActions.size(); i++ )
4066 aCtrlGroup->addAction( action( aCtrlActions[i] ) );
4068 // ----- create menu --------------
4069 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
4070 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
4071 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
4072 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
4073 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
4074 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
4075 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
4076 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
4078 createMenu( separator(), fileId );
4080 QMenu* nodeMenu = new QMenu(); QMenu* edgeMenu = new QMenu();
4081 QMenu* faceMenu = new QMenu(); QMenu* volumeMenu = new QMenu();
4082 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
4083 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
4084 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10, -1, nodeMenu ),
4085 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10, -1, edgeMenu ),
4086 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10, -1, faceMenu ),
4087 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10, -1, volumeMenu ),
4088 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
4089 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
4090 //renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
4091 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
4092 basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
4094 //createMenu( SMESHOp::OpImportDAT, importId, -1 );
4095 createMenu( SMESHOp::OpImportUNV, importId, -1 );
4096 createMenu( SMESHOp::OpImportMED, importId, -1 );
4097 createMenu( SMESHOp::OpImportSTL, importId, -1 );
4099 createMenu( SMESHOp::OpImportCGNS, importId, -1 );
4101 createMenu( SMESHOp::OpImportSAUV, importId, -1 );
4102 createMenu( SMESHOp::OpImportGMF, importId, -1 );
4103 createMenu( SMESHOp::OpExportDAT, exportId, -1 );
4104 createMenu( SMESHOp::OpExportMED, exportId, -1 );
4105 createMenu( SMESHOp::OpExportUNV, exportId, -1 );
4106 createMenu( SMESHOp::OpExportSTL, exportId, -1 );
4108 createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
4110 createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
4111 createMenu( SMESHOp::OpExportGMF, exportId, -1 );
4112 createMenu( separator(), fileId, 10 );
4114 createMenu( SMESHOp::OpDelete, editId, -1 );
4116 createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
4118 createMenu( SMESHOp::OpCreateMesh, meshId, -1 ); // "Mesh" menu
4119 createMenu( SMESHOp::OpCreateSubMesh, meshId, -1 );
4120 createMenu( SMESHOp::OpEditMeshOrSubMesh, meshId, -1 );
4121 createMenu( SMESHOp::OpBuildCompoundMesh, meshId, -1 );
4122 createMenu( SMESHOp::OpCopyMesh, meshId, -1 );
4123 createMenu( separator(), meshId, -1 );
4124 createMenu( SMESHOp::OpCompute, meshId, -1 );
4125 createMenu( SMESHOp::OpPreCompute, meshId, -1 );
4126 createMenu( SMESHOp::OpEvaluate, meshId, -1 );
4127 createMenu( SMESHOp::OpMeshOrder, meshId, -1 );
4128 createMenu( separator(), meshId, -1 );
4129 createMenu( SMESHOp::OpCreateGroup, meshId, -1 );
4130 createMenu( SMESHOp::OpCreateGeometryGroup, meshId, -1 );
4131 createMenu( SMESHOp::OpConstructGroup, meshId, -1 );
4132 createMenu( SMESHOp::OpEditGroup, meshId, -1 );
4133 createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4134 createMenu( separator(), meshId, -1 );
4135 createMenu( SMESHOp::OpUnionGroups, meshId, -1 );
4136 createMenu( SMESHOp::OpIntersectGroups, meshId, -1 );
4137 createMenu( SMESHOp::OpCutGroups, meshId, -1 );
4138 createMenu( separator(), meshId, -1 );
4139 createMenu( SMESHOp::OpGroupUnderlyingElem, meshId, -1 );
4140 createMenu( separator(), meshId, -1 );
4141 createMenu( SMESHOp::OpMeshInformation, meshId, -1 );
4142 //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4143 //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4144 createMenu( SMESHOp::OpFindElementByPoint, meshId, -1 );
4145 createMenu( separator(), meshId, -1 );
4147 createMenu( SMESHOp::OpFreeNode, nodeId, -1 );
4148 createMenu( SMESHOp::OpEqualNode, nodeId, -1 );
4149 //createMenu( SMESHOp::OpNodeConnectivityNb, nodeId, -1 );
4150 createMenu( SMESHOp::OpFreeBorder, edgeId, -1 );
4151 createMenu( SMESHOp::OpLength, edgeId, -1 );
4152 createMenu( SMESHOp::OpConnection, edgeId, -1 );
4153 createMenu( SMESHOp::OpEqualEdge, edgeId, -1 );
4154 createMenu( SMESHOp::OpFreeEdge, faceId, -1 );
4155 createMenu( SMESHOp::OpFreeFace, faceId, -1 );
4156 createMenu( SMESHOp::OpBareBorderFace, faceId, -1 );
4157 createMenu( SMESHOp::OpOverConstrainedFace, faceId, -1 );
4158 createMenu( SMESHOp::OpLength2D, faceId, -1 );
4159 createMenu( SMESHOp::OpConnection2D, faceId, -1 );
4160 createMenu( SMESHOp::OpArea, faceId, -1 );
4161 createMenu( SMESHOp::OpTaper, faceId, -1 );
4162 createMenu( SMESHOp::OpAspectRatio, faceId, -1 );
4163 createMenu( SMESHOp::OpMinimumAngle, faceId, -1 );
4164 createMenu( SMESHOp::OpWarpingAngle, faceId, -1 );
4165 createMenu( SMESHOp::OpSkew, faceId, -1 );
4166 createMenu( SMESHOp::OpMaxElementLength2D, faceId, -1 );
4167 createMenu( SMESHOp::OpEqualFace, faceId, -1 );
4168 createMenu( SMESHOp::OpAspectRatio3D, volumeId, -1 );
4169 createMenu( SMESHOp::OpVolume, volumeId, -1 );
4170 createMenu( SMESHOp::OpMaxElementLength3D, volumeId, -1 );
4171 createMenu( SMESHOp::OpBareBorderVolume, volumeId, -1 );
4172 createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4173 createMenu( SMESHOp::OpEqualVolume, volumeId, -1 );
4174 createMenu( separator(), ctrlId, -1 );
4175 createMenu( SMESHOp::OpReset, ctrlId, -1 );
4176 createMenu( separator(), ctrlId, -1 );
4177 createMenu( SMESHOp::OpOverallMeshQuality, ctrlId, -1 );
4179 createMenu( SMESHOp::OpNode, addId, -1 );
4180 createMenu( SMESHOp::OpElem0D, addId, -1 );
4181 createMenu( SMESHOp::OpElem0DOnElemNodes, addId, -1 );
4182 createMenu( SMESHOp::OpBall, addId, -1 );
4183 createMenu( SMESHOp::OpEdge, addId, -1 );
4184 createMenu( SMESHOp::OpTriangle, addId, -1 );
4185 createMenu( SMESHOp::OpQuadrangle, addId, -1 );
4186 createMenu( SMESHOp::OpPolygon, addId, -1 );
4187 createMenu( SMESHOp::OpTetrahedron, addId, -1 );
4188 createMenu( SMESHOp::OpHexahedron, addId, -1 );
4189 createMenu( SMESHOp::OpPentahedron, addId, -1 );
4190 createMenu( SMESHOp::OpPyramid, addId, -1 );
4191 createMenu( SMESHOp::OpHexagonalPrism, addId, -1 );
4192 createMenu( SMESHOp::OpPolyhedron, addId, -1 );
4193 createMenu( separator(), addId, -1 );
4194 createMenu( SMESHOp::OpQuadraticEdge, addId, -1 );
4195 createMenu( SMESHOp::OpQuadraticTriangle, addId, -1 );
4196 createMenu( SMESHOp::OpBiQuadraticTriangle , addId, -1 );
4197 createMenu( SMESHOp::OpQuadraticQuadrangle, addId, -1 );
4198 createMenu( SMESHOp::OpBiQuadraticQuadrangle, addId, -1 );
4199 createMenu( SMESHOp::OpQuadraticPolygon, addId, -1 );
4200 createMenu( SMESHOp::OpQuadraticTetrahedron, addId, -1 );
4201 createMenu( SMESHOp::OpQuadraticPyramid, addId, -1 );
4202 createMenu( SMESHOp::OpQuadraticPentahedron, addId, -1 );
4203 createMenu( SMESHOp::OpBiQuadraticPentahedron, addId, -1 );
4204 createMenu( SMESHOp::OpQuadraticHexahedron, addId, -1 );
4205 createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4207 createMenu( SMESHOp::OpRemoveNodes, removeId, -1 );
4208 createMenu( SMESHOp::OpRemoveElements, removeId, -1 );
4209 createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4210 createMenu( separator(), removeId, -1 );
4211 createMenu( SMESHOp::OpDeleteGroup, removeId, -1 );
4212 createMenu( separator(), removeId, -1 );
4213 createMenu( SMESHOp::OpClearMesh, removeId, -1 );
4215 //createMenu( SMESHOp::OpRenumberingNodes, renumId, -1 );
4216 //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4218 createMenu( SMESHOp::OpTranslation, transfId, -1 );
4219 createMenu( SMESHOp::OpRotation, transfId, -1 );
4220 createMenu( SMESHOp::OpSymmetry, transfId, -1 );
4221 createMenu( SMESHOp::OpScale, transfId, -1 );
4222 createMenu( SMESHOp::OpSewing, transfId, -1 );
4223 createMenu( SMESHOp::OpMergeNodes, transfId, -1 );
4224 createMenu( SMESHOp::OpMergeElements, transfId, -1 );
4225 createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4227 createMenu( SMESHOp::OpMoveNode, modifyId, -1 );
4228 createMenu( SMESHOp::OpDiagonalInversion, modifyId, -1 );
4229 createMenu( SMESHOp::OpUnionOfTwoTriangle, modifyId, -1 );
4230 createMenu( SMESHOp::OpOrientation, modifyId, -1 );
4231 createMenu( SMESHOp::OpReorientFaces, modifyId, -1 );
4232 createMenu( SMESHOp::OpUnionOfTriangles, modifyId, -1 );
4233 createMenu( SMESHOp::OpCuttingOfQuadrangles, modifyId, -1 );
4234 createMenu( SMESHOp::OpSplitVolumes, modifyId, -1 );
4235 createMenu( SMESHOp::OpSplitBiQuadratic, modifyId, -1 );
4236 createMenu( SMESHOp::OpSmoothing, modifyId, -1 );
4237 createMenu( SMESHOp::OpExtrusion, modifyId, -1 );
4238 createMenu( SMESHOp::OpExtrusionAlongAPath , modifyId, -1 );
4239 createMenu( SMESHOp::OpRevolution, modifyId, -1 );
4240 createMenu( SMESHOp::OpPatternMapping, modifyId, -1 );
4241 createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4242 createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4244 createMenu( SMESHOp::OpMinimumDistance, measureId, -1 );
4245 createMenu( SMESHOp::OpBoundingBox, measureId, -1 );
4246 createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4247 createMenu( SMESHOp::OpPropertiesArea, basicPropId, -1 );
4248 createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4249 createMenu( SMESHOp::OpUpdate, viewId, -1 );
4251 connect( nodeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4252 connect( edgeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4253 connect( faceMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4254 connect( volumeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4256 // ----- create toolbars --------------
4257 int meshTb = createTool( tr( "TB_MESH" ), QString( "SMESHMeshToolbar" ) ),
4258 info = createTool( tr( "TB_INFO" ), QString( "SMESHInformationToolbar" ) ),
4259 groupTb = createTool( tr( "TB_GROUP" ), QString( "SMESHGroupToolbar" ) ),
4260 ctrl0dTb = createTool( tr( "TB_CTRL0D" ), QString( "SMESHNodeControlsToolbar" ) ),
4261 ctrl1dTb = createTool( tr( "TB_CTRL1D" ), QString( "SMESHEdgeControlsToolbar" ) ),
4262 ctrl2dTb = createTool( tr( "TB_CTRL2D" ), QString( "SMESHFaceControlsToolbar" ) ),
4263 ctrl3dTb = createTool( tr( "TB_CTRL3D" ), QString( "SMESHVolumeControlsToolbar" ) ),
4264 addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ),
4265 addNonElemTb = createTool( tr( "TB_ADDNON" ), QString( "SMESHAddElementToolbar" ) ),
4266 remTb = createTool( tr( "TB_REM" ), QString( "SMESHRemoveToolbar" ) ),
4267 //renumbTb = createTool( tr( "TB_RENUMBER" ), QString( "SMESHRenumberingToolbar" ) ),
4268 transformTb = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ),
4269 modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ),
4270 measuremTb = createTool( tr( "TB_MEASUREM" ), QString( "SMESHMeasurementsToolbar" ) ),
4271 dispModeTb = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4273 createTool( SMESHOp::OpCreateMesh, meshTb );
4274 createTool( SMESHOp::OpCreateSubMesh, meshTb );
4275 createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4276 createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4277 createTool( SMESHOp::OpCopyMesh, meshTb );
4278 createTool( separator(), meshTb );
4279 createTool( SMESHOp::OpCompute, meshTb );
4280 createTool( SMESHOp::OpPreCompute, meshTb );
4281 createTool( SMESHOp::OpEvaluate, meshTb );
4282 createTool( SMESHOp::OpMeshOrder, meshTb );
4284 createTool( SMESHOp::OpCreateGroup, groupTb );
4285 createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4286 createTool( SMESHOp::OpConstructGroup, groupTb );
4287 createTool( SMESHOp::OpEditGroup, groupTb );
4289 createTool( SMESHOp::OpMeshInformation, info );
4290 //createTool( SMESHOp::OpStdInfo, meshTb );
4291 //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4292 createTool( SMESHOp::OpFindElementByPoint, info );
4294 createTool( SMESHOp::OpFreeNode, ctrl0dTb );
4295 createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4296 //createTool( SMESHOp::OpNodeConnectivityNb, ctrl0dTb );
4298 createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4299 createTool( SMESHOp::OpLength, ctrl1dTb );
4300 createTool( SMESHOp::OpConnection, ctrl1dTb );
4301 createTool( SMESHOp::OpEqualEdge, ctrl1dTb );
4303 createTool( SMESHOp::OpFreeEdge, ctrl2dTb );
4304 createTool( SMESHOp::OpFreeFace, ctrl2dTb );
4305 createTool( SMESHOp::OpBareBorderFace, ctrl2dTb );
4306 createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4307 createTool( SMESHOp::OpLength2D, ctrl2dTb );
4308 createTool( SMESHOp::OpConnection2D, ctrl2dTb );
4309 createTool( SMESHOp::OpArea, ctrl2dTb );
4310 createTool( SMESHOp::OpTaper, ctrl2dTb );
4311 createTool( SMESHOp::OpAspectRatio, ctrl2dTb );
4312 createTool( SMESHOp::OpMinimumAngle, ctrl2dTb );
4313 createTool( SMESHOp::OpWarpingAngle, ctrl2dTb );
4314 createTool( SMESHOp::OpSkew, ctrl2dTb );
4315 createTool( SMESHOp::OpMaxElementLength2D, ctrl2dTb );
4316 createTool( SMESHOp::OpEqualFace, ctrl2dTb );
4318 createTool( SMESHOp::OpAspectRatio3D, ctrl3dTb );
4319 createTool( SMESHOp::OpVolume, ctrl3dTb );
4320 createTool( SMESHOp::OpMaxElementLength3D, ctrl3dTb );
4321 createTool( SMESHOp::OpBareBorderVolume, ctrl3dTb );
4322 createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
4323 createTool( SMESHOp::OpEqualVolume, ctrl3dTb );
4325 createTool( SMESHOp::OpNode, addElemTb );
4326 createTool( SMESHOp::OpElem0D, addElemTb );
4327 createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4328 createTool( SMESHOp::OpBall, addElemTb );
4329 createTool( SMESHOp::OpEdge, addElemTb );
4330 createTool( SMESHOp::OpTriangle, addElemTb );
4331 createTool( SMESHOp::OpQuadrangle, addElemTb );
4332 createTool( SMESHOp::OpPolygon, addElemTb );
4333 createTool( SMESHOp::OpTetrahedron, addElemTb );
4334 createTool( SMESHOp::OpHexahedron, addElemTb );
4335 createTool( SMESHOp::OpPentahedron, addElemTb );
4336 createTool( SMESHOp::OpPyramid, addElemTb );
4337 createTool( SMESHOp::OpHexagonalPrism, addElemTb );
4338 createTool( SMESHOp::OpPolyhedron, addElemTb );
4340 createTool( SMESHOp::OpQuadraticEdge, addNonElemTb );
4341 createTool( SMESHOp::OpQuadraticTriangle, addNonElemTb );
4342 createTool( SMESHOp::OpBiQuadraticTriangle, addNonElemTb );
4343 createTool( SMESHOp::OpQuadraticQuadrangle, addNonElemTb );
4344 createTool( SMESHOp::OpBiQuadraticQuadrangle, addNonElemTb );
4345 createTool( SMESHOp::OpQuadraticPolygon, addNonElemTb );
4346 createTool( SMESHOp::OpQuadraticTetrahedron, addNonElemTb );
4347 createTool( SMESHOp::OpQuadraticPyramid, addNonElemTb );
4348 createTool( SMESHOp::OpQuadraticPentahedron, addNonElemTb );
4349 createTool( SMESHOp::OpBiQuadraticPentahedron, addNonElemTb );
4350 createTool( SMESHOp::OpQuadraticHexahedron, addNonElemTb );
4351 createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4353 createTool( SMESHOp::OpRemoveNodes, remTb );
4354 createTool( SMESHOp::OpRemoveElements, remTb );
4355 createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4356 createTool( SMESHOp::OpClearMesh, remTb );
4358 //createTool( SMESHOp::OpRenumberingNodes, renumbTb );
4359 //createTool( SMESHOp::OpRenumberingElements, renumbTb );
4361 createTool( SMESHOp::OpTranslation, transformTb );
4362 createTool( SMESHOp::OpRotation, transformTb );
4363 createTool( SMESHOp::OpSymmetry, transformTb );
4364 createTool( SMESHOp::OpScale, transformTb );
4365 createTool( SMESHOp::OpSewing, transformTb );
4366 createTool( SMESHOp::OpMergeNodes, transformTb );
4367 createTool( SMESHOp::OpMergeElements, transformTb );
4368 createTool( SMESHOp::OpDuplicateNodes, transformTb );
4370 createTool( SMESHOp::OpMoveNode, modifyTb );
4371 createTool( SMESHOp::OpDiagonalInversion, modifyTb );
4372 createTool( SMESHOp::OpUnionOfTwoTriangle, modifyTb );
4373 createTool( SMESHOp::OpOrientation, modifyTb );
4374 createTool( SMESHOp::OpReorientFaces, modifyTb );
4375 createTool( SMESHOp::OpUnionOfTriangles, modifyTb );
4376 createTool( SMESHOp::OpCuttingOfQuadrangles, modifyTb );
4377 createTool( SMESHOp::OpSplitVolumes, modifyTb );
4378 createTool( SMESHOp::OpSplitBiQuadratic, modifyTb );
4379 createTool( SMESHOp::OpSmoothing, modifyTb );
4380 createTool( SMESHOp::OpExtrusion, modifyTb );
4381 createTool( SMESHOp::OpExtrusionAlongAPath, modifyTb );
4382 createTool( SMESHOp::OpRevolution, modifyTb );
4383 createTool( SMESHOp::OpPatternMapping, modifyTb );
4384 createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4385 createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4387 createTool( SMESHOp::OpMinimumDistance, measuremTb );
4389 createTool( SMESHOp::OpUpdate, dispModeTb );
4391 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4392 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4396 OB = "'ObjectBrowser'",
4397 View = "'" + SVTK_Viewer::Type() + "'",
4399 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4400 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4401 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4402 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4403 smesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::COMPONENT ) ),
4404 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4405 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4406 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4407 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4408 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4409 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4410 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4412 mesh_part = mesh + " " + subMesh + " " + group,
4413 mesh_group = mesh + " " + group,
4414 mesh_submesh = mesh + " " + subMesh,
4415 hyp_alg = hypo + " " + algo;
4417 // popup for object browser
4419 isInvisible("not( isVisible )"),
4420 isEmpty("numberOfNodes = 0"),
4421 isNotEmpty("numberOfNodes <> 0"),
4423 // has nodes, edges, etc in VISIBLE! actor
4424 hasNodes("(numberOfNodes > 0 ) && hasActor"),
4425 hasElems("(count( elemTypes ) > 0)"),
4426 hasDifferentElems("(count( elemTypes ) > 1)"),
4427 hasDifferentObjElems("(count( objElemTypes ) > 1)"),
4428 hasBalls("({'BallElem'} in elemTypes)"),
4429 hasElems0d("({'Elem0d'} in elemTypes)"),
4430 hasEdges("({'Edge'} in elemTypes)"),
4431 hasFaces("({'Face'} in elemTypes)"),
4432 hasVolumes("({'Volume'} in elemTypes)"),
4433 hasFacesOrVolumes("(({'Face'} in elemTypes) || ({'Volume'} in elemTypes)) ");
4435 createPopupItem( SMESHOp::OpFileInformation, OB, mesh, "&& selcount=1 && isImported" );
4436 createPopupItem( SMESHOp::OpCreateSubMesh, OB, mesh, "&& hasGeomReference");
4437 createPopupItem( SMESHOp::OpEditMesh, OB, mesh, "&& selcount=1" );
4438 createPopupItem( SMESHOp::OpEditSubMesh, OB, subMesh, "&& selcount=1 && hasGeomReference" );
4439 createPopupItem( SMESHOp::OpEditGroup, OB, group );
4440 createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4442 popupMgr()->insert( separator(), -1, 0 );
4443 createPopupItem( SMESHOp::OpCompute, OB, mesh, "&& selcount=1 && isComputable" );
4444 createPopupItem( SMESHOp::OpComputeSubMesh, OB, subMesh, "&& selcount=1 && isComputable" );
4445 createPopupItem( SMESHOp::OpPreCompute, OB, mesh, "&& selcount=1 && isPreComputable" );
4446 createPopupItem( SMESHOp::OpEvaluate, OB, mesh, "&& selcount=1 && isComputable" );
4447 createPopupItem( SMESHOp::OpMeshOrder, OB, mesh, "&& selcount=1 && isComputable && hasGeomReference" );
4448 createPopupItem( SMESHOp::OpUpdate, OB, mesh_part );
4449 createPopupItem( SMESHOp::OpMeshInformation, OB, mesh_part );
4450 createPopupItem( SMESHOp::OpFindElementByPoint,OB, mesh_group, "&& selcount=1" );
4451 createPopupItem( SMESHOp::OpOverallMeshQuality,OB, mesh_part );
4452 popupMgr()->insert( separator(), -1, 0 );
4453 createPopupItem( SMESHOp::OpCreateGroup, OB, mesh, "&& selcount=1" );
4454 createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh, "&& selcount=1 && hasGeomReference" );
4455 createPopupItem( SMESHOp::OpConstructGroup, OB, subMesh );
4456 popupMgr()->insert( separator(), -1, 0 );
4457 createPopupItem( SMESHOp::OpEditHypothesis, OB, hypo, "&& isEditableHyp");
4458 createPopupItem( SMESHOp::OpUnassign, OB, hyp_alg );
4459 popupMgr()->insert( separator(), -1, 0 );
4460 createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh_submesh );
4461 createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh_group, "&& selcount=1 && dim>=2");
4462 popupMgr()->insert( separator(), -1, 0 );
4463 createPopupItem( SMESHOp::OpClearMesh, OB, mesh );
4464 //popupMgr()->insert( separator(), -1, 0 );
4466 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4467 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4468 QString only_one_2D = only_one_non_empty + " && dim>1";
4470 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4471 createPopupItem( SMESHOp::OpPopupExportMED, OB, mesh_group, multiple_non_empty, anId );
4472 createPopupItem( SMESHOp::OpPopupExportUNV, OB, mesh_group, only_one_non_empty, anId );
4473 createPopupItem( SMESHOp::OpPopupExportSTL, OB, mesh_group, only_one_2D, anId );
4475 createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4477 createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, only_one_non_empty, anId );
4478 createPopupItem( SMESHOp::OpPopupExportGMF, OB, mesh_group, only_one_non_empty, anId );
4479 createPopupItem( SMESHOp::OpPopupExportDAT, OB, mesh_group, only_one_non_empty, anId );
4480 createPopupItem( SMESHOp::OpDelete, OB, mesh_part + " " + hyp_alg );
4481 createPopupItem( SMESHOp::OpDeleteGroup, OB, group );
4483 anId = popupMgr()->insert( tr( "MEN_IMPORT" ), -1, -1 ); // IMPORT submenu
4484 createPopupItem( SMESHOp::OpPopupImportMED, OB, smesh, "", anId );
4485 createPopupItem( SMESHOp::OpPopupImportUNV, OB, smesh, "", anId );
4486 createPopupItem( SMESHOp::OpPopupImportSTL, OB, smesh, "", anId );
4488 createPopupItem( SMESHOp::OpPopupImportCGNS, OB, smesh, "", anId );
4490 createPopupItem( SMESHOp::OpPopupImportSAUV, OB, smesh, "", anId );
4491 createPopupItem( SMESHOp::OpPopupImportGMF, OB, smesh, "", anId );
4492 createPopupItem( SMESHOp::OpPopupImportDAT, OB, smesh, "", anId );
4493 popupMgr()->insert( separator(), -1, 0 );
4496 createPopupItem( SMESHOp::OpEditGroup, View, group );
4497 createPopupItem( SMESHOp::OpAddElemGroupPopup, View, elems, "&& guiState = 800" );
4498 createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems, "&& guiState = 800" );
4500 popupMgr()->insert( separator(), -1, 0 );
4501 createPopupItem( SMESHOp::OpUpdate, View, mesh_part );
4502 createPopupItem( SMESHOp::OpMeshInformation, View, mesh_part );
4503 createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4504 createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh );
4505 popupMgr()->insert( separator(), -1, 0 );
4507 createPopupItem( SMESHOp::OpAutoColor, OB + " " + View, mesh, "&& (not isAutoColor)" );
4508 createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4509 popupMgr()->insert( separator(), -1, 0 );
4511 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4512 QString aType = QString( "%1type in {%2}" ).arg( lc );
4513 aType = aType.arg( mesh_part );
4514 QString aMeshInVTK = aClient + "&&" + aType;
4516 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4517 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4518 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4520 //-------------------------------------------------
4522 //-------------------------------------------------
4523 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4525 popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4526 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4527 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4529 popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4530 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4531 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4533 popupMgr()->insert( separator(), -1, -1 );
4535 //-------------------------------------------------
4537 //-------------------------------------------------
4538 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4540 popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4541 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4542 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4544 popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4545 popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4546 popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4548 popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4549 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4550 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4552 popupMgr()->insert( separator(), anId, -1 );
4554 popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4555 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4556 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4558 //-------------------------------------------------
4560 //-------------------------------------------------
4561 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4563 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4565 popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4566 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4567 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4569 popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4570 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4571 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4573 popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4574 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4575 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4577 popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4578 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4579 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4581 popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4582 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4583 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4585 popupMgr()->insert( separator(), anId, -1 );
4587 popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4588 popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&& $type in {" + mesh + "} &&" + hasDifferentObjElems, QtxPopupMgr::VisibleRule );
4590 popupMgr()->insert( separator(), anId, -1 );
4592 popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4593 popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4596 //-------------------------------------------------
4597 // Representation of the 2D Quadratic elements
4598 //-------------------------------------------------
4599 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4600 popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4601 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "&& isVisible && isQuadratic",QtxPopupMgr::VisibleRule );
4602 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4604 popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4605 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "&& isVisible && isQuadratic", QtxPopupMgr::VisibleRule );
4606 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4608 //-------------------------------------------------
4609 // Orientation of faces
4610 //-------------------------------------------------
4611 popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4612 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4613 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4615 //-------------------------------------------------
4617 //-------------------------------------------------
4618 popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4619 popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4621 //-------------------------------------------------
4623 //-------------------------------------------------
4624 popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4625 popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4627 //-------------------------------------------------
4629 //-------------------------------------------------
4631 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4632 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4633 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4634 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4636 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4638 popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4639 popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4641 popupMgr()->insert( separator(), anId, -1 );
4643 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4645 popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4646 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4647 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4649 popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4650 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4651 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4653 // popupMgr()->insert( action( SMESHOp::OpNodeConnectivityNb ), aSubId, -1 );
4654 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4655 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), "controlMode = 'eNodeConnectivityNb'", QtxPopupMgr::ToggleRule );
4657 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4659 popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4660 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVTK + "&&" + hasEdges + "&&" + hasFacesOrVolumes, QtxPopupMgr::VisibleRule );
4661 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4663 popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4664 popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4665 popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4667 popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4668 popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4669 popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4670 popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4671 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4672 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4674 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4676 popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4677 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4678 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4680 popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4681 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4682 QtxPopupMgr::VisibleRule );
4683 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4685 popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4686 popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4687 popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4689 popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4690 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4691 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4693 popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
4694 popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4695 popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4697 popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
4698 popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4699 popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4701 popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
4702 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4703 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4705 popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
4706 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4707 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4709 popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
4710 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4711 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4713 popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
4714 popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4715 popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4717 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
4718 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4719 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4721 popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
4722 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4723 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4725 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
4726 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4727 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4728 popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
4729 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4730 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4732 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4734 popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D ), aSubId, -1 );
4735 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4736 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4738 popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
4739 popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4740 popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4742 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
4743 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4744 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4746 popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
4747 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4748 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4750 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
4751 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4752 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4754 popupMgr()->insert ( action( SMESHOp::OpEqualVolume ), aSubId, -1 );
4755 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4756 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4758 popupMgr()->insert( separator(), anId, -1 );
4760 popupMgr()->insert( action( SMESHOp::OpShowScalarBar ), anId, -1 );
4761 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4762 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone' && isScalarBarVisible", QtxPopupMgr::ToggleRule );
4763 popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
4764 popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4766 popupMgr()->insert( separator(), anId, -1 );
4768 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4770 popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
4771 popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4773 popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
4774 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4775 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isScalarBarVisible && isDistributionVisible", QtxPopupMgr::ToggleRule);
4777 #ifndef DISABLE_PLOT2DVIEWER
4778 popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
4779 popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4782 //-------------------------------------------------
4784 //-------------------------------------------------
4785 popupMgr()->insert( separator(), -1, -1 );
4786 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4787 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4788 popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
4789 popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4791 popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
4792 popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4794 popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
4795 popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4797 popupMgr()->insert( separator(), -1, -1 );
4799 //-------------------------------------------------
4801 //-------------------------------------------------
4802 popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
4803 popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4805 popupMgr()->insert( separator(), -1, -1 );
4807 popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
4808 popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
4809 popupMgr()->insert( separator(), -1, -1 );
4811 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4812 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4814 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4815 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4818 //================================================================================
4820 * \brief Return true if SMESH or GEOM objects are selected.
4821 * Is called form LightApp_Module::activateModule() which clear selection if
4822 * not isSelectionCompatible()
4824 //================================================================================
4826 bool SMESHGUI::isSelectionCompatible()
4828 bool isCompatible = true;
4829 SALOME_ListIO selected;
4830 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4831 Sel->selectedObjects( selected );
4833 SALOME_ListIteratorOfListIO It( selected );
4834 for ( ; isCompatible && It.More(); It.Next())
4836 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4837 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4839 return isCompatible;
4843 bool SMESHGUI::reusableOperation( const int id )
4845 // compute, evaluate and precompute are not reusable operations
4846 return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate ) ? false : SalomeApp_Module::reusableOperation( id );
4849 bool SMESHGUI::activateModule( SUIT_Study* study )
4851 bool res = SalomeApp_Module::activateModule( study );
4853 setMenuShown( true );
4854 setToolShown( true );
4856 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4857 PyGILState_STATE gstate = PyGILState_Ensure();
4858 PyObject* pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4859 if ( !pluginsmanager ) {
4863 PyObject* result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toUtf8().data(),tr("SMESH_PLUGINS_OTHER").toUtf8().data());
4868 PyGILState_Release(gstate);
4869 // end of SMESH plugins loading
4871 // Reset actions accelerator keys
4872 action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
4874 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4875 GetSMESHGen()->SetCurrentStudy(SALOMEDS::Study::_nil());
4876 if ( SalomeApp_Study* s = dynamic_cast<SalomeApp_Study*>( study )) {
4877 if ( _PTR(Study) aStudy = s->studyDS() )
4878 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
4881 // get all view currently opened in the study and connect their signals to
4882 // the corresponding slots of the class.
4883 SUIT_Desktop* aDesk = study->application()->desktop();
4885 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4886 SUIT_ViewWindow* wnd;
4887 foreach ( wnd, wndList )
4891 Py_XDECREF(pluginsmanager);
4895 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4897 setMenuShown( false );
4898 setToolShown( false );
4900 EmitSignalCloseAllDialogs();
4902 // Unset actions accelerator keys
4903 action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
4905 return SalomeApp_Module::deactivateModule( study );
4908 void SMESHGUI::studyClosed( SUIT_Study* s )
4912 SMESH::RemoveVisuData( s->id() );
4913 SalomeApp_Module::studyClosed( s );
4916 void SMESHGUI::OnGUIEvent()
4918 const QObject* obj = sender();
4919 if ( !obj || !obj->inherits( "QAction" ) )
4921 int id = actionId((QAction*)obj);
4926 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4928 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
4929 if ( CORBA::is_nil( myComponentSMESH ) )
4931 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4933 aGUI.myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4934 return aGUI.myComponentSMESH;
4937 myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4938 return myComponentSMESH;
4941 QString SMESHGUI::engineIOR() const
4943 CORBA::ORB_var anORB = getApp()->orb();
4944 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4945 return QString( anIOR.in() );
4948 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4950 SalomeApp_Module::contextMenuPopup( client, menu, title );
4952 selectionMgr()->selectedObjects( lst );
4953 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4954 Handle(SALOME_InteractiveObject) io = lst.First();
4955 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4956 _PTR(Study) study = appStudy->studyDS();
4957 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4959 QString aName = QString( SMESH::fromUtf8(obj->GetName()) );
4960 while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4961 aName.remove( (aName.length() - 1), 1 );
4967 LightApp_Selection* SMESHGUI::createSelection() const
4969 return new SMESHGUI_Selection();
4972 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4974 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4975 aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
4976 #ifndef DISABLE_PYCONSOLE
4977 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4981 void SMESHGUI::viewManagers( QStringList& list ) const
4983 list.append( SVTK_Viewer::Type() );
4986 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4988 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4989 SMESH::UpdateSelectionProp( this );
4991 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
4992 for(int i = 0; i < aViews.count() ; i++){
4993 SUIT_ViewWindow *sf = aViews[i];
4996 EmitSignalActivatedViewManager();
5000 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
5002 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
5003 myClippingPlaneInfoMap.erase( theViewManager );
5006 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
5008 theActor->AddObserver( SMESH::DeleteActorEvent,
5009 myEventCallbackCommand.GetPointer(),
5013 void SMESHGUI::ProcessEvents( vtkObject* theObject,
5014 unsigned long theEvent,
5015 void* theClientData,
5018 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
5019 if( theObject && (int) theEvent == SMESH::DeleteActorEvent ) {
5020 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
5021 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
5022 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
5023 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
5024 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
5025 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
5026 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
5027 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
5028 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
5029 SMESH::TActorList::iterator anIter3 = anActorList.begin();
5030 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
5031 if( anActor == *anIter3 ) {
5032 anActorList.erase( anIter3 );
5043 void SMESHGUI::createPreferences()
5045 // General tab ------------------------------------------------------------------------
5046 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
5048 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
5049 setPreferenceProperty( autoUpdate, "columns", 2 );
5050 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
5051 setPreferenceProperty( lim, "min", 0 );
5052 setPreferenceProperty( lim, "max", 100000000 );
5053 setPreferenceProperty( lim, "step", 1000 );
5054 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5055 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
5057 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
5058 setPreferenceProperty( dispgroup, "columns", 2 );
5059 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
5061 modes.append( tr("MEN_WIRE") );
5062 modes.append( tr("MEN_SHADE") );
5063 modes.append( tr("MEN_NODES") );
5064 modes.append( tr("MEN_SHRINK") );
5065 QList<QVariant> indices;
5066 indices.append( 0 );
5067 indices.append( 1 );
5068 indices.append( 2 );
5069 indices.append( 3 );
5070 setPreferenceProperty( dispmode, "strings", modes );
5071 setPreferenceProperty( dispmode, "indexes", indices );
5073 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
5074 setPreferenceProperty( arcgroup, "columns", 2 );
5075 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
5076 QStringList quadraticModes;
5077 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
5078 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
5080 indices.append( 0 );
5081 indices.append( 1 );
5082 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
5083 setPreferenceProperty( quadraticmode, "indexes", indices );
5085 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
5086 "SMESH", "max_angle" );
5087 setPreferenceProperty( maxAngle, "min", 1 );
5088 setPreferenceProperty( maxAngle, "max", 90 );
5090 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
5091 setPreferenceProperty( qaGroup, "columns", 2 );
5092 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
5093 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
5094 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
5095 setPreferenceProperty( prec, "min", 0 );
5096 setPreferenceProperty( prec, "max", 100 );
5097 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
5098 setPreferenceProperty( doubleNodesTol, "precision", 10 );
5099 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
5100 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
5101 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
5104 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
5105 setPreferenceProperty( exportgroup, "columns", 2 );
5106 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
5107 addPreference( tr( "PREF_SHOW_WARN" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "show_warning" );
5108 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
5110 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
5111 setPreferenceProperty( computeGroup, "columns", 2 );
5112 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
5114 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5115 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5116 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5118 indices.append( 0 );
5119 indices.append( 1 );
5120 indices.append( 2 );
5121 setPreferenceProperty( notifyMode, "strings", modes );
5122 setPreferenceProperty( notifyMode, "indexes", indices );
5124 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5125 setPreferenceProperty( infoGroup, "columns", 2 );
5126 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5128 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5129 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5131 indices.append( 0 );
5132 indices.append( 1 );
5133 setPreferenceProperty( elemInfo, "strings", modes );
5134 setPreferenceProperty( elemInfo, "indexes", indices );
5135 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5136 setPreferenceProperty( nodesLim, "min", 0 );
5137 setPreferenceProperty( nodesLim, "max", 10000000 );
5138 setPreferenceProperty( nodesLim, "step", 10000 );
5139 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5140 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5141 setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5142 setPreferenceProperty( ctrlLim, "min", 0 );
5143 setPreferenceProperty( ctrlLim, "max", 10000000 );
5144 setPreferenceProperty( ctrlLim, "step", 1000 );
5145 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5146 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5147 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5148 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5149 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5151 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5152 setPreferenceProperty( segGroup, "columns", 2 );
5153 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5154 "SMESH", "segmentation" );
5155 setPreferenceProperty( segLen, "min", 1 );
5156 setPreferenceProperty( segLen, "max", 10000000 );
5157 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5158 "SMESH", "nb_segments_per_edge" );
5159 setPreferenceProperty( nbSeg, "min", 1 );
5160 setPreferenceProperty( nbSeg, "max", 10000000 );
5162 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5163 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5164 "SMESH", "forget_mesh_on_hyp_modif" );
5167 // Quantities with individual precision settings
5168 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5169 setPreferenceProperty( precGroup, "columns", 2 );
5171 const int nbQuantities = 6;
5172 int precs[nbQuantities], ii = 0;
5173 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5174 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5175 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5176 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5177 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5178 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5179 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5180 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5181 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5182 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5183 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5184 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5186 // Set property for precision value for spinboxes
5187 for ( ii = 0; ii < nbQuantities; ii++ ){
5188 setPreferenceProperty( precs[ii], "min", -14 );
5189 setPreferenceProperty( precs[ii], "max", 14 );
5190 setPreferenceProperty( precs[ii], "precision", 2 );
5193 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5194 setPreferenceProperty( previewGroup, "columns", 2 );
5195 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5196 setPreferenceProperty( chunkSize, "min", 1 );
5197 setPreferenceProperty( chunkSize, "max", 1000 );
5198 setPreferenceProperty( chunkSize, "step", 50 );
5200 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5201 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5203 // Mesh tab ------------------------------------------------------------------------
5204 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5205 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5206 setPreferenceProperty( nodeGroup, "columns", 3 );
5208 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5210 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5212 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5213 QList<QVariant> aMarkerTypeIndicesList;
5214 QList<QVariant> aMarkerTypeIconsList;
5215 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5216 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5217 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5218 aMarkerTypeIndicesList << i;
5219 aMarkerTypeIconsList << pixmap;
5221 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5222 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
5224 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5226 QList<QVariant> aMarkerScaleIndicesList;
5227 QStringList aMarkerScaleValuesList;
5228 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5229 aMarkerScaleIndicesList << i;
5230 //aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5231 aMarkerScaleValuesList << QString::number( i );
5233 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5234 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5236 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5237 //setPreferenceProperty( elemGroup, "columns", 2 );
5239 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5240 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5241 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5242 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5243 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5244 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5245 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5246 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5247 addPreference( tr( "PREF_PREVIEW_COLOR" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5250 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5251 setPreferenceProperty( grpGroup, "columns", 2 );
5253 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5254 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5256 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5257 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5258 /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5259 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5260 double ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5261 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5262 double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5263 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5264 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
5265 LightApp_Preferences::IntSpin, "SMESH", "element_width");
5266 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5267 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5268 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5269 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5271 setPreferenceProperty( size0d, "min", 1 );
5272 setPreferenceProperty( size0d, "max", 10 );
5274 // setPreferenceProperty( ballSize, "min", 1 );
5275 // setPreferenceProperty( ballSize, "max", 10 );
5277 setPreferenceProperty( ballDiameter, "min", 1e-7 );
5278 setPreferenceProperty( ballDiameter, "max", 1e9 );
5279 setPreferenceProperty( ballDiameter, "step", 0.1 );
5281 setPreferenceProperty( ballScale, "min", 1e-2 );
5282 setPreferenceProperty( ballScale, "max", 1e7 );
5283 setPreferenceProperty( ballScale, "step", 0.5 );
5285 setPreferenceProperty( elemW, "min", 1 );
5286 setPreferenceProperty( elemW, "max", 5 );
5288 setPreferenceProperty( outW, "min", 1 );
5289 setPreferenceProperty( outW, "max", 5 );
5291 setPreferenceProperty( shrink, "min", 0 );
5292 setPreferenceProperty( shrink, "max", 100 );
5294 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5295 setPreferenceProperty( numGroup, "columns", 2 );
5297 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5298 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5300 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5301 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5303 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5304 setPreferenceProperty( orientGroup, "columns", 1 );
5306 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5307 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5309 setPreferenceProperty( orientScale, "min", 0.05 );
5310 setPreferenceProperty( orientScale, "max", 0.5 );
5311 setPreferenceProperty( orientScale, "step", 0.05 );
5313 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5315 // Selection tab ------------------------------------------------------------------------
5316 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5318 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5319 setPreferenceProperty( selGroup, "columns", 2 );
5321 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5322 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5324 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5325 setPreferenceProperty( preGroup, "columns", 2 );
5327 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5329 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5330 setPreferenceProperty( precSelGroup, "columns", 2 );
5332 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5333 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5334 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5336 // Scalar Bar tab ------------------------------------------------------------------------
5337 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5338 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5339 setPreferenceProperty( fontGr, "columns", 2 );
5341 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5342 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5344 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5345 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5347 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5348 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5350 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5351 setPreferenceProperty( numcol, "min", 2 );
5352 setPreferenceProperty( numcol, "max", 256 );
5354 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5355 setPreferenceProperty( numlab, "min", 2 );
5356 setPreferenceProperty( numlab, "max", 65 );
5358 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5359 setPreferenceProperty( orientGr, "columns", 2 );
5360 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5361 QStringList orients;
5362 orients.append( tr( "SMESH_VERTICAL" ) );
5363 orients.append( tr( "SMESH_HORIZONTAL" ) );
5364 indices.clear(); indices.append( 0 ); indices.append( 1 );
5365 setPreferenceProperty( orient, "strings", orients );
5366 setPreferenceProperty( orient, "indexes", indices );
5368 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5369 setPreferenceProperty( posVSizeGr, "columns", 2 );
5370 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5371 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5372 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5373 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5374 setPreferenceProperty( xv, "step", 0.1 );
5375 setPreferenceProperty( xv, "min", 0.0 );
5376 setPreferenceProperty( xv, "max", 1.0 );
5377 setPreferenceProperty( yv, "step", 0.1 );
5378 setPreferenceProperty( yv, "min", 0.0 );
5379 setPreferenceProperty( yv, "max", 1.0 );
5380 setPreferenceProperty( wv, "step", 0.1 );
5381 setPreferenceProperty( wv, "min", 0.0 );
5382 setPreferenceProperty( wv, "max", 1.0 );
5383 setPreferenceProperty( hv, "min", 0.0 );
5384 setPreferenceProperty( hv, "max", 1.0 );
5385 setPreferenceProperty( hv, "step", 0.1 );
5387 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5388 setPreferenceProperty( posHSizeGr, "columns", 2 );
5389 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5390 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5391 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5392 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5393 setPreferenceProperty( xv, "min", 0.0 );
5394 setPreferenceProperty( xv, "max", 1.0 );
5395 setPreferenceProperty( xv, "step", 0.1 );
5396 setPreferenceProperty( xh, "min", 0.0 );
5397 setPreferenceProperty( xh, "max", 1.0 );
5398 setPreferenceProperty( xh, "step", 0.1 );
5399 setPreferenceProperty( yh, "min", 0.0 );
5400 setPreferenceProperty( yh, "max", 1.0 );
5401 setPreferenceProperty( yh, "step", 0.1 );
5402 setPreferenceProperty( wh, "min", 0.0 );
5403 setPreferenceProperty( wh, "max", 1.0 );
5404 setPreferenceProperty( wh, "step", 0.1 );
5405 setPreferenceProperty( hh, "min", 0.0 );
5406 setPreferenceProperty( hh, "max", 1.0 );
5407 setPreferenceProperty( hh, "step", 0.1 );
5409 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5410 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5411 setPreferenceProperty( distributionGr, "columns", 3 );
5413 types.append( tr( "SMESH_MONOCOLOR" ) );
5414 types.append( tr( "SMESH_MULTICOLOR" ) );
5415 indices.clear(); indices.append( 0 ); indices.append( 1 );
5416 setPreferenceProperty( coloringType, "strings", types );
5417 setPreferenceProperty( coloringType, "indexes", indices );
5418 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5422 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5424 if ( sect=="SMESH" ) {
5425 float sbX1 = 0.01, sbY1 = 0.01, sbW = 0.08, sbH = 0.08;
5426 float aTol = 1.00000009999999;
5427 std::string aWarning;
5428 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5430 if ( name== "selection_object_color" ||
5431 name=="selection_element_color" ||
5432 name== "highlight_color" ||
5433 name=="selection_precision_node" ||
5434 name=="selection_precision_element" ||
5435 name=="selection_precision_object" )
5437 SMESH::UpdateSelectionProp( this );
5439 else if (name == "scalar_bar_vertical_x" || name == "scalar_bar_vertical_width")
5441 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5442 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5443 if ( sbX1+sbW > aTol ) {
5444 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5447 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5448 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5451 else if (name == "scalar_bar_vertical_y" || name == "scalar_bar_vertical_height" )
5453 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5454 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5455 if ( sbY1 + sbH > aTol ) {
5456 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5457 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5458 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5461 else if (name == "scalar_bar_horizontal_x" || name == "scalar_bar_horizontal_width")
5463 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5464 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5465 if ( sbX1 + sbW > aTol ) {
5466 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5469 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5470 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5473 else if (name == "scalar_bar_horizontal_y" || name == "scalar_bar_horizontal_height")
5475 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5476 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5477 if ( sbY1 + sbH > aTol ) {
5478 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5481 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5482 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5485 else if ( name == "segmentation" )
5487 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5488 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5490 else if ( name == "nb_segments_per_edge" )
5492 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5493 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5495 else if ( name == "historical_python_dump" || name == "forget_mesh_on_hyp_modif" || name == "default_grp_color" )
5497 QString val = aResourceMgr->stringValue( "SMESH", name );
5498 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5500 else if ( name == "numbering_node_color" || name == "numbering_node_font" )
5502 SMESH::UpdateFontProp( this );
5504 else if ( name == "numbering_elem_color" || name == "numbering_elem_font" )
5506 SMESH::UpdateFontProp( this );
5509 if ( aWarning.size() != 0 ) {
5510 aWarning += "The default values are applied instead.";
5511 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5512 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5513 QObject::tr(aWarning.c_str()));
5518 //================================================================================
5520 * \brief Update something in accordance with update flags
5521 * \param theFlags - update flags
5523 * Update viewer or/and object browser etc. in accordance with update flags ( see
5524 * LightApp_UpdateFlags enumeration ).
5526 //================================================================================
5527 void SMESHGUI::update( const int flags )
5529 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5530 SMESH::UpdateView();
5532 SalomeApp_Module::update( flags );
5535 //================================================================================
5537 * \brief Set default selection mode
5539 * SLOT called when operation committed. Sets default selection mode
5541 //================================================================================
5542 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5544 SVTK_ViewWindow* vtkWnd =
5545 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5547 vtkWnd->SetSelectionMode( ActorSelection );
5550 //================================================================================
5552 * \brief Set default selection mode
5554 * SLOT called when operation aborted. Sets default selection mode
5556 //================================================================================
5557 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5559 SVTK_ViewWindow* vtkWnd =
5560 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5562 vtkWnd->SetSelectionMode( ActorSelection );
5565 //================================================================================
5567 * \brief Creates operation with given identifier
5568 * \param id - identifier of operation to be started
5569 * \return Pointer on created operation or NULL if operation is not created
5571 * Virtual method redefined from the base class creates operation with given id.
5572 * It is called called automatically from startOperation method of base class.
5574 //================================================================================
5575 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5577 LightApp_Operation* op = 0;
5578 // to do : create operation here
5581 case SMESHOp::OpSplitBiQuadratic:
5582 op = new SMESHGUI_SplitBiQuadOp();
5584 case SMESHOp::OpConvertMeshToQuadratic:
5585 op = new SMESHGUI_ConvToQuadOp();
5587 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5588 op = new SMESHGUI_Make2DFrom3DOp();
5590 case SMESHOp::OpReorientFaces:
5591 op = new SMESHGUI_ReorientFacesOp();
5593 case SMESHOp::OpCreateMesh:
5594 op = new SMESHGUI_MeshOp( true, true );
5596 case SMESHOp::OpCreateSubMesh:
5597 op = new SMESHGUI_MeshOp( true, false );
5599 case SMESHOp::OpEditMeshOrSubMesh:
5600 case SMESHOp::OpEditMesh:
5601 case SMESHOp::OpEditSubMesh:
5602 op = new SMESHGUI_MeshOp( false );
5604 case SMESHOp::OpCompute:
5605 case SMESHOp::OpComputeSubMesh:
5606 op = new SMESHGUI_ComputeOp();
5608 case SMESHOp::OpPreCompute:
5609 op = new SMESHGUI_PrecomputeOp();
5611 case SMESHOp::OpEvaluate:
5612 op = new SMESHGUI_EvaluateOp();
5614 case SMESHOp::OpMeshOrder:
5615 op = new SMESHGUI_MeshOrderOp();
5617 case SMESHOp::OpCreateGeometryGroup:
5618 op = new SMESHGUI_GroupOnShapeOp();
5620 case SMESHOp::OpFindElementByPoint:
5621 op = new SMESHGUI_FindElemByPointOp();
5623 case SMESHOp::OpMoveNode: // Make mesh pass through point
5624 op = new SMESHGUI_MakeNodeAtPointOp();
5626 case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
5627 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5634 op = SalomeApp_Module::createOperation( id );
5638 //================================================================================
5640 * \brief Stops current operations and starts a given one
5641 * \param id - The id of the operation to start
5643 //================================================================================
5645 void SMESHGUI::switchToOperation(int id)
5647 if ( _PTR(Study) aStudy = SMESH::GetActiveStudyDocument() )
5648 activeStudy()->abortAllOperations();
5649 startOperation( id );
5652 LightApp_Displayer* SMESHGUI::displayer()
5655 myDisplayer = new SMESHGUI_Displayer( getApp() );
5659 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5662 int aTolerance = 64;
5663 int anIterations = 0;
5669 if( anIterations % aPeriod == 0 )
5672 if( aTolerance < 1 )
5676 aHue = (int)( 360.0 * rand() / RAND_MAX );
5679 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5680 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5681 for( ; it != itEnd; ++it )
5683 SALOMEDS::Color anAutoColor = *it;
5684 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5687 aQColor.getHsv( &h, &s, &v );
5688 if( abs( h - aHue ) < aTolerance )
5700 aColor.setHsv( aHue, 255, 255 );
5702 SALOMEDS::Color aSColor;
5703 aSColor.R = aColor.redF();
5704 aSColor.G = aColor.greenF();
5705 aSColor.B = aColor.blueF();
5710 const char* gSeparator = "_"; // character used to separate parameter names
5711 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5712 const char* gPathSep = "|"; // character used to separate paths
5715 * \brief Store visual parameters
5717 * This method is called just before the study document is saved.
5718 * Store visual parameters in AttributeParameter attribue(s)
5720 void SMESHGUI::storeVisualParameters (int savePoint)
5723 Kernel_Utils::Localizer loc;
5725 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5726 if (!appStudy || !appStudy->studyDS())
5728 _PTR(Study) studyDS = appStudy->studyDS();
5730 // componentName is used for encoding of entries when storing them in IParameters
5731 std::string componentName = myComponentSMESH->ComponentDataType();
5732 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5733 //if (!aSComponent) return;
5736 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5737 componentName.c_str(),
5739 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5741 // store map of custom markers
5742 const VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5743 if( !aMarkerMap.empty() )
5745 VTK::MarkerMap::const_iterator anIter = aMarkerMap.begin();
5746 for( ; anIter != aMarkerMap.end(); anIter++ )
5748 int anId = anIter->first;
5749 VTK::MarkerData aMarkerData = anIter->second;
5750 std::string aMarkerFileName = aMarkerData.first;
5751 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5752 if( aMarkerTexture.size() < 3 )
5753 continue; // should contain at least width, height and the first value
5755 QString aPropertyName( "texture" );
5756 aPropertyName += gSeparator;
5757 aPropertyName += QString::number( anId );
5759 QString aPropertyValue = aMarkerFileName.c_str();
5760 aPropertyValue += gPathSep;
5762 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5763 ushort aWidth = *aTextureIter++;
5764 ushort aHeight = *aTextureIter++;
5765 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5766 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5767 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5768 aPropertyValue += QString::number( *aTextureIter );
5770 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5774 // viewers counters are used for storing view_numbers in IParameters
5777 // main cycle to store parameters of displayed objects
5778 QList<SUIT_ViewManager*> lst;
5779 QList<SUIT_ViewManager*>::Iterator it;
5780 getApp()->viewManagers(lst);
5781 for (it = lst.begin(); it != lst.end(); it++)
5783 SUIT_ViewManager* vman = *it;
5784 QString vType = vman->getType();
5786 // saving VTK actors properties
5787 if (vType == SVTK_Viewer::Type())
5789 // store the clipping planes attached to the view manager
5790 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5791 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5792 if( anIter != myClippingPlaneInfoMap.end() )
5793 aClippingPlaneInfoList = anIter->second;
5795 if( !aClippingPlaneInfoList.empty() ) {
5796 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5797 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5799 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5800 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5802 QString aPropertyName( "ClippingPlane" );
5803 aPropertyName += gSeparator;
5804 aPropertyName += QString::number( vtkViewers );
5805 aPropertyName += gSeparator;
5806 aPropertyName += QString::number( anId );
5808 QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
5809 aPropertyValue += gDigitsSep;
5810 aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
5811 aPropertyValue += gDigitsSep;
5812 if ( aPlane->PlaneMode == SMESH::Absolute ) {
5813 aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
5814 aPropertyValue += gDigitsSep;
5815 aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
5816 aPropertyValue += gDigitsSep;
5817 aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
5818 aPropertyValue += gDigitsSep;
5819 aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
5820 aPropertyValue += gDigitsSep;
5821 aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
5822 aPropertyValue += gDigitsSep;
5823 aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
5824 aPropertyValue += gDigitsSep;
5825 aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
5827 else if ( aPlane->PlaneMode == SMESH::Relative ) {
5828 aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
5829 aPropertyValue += gDigitsSep;
5830 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5831 aPropertyValue += gDigitsSep;
5832 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5833 aPropertyValue += gDigitsSep;
5834 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5837 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5841 QVector<SUIT_ViewWindow*> views = vman->getViews();
5842 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5844 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5846 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5847 vtkActorCollection* allActors = aCopy.GetActors();
5848 allActors->InitTraversal();
5849 while (vtkActor* actor = allActors->GetNextActor())
5851 if (actor->GetVisibility()) // store only visible actors
5853 SMESH_Actor* aSmeshActor = 0;
5854 if (actor->IsA("SMESH_Actor"))
5855 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5856 if (aSmeshActor && aSmeshActor->hasIO())
5858 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5861 // entry is "encoded" = it does NOT contain component address,
5862 // since it is a subject to change on next component loading
5863 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5865 std::string param, vtkParam = vType.toLatin1().data();
5866 vtkParam += gSeparator;
5867 vtkParam += QString::number(vtkViewers).toLatin1().data();
5868 vtkParam += gSeparator;
5871 param = vtkParam + "Visibility";
5872 ip->setParameter(entry, param, "On");
5875 param = vtkParam + "Representation";
5876 ip->setParameter(entry, param, QString::number
5877 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5880 param = vtkParam + "IsShrunk";
5881 ip->setParameter(entry, param, QString::number
5882 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5884 // Displayed entities
5885 unsigned int aMode = aSmeshActor->GetEntityMode();
5886 bool isE = aMode & SMESH_Actor::eEdges;
5887 bool isF = aMode & SMESH_Actor::eFaces;
5888 bool isV = aMode & SMESH_Actor::eVolumes;
5889 bool is0d = aMode & SMESH_Actor::e0DElements;
5890 bool isB = aMode & SMESH_Actor::eBallElem;
5892 QString modeStr ("e");
5893 modeStr += gDigitsSep; modeStr += QString::number(isE);
5894 modeStr += gDigitsSep; modeStr += "f";
5895 modeStr += gDigitsSep; modeStr += QString::number(isF);
5896 modeStr += gDigitsSep; modeStr += "v";
5897 modeStr += gDigitsSep; modeStr += QString::number(isV);
5898 modeStr += gDigitsSep; modeStr += "0d";
5899 modeStr += gDigitsSep; modeStr += QString::number(is0d);
5900 modeStr += gDigitsSep; modeStr += "b";
5901 modeStr += gDigitsSep; modeStr += QString::number(isB);
5903 param = vtkParam + "Entities";
5904 ip->setParameter(entry, param, modeStr.toLatin1().data());
5910 aSmeshActor->GetSufaceColor(r, g, b, delta);
5911 QStringList colorStr;
5912 colorStr << "surface";
5913 colorStr << QString::number(r);
5914 colorStr << QString::number(g);
5915 colorStr << QString::number(b);
5917 colorStr << "backsurface";
5918 colorStr << QString::number(delta);
5920 aSmeshActor->GetVolumeColor(r, g, b, delta);
5921 colorStr << "volume";
5922 colorStr << QString::number(r);
5923 colorStr << QString::number(g);
5924 colorStr << QString::number(b);
5925 colorStr << QString::number(delta);
5927 aSmeshActor->GetEdgeColor(r, g, b);
5929 colorStr << QString::number(r);
5930 colorStr << QString::number(g);
5931 colorStr << QString::number(b);
5933 aSmeshActor->GetNodeColor(r, g, b);
5935 colorStr << QString::number(r);
5936 colorStr << QString::number(g);
5937 colorStr << QString::number(b);
5939 aSmeshActor->GetOutlineColor(r, g, b);
5940 colorStr << "outline";
5941 colorStr << QString::number(r);
5942 colorStr << QString::number(g);
5943 colorStr << QString::number(b);
5945 aSmeshActor->Get0DColor(r, g, b);
5946 colorStr << "elem0d";
5947 colorStr << QString::number(r);
5948 colorStr << QString::number(g);
5949 colorStr << QString::number(b);
5951 aSmeshActor->GetBallColor(r, g, b);
5953 colorStr << QString::number(r);
5954 colorStr << QString::number(g);
5955 colorStr << QString::number(b);
5957 aSmeshActor->GetFacesOrientationColor(r, g, b);
5958 colorStr << "orientation";
5959 colorStr << QString::number(r);
5960 colorStr << QString::number(g);
5961 colorStr << QString::number(b);
5963 param = vtkParam + "Colors";
5964 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
5967 QStringList sizeStr;
5969 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
5970 sizeStr << "outline";
5971 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
5972 sizeStr << "elem0d";
5973 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
5975 //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
5976 sizeStr << QString::number((double)aSmeshActor->GetBallSize());
5977 sizeStr << QString::number((double)aSmeshActor->GetBallScale());
5978 sizeStr << "shrink";
5979 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
5980 sizeStr << "orientation";
5981 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
5982 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
5984 param = vtkParam + "Sizes";
5985 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
5990 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5991 if( aMarkerType == VTK::MT_USER ) {
5992 markerStr += "custom";
5993 markerStr += gDigitsSep;
5994 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
5998 markerStr += gDigitsSep;
5999 markerStr += QString::number( (int)aMarkerType );
6000 markerStr += gDigitsSep;
6001 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
6004 param = vtkParam + "PointMarker";
6005 ip->setParameter(entry, param, markerStr.toLatin1().data());
6008 param = vtkParam + "Opacity";
6009 ip->setParameter(entry, param,
6010 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
6013 param = vtkParam + "ClippingPlane";
6015 if( !aClippingPlaneInfoList.empty() ) {
6016 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
6017 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
6019 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
6020 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
6021 SMESH::TActorList::iterator anIter2 = anActorList.begin();
6022 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
6023 if( aSmeshActor == *anIter2 ) {
6024 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
6025 QString::number( anId ).toLatin1().constData() );
6032 ip->setParameter( entry, param, "Off" );
6033 } // if (io->hasEntry())
6034 } // SMESH_Actor && hasIO
6036 } // while.. actors traversal
6040 } // if (SVTK view model)
6041 } // for (viewManagers)
6044 // data structures for clipping planes processing
6048 bool isOpenGLClipping;
6049 vtkIdType RelativeOrientation;
6052 int AbsoluteOrientation;
6053 double X, Y, Z, Dx, Dy, Dz;
6055 typedef std::list<TPlaneData> TPlaneDataList;
6056 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
6058 typedef std::list<vtkActor*> TActorList;
6061 TActorList ActorList;
6062 SUIT_ViewManager* ViewManager;
6064 typedef std::list<TPlaneInfo> TPlaneInfoList;
6065 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
6068 * \brief Restore visual parameters
6070 * This method is called after the study document is opened.
6071 * Restore visual parameters from AttributeParameter attribue(s)
6073 void SMESHGUI::restoreVisualParameters (int savePoint)
6076 Kernel_Utils::Localizer loc;
6078 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6079 if (!appStudy || !appStudy->studyDS())
6081 _PTR(Study) studyDS = appStudy->studyDS();
6083 // componentName is used for encoding of entries when storing them in IParameters
6084 std::string componentName = myComponentSMESH->ComponentDataType();
6085 //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
6086 //if (!aSComponent) return;
6089 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6090 componentName.c_str(),
6092 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6094 // restore map of custom markers and map of clipping planes
6095 VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
6096 TPlaneDataMap aPlaneDataMap;
6098 std::vector<std::string> properties = ip->getProperties();
6099 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
6101 std::string property = *propIt;
6102 QString aPropertyName( property.c_str() );
6103 QString aPropertyValue( ip->getProperty( property ).c_str() );
6105 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
6106 if( aPropertyNameList.isEmpty() )
6109 QString aPropertyType = aPropertyNameList[0];
6110 if( aPropertyType == "texture" )
6112 if( aPropertyNameList.size() != 2 )
6116 int anId = aPropertyNameList[1].toInt( &ok );
6117 if( !ok || anId < 1 )
6120 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
6121 if( aPropertyValueList.size() != 2 )
6124 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
6125 QString aMarkerTextureString = aPropertyValueList[1];
6126 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
6127 if( aMarkerTextureStringList.size() != 3 )
6131 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6136 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6140 VTK::MarkerTexture aMarkerTexture;
6141 aMarkerTexture.push_back( aWidth );
6142 aMarkerTexture.push_back( aHeight );
6144 QString aMarkerTextureData = aMarkerTextureStringList[2];
6145 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6147 QChar aChar = aMarkerTextureData.at( i );
6148 if( aChar.isDigit() )
6149 aMarkerTexture.push_back( aChar.digitValue() );
6152 aMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6154 else if( aPropertyType == "ClippingPlane" )
6156 if( aPropertyNameList.size() != 3 )
6160 int aViewId = aPropertyNameList[1].toInt( &ok );
6161 if( !ok || aViewId < 0 )
6165 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6166 if( !ok || aClippingPlaneId < 0 )
6169 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6170 if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6173 TPlaneData aPlaneData;
6174 aPlaneData.AbsoluteOrientation = false;
6175 aPlaneData.RelativeOrientation = 0;
6176 aPlaneData.Distance = aPlaneData.Angle[0] = aPlaneData.Angle[1] = 0;
6177 aPlaneData.X = aPlaneData.Y = aPlaneData.Z = 0;
6178 aPlaneData.Dx = aPlaneData.Dy = aPlaneData.Dz = 0;
6180 aPlaneData.Id = aClippingPlaneId;
6183 aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6188 aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6192 if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6195 aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6200 aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6205 aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6210 aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6215 aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6220 aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6225 aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6229 else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6231 aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6236 aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6241 aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6246 aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6251 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6252 aPlaneDataList.push_back( aPlaneData );
6256 TPlaneInfoMap aPlaneInfoMap;
6258 std::vector<std::string> entries = ip->getEntries();
6260 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6262 // entry is a normal entry - it should be "decoded" (setting base address of component)
6263 QString entry (ip->decodeEntry(*entIt).c_str());
6265 // Check that the entry corresponds to a real object in the Study
6266 // as the object may be deleted or modified after the visual state is saved.
6267 _PTR(SObject) so = studyDS->FindObjectID(entry.toLatin1().data());
6268 if (!so) continue; //Skip the not existent entry
6270 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6271 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6273 std::vector<std::string>::iterator namesIt = paramNames.begin();
6274 std::vector<std::string>::iterator valuesIt = paramValues.begin();
6276 // actors are stored in a map after displaying of them for
6277 // quicker access in the future: map < viewID to actor >
6278 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6280 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6282 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6283 // '_' is used as separator and should not be used in viewer type or parameter names.
6284 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6285 if (lst.size() != 3)
6288 QString viewerTypStr = lst[0];
6289 QString viewIndexStr = lst[1];
6290 QString paramNameStr = lst[2];
6293 int viewIndex = viewIndexStr.toUInt(&ok);
6294 if (!ok) // bad conversion of view index to integer
6298 if (viewerTypStr == SVTK_Viewer::Type())
6300 SMESH_Actor* aSmeshActor = 0;
6301 if (vtkActors.IsBound(viewIndex))
6302 aSmeshActor = vtkActors.Find(viewIndex);
6304 QList<SUIT_ViewManager*> lst;
6305 getApp()->viewManagers(viewerTypStr, lst);
6307 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6308 SUIT_ViewManager* vman = NULL;
6309 if (viewIndex >= 0 && viewIndex < lst.count())
6310 vman = lst.at(viewIndex);
6312 if (paramNameStr == "Visibility")
6314 if (!aSmeshActor && displayer() && vman)
6316 SUIT_ViewModel* vmodel = vman->getViewModel();
6317 // SVTK view model can be casted to SALOME_View
6318 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6320 // store displayed actor in a temporary map for quicker
6321 // access later when restoring other parameters
6322 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6323 vtkRenderer* Renderer = vtkView->getRenderer();
6324 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6325 vtkActorCollection* theActors = aCopy.GetActors();
6326 theActors->InitTraversal();
6327 bool isFound = false;
6328 vtkActor *ac = theActors->GetNextActor();
6329 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6330 if (ac->IsA("SMESH_Actor")) {
6331 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6332 if (aGeomAc->hasIO()) {
6333 Handle(SALOME_InteractiveObject) io = aGeomAc->getIO();
6334 if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) {
6336 vtkActors.Bind(viewIndex, aGeomAc);
6342 } // if (paramNameStr == "Visibility")
6345 // the rest properties "work" with SMESH_Actor
6348 QString val ((*valuesIt).c_str());
6351 if (paramNameStr == "Representation") {
6352 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6355 else if (paramNameStr == "IsShrunk") {
6357 if (!aSmeshActor->IsShrunk())
6358 aSmeshActor->SetShrink();
6361 if (aSmeshActor->IsShrunk())
6362 aSmeshActor->UnShrink();
6365 // Displayed entities
6366 else if (paramNameStr == "Entities") {
6367 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6368 int aEntityMode = SMESH_Actor::eAllEntity;
6369 for ( int i = 0; i < mode.count(); i+=2 ) {
6370 if ( i < mode.count()-1 ) {
6371 QString type = mode[i];
6372 bool val = mode[i+1].toInt();
6373 if ( type == "e" && !val )
6374 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6375 else if ( type == "f" && !val )
6376 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6377 else if ( type == "v" && !val )
6378 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6379 else if ( type == "0d" && !val )
6380 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6381 else if ( type == "b" && !val )
6382 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6385 aSmeshActor->SetEntityMode( aEntityMode );
6388 else if (paramNameStr == "Colors") {
6389 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6396 QColor outlineColor;
6397 QColor orientationColor;
6403 // below lines are required to get default values for delta coefficients
6404 // of backface color for faces and color of reversed volumes
6405 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
6406 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6407 for ( int i = 0; i < colors.count(); i++ ) {
6408 QString type = colors[i];
6409 if ( type == "surface" ) {
6410 // face color is set by 3 values r:g:b, where
6411 // - r,g,b - is rgb color components
6412 if ( i+1 >= colors.count() ) break; // format error
6413 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6414 if ( i+2 >= colors.count() ) break; // format error
6415 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6416 if ( i+3 >= colors.count() ) break; // format error
6417 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6418 faceColor.setRgbF( r, g, b );
6421 else if ( type == "backsurface" ) {
6422 // backface color can be defined in several ways
6423 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6424 // - in latest versions, it is set as delta coefficient
6425 bool rgbOk = false, deltaOk;
6426 if ( i+1 >= colors.count() ) break; // format error
6427 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6428 int delta = colors[i+1].toInt( &deltaOk );
6430 if ( i+1 < colors.count() ) // index is shifted to 1
6431 g = colors[i+1].toDouble( &rgbOk );
6432 if ( rgbOk ) i++; // shift index
6433 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6434 b = colors[i+1].toDouble( &rgbOk );
6436 // - as currently there's no way to set directly backsurface color as it was before,
6437 // we ignore old dump where r,g,b triple was set
6438 // - also we check that delta parameter is set properly
6439 if ( !rgbOk && deltaOk )
6442 else if ( type == "volume" ) {
6443 // volume color is set by 4 values r:g:b:delta, where
6444 // - r,g,b - is a normal volume rgb color components
6445 // - delta - is a reversed volume color delta coefficient
6446 if ( i+1 >= colors.count() ) break; // format error
6447 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6448 if ( i+2 >= colors.count() ) break; // format error
6449 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6450 if ( i+3 >= colors.count() ) break; // format error
6451 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6452 if ( i+4 >= colors.count() ) break; // format error
6453 int delta = colors[i+4].toInt( &bOk );
6454 if ( !bOk ) break; // format error
6455 volumeColor.setRgbF( r, g, b );
6459 else if ( type == "edge" ) {
6460 // edge color is set by 3 values r:g:b, where
6461 // - r,g,b - is rgb color components
6462 if ( i+1 >= colors.count() ) break; // format error
6463 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6464 if ( i+2 >= colors.count() ) break; // format error
6465 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6466 if ( i+3 >= colors.count() ) break; // format error
6467 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6468 edgeColor.setRgbF( r, g, b );
6471 else if ( type == "node" ) {
6472 // node color is set by 3 values r:g:b, where
6473 // - r,g,b - is rgb color components
6474 if ( i+1 >= colors.count() ) break; // format error
6475 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6476 if ( i+2 >= colors.count() ) break; // format error
6477 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6478 if ( i+3 >= colors.count() ) break; // format error
6479 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6480 nodeColor.setRgbF( r, g, b );
6483 else if ( type == "elem0d" ) {
6484 // 0d element color is set by 3 values r:g:b, where
6485 // - r,g,b - is rgb color components
6486 if ( i+1 >= colors.count() ) break; // format error
6487 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6488 if ( i+2 >= colors.count() ) break; // format error
6489 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6490 if ( i+3 >= colors.count() ) break; // format error
6491 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6492 elem0dColor.setRgbF( r, g, b );
6495 else if ( type == "ball" ) {
6496 // ball color is set by 3 values r:g:b, where
6497 // - r,g,b - is rgb color components
6498 if ( i+1 >= colors.count() ) break; // format error
6499 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6500 if ( i+2 >= colors.count() ) break; // format error
6501 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6502 if ( i+3 >= colors.count() ) break; // format error
6503 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6504 ballColor.setRgbF( r, g, b );
6507 else if ( type == "outline" ) {
6508 // outline color is set by 3 values r:g:b, where
6509 // - r,g,b - is rgb color components
6510 if ( i+1 >= colors.count() ) break; // format error
6511 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6512 if ( i+2 >= colors.count() ) break; // format error
6513 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6514 if ( i+3 >= colors.count() ) break; // format error
6515 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6516 outlineColor.setRgbF( r, g, b );
6519 else if ( type == "orientation" ) {
6520 // orientation color is set by 3 values r:g:b, where
6521 // - r,g,b - is rgb color components
6522 if ( i+1 >= colors.count() ) break; // format error
6523 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6524 if ( i+2 >= colors.count() ) break; // format error
6525 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6526 if ( i+3 >= colors.count() ) break; // format error
6527 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6528 orientationColor.setRgbF( r, g, b );
6533 if ( nodeColor.isValid() )
6534 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6536 if ( edgeColor.isValid() )
6537 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6539 if ( faceColor.isValid() )
6540 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6542 if ( volumeColor.isValid() )
6543 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6544 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6545 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6547 if ( elem0dColor.isValid() )
6548 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6550 if ( ballColor.isValid() )
6551 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6553 if ( outlineColor.isValid() )
6554 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6555 // orientation color
6556 if ( orientationColor.isValid() )
6557 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6560 else if (paramNameStr == "Sizes") {
6561 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6564 int outlineWidth = -1;
6565 int elem0dSize = -1;
6566 //int ballSize = -1;
6567 double ballDiameter = -1.0;
6568 double ballScale = -1.0;
6569 double shrinkSize = -1;
6570 double orientationSize = -1;
6571 bool orientation3d = false;
6572 for ( int i = 0; i < sizes.count(); i++ ) {
6573 QString type = sizes[i];
6574 if ( type == "line" ) {
6575 // line (wireframe) width is given as single integer value
6576 if ( i+1 >= sizes.count() ) break; // format error
6577 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6581 if ( type == "outline" ) {
6582 // outline width is given as single integer value
6583 if ( i+1 >= sizes.count() ) break; // format error
6584 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6588 else if ( type == "elem0d" ) {
6589 // 0d element size is given as single integer value
6590 if ( i+1 >= sizes.count() ) break; // format error
6591 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6595 else if ( type == "ball" ) {
6596 // balls are specified by two values: size:scale, where
6597 // - size - is a integer value specifying size
6598 // - scale - is a double value specifying scale factor
6599 if ( i+1 >= sizes.count() ) break; // format error
6600 //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6601 double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6602 if ( i+2 >= sizes.count() ) break; // format error
6603 double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6609 else if ( type == "shrink" ) {
6610 // shrink factor is given as single floating point value
6611 if ( i+1 >= sizes.count() ) break; // format error
6612 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6616 else if ( type == "orientation" ) {
6617 // orientation vectors are specified by two values size:3d, where
6618 // - size - is a floating point value specifying scale factor
6619 // - 3d - is a boolean
6620 if ( i+1 >= sizes.count() ) break; // format error
6621 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6622 if ( i+2 >= sizes.count() ) break; // format error
6623 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6624 orientationSize = v1;
6625 orientation3d = (bool)v2;
6629 // line (wireframe) width
6630 if ( lineWidth > 0 )
6631 aSmeshActor->SetLineWidth( lineWidth );
6633 if ( outlineWidth > 0 )
6634 aSmeshActor->SetOutlineWidth( outlineWidth );
6635 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6636 aSmeshActor->SetOutlineWidth( lineWidth );
6638 if ( elem0dSize > 0 )
6639 aSmeshActor->Set0DSize( elem0dSize );
6641 /*if ( ballSize > 0 )
6642 aSmeshActor->SetBallSize( ballSize );*/
6644 if ( ballDiameter > 0 )
6645 aSmeshActor->SetBallSize( ballDiameter );
6647 if ( ballScale > 0.0 )
6648 aSmeshActor->SetBallScale( ballScale );
6650 if ( shrinkSize > 0 )
6651 aSmeshActor->SetShrinkFactor( shrinkSize );
6652 // orientation vectors
6653 if ( orientationSize > 0 ) {
6654 aSmeshActor->SetFacesOrientationScale( orientationSize );
6655 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6659 else if (paramNameStr == "PointMarker") {
6660 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6661 if( data.count() >= 2 ) {
6663 int aParam1 = data[1].toInt( &ok );
6665 if( data[0] == "std" && data.count() == 3 ) {
6666 int aParam2 = data[2].toInt( &ok );
6667 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6669 else if( data[0] == "custom" ) {
6670 VTK::MarkerMap::const_iterator markerIt = aMarkerMap.find( aParam1 );
6671 if( markerIt != aMarkerMap.end() ) {
6672 VTK::MarkerData aMarkerData = markerIt->second;
6673 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6680 else if (paramNameStr == "Opacity") {
6681 aSmeshActor->SetOpacity(val.toFloat());
6684 else if (paramNameStr.startsWith("ClippingPlane")) {
6685 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6686 // old format - val looks like "Off" or "1:0:0:0.5:0:0"
6687 // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
6688 // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
6689 // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
6690 // new format - val looks like "Off" or "0" (plane id)
6691 // (note: in new format "Off" value is used only for consistency,
6692 // so it is processed together with values in old format)
6693 bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
6694 if( anIsOldFormat ) {
6695 if (paramNameStr == "ClippingPlane1" || val == "Off")
6696 aSmeshActor->RemoveAllClippingPlanes();
6698 QList<SUIT_ViewManager*> lst;
6699 getApp()->viewManagers(viewerTypStr, lst);
6700 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6701 if (viewIndex >= 0 && viewIndex < lst.count()) {
6702 SUIT_ViewManager* vman = lst.at(viewIndex);
6703 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6705 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6707 SMESH::TActorList anActorList;
6708 anActorList.push_back( aSmeshActor );
6709 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
6710 aPlane->myViewWindow = vtkView;
6711 SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
6712 aPlane->PlaneMode = aMode;
6713 bool isOpenGLClipping = ( bool )vals[1].toInt();
6714 aPlane->IsOpenGLClipping = isOpenGLClipping;
6715 if ( aMode == SMESH::Absolute ) {
6716 aPlane->myAbsoluteOrientation = vals[2].toInt();
6717 aPlane->X = vals[3].toFloat();
6718 aPlane->Y = vals[4].toFloat();
6719 aPlane->Z = vals[5].toFloat();
6720 aPlane->Dx = vals[6].toFloat();
6721 aPlane->Dy = vals[7].toFloat();
6722 aPlane->Dz = vals[8].toFloat();
6724 else if ( aMode == SMESH::Relative ) {
6725 aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
6726 aPlane->myDistance = vals[3].toFloat();
6727 aPlane->myAngle[0] = vals[4].toFloat();
6728 aPlane->myAngle[1] = vals[5].toFloat();
6732 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6733 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6734 aClippingPlaneInfo.Plane = aPlane;
6735 aClippingPlaneInfo.ActorList = anActorList;
6736 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6744 int aPlaneId = val.toInt( &ok );
6745 if( ok && aPlaneId >= 0 ) {
6746 bool anIsDefinedPlane = false;
6747 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6748 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6749 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6750 TPlaneInfo& aPlaneInfo = *anIter;
6751 if( aPlaneInfo.PlaneId == aPlaneId ) {
6752 aPlaneInfo.ActorList.push_back( aSmeshActor );
6753 anIsDefinedPlane = true;
6757 if( !anIsDefinedPlane ) {
6758 TPlaneInfo aPlaneInfo;
6759 aPlaneInfo.PlaneId = aPlaneId;
6760 aPlaneInfo.ActorList.push_back( aSmeshActor );
6761 aPlaneInfo.ViewManager = vman;
6763 // to make the list sorted by plane id
6764 anIter = aPlaneInfoList.begin();
6765 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6766 const TPlaneInfo& aPlaneInfoRef = *anIter;
6767 if( aPlaneInfoRef.PlaneId > aPlaneId )
6770 aPlaneInfoList.insert( anIter, aPlaneInfo );
6775 } // if (aSmeshActor)
6776 } // other parameters than Visibility
6778 } // for names/parameters iterator
6779 } // for entries iterator
6781 // take into account planes with empty list of actors referred to them
6782 QList<SUIT_ViewManager*> aVMList;
6783 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6785 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6786 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6787 int aViewId = aPlaneDataIter->first;
6788 if( aViewId >= 0 && aViewId < aVMList.count() ) {
6789 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6791 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6793 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6794 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6795 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6796 const TPlaneData& aPlaneData = *anIter2;
6797 int aPlaneId = aPlaneData.Id;
6799 bool anIsFound = false;
6800 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6801 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6802 const TPlaneInfo& aPlaneInfo = *anIter3;
6803 if( aPlaneInfo.PlaneId == aPlaneId ) {
6810 TPlaneInfo aPlaneInfo; // ActorList field is empty
6811 aPlaneInfo.PlaneId = aPlaneId;
6812 aPlaneInfo.ViewManager = aViewManager;
6814 // to make the list sorted by plane id
6815 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6816 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6817 const TPlaneInfo& aPlaneInfoRef = *anIter4;
6818 if( aPlaneInfoRef.PlaneId > aPlaneId )
6821 aPlaneInfoList.insert( anIter4, aPlaneInfo );
6827 // add clipping planes to actors according to the restored parameters
6828 // and update the clipping plane map
6829 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6830 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6831 int aViewId = anIter1->first;
6832 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6834 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6835 if( anIter2 == aPlaneDataMap.end() )
6837 const TPlaneDataList& aPlaneDataList = anIter2->second;
6839 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6840 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6841 const TPlaneInfo& aPlaneInfo = *anIter3;
6842 int aPlaneId = aPlaneInfo.PlaneId;
6843 const TActorList& anActorList = aPlaneInfo.ActorList;
6844 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6848 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6852 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6854 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6855 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6856 const TPlaneData& aPlaneData = *anIter4;
6857 if( aPlaneData.Id == aPlaneId ) {
6858 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
6859 aPlane->myViewWindow = aViewWindow;
6860 aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
6861 aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
6862 if ( aPlane->PlaneMode == SMESH::Absolute ) {
6863 aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
6864 aPlane->X = aPlaneData.X;
6865 aPlane->Y = aPlaneData.Y;
6866 aPlane->Z = aPlaneData.Z;
6867 aPlane->Dx = aPlaneData.Dx;
6868 aPlane->Dy = aPlaneData.Dy;
6869 aPlane->Dz = aPlaneData.Dz;
6871 else if ( aPlane->PlaneMode == SMESH::Relative ) {
6872 aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
6873 aPlane->myDistance = aPlaneData.Distance;
6874 aPlane->myAngle[0] = aPlaneData.Angle[0];
6875 aPlane->myAngle[1] = aPlaneData.Angle[1];
6878 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6879 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6880 aClippingPlaneInfo.Plane = aPlane;
6881 aClippingPlaneInfo.ActorList = anActorList;
6882 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6893 // update all VTK views
6894 QList<SUIT_ViewManager*> lst;
6895 getApp()->viewManagers(lst);
6896 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6897 SUIT_ViewModel* vmodel = (*it)->getViewModel();
6898 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6899 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6900 // set OpenGL clipping planes
6901 VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
6902 vtkActorCollection* anAllActors = aCopy.GetActors();
6903 anAllActors->InitTraversal();
6904 while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
6905 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
6906 anActor->SetOpenGLClippingPlane();
6908 vtkView->getRenderer()->ResetCameraClippingRange();
6915 \brief Adds preferences for dfont of VTK viewer
6917 \param pIf group identifier
6918 \param param parameter
6919 \return identifier of preferences
6921 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
6923 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6925 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6928 fam.append( tr( "SMESH_FONT_ARIAL" ) );
6929 fam.append( tr( "SMESH_FONT_COURIER" ) );
6930 fam.append( tr( "SMESH_FONT_TIMES" ) );
6932 setPreferenceProperty( tfont, "fonts", fam );
6934 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6935 if ( needSize ) f = f | QtxFontEdit::Size;
6936 setPreferenceProperty( tfont, "features", f );
6942 \brief Actions after hypothesis edition
6943 Updates object browser after hypothesis edition
6945 void SMESHGUI::onHypothesisEdit( int result )
6948 SMESHGUI::Modified();
6949 updateObjBrowser( true );
6953 \brief Actions after choosing menu of control modes
6954 Updates control mode actions according to current selection
6956 void SMESHGUI::onUpdateControlActions()
6958 SALOME_ListIO selected;
6959 if ( LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr() )
6960 aSel->selectedObjects( selected );
6962 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
6963 if ( selected.Extent() ) {
6964 if ( selected.First()->hasEntry() ) {
6965 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( selected.First()->getEntry() )) {
6966 aControl = anActor->GetControlMode();
6967 SALOME_ListIteratorOfListIO it(selected);
6968 for ( it.Next(); it.More(); it.Next() ) {
6969 Handle(SALOME_InteractiveObject) anIO = it.Value();
6970 if ( anIO->hasEntry() ) {
6971 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
6972 if ( aControl != anActor->GetControlMode() ) {
6973 aControl = SMESH_Actor::eNone;
6983 int anAction = ActionToControl( aControl, true );
6985 action( anAction )->setChecked( true );
6987 QMenu* send = (QMenu*)sender();
6988 QList<QAction*> actions = send->actions();
6989 for ( int i = 0; i < actions.size(); i++ )
6990 actions[i]->setChecked( false );
6996 \brief Signal handler closing(SUIT_ViewWindow*) of a view
6997 \param pview view being closed
6999 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
7000 #ifndef DISABLE_PLOT2DVIEWER
7001 //Crear all Plot2d Viewers if need.
7002 SMESH::ClearPlot2Viewers(pview);
7004 EmitSignalCloseView();
7007 void SMESHGUI::message( const QString& msg )
7010 QStringList data = msg.split("/");
7011 if ( data.count() > 0 ) {
7012 if ( data.first() == "mesh_loading" ) {
7014 QString entry = data.count() > 1 ? data[1] : QString();
7015 if ( entry.isEmpty() )
7018 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
7020 _PTR(SObject) obj = study->FindObjectID( entry.toLatin1().constData() );
7023 name = SMESH::fromUtf8(obj->GetName());
7024 if ( name.isEmpty() )
7027 if ( data.last() == "stop" )
7028 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
7030 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
7031 QApplication::processEvents();
7037 \brief Connects or disconnects signals about activating and cloning view on the module slots
7038 \param pview view which is connected/disconnected
7040 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
7044 SUIT_ViewManager* viewMgr = pview->getViewManager();
7046 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7047 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7049 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7050 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7055 \brief Return \c true if object can be renamed
7057 bool SMESHGUI::renameAllowed( const QString& entry) const {
7058 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7062 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7066 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
7071 if(appStudy->isComponent(entry) || obj->isReference())
7074 // check type to prevent renaming of inappropriate objects
7075 int aType = SMESHGUI_Selection::type(qPrintable(entry), SMESH::GetActiveStudyDocument());
7076 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7077 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7078 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7079 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7080 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
7087 Rename object by entry.
7088 \param entry entry of the object
7089 \param name new name of the object
7090 \brief Return \c true if rename operation finished successfully, \c false otherwise.
7092 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
7094 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7098 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7103 _PTR(Study) aStudy = appStudy->studyDS();
7108 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
7110 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
7115 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
7116 _PTR(GenericAttribute) anAttr;
7117 _PTR(AttributeName) aName;
7119 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
7121 // check type to prevent renaming of inappropriate objects
7122 int aType = SMESHGUI_Selection::type( qPrintable(entry), SMESH::GetActiveStudyDocument() );
7123 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7124 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7125 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7126 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7127 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
7128 if ( !name.isEmpty() ) {
7129 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
7131 // update name of group object and its actor
7132 Handle(SALOME_InteractiveObject) IObject =
7133 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
7135 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
7136 if( !aGroupObject->_is_nil() ) {
7137 aGroupObject->SetName( qPrintable(name) );
7138 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
7139 anActor->setName( qPrintable(name) );
7149 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
7151 static QList<QColor> colors;
7153 if ( colors.isEmpty() ) {
7155 for (int s = 0; s < 2 ; s++)
7157 for (int v = 100; v >= 40; v = v - 20)
7159 for (int h = 0; h < 359 ; h = h + 60)
7161 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
7166 static int currentColor = randomize( colors.size() );
7168 SALOMEDS::Color color;
7169 color.R = (double)colors[currentColor].red() / 255.0;
7170 color.G = (double)colors[currentColor].green() / 255.0;
7171 color.B = (double)colors[currentColor].blue() / 255.0;
7173 currentColor = (currentColor+1) % colors.count();