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;
1854 for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1856 Handle(SALOME_InteractiveObject) anIO = anIt.Value();
1857 if ( anIO.IsNull() ) continue;
1859 QString father = "unknown";
1861 _PTR(SObject) aSO = aStudy->FindObjectID( anIO->getEntry() );
1863 father = QString::fromStdString( aSO->GetFatherComponent()->ComponentDataType() );
1864 // check if object is reference
1865 _PTR(SObject) aRefSObj;
1866 aNameList.append("\n - ");
1867 if ( aSO->ReferencedObject( aRefSObj ) ) {
1868 QString aRefName = QString::fromStdString ( aRefSObj->GetName() );
1869 aNameList.append( aRefName );
1870 father = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1873 aNameList.append(anIO->getName());
1877 if( aParentComponent.isNull() )
1878 aParentComponent = father;
1879 else if( !aParentComponent.isEmpty() && aParentComponent!=father )
1880 aParentComponent = "";
1883 if ( objectCount == 0 )
1884 return; // No Valid Objects Selected
1886 if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
1887 SUIT_MessageBox::warning( SMESHGUI::desktop(),
1888 QObject::tr("ERR_ERROR"),
1889 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
1892 // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
1893 if (SUIT_MessageBox::warning
1894 (SMESHGUI::desktop(),
1895 QObject::tr("SMESH_WRN_WARNING"),
1896 QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
1897 SUIT_MessageBox::Yes | SUIT_MessageBox::No,
1898 SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
1901 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1903 // Put the whole hierarchy of sub-objects of the selected SO's into a list and
1904 // then treat them all starting from the deepest objects (at list back)
1905 std::list< _PTR(SObject) > listSO;
1906 SALOME_ListIteratorOfListIO It(selected);
1907 for( ; It.More(); It.Next()) // loop on selected IO's
1909 Handle(SALOME_InteractiveObject) IObject = It.Value();
1910 if(IObject->hasEntry()) {
1911 _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
1913 // disable removal of "SMESH" component object
1914 if(aSO->FindAttribute(anAttr, "AttributeIOR")){
1916 if ( engineIOR() == anIOR->Value().c_str() )
1919 //Check the referenced object
1920 _PTR(SObject) aRefSObject;
1921 if ( aSO && aSO->ReferencedObject( aRefSObject ) )
1922 aSO = aRefSObject; // Delete main Object instead of reference
1924 listSO.push_back( aSO );
1925 std::list< _PTR(SObject) >::iterator itSO = --listSO.end();
1926 for ( ; itSO != listSO.end(); ++itSO ) {
1927 _PTR(ChildIterator) it = aStudy->NewChildIterator( *itSO );
1928 for (it->InitEx(false); it->More(); it->Next())
1929 listSO.push_back( it->Value() );
1933 // Check if none of objects to delete is referred from outside
1934 std::list< _PTR(SObject) >::reverse_iterator ritSO;
1935 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1937 _PTR(SObject) SO = *ritSO;
1938 if ( !SO ) continue;
1939 std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( *ritSO );
1940 for (size_t i = 0; i < aReferences.size(); i++) {
1941 _PTR(SComponent) aComponent = aReferences[i]->GetFatherComponent();
1942 std::string type = aComponent->ComponentDataType();
1943 if ( type != "SMESH" )
1945 SUIT_MessageBox::warning( anApp->desktop(),
1946 QObject::tr("WRN_WARNING"),
1947 QObject::tr("DEP_OBJECT") );
1948 return; // outside SMESH, there is an object depending on a SMESH object
1953 // Call mesh->Clear() to prevent loading mesh from file caused by hypotheses removal
1954 for( It.Initialize( selected ); It.More(); It.Next()) // loop on selected IO's
1956 Handle(SALOME_InteractiveObject) IObject = It.Value();
1957 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface< SMESH::SMESH_Mesh >( IObject );
1958 if ( !mesh->_is_nil() )
1962 // Treat SO's in the list starting from the back
1963 aStudyBuilder->NewCommand(); // There is a transaction
1964 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1966 _PTR(SObject) SO = *ritSO;
1967 if ( !SO ) continue;
1968 std::string anEntry = SO->GetID();
1970 /** Erase graphical object and remove all its data **/
1971 if(SO->FindAttribute(anAttr, "AttributeIOR")) {
1972 SMESH::RemoveVisualObjectWithActors( anEntry.c_str(), true);
1974 /** Remove an object from data structures **/
1975 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
1976 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
1977 if ( !aGroup->_is_nil() ) { // DELETE GROUP
1978 SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
1979 aMesh->RemoveGroup( aGroup );
1981 else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
1982 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
1983 aMesh->RemoveSubMesh( aSubMesh );
1985 _PTR(SObject) aMeshSO = SMESH::FindSObject(aMesh);
1987 SMESH::ModifiedMesh(aMeshSO, false, aMesh->NbNodes()==0);
1990 Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
1991 ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
1992 QString objType = CheckTypeObject(IObject);
1993 if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
1994 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
1995 aStudyBuilder->RemoveObjectWithChildren( SO );
1997 else {// default action: remove SObject from the study
1998 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
1999 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
2001 aStudyBuilder->RemoveObjectWithChildren( SO );
2005 } /* listSO back loop */
2007 aStudyBuilder->CommitCommand();
2009 /* Clear any previous selection */
2011 aSel->setSelectedObjects( l1 );
2013 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
2017 SMESHGUI_EXPORT CAM_Module* createModule()
2019 return new SMESHGUI();
2022 SMESHGUI_EXPORT char* getModuleVersion() {
2023 return (char*)SMESH_VERSION_STR;
2027 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
2029 //=============================================================================
2033 //=============================================================================
2034 SMESHGUI::SMESHGUI() :
2035 SalomeApp_Module( "SMESH" )
2037 if ( CORBA::is_nil( myComponentSMESH ) )
2039 CORBA::Boolean anIsEmbeddedMode;
2040 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
2041 //MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
2043 // 0019923: EDF 765 SMESH : default values of hypothesis
2044 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
2045 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
2046 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
2047 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
2048 myComponentSMESH->SetDefaultNbSegments( nbSeg );
2050 const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif", "default_grp_color" };
2051 for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
2052 if ( aResourceMgr->hasValue( "SMESH", options[i] ))
2054 QString val = aResourceMgr->stringValue( "SMESH", options[i] );
2055 myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
2059 myActiveDialogBox = 0;
2060 myFilterLibraryDlg = 0;
2064 myEventCallbackCommand = vtkCallbackCommand::New();
2065 myEventCallbackCommand->Delete();
2066 myEventCallbackCommand->SetClientData( this );
2067 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
2070 /* load resources for all available meshers */
2071 SMESH::InitAvailableHypotheses();
2074 //=============================================================================
2078 //=============================================================================
2079 SMESHGUI::~SMESHGUI()
2083 //=============================================================================
2087 //=============================================================================
2088 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
2090 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2092 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
2097 //=============================================================================
2101 //=============================================================================
2102 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
2104 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2108 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2109 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2110 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2111 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2112 return autoUpdate && !exceeded;
2115 //=============================================================================
2119 //=============================================================================
2120 bool SMESHGUI::automaticUpdate( SMESH::SMESH_IDSource_ptr theMesh,
2121 int* entities, bool* limitExceeded, int* hidden, long* nbElements )
2123 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2127 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2128 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2129 bool incrementalLimit = resMgr->booleanValue( "SMESH", "incremental_limit", false );
2131 SMESH::long_array_var info = theMesh->GetMeshInfo();
2132 long nbOdElems = info[SMDSEntity_0D];
2133 long nbEdges = info[SMDSEntity_Edge] + info[SMDSEntity_Quad_Edge];
2134 long nbFaces = info[SMDSEntity_Triangle] + info[SMDSEntity_Quad_Triangle] + info[SMDSEntity_BiQuad_Triangle] +
2135 info[SMDSEntity_Quadrangle] + info[SMDSEntity_Quad_Quadrangle] + info[SMDSEntity_BiQuad_Quadrangle] +
2136 info[SMDSEntity_Polygon] + info[SMDSEntity_Quad_Polygon];
2137 long nbVolumes = info[SMDSEntity_Tetra] + info[SMDSEntity_Quad_Tetra] +
2138 info[SMDSEntity_Hexa] + info[SMDSEntity_Quad_Hexa] + info[SMDSEntity_TriQuad_Hexa] +
2139 info[SMDSEntity_Pyramid] + info[SMDSEntity_Quad_Pyramid] +
2140 info[SMDSEntity_Penta] + info[SMDSEntity_Quad_Penta] + info[SMDSEntity_BiQuad_Penta] +
2141 info[SMDSEntity_Polyhedra] +
2142 info[SMDSEntity_Hexagonal_Prism];
2143 long nbBalls = info[SMDSEntity_Ball];
2145 long requestedSize = nbOdElems + nbBalls + nbEdges + nbFaces + nbVolumes;
2146 *nbElements = requestedSize;
2148 *entities = SMESH_Actor::eAllEntity;
2151 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2153 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2155 if ( incrementalLimit ) {
2158 if ( nbOdElems > 0 ) {
2159 if ( total + nbOdElems > updateLimit ) {
2160 *entities = *entities & ~SMESH_Actor::e0DElements;
2161 *hidden = *hidden | SMESH_Actor::e0DElements;
2168 if ( nbEdges > 0 ) {
2169 if ( total + nbEdges > updateLimit ) {
2170 *entities = *entities & ~SMESH_Actor::eEdges;
2171 *hidden = *hidden | SMESH_Actor::eEdges;
2178 if ( nbFaces > 0 ) {
2179 if ( total + nbFaces > updateLimit ) {
2180 *entities = *entities & ~SMESH_Actor::eFaces;
2181 *hidden = *hidden | SMESH_Actor::eFaces;
2188 if ( nbVolumes > 0 ) {
2189 if ( total + nbVolumes > updateLimit ) {
2190 *entities = *entities & ~SMESH_Actor::eVolumes;
2191 *hidden = *hidden | SMESH_Actor::eVolumes;
2198 if ( nbBalls > 0 ) {
2199 if ( total + nbBalls > updateLimit ) {
2200 *entities = *entities & ~SMESH_Actor::eBallElem;
2201 *hidden = *hidden | SMESH_Actor::eBallElem;
2209 return autoUpdate && !exceeded;
2212 //=============================================================================
2216 //=============================================================================
2217 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
2219 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
2222 //=============================================================================
2226 //=============================================================================
2227 SMESHGUI* SMESHGUI::GetSMESHGUI()
2229 SMESHGUI* smeshMod = 0;
2230 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
2233 CAM_Module* module = app->module( "Mesh" );
2234 smeshMod = dynamic_cast<SMESHGUI*>( module );
2237 if ( smeshMod && smeshMod->application() && smeshMod->application()->activeStudy() )
2239 SalomeApp_Study* study = dynamic_cast<SalomeApp_Study*>( smeshMod->application()->activeStudy() );
2242 _PTR(Study) aStudy = study->studyDS();
2244 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
2253 Standard_EXPORT SMESHGUI* GetComponentGUI()
2255 return SMESHGUI::GetSMESHGUI();
2259 //=============================================================================
2263 //=============================================================================
2264 void SMESHGUI::SetState(int aState)
2269 //=============================================================================
2273 //=============================================================================
2274 void SMESHGUI::ResetState()
2279 //=============================================================================
2283 //=============================================================================
2284 void SMESHGUI::EmitSignalDeactivateDialog()
2286 emit SignalDeactivateActiveDialog();
2289 //=============================================================================
2293 //=============================================================================
2294 void SMESHGUI::EmitSignalStudyFrameChanged()
2296 emit SignalStudyFrameChanged();
2299 //=============================================================================
2303 //=============================================================================
2304 void SMESHGUI::EmitSignalCloseAllDialogs()
2306 emit SignalCloseAllDialogs();
2309 //=============================================================================
2313 //=============================================================================
2314 void SMESHGUI::EmitSignalVisibilityChanged()
2316 emit SignalVisibilityChanged();
2319 //=============================================================================
2323 //=============================================================================
2324 void SMESHGUI::EmitSignalCloseView()
2326 emit SignalCloseView();
2329 //=============================================================================
2333 //=============================================================================
2334 void SMESHGUI::EmitSignalActivatedViewManager()
2336 emit SignalActivatedViewManager();
2339 //=============================================================================
2343 //=============================================================================
2344 QDialog *SMESHGUI::GetActiveDialogBox()
2346 return myActiveDialogBox;
2349 //=============================================================================
2353 //=============================================================================
2354 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2356 myActiveDialogBox = (QDialog *) aDlg;
2360 //=============================================================================
2364 //=============================================================================
2365 SUIT_Desktop* SMESHGUI::desktop()
2367 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2369 return app->desktop();
2374 //=============================================================================
2378 //=============================================================================
2379 SalomeApp_Study* SMESHGUI::activeStudy()
2381 SUIT_Application* app = SUIT_Session::session()->activeApplication();
2383 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2388 //=============================================================================
2392 //=============================================================================
2393 void SMESHGUI::Modified( bool theIsUpdateActions )
2395 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2396 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2397 appStudy->Modified();
2398 if( theIsUpdateActions )
2399 app->updateActions();
2404 //=============================================================================
2408 //=============================================================================
2409 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2411 /* Here the position is on the bottom right corner - 10 */
2412 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2414 SUIT_Desktop *PP = desktop();
2415 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2416 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2420 //=============================================================================
2424 //=============================================================================
2425 static int isStudyLocked(_PTR(Study) theStudy){
2426 return theStudy->GetProperties()->IsLocked();
2429 static bool checkLock(_PTR(Study) theStudy) {
2430 if (isStudyLocked(theStudy)) {
2431 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2432 QObject::tr("WRN_WARNING"),
2433 QObject::tr("WRN_STUDY_LOCKED") );
2439 //=======================================================================
2440 //function : CheckActiveStudyLocked
2442 //=======================================================================
2444 bool SMESHGUI::isActiveStudyLocked()
2446 _PTR(Study) aStudy = activeStudy()->studyDS();
2447 return checkLock( aStudy );
2450 //=============================================================================
2454 //=============================================================================
2455 bool SMESHGUI::OnGUIEvent( int theCommandID )
2457 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2461 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
2462 SUIT_ResourceMgr* mgr = resourceMgr();
2466 if (CORBA::is_nil(GetSMESHGen()->GetCurrentStudy())) {
2467 GetSMESHGen()->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
2470 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2471 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2473 //QAction* act = action( theCommandID );
2475 switch (theCommandID) {
2476 case SMESHOp::OpDelete:
2477 if(checkLock(aStudy)) break;
2480 case SMESHOp::OpImportDAT:
2481 case SMESHOp::OpImportUNV:
2482 case SMESHOp::OpImportMED:
2483 case SMESHOp::OpImportSTL:
2484 case SMESHOp::OpImportCGNS:
2485 case SMESHOp::OpImportSAUV:
2486 case SMESHOp::OpImportGMF:
2487 case SMESHOp::OpPopupImportDAT:
2488 case SMESHOp::OpPopupImportUNV:
2489 case SMESHOp::OpPopupImportMED:
2490 case SMESHOp::OpPopupImportSTL:
2491 case SMESHOp::OpPopupImportCGNS:
2492 case SMESHOp::OpPopupImportSAUV:
2493 case SMESHOp::OpPopupImportGMF:
2495 if(checkLock(aStudy)) break;
2496 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2500 case SMESHOp::OpFileInformation:
2502 SALOME_ListIO selected;
2503 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2505 aSel->selectedObjects( selected );
2506 if( selected.Extent() )
2508 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2509 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2510 if ( !aMesh->_is_nil() )
2512 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2518 case SMESHOp::OpExportDAT:
2519 case SMESHOp::OpExportMED:
2520 case SMESHOp::OpExportUNV:
2521 case SMESHOp::OpExportSTL:
2522 case SMESHOp::OpExportCGNS:
2523 case SMESHOp::OpExportSAUV:
2524 case SMESHOp::OpExportGMF:
2525 case SMESHOp::OpPopupExportDAT:
2526 case SMESHOp::OpPopupExportMED:
2527 case SMESHOp::OpPopupExportUNV:
2528 case SMESHOp::OpPopupExportSTL:
2529 case SMESHOp::OpPopupExportCGNS:
2530 case SMESHOp::OpPopupExportSAUV:
2531 case SMESHOp::OpPopupExportGMF:
2533 ::ExportMeshToFile(theCommandID);
2537 case SMESHOp::OpReset: // SCALAR BAR
2539 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2540 SALOME_ListIO selected;
2542 aSel->selectedObjects( selected );
2544 SALOME_ListIteratorOfListIO it(selected);
2545 for( ; it.More(); it.Next()) {
2546 Handle(SALOME_InteractiveObject) anIO = it.Value();
2547 if( anIO->hasEntry() ) {
2548 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2549 anActor->SetControlMode( SMESH_Actor::eNone );
2550 #ifndef DISABLE_PLOT2DVIEWER
2551 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2556 SMESH::UpdateView();
2559 case SMESHOp::OpScalarBarProperties:
2561 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2564 case SMESHOp::OpShowScalarBar:
2566 // show/hide scalar bar
2567 ::ShowElement(theCommandID);
2570 case SMESHOp::OpSaveDistribution:
2572 // dump control distribution data to the text file
2573 ::SaveDistribution();
2577 case SMESHOp::OpShowDistribution:
2579 // show/hide distribution
2580 ::ShowElement(theCommandID);
2584 #ifndef DISABLE_PLOT2DVIEWER
2585 case SMESHOp::OpPlotDistribution:
2587 // plot distribution
2588 ::PlotDistribution();
2594 case SMESHOp::OpAutoColor:
2598 case SMESHOp::OpDisableAutoColor:
2599 ::DisableAutoColor();
2602 case SMESHOp::OpClipping:
2603 case SMESHOp::OpTransparency:
2604 case SMESHOp::OpProperties: // Display preferences (colors, shrink size, line width, ...)
2607 case SMESHOp::OpDMWireframe:
2608 case SMESHOp::OpDMShading:
2609 case SMESHOp::OpDMNodes:
2610 case SMESHOp::OpDMShrink:
2611 ::SetDisplayMode(theCommandID, myMarkerMap);
2614 //2D quadratic representation
2615 case SMESHOp::OpRepresentationLines:
2616 case SMESHOp::OpRepresentationArcs:
2617 ::SetDisplayMode(theCommandID, myMarkerMap);
2621 case SMESHOp::OpDE0DElements:
2622 case SMESHOp::OpDEEdges:
2623 case SMESHOp::OpDEFaces:
2624 case SMESHOp::OpDEVolumes:
2625 case SMESHOp::OpDEBalls:
2626 case SMESHOp::OpDEAllEntity:
2627 ::SetDisplayEntity(theCommandID);
2630 // Choose entities to be displayed
2631 case SMESHOp::OpDEChoose:
2633 ( new SMESHGUI_DisplayEntitiesDlg( SMESHGUI::desktop() ) )->exec();
2637 case SMESHOp::OpOrientationOnFaces:
2639 SUIT_OverrideCursor wc;
2640 LightApp_SelectionMgr* mgr = selectionMgr();
2641 SALOME_ListIO selected; mgr->selectedObjects( selected );
2643 SALOME_ListIteratorOfListIO it(selected);
2644 for( ; it.More(); it.Next()) {
2645 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2646 if(anIObject->hasEntry()) {
2647 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2648 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2655 case SMESHOp::OpUpdate:
2657 if(checkLock(aStudy)) break;
2658 SUIT_OverrideCursor wc;
2661 SMESH::UpdateView();
2663 catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2664 SMESH::OnVisuException();
2666 catch (...) { // PAL16774 (Crash after display of many groups)
2667 SMESH::OnVisuException();
2671 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2672 aSel->selectedObjects( l );
2673 aSel->setSelectedObjects( l );
2677 case SMESHOp::OpHide:
2678 case SMESHOp::OpShow:
2679 case SMESHOp::OpShowOnly:
2681 SUIT_OverrideCursor wc;
2682 SMESH::EDisplaing anAction;
2683 switch (theCommandID) {
2684 case SMESHOp::OpHide: anAction = SMESH::eErase; break;
2685 case SMESHOp::OpShow: anAction = SMESH::eDisplay; break;
2686 case SMESHOp::OpShowOnly: anAction = SMESH::eDisplayOnly; break;
2689 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2690 SALOME_ListIO sel_objects, to_process;
2692 aSel->selectedObjects( sel_objects );
2694 if ( theCommandID==SMESHOp::OpShowOnly )
2696 //MESSAGE("anAction = SMESH::eDisplayOnly");
2697 startOperation( myEraseAll );
2700 extractContainers( sel_objects, to_process );
2705 SALOME_ListIteratorOfListIO It( to_process );
2706 for ( ; It.More(); It.Next())
2708 Handle(SALOME_InteractiveObject) IOS = It.Value();
2709 if ( IOS->hasEntry() )
2711 if ( !SMESH::UpdateView( anAction, IOS->getEntry() )) {
2712 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2713 break; // PAL16774 (Crash after display of many groups)
2715 if (anAction == SMESH::eDisplayOnly)
2716 anAction = SMESH::eDisplay;
2721 // PAL13338 + PAL15161 -->
2722 if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !checkLock(aStudy)) {
2723 SMESH::UpdateView();
2724 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2726 // PAL13338 + PAL15161 <--
2728 catch (...) { // PAL16774 (Crash after display of many groups)
2729 SMESH::OnVisuException();
2732 if (anAction == SMESH::eErase) {
2734 aSel->setSelectedObjects( l1 );
2737 aSel->setSelectedObjects( to_process );
2742 case SMESHOp::OpNode:
2744 if(checkLock(aStudy)) break;
2747 EmitSignalDeactivateDialog();
2749 ( new SMESHGUI_NodesDlg( this ) )->show();
2752 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"),tr("SMESH_WRN_VIEWER_VTK"));
2757 case SMESHOp::OpCreateMesh:
2758 case SMESHOp::OpCreateSubMesh:
2759 case SMESHOp::OpEditMeshOrSubMesh:
2760 case SMESHOp::OpEditMesh:
2761 case SMESHOp::OpEditSubMesh:
2762 case SMESHOp::OpCompute:
2763 case SMESHOp::OpComputeSubMesh:
2764 case SMESHOp::OpPreCompute:
2765 case SMESHOp::OpEvaluate:
2766 case SMESHOp::OpMeshOrder:
2767 startOperation( theCommandID );
2769 case SMESHOp::OpCopyMesh:
2771 if (checkLock(aStudy)) break;
2772 EmitSignalDeactivateDialog();
2773 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2776 case SMESHOp::OpBuildCompoundMesh:
2778 if (checkLock(aStudy)) break;
2779 EmitSignalDeactivateDialog();
2780 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2784 case SMESHOp::OpDiagonalInversion:
2785 case SMESHOp::OpUnionOfTwoTriangle:
2789 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2793 if ( checkLock( aStudy ) )
2796 /*Standard_Boolean aRes;
2797 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2798 if ( aMesh->_is_nil() )
2800 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2801 tr( "SMESH_BAD_SELECTION" ) );
2805 EmitSignalDeactivateDialog();
2806 if ( theCommandID == SMESHOp::OpDiagonalInversion )
2807 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2809 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2812 case SMESHOp::OpOrientation:
2813 case SMESHOp::OpUnionOfTriangles:
2814 case SMESHOp::OpCuttingOfQuadrangles:
2815 case SMESHOp::OpSplitVolumes:
2819 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2823 if ( checkLock( aStudy ) )
2826 EmitSignalDeactivateDialog();
2827 SMESHGUI_MultiEditDlg* aDlg = NULL;
2828 if ( theCommandID == SMESHOp::OpOrientation )
2829 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2830 else if ( theCommandID == SMESHOp::OpUnionOfTriangles )
2831 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2832 else if ( theCommandID == SMESHOp::OpSplitVolumes )
2833 aDlg = new SMESHGUI_SplitVolumesDlg(this);
2835 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2840 case SMESHOp::OpSmoothing:
2842 if(checkLock(aStudy)) break;
2844 EmitSignalDeactivateDialog();
2845 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2848 SUIT_MessageBox::warning(desktop(), tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2852 case SMESHOp::OpExtrusion:
2854 if (checkLock(aStudy)) break;
2856 EmitSignalDeactivateDialog();
2857 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2859 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2863 case SMESHOp::OpExtrusionAlongAPath:
2865 if (checkLock(aStudy)) break;
2867 EmitSignalDeactivateDialog();
2868 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2870 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2874 case SMESHOp::OpRevolution:
2876 if(checkLock(aStudy)) break;
2878 EmitSignalDeactivateDialog();
2879 ( new SMESHGUI_RevolutionDlg( this ) )->show();
2882 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2886 case SMESHOp::OpPatternMapping:
2888 if ( checkLock( aStudy ) )
2892 EmitSignalDeactivateDialog();
2893 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2896 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2900 case SMESHOp::OpSplitBiQuadratic:
2901 case SMESHOp::OpConvertMeshToQuadratic:
2902 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
2903 case SMESHOp::OpReorientFaces:
2904 case SMESHOp::OpCreateGeometryGroup:
2906 startOperation( theCommandID );
2909 case SMESHOp::OpCreateGroup:
2913 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2917 if(checkLock(aStudy)) break;
2918 EmitSignalDeactivateDialog();
2919 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2921 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2922 SALOME_ListIO selected;
2924 aSel->selectedObjects( selected );
2926 int nbSel = selected.Extent();
2928 // check if mesh is selected
2929 aMesh = SMESH::GetMeshByIO( selected.First() );
2931 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2936 case SMESHOp::OpConstructGroup:
2940 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2944 if(checkLock(aStudy)) break;
2945 EmitSignalDeactivateDialog();
2947 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2948 SALOME_ListIO selected;
2950 aSel->selectedObjects( selected );
2952 int nbSel = selected.Extent();
2954 // check if submesh is selected
2955 Handle(SALOME_InteractiveObject) IObject = selected.First();
2956 if (IObject->hasEntry()) {
2957 _PTR(SObject) aSObj = aStudy->FindObjectID(IObject->getEntry());
2959 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2960 if (!aSubMesh->_is_nil()) {
2962 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2963 // get submesh elements list by types
2964 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2965 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2966 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2967 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2968 // create group for each type o elements
2969 QString aName = IObject->getName();
2970 QStringList anEntryList;
2971 if (aNodes->length() > 0) {
2972 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2973 aGroup->Add(aNodes.inout());
2974 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2975 anEntryList.append( aSObject->GetID().c_str() );
2977 if (aEdges->length() > 0) {
2978 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2979 aGroup->Add(aEdges.inout());
2980 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2981 anEntryList.append( aSObject->GetID().c_str() );
2983 if (aFaces->length() > 0) {
2984 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2985 aGroup->Add(aFaces.inout());
2986 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2987 anEntryList.append( aSObject->GetID().c_str() );
2989 if (aVolumes->length() > 0) {
2990 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2991 aGroup->Add(aVolumes.inout());
2992 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2993 anEntryList.append( aSObject->GetID().c_str() );
2996 anApp->browseObjects( anEntryList );
2998 catch(const SALOME::SALOME_Exception & S_ex){
2999 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3006 SUIT_MessageBox::warning(desktop(),
3007 tr("SMESH_WRN_WARNING"),
3008 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
3013 case SMESHOp::OpEditGroup:
3017 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3021 if(checkLock(aStudy)) break;
3022 EmitSignalDeactivateDialog();
3024 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3025 SALOME_ListIO selected;
3027 aSel->selectedObjects( selected );
3029 SALOME_ListIteratorOfListIO It (selected);
3030 int nbSelectedGroups = 0;
3031 for ( ; It.More(); It.Next() )
3033 SMESH::SMESH_GroupBase_var aGroup =
3034 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
3035 if (!aGroup->_is_nil()) {
3037 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
3041 if (nbSelectedGroups == 0)
3043 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
3049 case SMESHOp::OpAddElemGroupPopup: // Add elements to group
3051 if(checkLock(aStudy)) break;
3052 if (myState == 800) {
3053 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3054 if (aDlg) aDlg->onAdd();
3059 case SMESHOp::OpRemoveElemGroupPopup: // Remove elements from group
3061 if(checkLock(aStudy)) break;
3062 if (myState == 800) {
3063 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3064 if (aDlg) aDlg->onRemove();
3069 case SMESHOp::OpEditGeomGroupAsGroup:
3073 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3077 if(checkLock(aStudy)) break;
3078 EmitSignalDeactivateDialog();
3080 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3081 SALOME_ListIO selected;
3083 aSel->selectedObjects( selected );
3085 SALOME_ListIteratorOfListIO It (selected);
3086 for ( ; It.More(); It.Next() )
3088 SMESH::SMESH_GroupOnGeom_var aGroup =
3089 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
3090 if (!aGroup->_is_nil()) {
3091 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3096 SMESH::SMESH_GroupOnFilter_var aGroup =
3097 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
3098 if (!aGroup->_is_nil()) {
3099 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3107 case SMESHOp::OpUnionGroups:
3108 case SMESHOp::OpIntersectGroups:
3109 case SMESHOp::OpCutGroups:
3113 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3117 if ( checkLock( aStudy ) )
3120 EmitSignalDeactivateDialog();
3122 SMESHGUI_GroupOpDlg* aDlg = 0;
3123 if ( theCommandID == SMESHOp::OpUnionGroups )
3124 aDlg = new SMESHGUI_UnionGroupsDlg( this );
3125 else if ( theCommandID == SMESHOp::OpIntersectGroups )
3126 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3128 aDlg = new SMESHGUI_CutGroupsDlg( this );
3135 case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
3137 if ( checkLock( aStudy ) )
3140 EmitSignalDeactivateDialog();
3141 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3147 case SMESHOp::OpDeleteGroup: // Delete groups with their contents
3151 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3155 if ( checkLock( aStudy ) )
3158 EmitSignalDeactivateDialog();
3160 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3164 case SMESHOp::OpMeshInformation:
3165 case SMESHOp::OpWhatIs:
3167 int page = theCommandID == SMESHOp::OpMeshInformation ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3168 EmitSignalDeactivateDialog();
3169 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3170 SALOME_ListIO selected;
3172 aSel->selectedObjects( selected );
3174 if ( selected.Extent() > 1 ) { // a dlg for each IO
3175 SALOME_ListIteratorOfListIO It( selected );
3176 for ( ; It.More(); It.Next() ) {
3177 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3178 dlg->showInfo( It.Value() );
3183 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3189 case SMESHOp::OpFindElementByPoint:
3191 startOperation( theCommandID );
3195 case SMESHOp::OpEditHypothesis:
3197 if(checkLock(aStudy)) break;
3199 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3200 SALOME_ListIO selected;
3202 aSel->selectedObjects( selected );
3204 int nbSel = selected.Extent();
3207 Handle(SALOME_InteractiveObject) anIObject = selected.First();
3208 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3210 if ( !aHypothesis->_is_nil() )
3212 SMESHGUI_GenericHypothesisCreator* aCreator =
3213 SMESH::GetHypothesisCreator( SMESH::toQStr( aHypothesis->GetName() ));
3216 // set geometry of mesh and sub-mesh to aCreator
3217 aSel->selectedObjects( selected, "", /*convertReferences=*/false);
3218 if ( selected.Extent() == 1 )
3220 QString subGeomID, meshGeomID;
3221 Handle(SALOME_InteractiveObject) hypIO = selected.First();
3222 if ( SMESH::GetGeomEntries( hypIO, subGeomID, meshGeomID ))
3224 if ( subGeomID.isEmpty() ) subGeomID = meshGeomID;
3225 aCreator->setShapeEntry( subGeomID );
3226 aCreator->setMainShapeEntry( meshGeomID );
3230 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3240 case SMESHOp::OpUnassign: // REMOVE HYPOTHESIS / ALGORITHMS
3242 if(checkLock(aStudy)) break;
3243 SUIT_OverrideCursor wc;
3245 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3246 SALOME_ListIO selected;
3248 aSel->selectedObjects( selected, QString::null, false );
3250 SALOME_ListIteratorOfListIO It(selected);
3251 for (int i = 0; It.More(); It.Next(), i++) {
3252 Handle(SALOME_InteractiveObject) IObject = It.Value();
3253 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3256 aSel->setSelectedObjects( l1 );
3261 case SMESHOp::OpElem0D:
3262 case SMESHOp::OpBall:
3263 case SMESHOp::OpEdge:
3264 case SMESHOp::OpTriangle:
3265 case SMESHOp::OpQuadrangle:
3266 case SMESHOp::OpPolygon:
3267 case SMESHOp::OpTetrahedron:
3268 case SMESHOp::OpHexahedron:
3269 case SMESHOp::OpPentahedron:
3270 case SMESHOp::OpPyramid:
3271 case SMESHOp::OpHexagonalPrism:
3273 if(checkLock(aStudy)) break;
3275 EmitSignalDeactivateDialog();
3276 SMDSAbs_EntityType type = SMDSEntity_Edge;
3277 switch (theCommandID) {
3278 case SMESHOp::OpElem0D: type = SMDSEntity_0D; break;
3279 case SMESHOp::OpBall: type = SMDSEntity_Ball; break;
3280 case SMESHOp::OpTriangle: type = SMDSEntity_Triangle; break;
3281 case SMESHOp::OpQuadrangle: type = SMDSEntity_Quadrangle; break;
3282 case SMESHOp::OpTetrahedron: type = SMDSEntity_Tetra; break;
3283 case SMESHOp::OpPolygon: type = SMDSEntity_Polygon; break;
3284 case SMESHOp::OpHexahedron: type = SMDSEntity_Hexa; break;
3285 case SMESHOp::OpPentahedron: type = SMDSEntity_Penta; break;
3286 case SMESHOp::OpPyramid: type = SMDSEntity_Pyramid; break;
3287 case SMESHOp::OpHexagonalPrism: type = SMDSEntity_Hexagonal_Prism; break;
3290 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3293 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3297 case SMESHOp::OpPolyhedron:
3299 if(checkLock(aStudy)) break;
3301 EmitSignalDeactivateDialog();
3302 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3305 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3309 case SMESHOp::OpQuadraticEdge:
3310 case SMESHOp::OpQuadraticTriangle:
3311 case SMESHOp::OpBiQuadraticTriangle:
3312 case SMESHOp::OpQuadraticQuadrangle:
3313 case SMESHOp::OpBiQuadraticQuadrangle:
3314 case SMESHOp::OpQuadraticPolygon:
3315 case SMESHOp::OpQuadraticTetrahedron:
3316 case SMESHOp::OpQuadraticPyramid:
3317 case SMESHOp::OpQuadraticPentahedron:
3318 case SMESHOp::OpBiQuadraticPentahedron:
3319 case SMESHOp::OpQuadraticHexahedron:
3320 case SMESHOp::OpTriQuadraticHexahedron:
3322 if(checkLock(aStudy)) break;
3324 EmitSignalDeactivateDialog();
3325 SMDSAbs_EntityType type = SMDSEntity_Last;
3327 switch (theCommandID) {
3328 case SMESHOp::OpQuadraticEdge: type = SMDSEntity_Quad_Edge; break;
3329 case SMESHOp::OpQuadraticTriangle: type = SMDSEntity_Quad_Triangle; break;
3330 case SMESHOp::OpBiQuadraticTriangle: type = SMDSEntity_BiQuad_Triangle; break;
3331 case SMESHOp::OpQuadraticQuadrangle: type = SMDSEntity_Quad_Quadrangle; break;
3332 case SMESHOp::OpBiQuadraticQuadrangle: type = SMDSEntity_BiQuad_Quadrangle; break;
3333 case SMESHOp::OpQuadraticPolygon: type = SMDSEntity_Quad_Polygon; break;
3334 case SMESHOp::OpQuadraticTetrahedron: type = SMDSEntity_Quad_Tetra; break;
3335 case SMESHOp::OpQuadraticPyramid: type = SMDSEntity_Quad_Pyramid; break;
3336 case SMESHOp::OpQuadraticPentahedron: type = SMDSEntity_Quad_Penta; break;
3337 case SMESHOp::OpBiQuadraticPentahedron: type = SMDSEntity_BiQuad_Penta; break;
3338 case SMESHOp::OpQuadraticHexahedron: type = SMDSEntity_Quad_Hexa; break;
3339 case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
3342 if ( type != SMDSEntity_Last )
3343 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3346 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3347 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3351 case SMESHOp::OpRemoveNodes:
3353 if(checkLock(aStudy)) break;
3355 EmitSignalDeactivateDialog();
3356 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3359 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3360 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3364 case SMESHOp::OpRemoveElements: // REMOVES ELEMENTS
3366 if(checkLock(aStudy)) break;
3368 EmitSignalDeactivateDialog();
3369 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3373 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3374 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3378 case SMESHOp::OpClearMesh: {
3380 if(checkLock(aStudy)) break;
3382 SALOME_ListIO selected;
3383 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3384 aSel->selectedObjects( selected );
3386 SUIT_OverrideCursor wc;
3387 SALOME_ListIteratorOfListIO It (selected);
3388 for ( ; It.More(); It.Next() )
3390 Handle(SALOME_InteractiveObject) IOS = It.Value();
3391 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3392 if ( aMesh->_is_nil()) continue;
3395 if ( aMesh->NbNodes() == 0 ) // imported mesh is not empty
3396 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3397 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3398 SMESH::ModifiedMesh( aMeshSObj, false, true);
3399 // hide groups and submeshes
3400 _PTR(ChildIterator) anIter =
3401 SMESH::GetActiveStudyDocument()->NewChildIterator( aMeshSObj );
3402 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3404 _PTR(SObject) so = anIter->Value();
3405 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3408 catch (const SALOME::SALOME_Exception& S_ex){
3410 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3414 SMESH::UpdateView();
3418 case SMESHOp::OpRemoveOrphanNodes:
3420 if(checkLock(aStudy)) break;
3421 SALOME_ListIO selected;
3422 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3423 aSel->selectedObjects( selected );
3424 if ( selected.Extent() == 1 ) {
3425 Handle(SALOME_InteractiveObject) anIO = selected.First();
3426 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3427 if ( !aMesh->_is_nil() ) {
3428 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3429 tr( "SMESH_WARNING" ),
3430 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3431 SUIT_MessageBox::Yes |
3432 SUIT_MessageBox::No,
3433 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3436 SUIT_OverrideCursor wc;
3437 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3438 int removed = aMeshEditor->RemoveOrphanNodes();
3439 SUIT_MessageBox::information(SMESHGUI::desktop(),
3440 tr("SMESH_INFORMATION"),
3441 tr("NB_NODES_REMOVED").arg(removed));
3442 if ( removed > 0 ) {
3443 SMESH::UpdateView();
3444 SMESHGUI::Modified();
3447 catch (const SALOME::SALOME_Exception& S_ex) {
3448 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3457 case SMESHOp::OpRenumberingNodes:
3459 if(checkLock(aStudy)) break;
3461 EmitSignalDeactivateDialog();
3462 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3466 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3467 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3471 case SMESHOp::OpRenumberingElements:
3473 if(checkLock(aStudy)) break;
3475 EmitSignalDeactivateDialog();
3476 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3480 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3481 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3485 case SMESHOp::OpTranslation:
3487 if(checkLock(aStudy)) break;
3489 EmitSignalDeactivateDialog();
3490 ( new SMESHGUI_TranslationDlg( this ) )->show();
3493 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3494 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3498 case SMESHOp::OpRotation:
3500 if(checkLock(aStudy)) break;
3502 EmitSignalDeactivateDialog();
3503 ( new SMESHGUI_RotationDlg( this ) )->show();
3506 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3507 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3511 case SMESHOp::OpSymmetry:
3513 if(checkLock(aStudy)) break;
3515 EmitSignalDeactivateDialog();
3516 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3519 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3520 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3524 case SMESHOp::OpScale:
3526 if(checkLock(aStudy)) break;
3528 EmitSignalDeactivateDialog();
3529 ( new SMESHGUI_ScaleDlg( this ) )->show();
3532 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3533 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3538 case SMESHOp::OpSewing:
3540 if(checkLock(aStudy)) break;
3542 EmitSignalDeactivateDialog();
3543 ( new SMESHGUI_SewingDlg( this ) )->show();
3546 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3547 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3551 case SMESHOp::OpMergeNodes:
3553 if(checkLock(aStudy)) break;
3555 EmitSignalDeactivateDialog();
3556 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3559 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3560 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3564 case SMESHOp::OpMergeElements:
3566 if (checkLock(aStudy)) break;
3568 EmitSignalDeactivateDialog();
3569 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3571 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3572 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3577 case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
3578 startOperation( SMESHOp::OpMoveNode );
3581 case SMESHOp::OpDuplicateNodes:
3583 if(checkLock(aStudy)) break;
3585 EmitSignalDeactivateDialog();
3586 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3589 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3590 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3595 case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
3596 startOperation( SMESHOp::OpElem0DOnElemNodes );
3599 case SMESHOp::OpSelectFiltersLibrary: // Library of selection filters
3601 static QList<int> aTypes;
3602 if ( aTypes.isEmpty() )
3604 aTypes.append( SMESH::NODE );
3605 aTypes.append( SMESH::EDGE );
3606 aTypes.append( SMESH::FACE );
3607 aTypes.append( SMESH::VOLUME );
3609 if (!myFilterLibraryDlg)
3610 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3611 else if (myFilterLibraryDlg->isHidden())
3612 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3613 myFilterLibraryDlg->raise();
3617 case SMESHOp::OpFreeNode:
3618 case SMESHOp::OpEqualNode:
3619 case SMESHOp::OpNodeConnectivityNb:
3620 case SMESHOp::OpFreeEdge:
3621 case SMESHOp::OpFreeBorder:
3622 case SMESHOp::OpLength:
3623 case SMESHOp::OpConnection:
3624 case SMESHOp::OpEqualEdge:
3625 case SMESHOp::OpFreeFace:
3626 case SMESHOp::OpBareBorderFace:
3627 case SMESHOp::OpOverConstrainedFace:
3628 case SMESHOp::OpLength2D:
3629 case SMESHOp::OpConnection2D:
3630 case SMESHOp::OpArea:
3631 case SMESHOp::OpTaper:
3632 case SMESHOp::OpAspectRatio:
3633 case SMESHOp::OpMinimumAngle:
3634 case SMESHOp::OpWarpingAngle:
3635 case SMESHOp::OpSkew:
3636 case SMESHOp::OpMaxElementLength2D:
3637 case SMESHOp::OpEqualFace:
3638 case SMESHOp::OpAspectRatio3D:
3639 case SMESHOp::OpVolume:
3640 case SMESHOp::OpMaxElementLength3D:
3641 case SMESHOp::OpBareBorderVolume:
3642 case SMESHOp::OpOverConstrainedVolume:
3643 case SMESHOp::OpEqualVolume:
3646 LightApp_SelectionMgr* mgr = selectionMgr();
3647 SALOME_ListIO selected; mgr->selectedObjects( selected );
3649 if( !selected.IsEmpty() ) {
3650 SUIT_OverrideCursor wc;
3651 ::Control( theCommandID );
3654 SUIT_MessageBox::warning(desktop(),
3655 tr( "SMESH_WRN_WARNING" ),
3656 tr( "SMESH_BAD_SELECTION" ) );
3660 SUIT_MessageBox::warning(desktop(),
3661 tr( "SMESH_WRN_WARNING" ),
3662 tr( "NOT_A_VTK_VIEWER" ) );
3665 case SMESHOp::OpOverallMeshQuality:
3666 OverallMeshQuality();
3668 case SMESHOp::OpNumberingNodes:
3670 SUIT_OverrideCursor wc;
3671 LightApp_SelectionMgr* mgr = selectionMgr();
3672 SALOME_ListIO selected; mgr->selectedObjects( selected );
3674 SALOME_ListIteratorOfListIO it(selected);
3675 for( ; it.More(); it.Next()) {
3676 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3677 if(anIObject->hasEntry()) {
3678 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3679 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3685 case SMESHOp::OpNumberingElements:
3687 SUIT_OverrideCursor wc;
3688 LightApp_SelectionMgr* mgr = selectionMgr();
3689 SALOME_ListIO selected; mgr->selectedObjects( selected );
3691 SALOME_ListIteratorOfListIO it(selected);
3692 for( ; it.More(); it.Next()) {
3693 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3694 if(anIObject->hasEntry())
3695 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3696 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3701 case SMESHOp::OpPropertiesLength:
3702 case SMESHOp::OpPropertiesArea:
3703 case SMESHOp::OpPropertiesVolume:
3704 case SMESHOp::OpMinimumDistance:
3705 case SMESHOp::OpBoundingBox:
3707 int page = SMESHGUI_MeasureDlg::MinDistance;
3708 if ( theCommandID == SMESHOp::OpBoundingBox )
3709 page = SMESHGUI_MeasureDlg::BoundingBox;
3710 else if ( theCommandID == SMESHOp::OpPropertiesLength )
3711 page = SMESHGUI_MeasureDlg::Length;
3712 else if ( theCommandID == SMESHOp::OpPropertiesArea )
3713 page = SMESHGUI_MeasureDlg::Area;
3714 else if ( theCommandID == SMESHOp::OpPropertiesVolume )
3715 page = SMESHGUI_MeasureDlg::Volume;
3717 EmitSignalDeactivateDialog();
3718 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3722 case SMESHOp::OpSortChild:
3728 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3729 //updateObjBrowser();
3733 //=============================================================================
3737 //=============================================================================
3738 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3743 //=============================================================================
3747 //=============================================================================
3748 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3753 //=============================================================================
3757 //=============================================================================
3758 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3763 //=============================================================================
3764 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3765 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3767 //=============================================================================
3768 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3769 SUIT_ViewWindow* wnd )
3771 if(theIO->hasEntry()){
3772 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3773 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3777 //=======================================================================
3778 // function : createSMESHAction
3780 //=======================================================================
3781 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3782 const int key, const bool toggle, const QString& shortcutAction )
3785 QWidget* parent = application()->desktop();
3786 SUIT_ResourceMgr* resMgr = resourceMgr();
3788 if ( !icon_id.isEmpty() )
3789 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3791 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3792 if ( !pix.isNull() )
3793 icon = QIcon( pix );
3795 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3796 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3797 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3799 createAction( id, tooltip, icon, menu, status_bar, key, parent,
3800 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3803 //=======================================================================
3804 // function : createPopupItem
3806 //=======================================================================
3807 void SMESHGUI::createPopupItem( const int id,
3808 const QString& clients,
3809 const QString& types,
3810 const QString& theRule,
3813 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3814 popupMgr()->insert( action( id ), pId, 0 );
3816 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3817 QString dc = "selcount"; // VSR : insetad of QtxPopupSelection::defSelCountParam()
3818 QString rule = "(%1) and (%2) and (%3)";
3819 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3820 if( clients.isEmpty() )
3821 rule = rule.arg( QString( "true" ) );
3823 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3824 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3827 bool cont = myRules.contains( id );
3829 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3831 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3832 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3835 //=======================================================================
3836 // function : initialize
3838 //=======================================================================
3839 void SMESHGUI::initialize( CAM_Application* app )
3841 SalomeApp_Module::initialize( app );
3843 // SUIT_ResourceMgr* mgr = app->resourceMgr();
3845 /* Automatic Update flag */
3846 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3848 // ----- create actions --------------
3850 //createSMESHAction( SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
3851 createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_I) );
3852 createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
3853 createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL" );
3855 createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
3857 createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
3858 createSMESHAction( SMESHOp::OpImportGMF, "IMPORT_GMF" );
3859 createSMESHAction( SMESHOp::OpPopupImportUNV, "IMPORT_UNV");
3860 createSMESHAction( SMESHOp::OpPopupImportMED, "IMPORT_MED");
3861 createSMESHAction( SMESHOp::OpPopupImportSTL, "IMPORT_STL" );
3863 createSMESHAction( SMESHOp::OpPopupImportCGNS, "IMPORT_CGNS" );
3865 createSMESHAction( SMESHOp::OpPopupImportSAUV, "IMPORT_SAUV" );
3866 createSMESHAction( SMESHOp::OpPopupImportGMF, "IMPORT_GMF" );
3868 createSMESHAction( SMESHOp::OpExportDAT, "DAT" );
3869 createSMESHAction( SMESHOp::OpExportMED, "MED" );
3870 createSMESHAction( SMESHOp::OpExportUNV, "UNV" );
3871 createSMESHAction( SMESHOp::OpExportSTL, "STL" );
3873 createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
3875 createSMESHAction( SMESHOp::OpExportSAUV, "SAUV");
3876 createSMESHAction( SMESHOp::OpExportGMF, "GMF" );
3877 createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
3878 createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
3879 createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
3880 createSMESHAction( SMESHOp::OpPopupExportSTL, "STL" );
3882 createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
3884 createSMESHAction( SMESHOp::OpPopupExportSAUV, "SAUV");
3885 createSMESHAction( SMESHOp::OpPopupExportGMF, "GMF" );
3886 createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
3887 createSMESHAction( SMESHOp::OpDelete, "DELETE", "ICON_DELETE", Qt::Key_Delete );
3888 createSMESHAction( SMESHOp::OpSelectFiltersLibrary, "SEL_FILTER_LIB" );
3889 createSMESHAction( SMESHOp::OpCreateMesh, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
3890 createSMESHAction( SMESHOp::OpCreateSubMesh, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
3891 createSMESHAction( SMESHOp::OpEditMeshOrSubMesh, "EDIT_MESHSUBMESH", "ICON_DLG_EDIT_MESH" );
3892 createSMESHAction( SMESHOp::OpEditMesh, "EDIT_MESH", "ICON_DLG_EDIT_MESH" );
3893 createSMESHAction( SMESHOp::OpEditSubMesh, "EDIT_SUBMESH", "ICON_DLG_EDIT_MESH" );
3894 createSMESHAction( SMESHOp::OpBuildCompoundMesh, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
3895 createSMESHAction( SMESHOp::OpCopyMesh, "COPY_MESH", "ICON_COPY_MESH" );
3896 createSMESHAction( SMESHOp::OpCompute, "COMPUTE", "ICON_COMPUTE" );
3897 createSMESHAction( SMESHOp::OpComputeSubMesh, "COMPUTE_SUBMESH", "ICON_COMPUTE" );
3898 createSMESHAction( SMESHOp::OpPreCompute, "PRECOMPUTE", "ICON_PRECOMPUTE" );
3899 createSMESHAction( SMESHOp::OpEvaluate, "EVALUATE", "ICON_EVALUATE" );
3900 createSMESHAction( SMESHOp::OpMeshOrder, "MESH_ORDER", "ICON_MESH_ORDER");
3901 createSMESHAction( SMESHOp::OpCreateGroup, "CREATE_GROUP", "ICON_CREATE_GROUP" );
3902 createSMESHAction( SMESHOp::OpCreateGeometryGroup, "CREATE_GEO_GROUP", "ICON_CREATE_GEO_GROUP" );
3903 createSMESHAction( SMESHOp::OpConstructGroup, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
3904 createSMESHAction( SMESHOp::OpEditGroup, "EDIT_GROUP", "ICON_EDIT_GROUP" );
3905 createSMESHAction( SMESHOp::OpEditGeomGroupAsGroup, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3906 createSMESHAction( SMESHOp::OpUnionGroups, "UN_GROUP", "ICON_UNION" );
3907 createSMESHAction( SMESHOp::OpIntersectGroups, "INT_GROUP", "ICON_INTERSECT" );
3908 createSMESHAction( SMESHOp::OpCutGroups, "CUT_GROUP", "ICON_CUT" );
3909 createSMESHAction( SMESHOp::OpGroupUnderlyingElem, "UNDERLYING_ELEMS", "ICON_UNDERLYING_ELEMS" );
3910 createSMESHAction( SMESHOp::OpAddElemGroupPopup, "ADD_TO_GROUP" );
3911 createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE_FROM_GROUP" );
3912 createSMESHAction( SMESHOp::OpDeleteGroup, "DEL_GROUP", "ICON_DEL_GROUP" );
3913 createSMESHAction( SMESHOp::OpMeshInformation , "ADV_INFO", "ICON_ADV_INFO" );
3914 //createSMESHAction( SMESHOp::OpStdInfo, "STD_INFO", "ICON_STD_INFO" );
3915 //createSMESHAction( SMESHOp::OpWhatIs, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3916 createSMESHAction( SMESHOp::OpFindElementByPoint, "FIND_ELEM", "ICON_FIND_ELEM" );
3918 createSMESHAction( SMESHOp::OpFreeNode, "FREE_NODE", "ICON_FREE_NODE", 0, true );
3919 createSMESHAction( SMESHOp::OpEqualNode, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
3920 createSMESHAction( SMESHOp::OpNodeConnectivityNb, "NODE_CONNECTIVITY_NB", "ICON_NODE_CONN_NB", 0, true );
3921 createSMESHAction( SMESHOp::OpFreeEdge, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
3922 createSMESHAction( SMESHOp::OpFreeBorder, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
3923 createSMESHAction( SMESHOp::OpLength, "LENGTH", "ICON_LENGTH", 0, true );
3924 createSMESHAction( SMESHOp::OpConnection, "CONNECTION", "ICON_CONNECTION", 0, true );
3925 createSMESHAction( SMESHOp::OpEqualEdge, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
3926 createSMESHAction( SMESHOp::OpFreeFace, "FREE_FACES", "ICON_FREE_FACES", 0, true );
3927 createSMESHAction( SMESHOp::OpBareBorderFace, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
3928 createSMESHAction( SMESHOp::OpOverConstrainedFace, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
3929 createSMESHAction( SMESHOp::OpLength2D, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
3930 createSMESHAction( SMESHOp::OpConnection2D, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
3931 createSMESHAction( SMESHOp::OpArea, "AREA", "ICON_AREA", 0, true );
3932 createSMESHAction( SMESHOp::OpTaper, "TAPER", "ICON_TAPER", 0, true );
3933 createSMESHAction( SMESHOp::OpAspectRatio, "ASPECT", "ICON_ASPECT", 0, true );
3934 createSMESHAction( SMESHOp::OpMinimumAngle, "MIN_ANG", "ICON_ANGLE", 0, true );
3935 createSMESHAction( SMESHOp::OpWarpingAngle, "WARP", "ICON_WARP", 0, true );
3936 createSMESHAction( SMESHOp::OpSkew, "SKEW", "ICON_SKEW", 0, true );
3937 createSMESHAction( SMESHOp::OpMaxElementLength2D, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
3938 createSMESHAction( SMESHOp::OpEqualFace, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
3939 createSMESHAction( SMESHOp::OpAspectRatio3D, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
3940 createSMESHAction( SMESHOp::OpVolume, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
3941 createSMESHAction( SMESHOp::OpMaxElementLength3D, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
3942 createSMESHAction( SMESHOp::OpBareBorderVolume, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
3943 createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
3944 createSMESHAction( SMESHOp::OpEqualVolume, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
3945 createSMESHAction( SMESHOp::OpOverallMeshQuality, "OVERALL_MESH_QUALITY", "ICON_OVL_MESH_QUALITY" );
3947 createSMESHAction( SMESHOp::OpNode, "NODE", "ICON_DLG_NODE" );
3948 createSMESHAction( SMESHOp::OpElem0D, "ELEM0D", "ICON_DLG_ELEM0D" );
3949 createSMESHAction( SMESHOp::OpElem0DOnElemNodes, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
3950 createSMESHAction( SMESHOp::OpBall, "BALL", "ICON_DLG_BALL" );
3951 createSMESHAction( SMESHOp::OpEdge, "EDGE", "ICON_DLG_EDGE" );
3952 createSMESHAction( SMESHOp::OpTriangle, "TRIANGLE", "ICON_DLG_TRIANGLE" );
3953 createSMESHAction( SMESHOp::OpQuadrangle, "QUAD", "ICON_DLG_QUADRANGLE" );
3954 createSMESHAction( SMESHOp::OpPolygon, "POLYGON", "ICON_DLG_POLYGON" );
3955 createSMESHAction( SMESHOp::OpTetrahedron, "TETRA", "ICON_DLG_TETRAS" );
3956 createSMESHAction( SMESHOp::OpHexahedron, "HEXA", "ICON_DLG_HEXAS" );
3957 createSMESHAction( SMESHOp::OpPentahedron, "PENTA", "ICON_DLG_PENTA" );
3958 createSMESHAction( SMESHOp::OpPyramid , "PYRAMID", "ICON_DLG_PYRAMID" );
3959 createSMESHAction( SMESHOp::OpHexagonalPrism, "OCTA", "ICON_DLG_OCTA" );
3960 createSMESHAction( SMESHOp::OpPolyhedron, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
3961 createSMESHAction( SMESHOp::OpQuadraticEdge, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
3962 createSMESHAction( SMESHOp::OpQuadraticTriangle, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
3963 createSMESHAction( SMESHOp::OpBiQuadraticTriangle, "BIQUADRATIC_TRIANGLE", "ICON_DLG_BIQUADRATIC_TRIANGLE" );
3964 createSMESHAction( SMESHOp::OpQuadraticQuadrangle, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
3965 createSMESHAction( SMESHOp::OpBiQuadraticQuadrangle, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
3966 createSMESHAction( SMESHOp::OpQuadraticPolygon, "QUADRATIC_POLYGON", "ICON_DLG_QUADRATIC_POLYGON" );
3967 createSMESHAction( SMESHOp::OpQuadraticTetrahedron, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
3968 createSMESHAction( SMESHOp::OpQuadraticPyramid, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
3969 createSMESHAction( SMESHOp::OpQuadraticPentahedron, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
3970 createSMESHAction( SMESHOp::OpBiQuadraticPentahedron, "BIQUADRATIC_PENTAHEDRON", "ICON_DLG_BIQUADRATIC_PENTAHEDRON" );
3971 createSMESHAction( SMESHOp::OpQuadraticHexahedron, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
3972 createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
3974 createSMESHAction( SMESHOp::OpRemoveNodes, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
3975 createSMESHAction( SMESHOp::OpRemoveElements, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
3976 createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
3977 createSMESHAction( SMESHOp::OpClearMesh, "CLEAR_MESH", "ICON_CLEAR_MESH" );
3979 //createSMESHAction( SMESHOp::OpRenumberingNodes, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
3980 //createSMESHAction( SMESHOp::OpRenumberingElements, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
3982 createSMESHAction( SMESHOp::OpTranslation, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
3983 createSMESHAction( SMESHOp::OpRotation, "ROT", "ICON_DLG_MESH_ROTATION" );
3984 createSMESHAction( SMESHOp::OpSymmetry, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
3985 createSMESHAction( SMESHOp::OpScale, "SCALE", "ICON_DLG_MESH_SCALE" );
3986 createSMESHAction( SMESHOp::OpSewing, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
3987 createSMESHAction( SMESHOp::OpMergeNodes, "MERGE", "ICON_SMESH_MERGE_NODES" );
3988 createSMESHAction( SMESHOp::OpMergeElements, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
3989 createSMESHAction( SMESHOp::OpMoveNode, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
3990 createSMESHAction( SMESHOp::OpDuplicateNodes, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
3991 createSMESHAction( SMESHOp::OpDiagonalInversion, "INV", "ICON_DLG_MESH_DIAGONAL" );
3992 createSMESHAction( SMESHOp::OpUnionOfTwoTriangle, "UNION2", "ICON_UNION2TRI" );
3993 createSMESHAction( SMESHOp::OpOrientation, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
3994 createSMESHAction( SMESHOp::OpReorientFaces, "REORIENT_2D", "ICON_REORIENT_2D" );
3995 createSMESHAction( SMESHOp::OpUnionOfTriangles, "UNION", "ICON_UNIONTRI" );
3996 createSMESHAction( SMESHOp::OpCuttingOfQuadrangles, "CUT", "ICON_CUTQUAD" );
3997 createSMESHAction( SMESHOp::OpSplitVolumes, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
3998 createSMESHAction( SMESHOp::OpSplitBiQuadratic, "SPLIT_BIQUAD", "ICON_SPLIT_BIQUAD" );
3999 createSMESHAction( SMESHOp::OpSmoothing, "SMOOTH", "ICON_DLG_SMOOTHING" );
4000 createSMESHAction( SMESHOp::OpExtrusion, "EXTRUSION", "ICON_EXTRUSION" );
4001 createSMESHAction( SMESHOp::OpExtrusionAlongAPath, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
4002 createSMESHAction( SMESHOp::OpRevolution, "REVOLUTION", "ICON_REVOLUTION" );
4003 createSMESHAction( SMESHOp::OpPatternMapping, "MAP", "ICON_MAP" );
4004 createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
4005 createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D", "ICON_2D_FROM_3D" );
4007 createSMESHAction( SMESHOp::OpReset, "RESET" );
4008 createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
4009 createSMESHAction( SMESHOp::OpShowScalarBar, "SHOW_SCALAR_BAR","",0, true );
4010 createSMESHAction( SMESHOp::OpSaveDistribution, "SAVE_DISTRIBUTION" );
4011 createSMESHAction( SMESHOp::OpShowDistribution, "SHOW_DISTRIBUTION","",0, true );
4012 #ifndef DISABLE_PLOT2DVIEWER
4013 createSMESHAction( SMESHOp::OpPlotDistribution, "PLOT_DISTRIBUTION" );
4015 createSMESHAction( SMESHOp::OpDMWireframe, "WIRE", "ICON_WIRE", 0, true );
4016 createSMESHAction( SMESHOp::OpDMShading, "SHADE", "ICON_SHADE", 0, true );
4017 createSMESHAction( SMESHOp::OpDMNodes, "NODES", "ICON_POINTS", 0, true );
4018 createSMESHAction( SMESHOp::OpDMShrink, "SHRINK", "ICON_SHRINK", 0, true );
4019 createSMESHAction( SMESHOp::OpUpdate, "UPDATE", "ICON_UPDATE" );
4020 createSMESHAction( SMESHOp::OpDE0DElements, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
4021 createSMESHAction( SMESHOp::OpDEEdges, "EDGES", "ICON_DLG_EDGE", 0, true );
4022 createSMESHAction( SMESHOp::OpDEFaces, "FACES", "ICON_DLG_TRIANGLE", 0, true );
4023 createSMESHAction( SMESHOp::OpDEVolumes, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
4024 createSMESHAction( SMESHOp::OpDEBalls, "BALLS", "ICON_DLG_BALL", 0, true );
4025 createSMESHAction( SMESHOp::OpDEChoose, "CHOOSE", "ICON_DLG_CHOOSE", 0, false );
4026 createSMESHAction( SMESHOp::OpDEAllEntity, "ALL", "ICON_DLG_CHOOSE_ALL", 0, false );
4027 createSMESHAction( SMESHOp::OpOrientationOnFaces, "FACE_ORIENTATION", "", 0, true );
4029 createSMESHAction( SMESHOp::OpRepresentationLines, "LINE_REPRESENTATION", "", 0, true );
4030 createSMESHAction( SMESHOp::OpRepresentationArcs, "ARC_REPRESENTATION", "", 0, true );
4032 createSMESHAction( SMESHOp::OpEditHypothesis, "EDIT_HYPO" );
4033 createSMESHAction( SMESHOp::OpUnassign, "UNASSIGN" );
4034 createSMESHAction( SMESHOp::OpNumberingNodes, "NUM_NODES", "", 0, true );
4035 createSMESHAction( SMESHOp::OpNumberingElements, "NUM_ELEMENTS", "", 0, true );
4036 createSMESHAction( SMESHOp::OpProperties, "COLORS" );
4037 createSMESHAction( SMESHOp::OpTransparency, "TRANSP" );
4038 createSMESHAction( SMESHOp::OpClipping, "CLIP" );
4039 createSMESHAction( SMESHOp::OpAutoColor, "AUTO_COLOR" );
4040 createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
4042 createSMESHAction( SMESHOp::OpMinimumDistance, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
4043 createSMESHAction( SMESHOp::OpBoundingBox, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
4044 createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH", "ICON_MEASURE_LENGTH" );
4045 createSMESHAction( SMESHOp::OpPropertiesArea, "MEASURE_AREA", "ICON_MEASURE_AREA" );
4046 createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME", "ICON_MEASURE_VOLUME" );
4048 createSMESHAction( SMESHOp::OpHide, "HIDE", "ICON_HIDE" );
4049 createSMESHAction( SMESHOp::OpShow, "SHOW", "ICON_SHOW" );
4050 createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
4052 createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
4054 QList<int> aCtrlActions;
4055 aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode
4056 << SMESHOp::OpNodeConnectivityNb // node controls
4057 << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
4058 << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge // edge controls
4059 << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
4060 << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
4061 << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
4062 << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
4063 << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace // face controls
4064 << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
4065 << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
4066 << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume; // volume controls
4067 QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
4068 aCtrlGroup->setExclusive( true );
4069 for( int i = 0; i < aCtrlActions.size(); i++ )
4070 aCtrlGroup->addAction( action( aCtrlActions[i] ) );
4072 // ----- create menu --------------
4073 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
4074 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
4075 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
4076 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
4077 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
4078 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
4079 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
4080 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
4082 createMenu( separator(), fileId );
4084 QMenu* nodeMenu = new QMenu(); QMenu* edgeMenu = new QMenu();
4085 QMenu* faceMenu = new QMenu(); QMenu* volumeMenu = new QMenu();
4086 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
4087 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
4088 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10, -1, nodeMenu ),
4089 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10, -1, edgeMenu ),
4090 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10, -1, faceMenu ),
4091 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10, -1, volumeMenu ),
4092 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
4093 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
4094 //renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
4095 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
4096 basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
4098 //createMenu( SMESHOp::OpImportDAT, importId, -1 );
4099 createMenu( SMESHOp::OpImportUNV, importId, -1 );
4100 createMenu( SMESHOp::OpImportMED, importId, -1 );
4101 createMenu( SMESHOp::OpImportSTL, importId, -1 );
4103 createMenu( SMESHOp::OpImportCGNS, importId, -1 );
4105 createMenu( SMESHOp::OpImportSAUV, importId, -1 );
4106 createMenu( SMESHOp::OpImportGMF, importId, -1 );
4107 createMenu( SMESHOp::OpExportDAT, exportId, -1 );
4108 createMenu( SMESHOp::OpExportMED, exportId, -1 );
4109 createMenu( SMESHOp::OpExportUNV, exportId, -1 );
4110 createMenu( SMESHOp::OpExportSTL, exportId, -1 );
4112 createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
4114 createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
4115 createMenu( SMESHOp::OpExportGMF, exportId, -1 );
4116 createMenu( separator(), fileId, 10 );
4118 createMenu( SMESHOp::OpDelete, editId, -1 );
4120 createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
4122 createMenu( SMESHOp::OpCreateMesh, meshId, -1 ); // "Mesh" menu
4123 createMenu( SMESHOp::OpCreateSubMesh, meshId, -1 );
4124 createMenu( SMESHOp::OpEditMeshOrSubMesh, meshId, -1 );
4125 createMenu( SMESHOp::OpBuildCompoundMesh, meshId, -1 );
4126 createMenu( SMESHOp::OpCopyMesh, meshId, -1 );
4127 createMenu( separator(), meshId, -1 );
4128 createMenu( SMESHOp::OpCompute, meshId, -1 );
4129 createMenu( SMESHOp::OpPreCompute, meshId, -1 );
4130 createMenu( SMESHOp::OpEvaluate, meshId, -1 );
4131 createMenu( SMESHOp::OpMeshOrder, meshId, -1 );
4132 createMenu( separator(), meshId, -1 );
4133 createMenu( SMESHOp::OpCreateGroup, meshId, -1 );
4134 createMenu( SMESHOp::OpCreateGeometryGroup, meshId, -1 );
4135 createMenu( SMESHOp::OpConstructGroup, meshId, -1 );
4136 createMenu( SMESHOp::OpEditGroup, meshId, -1 );
4137 createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4138 createMenu( separator(), meshId, -1 );
4139 createMenu( SMESHOp::OpUnionGroups, meshId, -1 );
4140 createMenu( SMESHOp::OpIntersectGroups, meshId, -1 );
4141 createMenu( SMESHOp::OpCutGroups, meshId, -1 );
4142 createMenu( separator(), meshId, -1 );
4143 createMenu( SMESHOp::OpGroupUnderlyingElem, meshId, -1 );
4144 createMenu( separator(), meshId, -1 );
4145 createMenu( SMESHOp::OpMeshInformation, meshId, -1 );
4146 //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4147 //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4148 createMenu( SMESHOp::OpFindElementByPoint, meshId, -1 );
4149 createMenu( separator(), meshId, -1 );
4151 createMenu( SMESHOp::OpFreeNode, nodeId, -1 );
4152 createMenu( SMESHOp::OpEqualNode, nodeId, -1 );
4153 //createMenu( SMESHOp::OpNodeConnectivityNb, nodeId, -1 );
4154 createMenu( SMESHOp::OpFreeBorder, edgeId, -1 );
4155 createMenu( SMESHOp::OpLength, edgeId, -1 );
4156 createMenu( SMESHOp::OpConnection, edgeId, -1 );
4157 createMenu( SMESHOp::OpEqualEdge, edgeId, -1 );
4158 createMenu( SMESHOp::OpFreeEdge, faceId, -1 );
4159 createMenu( SMESHOp::OpFreeFace, faceId, -1 );
4160 createMenu( SMESHOp::OpBareBorderFace, faceId, -1 );
4161 createMenu( SMESHOp::OpOverConstrainedFace, faceId, -1 );
4162 createMenu( SMESHOp::OpLength2D, faceId, -1 );
4163 createMenu( SMESHOp::OpConnection2D, faceId, -1 );
4164 createMenu( SMESHOp::OpArea, faceId, -1 );
4165 createMenu( SMESHOp::OpTaper, faceId, -1 );
4166 createMenu( SMESHOp::OpAspectRatio, faceId, -1 );
4167 createMenu( SMESHOp::OpMinimumAngle, faceId, -1 );
4168 createMenu( SMESHOp::OpWarpingAngle, faceId, -1 );
4169 createMenu( SMESHOp::OpSkew, faceId, -1 );
4170 createMenu( SMESHOp::OpMaxElementLength2D, faceId, -1 );
4171 createMenu( SMESHOp::OpEqualFace, faceId, -1 );
4172 createMenu( SMESHOp::OpAspectRatio3D, volumeId, -1 );
4173 createMenu( SMESHOp::OpVolume, volumeId, -1 );
4174 createMenu( SMESHOp::OpMaxElementLength3D, volumeId, -1 );
4175 createMenu( SMESHOp::OpBareBorderVolume, volumeId, -1 );
4176 createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4177 createMenu( SMESHOp::OpEqualVolume, volumeId, -1 );
4178 createMenu( separator(), ctrlId, -1 );
4179 createMenu( SMESHOp::OpReset, ctrlId, -1 );
4180 createMenu( separator(), ctrlId, -1 );
4181 createMenu( SMESHOp::OpOverallMeshQuality, ctrlId, -1 );
4183 createMenu( SMESHOp::OpNode, addId, -1 );
4184 createMenu( SMESHOp::OpElem0D, addId, -1 );
4185 createMenu( SMESHOp::OpElem0DOnElemNodes, addId, -1 );
4186 createMenu( SMESHOp::OpBall, addId, -1 );
4187 createMenu( SMESHOp::OpEdge, addId, -1 );
4188 createMenu( SMESHOp::OpTriangle, addId, -1 );
4189 createMenu( SMESHOp::OpQuadrangle, addId, -1 );
4190 createMenu( SMESHOp::OpPolygon, addId, -1 );
4191 createMenu( SMESHOp::OpTetrahedron, addId, -1 );
4192 createMenu( SMESHOp::OpHexahedron, addId, -1 );
4193 createMenu( SMESHOp::OpPentahedron, addId, -1 );
4194 createMenu( SMESHOp::OpPyramid, addId, -1 );
4195 createMenu( SMESHOp::OpHexagonalPrism, addId, -1 );
4196 createMenu( SMESHOp::OpPolyhedron, addId, -1 );
4197 createMenu( separator(), addId, -1 );
4198 createMenu( SMESHOp::OpQuadraticEdge, addId, -1 );
4199 createMenu( SMESHOp::OpQuadraticTriangle, addId, -1 );
4200 createMenu( SMESHOp::OpBiQuadraticTriangle , addId, -1 );
4201 createMenu( SMESHOp::OpQuadraticQuadrangle, addId, -1 );
4202 createMenu( SMESHOp::OpBiQuadraticQuadrangle, addId, -1 );
4203 createMenu( SMESHOp::OpQuadraticPolygon, addId, -1 );
4204 createMenu( SMESHOp::OpQuadraticTetrahedron, addId, -1 );
4205 createMenu( SMESHOp::OpQuadraticPyramid, addId, -1 );
4206 createMenu( SMESHOp::OpQuadraticPentahedron, addId, -1 );
4207 createMenu( SMESHOp::OpBiQuadraticPentahedron, addId, -1 );
4208 createMenu( SMESHOp::OpQuadraticHexahedron, addId, -1 );
4209 createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4211 createMenu( SMESHOp::OpRemoveNodes, removeId, -1 );
4212 createMenu( SMESHOp::OpRemoveElements, removeId, -1 );
4213 createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4214 createMenu( separator(), removeId, -1 );
4215 createMenu( SMESHOp::OpDeleteGroup, removeId, -1 );
4216 createMenu( separator(), removeId, -1 );
4217 createMenu( SMESHOp::OpClearMesh, removeId, -1 );
4219 //createMenu( SMESHOp::OpRenumberingNodes, renumId, -1 );
4220 //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4222 createMenu( SMESHOp::OpTranslation, transfId, -1 );
4223 createMenu( SMESHOp::OpRotation, transfId, -1 );
4224 createMenu( SMESHOp::OpSymmetry, transfId, -1 );
4225 createMenu( SMESHOp::OpScale, transfId, -1 );
4226 createMenu( SMESHOp::OpSewing, transfId, -1 );
4227 createMenu( SMESHOp::OpMergeNodes, transfId, -1 );
4228 createMenu( SMESHOp::OpMergeElements, transfId, -1 );
4229 createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4231 createMenu( SMESHOp::OpMoveNode, modifyId, -1 );
4232 createMenu( SMESHOp::OpDiagonalInversion, modifyId, -1 );
4233 createMenu( SMESHOp::OpUnionOfTwoTriangle, modifyId, -1 );
4234 createMenu( SMESHOp::OpOrientation, modifyId, -1 );
4235 createMenu( SMESHOp::OpReorientFaces, modifyId, -1 );
4236 createMenu( SMESHOp::OpUnionOfTriangles, modifyId, -1 );
4237 createMenu( SMESHOp::OpCuttingOfQuadrangles, modifyId, -1 );
4238 createMenu( SMESHOp::OpSplitVolumes, modifyId, -1 );
4239 createMenu( SMESHOp::OpSplitBiQuadratic, modifyId, -1 );
4240 createMenu( SMESHOp::OpSmoothing, modifyId, -1 );
4241 createMenu( SMESHOp::OpExtrusion, modifyId, -1 );
4242 createMenu( SMESHOp::OpExtrusionAlongAPath , modifyId, -1 );
4243 createMenu( SMESHOp::OpRevolution, modifyId, -1 );
4244 createMenu( SMESHOp::OpPatternMapping, modifyId, -1 );
4245 createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4246 createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4248 createMenu( SMESHOp::OpMinimumDistance, measureId, -1 );
4249 createMenu( SMESHOp::OpBoundingBox, measureId, -1 );
4250 createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4251 createMenu( SMESHOp::OpPropertiesArea, basicPropId, -1 );
4252 createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4253 createMenu( SMESHOp::OpUpdate, viewId, -1 );
4255 connect( nodeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4256 connect( edgeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4257 connect( faceMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4258 connect( volumeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4260 // ----- create toolbars --------------
4261 int meshTb = createTool( tr( "TB_MESH" ), QString( "SMESHMeshToolbar" ) ),
4262 info = createTool( tr( "TB_INFO" ), QString( "SMESHInformationToolbar" ) ),
4263 groupTb = createTool( tr( "TB_GROUP" ), QString( "SMESHGroupToolbar" ) ),
4264 ctrl0dTb = createTool( tr( "TB_CTRL0D" ), QString( "SMESHNodeControlsToolbar" ) ),
4265 ctrl1dTb = createTool( tr( "TB_CTRL1D" ), QString( "SMESHEdgeControlsToolbar" ) ),
4266 ctrl2dTb = createTool( tr( "TB_CTRL2D" ), QString( "SMESHFaceControlsToolbar" ) ),
4267 ctrl3dTb = createTool( tr( "TB_CTRL3D" ), QString( "SMESHVolumeControlsToolbar" ) ),
4268 addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ),
4269 addNonElemTb = createTool( tr( "TB_ADDNON" ), QString( "SMESHAddElementToolbar" ) ),
4270 remTb = createTool( tr( "TB_REM" ), QString( "SMESHRemoveToolbar" ) ),
4271 //renumbTb = createTool( tr( "TB_RENUMBER" ), QString( "SMESHRenumberingToolbar" ) ),
4272 transformTb = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ),
4273 modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ),
4274 measuremTb = createTool( tr( "TB_MEASUREM" ), QString( "SMESHMeasurementsToolbar" ) ),
4275 dispModeTb = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4277 createTool( SMESHOp::OpCreateMesh, meshTb );
4278 createTool( SMESHOp::OpCreateSubMesh, meshTb );
4279 createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4280 createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4281 createTool( SMESHOp::OpCopyMesh, meshTb );
4282 createTool( separator(), meshTb );
4283 createTool( SMESHOp::OpCompute, meshTb );
4284 createTool( SMESHOp::OpPreCompute, meshTb );
4285 createTool( SMESHOp::OpEvaluate, meshTb );
4286 createTool( SMESHOp::OpMeshOrder, meshTb );
4288 createTool( SMESHOp::OpCreateGroup, groupTb );
4289 createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4290 createTool( SMESHOp::OpConstructGroup, groupTb );
4291 createTool( SMESHOp::OpEditGroup, groupTb );
4293 createTool( SMESHOp::OpMeshInformation, info );
4294 //createTool( SMESHOp::OpStdInfo, meshTb );
4295 //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4296 createTool( SMESHOp::OpFindElementByPoint, info );
4298 createTool( SMESHOp::OpFreeNode, ctrl0dTb );
4299 createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4300 //createTool( SMESHOp::OpNodeConnectivityNb, ctrl0dTb );
4302 createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4303 createTool( SMESHOp::OpLength, ctrl1dTb );
4304 createTool( SMESHOp::OpConnection, ctrl1dTb );
4305 createTool( SMESHOp::OpEqualEdge, ctrl1dTb );
4307 createTool( SMESHOp::OpFreeEdge, ctrl2dTb );
4308 createTool( SMESHOp::OpFreeFace, ctrl2dTb );
4309 createTool( SMESHOp::OpBareBorderFace, ctrl2dTb );
4310 createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4311 createTool( SMESHOp::OpLength2D, ctrl2dTb );
4312 createTool( SMESHOp::OpConnection2D, ctrl2dTb );
4313 createTool( SMESHOp::OpArea, ctrl2dTb );
4314 createTool( SMESHOp::OpTaper, ctrl2dTb );
4315 createTool( SMESHOp::OpAspectRatio, ctrl2dTb );
4316 createTool( SMESHOp::OpMinimumAngle, ctrl2dTb );
4317 createTool( SMESHOp::OpWarpingAngle, ctrl2dTb );
4318 createTool( SMESHOp::OpSkew, ctrl2dTb );
4319 createTool( SMESHOp::OpMaxElementLength2D, ctrl2dTb );
4320 createTool( SMESHOp::OpEqualFace, ctrl2dTb );
4322 createTool( SMESHOp::OpAspectRatio3D, ctrl3dTb );
4323 createTool( SMESHOp::OpVolume, ctrl3dTb );
4324 createTool( SMESHOp::OpMaxElementLength3D, ctrl3dTb );
4325 createTool( SMESHOp::OpBareBorderVolume, ctrl3dTb );
4326 createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
4327 createTool( SMESHOp::OpEqualVolume, ctrl3dTb );
4329 createTool( SMESHOp::OpNode, addElemTb );
4330 createTool( SMESHOp::OpElem0D, addElemTb );
4331 createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4332 createTool( SMESHOp::OpBall, addElemTb );
4333 createTool( SMESHOp::OpEdge, addElemTb );
4334 createTool( SMESHOp::OpTriangle, addElemTb );
4335 createTool( SMESHOp::OpQuadrangle, addElemTb );
4336 createTool( SMESHOp::OpPolygon, addElemTb );
4337 createTool( SMESHOp::OpTetrahedron, addElemTb );
4338 createTool( SMESHOp::OpHexahedron, addElemTb );
4339 createTool( SMESHOp::OpPentahedron, addElemTb );
4340 createTool( SMESHOp::OpPyramid, addElemTb );
4341 createTool( SMESHOp::OpHexagonalPrism, addElemTb );
4342 createTool( SMESHOp::OpPolyhedron, addElemTb );
4344 createTool( SMESHOp::OpQuadraticEdge, addNonElemTb );
4345 createTool( SMESHOp::OpQuadraticTriangle, addNonElemTb );
4346 createTool( SMESHOp::OpBiQuadraticTriangle, addNonElemTb );
4347 createTool( SMESHOp::OpQuadraticQuadrangle, addNonElemTb );
4348 createTool( SMESHOp::OpBiQuadraticQuadrangle, addNonElemTb );
4349 createTool( SMESHOp::OpQuadraticPolygon, addNonElemTb );
4350 createTool( SMESHOp::OpQuadraticTetrahedron, addNonElemTb );
4351 createTool( SMESHOp::OpQuadraticPyramid, addNonElemTb );
4352 createTool( SMESHOp::OpQuadraticPentahedron, addNonElemTb );
4353 createTool( SMESHOp::OpBiQuadraticPentahedron, addNonElemTb );
4354 createTool( SMESHOp::OpQuadraticHexahedron, addNonElemTb );
4355 createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4357 createTool( SMESHOp::OpRemoveNodes, remTb );
4358 createTool( SMESHOp::OpRemoveElements, remTb );
4359 createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4360 createTool( SMESHOp::OpClearMesh, remTb );
4362 //createTool( SMESHOp::OpRenumberingNodes, renumbTb );
4363 //createTool( SMESHOp::OpRenumberingElements, renumbTb );
4365 createTool( SMESHOp::OpTranslation, transformTb );
4366 createTool( SMESHOp::OpRotation, transformTb );
4367 createTool( SMESHOp::OpSymmetry, transformTb );
4368 createTool( SMESHOp::OpScale, transformTb );
4369 createTool( SMESHOp::OpSewing, transformTb );
4370 createTool( SMESHOp::OpMergeNodes, transformTb );
4371 createTool( SMESHOp::OpMergeElements, transformTb );
4372 createTool( SMESHOp::OpDuplicateNodes, transformTb );
4374 createTool( SMESHOp::OpMoveNode, modifyTb );
4375 createTool( SMESHOp::OpDiagonalInversion, modifyTb );
4376 createTool( SMESHOp::OpUnionOfTwoTriangle, modifyTb );
4377 createTool( SMESHOp::OpOrientation, modifyTb );
4378 createTool( SMESHOp::OpReorientFaces, modifyTb );
4379 createTool( SMESHOp::OpUnionOfTriangles, modifyTb );
4380 createTool( SMESHOp::OpCuttingOfQuadrangles, modifyTb );
4381 createTool( SMESHOp::OpSplitVolumes, modifyTb );
4382 createTool( SMESHOp::OpSplitBiQuadratic, modifyTb );
4383 createTool( SMESHOp::OpSmoothing, modifyTb );
4384 createTool( SMESHOp::OpExtrusion, modifyTb );
4385 createTool( SMESHOp::OpExtrusionAlongAPath, modifyTb );
4386 createTool( SMESHOp::OpRevolution, modifyTb );
4387 createTool( SMESHOp::OpPatternMapping, modifyTb );
4388 createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4389 createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4391 createTool( SMESHOp::OpMinimumDistance, measuremTb );
4393 createTool( SMESHOp::OpUpdate, dispModeTb );
4395 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4396 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4400 OB = "'ObjectBrowser'",
4401 View = "'" + SVTK_Viewer::Type() + "'",
4403 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4404 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4405 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4406 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4407 smesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::COMPONENT ) ),
4408 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4409 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4410 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4411 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4412 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4413 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4414 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4416 mesh_part = mesh + " " + subMesh + " " + group,
4417 mesh_group = mesh + " " + group,
4418 mesh_submesh = mesh + " " + subMesh,
4419 hyp_alg = hypo + " " + algo;
4421 // popup for object browser
4423 isInvisible("not( isVisible )"),
4424 isEmpty("numberOfNodes = 0"),
4425 isNotEmpty("numberOfNodes <> 0"),
4427 // has nodes, edges, etc in VISIBLE! actor
4428 hasNodes("(numberOfNodes > 0 ) && hasActor"),
4429 hasElems("(count( elemTypes ) > 0)"),
4430 hasDifferentElems("(count( elemTypes ) > 1)"),
4431 hasDifferentObjElems("(count( objElemTypes ) > 1)"),
4432 hasBalls("({'BallElem'} in elemTypes)"),
4433 hasElems0d("({'Elem0d'} in elemTypes)"),
4434 hasEdges("({'Edge'} in elemTypes)"),
4435 hasFaces("({'Face'} in elemTypes)"),
4436 hasVolumes("({'Volume'} in elemTypes)"),
4437 hasFacesOrVolumes("(({'Face'} in elemTypes) || ({'Volume'} in elemTypes)) ");
4439 createPopupItem( SMESHOp::OpFileInformation, OB, mesh, "&& selcount=1 && isImported" );
4440 createPopupItem( SMESHOp::OpCreateSubMesh, OB, mesh, "&& hasGeomReference");
4441 createPopupItem( SMESHOp::OpEditMesh, OB, mesh, "&& selcount=1" );
4442 createPopupItem( SMESHOp::OpEditSubMesh, OB, subMesh, "&& selcount=1 && hasGeomReference" );
4443 createPopupItem( SMESHOp::OpEditGroup, OB, group );
4444 createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4446 popupMgr()->insert( separator(), -1, 0 );
4447 createPopupItem( SMESHOp::OpCompute, OB, mesh, "&& selcount=1 && isComputable" );
4448 createPopupItem( SMESHOp::OpComputeSubMesh, OB, subMesh, "&& selcount=1 && isComputable" );
4449 createPopupItem( SMESHOp::OpPreCompute, OB, mesh, "&& selcount=1 && isPreComputable" );
4450 createPopupItem( SMESHOp::OpEvaluate, OB, mesh, "&& selcount=1 && isComputable" );
4451 createPopupItem( SMESHOp::OpMeshOrder, OB, mesh, "&& selcount=1 && isComputable && hasGeomReference" );
4452 createPopupItem( SMESHOp::OpUpdate, OB, mesh_part );
4453 createPopupItem( SMESHOp::OpMeshInformation, OB, mesh_part );
4454 createPopupItem( SMESHOp::OpFindElementByPoint,OB, mesh_group, "&& selcount=1" );
4455 createPopupItem( SMESHOp::OpOverallMeshQuality,OB, mesh_part );
4456 popupMgr()->insert( separator(), -1, 0 );
4457 createPopupItem( SMESHOp::OpCreateGroup, OB, mesh, "&& selcount=1" );
4458 createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh, "&& selcount=1 && hasGeomReference" );
4459 createPopupItem( SMESHOp::OpConstructGroup, OB, subMesh );
4460 popupMgr()->insert( separator(), -1, 0 );
4461 createPopupItem( SMESHOp::OpEditHypothesis, OB, hypo, "&& isEditableHyp");
4462 createPopupItem( SMESHOp::OpUnassign, OB, hyp_alg );
4463 popupMgr()->insert( separator(), -1, 0 );
4464 createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh_submesh );
4465 createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh_group, "&& selcount=1 && dim>=2");
4466 popupMgr()->insert( separator(), -1, 0 );
4467 createPopupItem( SMESHOp::OpClearMesh, OB, mesh );
4468 //popupMgr()->insert( separator(), -1, 0 );
4470 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4471 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4472 QString only_one_2D = only_one_non_empty + " && dim>1";
4474 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4475 createPopupItem( SMESHOp::OpPopupExportMED, OB, mesh_group, multiple_non_empty, anId );
4476 createPopupItem( SMESHOp::OpPopupExportUNV, OB, mesh_group, only_one_non_empty, anId );
4477 createPopupItem( SMESHOp::OpPopupExportSTL, OB, mesh_group, only_one_2D, anId );
4479 createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4481 createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, only_one_non_empty, anId );
4482 createPopupItem( SMESHOp::OpPopupExportGMF, OB, mesh_group, only_one_non_empty, anId );
4483 createPopupItem( SMESHOp::OpPopupExportDAT, OB, mesh_group, only_one_non_empty, anId );
4484 createPopupItem( SMESHOp::OpDelete, OB, mesh_part + " " + hyp_alg );
4485 createPopupItem( SMESHOp::OpDeleteGroup, OB, group );
4487 anId = popupMgr()->insert( tr( "MEN_IMPORT" ), -1, -1 ); // IMPORT submenu
4488 createPopupItem( SMESHOp::OpPopupImportMED, OB, smesh, "", anId );
4489 createPopupItem( SMESHOp::OpPopupImportUNV, OB, smesh, "", anId );
4490 createPopupItem( SMESHOp::OpPopupImportSTL, OB, smesh, "", anId );
4492 createPopupItem( SMESHOp::OpPopupImportCGNS, OB, smesh, "", anId );
4494 createPopupItem( SMESHOp::OpPopupImportSAUV, OB, smesh, "", anId );
4495 createPopupItem( SMESHOp::OpPopupImportGMF, OB, smesh, "", anId );
4496 createPopupItem( SMESHOp::OpPopupImportDAT, OB, smesh, "", anId );
4497 popupMgr()->insert( separator(), -1, 0 );
4500 createPopupItem( SMESHOp::OpEditGroup, View, group );
4501 createPopupItem( SMESHOp::OpAddElemGroupPopup, View, elems, "&& guiState = 800" );
4502 createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems, "&& guiState = 800" );
4504 popupMgr()->insert( separator(), -1, 0 );
4505 createPopupItem( SMESHOp::OpUpdate, View, mesh_part );
4506 createPopupItem( SMESHOp::OpMeshInformation, View, mesh_part );
4507 createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4508 createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh );
4509 popupMgr()->insert( separator(), -1, 0 );
4511 createPopupItem( SMESHOp::OpAutoColor, OB + " " + View, mesh, "&& (not isAutoColor)" );
4512 createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4513 popupMgr()->insert( separator(), -1, 0 );
4515 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4516 QString aType = QString( "%1type in {%2}" ).arg( lc );
4517 aType = aType.arg( mesh_part );
4518 QString aMeshInVTK = aClient + "&&" + aType;
4520 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4521 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4522 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4524 //-------------------------------------------------
4526 //-------------------------------------------------
4527 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4529 popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4530 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4531 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4533 popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4534 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4535 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4537 popupMgr()->insert( separator(), -1, -1 );
4539 //-------------------------------------------------
4541 //-------------------------------------------------
4542 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4544 popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4545 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4546 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4548 popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4549 popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4550 popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4552 popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4553 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4554 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4556 popupMgr()->insert( separator(), anId, -1 );
4558 popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4559 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4560 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4562 //-------------------------------------------------
4564 //-------------------------------------------------
4565 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4567 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4569 popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4570 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4571 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4573 popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4574 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4575 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4577 popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4578 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4579 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4581 popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4582 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4583 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4585 popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4586 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4587 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4589 popupMgr()->insert( separator(), anId, -1 );
4591 popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4592 popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&& $type in {" + mesh + "} &&" + hasDifferentObjElems, QtxPopupMgr::VisibleRule );
4594 popupMgr()->insert( separator(), anId, -1 );
4596 popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4597 popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4600 //-------------------------------------------------
4601 // Representation of the 2D Quadratic elements
4602 //-------------------------------------------------
4603 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4604 popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4605 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "&& isVisible && isQuadratic",QtxPopupMgr::VisibleRule );
4606 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4608 popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4609 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "&& isVisible && isQuadratic", QtxPopupMgr::VisibleRule );
4610 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4612 //-------------------------------------------------
4613 // Orientation of faces
4614 //-------------------------------------------------
4615 popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4616 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4617 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4619 //-------------------------------------------------
4621 //-------------------------------------------------
4622 popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4623 popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4625 //-------------------------------------------------
4627 //-------------------------------------------------
4628 popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4629 popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4631 //-------------------------------------------------
4633 //-------------------------------------------------
4635 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4636 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4637 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4638 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4640 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4642 popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4643 popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4645 popupMgr()->insert( separator(), anId, -1 );
4647 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4649 popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4650 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4651 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4653 popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4654 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4655 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4657 // popupMgr()->insert( action( SMESHOp::OpNodeConnectivityNb ), aSubId, -1 );
4658 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4659 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), "controlMode = 'eNodeConnectivityNb'", QtxPopupMgr::ToggleRule );
4661 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4663 popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4664 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVTK + "&&" + hasEdges + "&&" + hasFacesOrVolumes, QtxPopupMgr::VisibleRule );
4665 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4667 popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4668 popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4669 popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4671 popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4672 popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4673 popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4674 popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4675 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4676 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4678 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4680 popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4681 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4682 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4684 popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4685 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4686 QtxPopupMgr::VisibleRule );
4687 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4689 popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4690 popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4691 popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4693 popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4694 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4695 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4697 popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
4698 popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4699 popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4701 popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
4702 popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4703 popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4705 popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
4706 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4707 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4709 popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
4710 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4711 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4713 popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
4714 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4715 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4717 popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
4718 popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4719 popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4721 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
4722 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4723 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4725 popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
4726 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4727 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4729 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
4730 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4731 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4732 popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
4733 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4734 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4736 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4738 popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D ), aSubId, -1 );
4739 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4740 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4742 popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
4743 popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4744 popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4746 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
4747 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4748 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4750 popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
4751 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4752 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4754 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
4755 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4756 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4758 popupMgr()->insert ( action( SMESHOp::OpEqualVolume ), aSubId, -1 );
4759 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4760 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4762 popupMgr()->insert( separator(), anId, -1 );
4764 popupMgr()->insert( action( SMESHOp::OpShowScalarBar ), anId, -1 );
4765 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4766 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone' && isScalarBarVisible", QtxPopupMgr::ToggleRule );
4767 popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
4768 popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4770 popupMgr()->insert( separator(), anId, -1 );
4772 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4774 popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
4775 popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4777 popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
4778 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4779 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isScalarBarVisible && isDistributionVisible", QtxPopupMgr::ToggleRule);
4781 #ifndef DISABLE_PLOT2DVIEWER
4782 popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
4783 popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4786 //-------------------------------------------------
4788 //-------------------------------------------------
4789 popupMgr()->insert( separator(), -1, -1 );
4790 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4791 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4792 popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
4793 popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4795 popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
4796 popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4798 popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
4799 popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4801 popupMgr()->insert( separator(), -1, -1 );
4803 //-------------------------------------------------
4805 //-------------------------------------------------
4806 popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
4807 popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4809 popupMgr()->insert( separator(), -1, -1 );
4811 popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
4812 popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
4813 popupMgr()->insert( separator(), -1, -1 );
4815 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4816 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4818 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4819 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4822 //================================================================================
4824 * \brief Return true if SMESH or GEOM objects are selected.
4825 * Is called form LightApp_Module::activateModule() which clear selection if
4826 * not isSelectionCompatible()
4828 //================================================================================
4830 bool SMESHGUI::isSelectionCompatible()
4832 bool isCompatible = true;
4833 SALOME_ListIO selected;
4834 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4835 Sel->selectedObjects( selected );
4837 SALOME_ListIteratorOfListIO It( selected );
4838 for ( ; isCompatible && It.More(); It.Next())
4840 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4841 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4843 return isCompatible;
4847 bool SMESHGUI::reusableOperation( const int id )
4849 // compute, evaluate and precompute are not reusable operations
4850 return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate ) ? false : SalomeApp_Module::reusableOperation( id );
4853 bool SMESHGUI::activateModule( SUIT_Study* study )
4855 bool res = SalomeApp_Module::activateModule( study );
4857 setMenuShown( true );
4858 setToolShown( true );
4860 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4861 PyGILState_STATE gstate = PyGILState_Ensure();
4862 PyObject* pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4863 if ( !pluginsmanager ) {
4867 PyObject* result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toUtf8().data(),tr("SMESH_PLUGINS_OTHER").toUtf8().data());
4872 PyGILState_Release(gstate);
4873 // end of SMESH plugins loading
4875 // Reset actions accelerator keys
4876 action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
4878 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4879 GetSMESHGen()->SetCurrentStudy(SALOMEDS::Study::_nil());
4880 if ( SalomeApp_Study* s = dynamic_cast<SalomeApp_Study*>( study )) {
4881 if ( _PTR(Study) aStudy = s->studyDS() )
4882 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
4885 // get all view currently opened in the study and connect their signals to
4886 // the corresponding slots of the class.
4887 SUIT_Desktop* aDesk = study->application()->desktop();
4889 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4890 SUIT_ViewWindow* wnd;
4891 foreach ( wnd, wndList )
4895 Py_XDECREF(pluginsmanager);
4899 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4901 setMenuShown( false );
4902 setToolShown( false );
4904 EmitSignalCloseAllDialogs();
4906 // Unset actions accelerator keys
4907 action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
4909 return SalomeApp_Module::deactivateModule( study );
4912 void SMESHGUI::studyClosed( SUIT_Study* s )
4916 SMESH::RemoveVisuData( s->id() );
4917 SalomeApp_Module::studyClosed( s );
4920 void SMESHGUI::OnGUIEvent()
4922 const QObject* obj = sender();
4923 if ( !obj || !obj->inherits( "QAction" ) )
4925 int id = actionId((QAction*)obj);
4930 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4932 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
4933 if ( CORBA::is_nil( myComponentSMESH ) )
4935 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4937 aGUI.myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4938 return aGUI.myComponentSMESH;
4941 myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4942 return myComponentSMESH;
4945 QString SMESHGUI::engineIOR() const
4947 CORBA::ORB_var anORB = getApp()->orb();
4948 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4949 return QString( anIOR.in() );
4952 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4954 SalomeApp_Module::contextMenuPopup( client, menu, title );
4956 selectionMgr()->selectedObjects( lst );
4957 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4958 Handle(SALOME_InteractiveObject) io = lst.First();
4959 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4960 _PTR(Study) study = appStudy->studyDS();
4961 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4963 QString aName = QString( SMESH::fromUtf8(obj->GetName()) );
4964 while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4965 aName.remove( (aName.length() - 1), 1 );
4971 LightApp_Selection* SMESHGUI::createSelection() const
4973 return new SMESHGUI_Selection();
4976 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4978 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4979 aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
4980 #ifndef DISABLE_PYCONSOLE
4981 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4985 void SMESHGUI::viewManagers( QStringList& list ) const
4987 list.append( SVTK_Viewer::Type() );
4990 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4992 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4993 SMESH::UpdateSelectionProp( this );
4995 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
4996 for(int i = 0; i < aViews.count() ; i++){
4997 SUIT_ViewWindow *sf = aViews[i];
5000 EmitSignalActivatedViewManager();
5004 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
5006 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
5007 myClippingPlaneInfoMap.erase( theViewManager );
5010 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
5012 theActor->AddObserver( SMESH::DeleteActorEvent,
5013 myEventCallbackCommand.GetPointer(),
5017 void SMESHGUI::ProcessEvents( vtkObject* theObject,
5018 unsigned long theEvent,
5019 void* theClientData,
5022 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
5023 if( theObject && (int) theEvent == SMESH::DeleteActorEvent ) {
5024 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
5025 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
5026 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
5027 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
5028 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
5029 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
5030 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
5031 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
5032 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
5033 SMESH::TActorList::iterator anIter3 = anActorList.begin();
5034 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
5035 if( anActor == *anIter3 ) {
5036 anActorList.erase( anIter3 );
5047 void SMESHGUI::createPreferences()
5049 // General tab ------------------------------------------------------------------------
5050 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
5052 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
5053 setPreferenceProperty( autoUpdate, "columns", 2 );
5054 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
5055 setPreferenceProperty( lim, "min", 0 );
5056 setPreferenceProperty( lim, "max", 100000000 );
5057 setPreferenceProperty( lim, "step", 1000 );
5058 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5059 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
5061 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
5062 setPreferenceProperty( dispgroup, "columns", 2 );
5063 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
5065 modes.append( tr("MEN_WIRE") );
5066 modes.append( tr("MEN_SHADE") );
5067 modes.append( tr("MEN_NODES") );
5068 modes.append( tr("MEN_SHRINK") );
5069 QList<QVariant> indices;
5070 indices.append( 0 );
5071 indices.append( 1 );
5072 indices.append( 2 );
5073 indices.append( 3 );
5074 setPreferenceProperty( dispmode, "strings", modes );
5075 setPreferenceProperty( dispmode, "indexes", indices );
5077 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
5078 setPreferenceProperty( arcgroup, "columns", 2 );
5079 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
5080 QStringList quadraticModes;
5081 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
5082 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
5084 indices.append( 0 );
5085 indices.append( 1 );
5086 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
5087 setPreferenceProperty( quadraticmode, "indexes", indices );
5089 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
5090 "SMESH", "max_angle" );
5091 setPreferenceProperty( maxAngle, "min", 1 );
5092 setPreferenceProperty( maxAngle, "max", 90 );
5094 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
5095 setPreferenceProperty( qaGroup, "columns", 2 );
5096 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
5097 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
5098 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
5099 setPreferenceProperty( prec, "min", 0 );
5100 setPreferenceProperty( prec, "max", 100 );
5101 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
5102 setPreferenceProperty( doubleNodesTol, "precision", 10 );
5103 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
5104 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
5105 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
5108 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
5109 setPreferenceProperty( exportgroup, "columns", 2 );
5110 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
5111 addPreference( tr( "PREF_SHOW_WARN" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "show_warning" );
5112 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
5114 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
5115 setPreferenceProperty( computeGroup, "columns", 2 );
5116 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
5118 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5119 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5120 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5122 indices.append( 0 );
5123 indices.append( 1 );
5124 indices.append( 2 );
5125 setPreferenceProperty( notifyMode, "strings", modes );
5126 setPreferenceProperty( notifyMode, "indexes", indices );
5128 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5129 setPreferenceProperty( infoGroup, "columns", 2 );
5130 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5132 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5133 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5135 indices.append( 0 );
5136 indices.append( 1 );
5137 setPreferenceProperty( elemInfo, "strings", modes );
5138 setPreferenceProperty( elemInfo, "indexes", indices );
5139 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5140 setPreferenceProperty( nodesLim, "min", 0 );
5141 setPreferenceProperty( nodesLim, "max", 10000000 );
5142 setPreferenceProperty( nodesLim, "step", 10000 );
5143 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5144 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5145 setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5146 setPreferenceProperty( ctrlLim, "min", 0 );
5147 setPreferenceProperty( ctrlLim, "max", 10000000 );
5148 setPreferenceProperty( ctrlLim, "step", 1000 );
5149 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5150 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5151 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5152 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5153 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5155 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5156 setPreferenceProperty( segGroup, "columns", 2 );
5157 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5158 "SMESH", "segmentation" );
5159 setPreferenceProperty( segLen, "min", 1 );
5160 setPreferenceProperty( segLen, "max", 10000000 );
5161 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5162 "SMESH", "nb_segments_per_edge" );
5163 setPreferenceProperty( nbSeg, "min", 1 );
5164 setPreferenceProperty( nbSeg, "max", 10000000 );
5166 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5167 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5168 "SMESH", "forget_mesh_on_hyp_modif" );
5171 // Quantities with individual precision settings
5172 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5173 setPreferenceProperty( precGroup, "columns", 2 );
5175 const int nbQuantities = 6;
5176 int precs[nbQuantities], ii = 0;
5177 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5178 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5179 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5180 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5181 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5182 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5183 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5184 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5185 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5186 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5187 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5188 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5190 // Set property for precision value for spinboxes
5191 for ( ii = 0; ii < nbQuantities; ii++ ){
5192 setPreferenceProperty( precs[ii], "min", -14 );
5193 setPreferenceProperty( precs[ii], "max", 14 );
5194 setPreferenceProperty( precs[ii], "precision", 2 );
5197 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5198 setPreferenceProperty( previewGroup, "columns", 2 );
5199 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5200 setPreferenceProperty( chunkSize, "min", 1 );
5201 setPreferenceProperty( chunkSize, "max", 1000 );
5202 setPreferenceProperty( chunkSize, "step", 50 );
5204 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5205 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5207 // Mesh tab ------------------------------------------------------------------------
5208 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5209 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5210 setPreferenceProperty( nodeGroup, "columns", 3 );
5212 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5214 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5216 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5217 QList<QVariant> aMarkerTypeIndicesList;
5218 QList<QVariant> aMarkerTypeIconsList;
5219 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5220 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5221 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5222 aMarkerTypeIndicesList << i;
5223 aMarkerTypeIconsList << pixmap;
5225 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5226 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
5228 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5230 QList<QVariant> aMarkerScaleIndicesList;
5231 QStringList aMarkerScaleValuesList;
5232 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5233 aMarkerScaleIndicesList << i;
5234 //aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5235 aMarkerScaleValuesList << QString::number( i );
5237 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5238 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5240 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5241 //setPreferenceProperty( elemGroup, "columns", 2 );
5243 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5244 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5245 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5246 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5247 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5248 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5249 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5250 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5251 addPreference( tr( "PREF_PREVIEW_COLOR" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5254 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5255 setPreferenceProperty( grpGroup, "columns", 2 );
5257 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5258 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5260 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5261 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5262 /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5263 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5264 double ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5265 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5266 double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5267 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5268 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
5269 LightApp_Preferences::IntSpin, "SMESH", "element_width");
5270 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5271 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5272 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5273 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5275 setPreferenceProperty( size0d, "min", 1 );
5276 setPreferenceProperty( size0d, "max", 10 );
5278 // setPreferenceProperty( ballSize, "min", 1 );
5279 // setPreferenceProperty( ballSize, "max", 10 );
5281 setPreferenceProperty( ballDiameter, "min", 1e-7 );
5282 setPreferenceProperty( ballDiameter, "max", 1e9 );
5283 setPreferenceProperty( ballDiameter, "step", 0.1 );
5285 setPreferenceProperty( ballScale, "min", 1e-2 );
5286 setPreferenceProperty( ballScale, "max", 1e7 );
5287 setPreferenceProperty( ballScale, "step", 0.5 );
5289 setPreferenceProperty( elemW, "min", 1 );
5290 setPreferenceProperty( elemW, "max", 5 );
5292 setPreferenceProperty( outW, "min", 1 );
5293 setPreferenceProperty( outW, "max", 5 );
5295 setPreferenceProperty( shrink, "min", 0 );
5296 setPreferenceProperty( shrink, "max", 100 );
5298 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5299 setPreferenceProperty( numGroup, "columns", 2 );
5301 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5302 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5304 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5305 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5307 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5308 setPreferenceProperty( orientGroup, "columns", 1 );
5310 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5311 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5313 setPreferenceProperty( orientScale, "min", 0.05 );
5314 setPreferenceProperty( orientScale, "max", 0.5 );
5315 setPreferenceProperty( orientScale, "step", 0.05 );
5317 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5319 // Selection tab ------------------------------------------------------------------------
5320 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5322 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5323 setPreferenceProperty( selGroup, "columns", 2 );
5325 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5326 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5328 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5329 setPreferenceProperty( preGroup, "columns", 2 );
5331 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5333 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5334 setPreferenceProperty( precSelGroup, "columns", 2 );
5336 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5337 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5338 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5340 // Scalar Bar tab ------------------------------------------------------------------------
5341 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5342 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5343 setPreferenceProperty( fontGr, "columns", 2 );
5345 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5346 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5348 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5349 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5351 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5352 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5354 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5355 setPreferenceProperty( numcol, "min", 2 );
5356 setPreferenceProperty( numcol, "max", 256 );
5358 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5359 setPreferenceProperty( numlab, "min", 2 );
5360 setPreferenceProperty( numlab, "max", 65 );
5362 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5363 setPreferenceProperty( orientGr, "columns", 2 );
5364 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5365 QStringList orients;
5366 orients.append( tr( "SMESH_VERTICAL" ) );
5367 orients.append( tr( "SMESH_HORIZONTAL" ) );
5368 indices.clear(); indices.append( 0 ); indices.append( 1 );
5369 setPreferenceProperty( orient, "strings", orients );
5370 setPreferenceProperty( orient, "indexes", indices );
5372 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5373 setPreferenceProperty( posVSizeGr, "columns", 2 );
5374 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5375 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5376 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5377 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5378 setPreferenceProperty( xv, "step", 0.1 );
5379 setPreferenceProperty( xv, "min", 0.0 );
5380 setPreferenceProperty( xv, "max", 1.0 );
5381 setPreferenceProperty( yv, "step", 0.1 );
5382 setPreferenceProperty( yv, "min", 0.0 );
5383 setPreferenceProperty( yv, "max", 1.0 );
5384 setPreferenceProperty( wv, "step", 0.1 );
5385 setPreferenceProperty( wv, "min", 0.0 );
5386 setPreferenceProperty( wv, "max", 1.0 );
5387 setPreferenceProperty( hv, "min", 0.0 );
5388 setPreferenceProperty( hv, "max", 1.0 );
5389 setPreferenceProperty( hv, "step", 0.1 );
5391 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5392 setPreferenceProperty( posHSizeGr, "columns", 2 );
5393 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5394 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5395 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5396 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5397 setPreferenceProperty( xv, "min", 0.0 );
5398 setPreferenceProperty( xv, "max", 1.0 );
5399 setPreferenceProperty( xv, "step", 0.1 );
5400 setPreferenceProperty( xh, "min", 0.0 );
5401 setPreferenceProperty( xh, "max", 1.0 );
5402 setPreferenceProperty( xh, "step", 0.1 );
5403 setPreferenceProperty( yh, "min", 0.0 );
5404 setPreferenceProperty( yh, "max", 1.0 );
5405 setPreferenceProperty( yh, "step", 0.1 );
5406 setPreferenceProperty( wh, "min", 0.0 );
5407 setPreferenceProperty( wh, "max", 1.0 );
5408 setPreferenceProperty( wh, "step", 0.1 );
5409 setPreferenceProperty( hh, "min", 0.0 );
5410 setPreferenceProperty( hh, "max", 1.0 );
5411 setPreferenceProperty( hh, "step", 0.1 );
5413 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5414 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5415 setPreferenceProperty( distributionGr, "columns", 3 );
5417 types.append( tr( "SMESH_MONOCOLOR" ) );
5418 types.append( tr( "SMESH_MULTICOLOR" ) );
5419 indices.clear(); indices.append( 0 ); indices.append( 1 );
5420 setPreferenceProperty( coloringType, "strings", types );
5421 setPreferenceProperty( coloringType, "indexes", indices );
5422 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5426 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5428 if ( sect=="SMESH" ) {
5429 float sbX1 = 0.01, sbY1 = 0.01, sbW = 0.08, sbH = 0.08;
5430 float aTol = 1.00000009999999;
5431 std::string aWarning;
5432 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5434 if ( name== "selection_object_color" ||
5435 name=="selection_element_color" ||
5436 name== "highlight_color" ||
5437 name=="selection_precision_node" ||
5438 name=="selection_precision_element" ||
5439 name=="selection_precision_object" )
5441 SMESH::UpdateSelectionProp( this );
5443 else if (name == "scalar_bar_vertical_x" || name == "scalar_bar_vertical_width")
5445 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5446 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5447 if ( sbX1+sbW > aTol ) {
5448 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5451 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5452 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5455 else if (name == "scalar_bar_vertical_y" || name == "scalar_bar_vertical_height" )
5457 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5458 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5459 if ( sbY1 + sbH > aTol ) {
5460 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5461 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5462 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5465 else if (name == "scalar_bar_horizontal_x" || name == "scalar_bar_horizontal_width")
5467 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5468 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5469 if ( sbX1 + sbW > aTol ) {
5470 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5473 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5474 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5477 else if (name == "scalar_bar_horizontal_y" || name == "scalar_bar_horizontal_height")
5479 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5480 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5481 if ( sbY1 + sbH > aTol ) {
5482 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5485 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5486 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5489 else if ( name == "segmentation" )
5491 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5492 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5494 else if ( name == "nb_segments_per_edge" )
5496 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5497 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5499 else if ( name == "historical_python_dump" || name == "forget_mesh_on_hyp_modif" || name == "default_grp_color" )
5501 QString val = aResourceMgr->stringValue( "SMESH", name );
5502 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5504 else if ( name == "numbering_node_color" || name == "numbering_node_font" )
5506 SMESH::UpdateFontProp( this );
5508 else if ( name == "numbering_elem_color" || name == "numbering_elem_font" )
5510 SMESH::UpdateFontProp( this );
5513 if ( aWarning.size() != 0 ) {
5514 aWarning += "The default values are applied instead.";
5515 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5516 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5517 QObject::tr(aWarning.c_str()));
5522 //================================================================================
5524 * \brief Update something in accordance with update flags
5525 * \param theFlags - update flags
5527 * Update viewer or/and object browser etc. in accordance with update flags ( see
5528 * LightApp_UpdateFlags enumeration ).
5530 //================================================================================
5531 void SMESHGUI::update( const int flags )
5533 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5534 SMESH::UpdateView();
5536 SalomeApp_Module::update( flags );
5539 //================================================================================
5541 * \brief Set default selection mode
5543 * SLOT called when operation committed. Sets default selection mode
5545 //================================================================================
5546 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5548 SVTK_ViewWindow* vtkWnd =
5549 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5551 vtkWnd->SetSelectionMode( ActorSelection );
5554 //================================================================================
5556 * \brief Set default selection mode
5558 * SLOT called when operation aborted. Sets default selection mode
5560 //================================================================================
5561 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5563 SVTK_ViewWindow* vtkWnd =
5564 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5566 vtkWnd->SetSelectionMode( ActorSelection );
5569 //================================================================================
5571 * \brief Creates operation with given identifier
5572 * \param id - identifier of operation to be started
5573 * \return Pointer on created operation or NULL if operation is not created
5575 * Virtual method redefined from the base class creates operation with given id.
5576 * It is called called automatically from startOperation method of base class.
5578 //================================================================================
5579 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5581 LightApp_Operation* op = 0;
5582 // to do : create operation here
5585 case SMESHOp::OpSplitBiQuadratic:
5586 op = new SMESHGUI_SplitBiQuadOp();
5588 case SMESHOp::OpConvertMeshToQuadratic:
5589 op = new SMESHGUI_ConvToQuadOp();
5591 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5592 op = new SMESHGUI_Make2DFrom3DOp();
5594 case SMESHOp::OpReorientFaces:
5595 op = new SMESHGUI_ReorientFacesOp();
5597 case SMESHOp::OpCreateMesh:
5598 op = new SMESHGUI_MeshOp( true, true );
5600 case SMESHOp::OpCreateSubMesh:
5601 op = new SMESHGUI_MeshOp( true, false );
5603 case SMESHOp::OpEditMeshOrSubMesh:
5604 case SMESHOp::OpEditMesh:
5605 case SMESHOp::OpEditSubMesh:
5606 op = new SMESHGUI_MeshOp( false );
5608 case SMESHOp::OpCompute:
5609 case SMESHOp::OpComputeSubMesh:
5610 op = new SMESHGUI_ComputeOp();
5612 case SMESHOp::OpPreCompute:
5613 op = new SMESHGUI_PrecomputeOp();
5615 case SMESHOp::OpEvaluate:
5616 op = new SMESHGUI_EvaluateOp();
5618 case SMESHOp::OpMeshOrder:
5619 op = new SMESHGUI_MeshOrderOp();
5621 case SMESHOp::OpCreateGeometryGroup:
5622 op = new SMESHGUI_GroupOnShapeOp();
5624 case SMESHOp::OpFindElementByPoint:
5625 op = new SMESHGUI_FindElemByPointOp();
5627 case SMESHOp::OpMoveNode: // Make mesh pass through point
5628 op = new SMESHGUI_MakeNodeAtPointOp();
5630 case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
5631 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5638 op = SalomeApp_Module::createOperation( id );
5642 //================================================================================
5644 * \brief Stops current operations and starts a given one
5645 * \param id - The id of the operation to start
5647 //================================================================================
5649 void SMESHGUI::switchToOperation(int id)
5651 if ( _PTR(Study) aStudy = SMESH::GetActiveStudyDocument() )
5652 activeStudy()->abortAllOperations();
5653 startOperation( id );
5656 LightApp_Displayer* SMESHGUI::displayer()
5659 myDisplayer = new SMESHGUI_Displayer( getApp() );
5663 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5666 int aTolerance = 64;
5667 int anIterations = 0;
5673 if( anIterations % aPeriod == 0 )
5676 if( aTolerance < 1 )
5680 aHue = (int)( 360.0 * rand() / RAND_MAX );
5683 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5684 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5685 for( ; it != itEnd; ++it )
5687 SALOMEDS::Color anAutoColor = *it;
5688 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5691 aQColor.getHsv( &h, &s, &v );
5692 if( abs( h - aHue ) < aTolerance )
5704 aColor.setHsv( aHue, 255, 255 );
5706 SALOMEDS::Color aSColor;
5707 aSColor.R = aColor.redF();
5708 aSColor.G = aColor.greenF();
5709 aSColor.B = aColor.blueF();
5714 const char* gSeparator = "_"; // character used to separate parameter names
5715 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5716 const char* gPathSep = "|"; // character used to separate paths
5719 * \brief Store visual parameters
5721 * This method is called just before the study document is saved.
5722 * Store visual parameters in AttributeParameter attribue(s)
5724 void SMESHGUI::storeVisualParameters (int savePoint)
5727 Kernel_Utils::Localizer loc;
5729 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5730 if (!appStudy || !appStudy->studyDS())
5732 _PTR(Study) studyDS = appStudy->studyDS();
5734 // componentName is used for encoding of entries when storing them in IParameters
5735 std::string componentName = myComponentSMESH->ComponentDataType();
5736 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5737 //if (!aSComponent) return;
5740 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5741 componentName.c_str(),
5743 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5745 // store map of custom markers
5746 const VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5747 if( !aMarkerMap.empty() )
5749 VTK::MarkerMap::const_iterator anIter = aMarkerMap.begin();
5750 for( ; anIter != aMarkerMap.end(); anIter++ )
5752 int anId = anIter->first;
5753 VTK::MarkerData aMarkerData = anIter->second;
5754 std::string aMarkerFileName = aMarkerData.first;
5755 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5756 if( aMarkerTexture.size() < 3 )
5757 continue; // should contain at least width, height and the first value
5759 QString aPropertyName( "texture" );
5760 aPropertyName += gSeparator;
5761 aPropertyName += QString::number( anId );
5763 QString aPropertyValue = aMarkerFileName.c_str();
5764 aPropertyValue += gPathSep;
5766 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5767 ushort aWidth = *aTextureIter++;
5768 ushort aHeight = *aTextureIter++;
5769 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5770 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5771 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5772 aPropertyValue += QString::number( *aTextureIter );
5774 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5778 // viewers counters are used for storing view_numbers in IParameters
5781 // main cycle to store parameters of displayed objects
5782 QList<SUIT_ViewManager*> lst;
5783 QList<SUIT_ViewManager*>::Iterator it;
5784 getApp()->viewManagers(lst);
5785 for (it = lst.begin(); it != lst.end(); it++)
5787 SUIT_ViewManager* vman = *it;
5788 QString vType = vman->getType();
5790 // saving VTK actors properties
5791 if (vType == SVTK_Viewer::Type())
5793 // store the clipping planes attached to the view manager
5794 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5795 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5796 if( anIter != myClippingPlaneInfoMap.end() )
5797 aClippingPlaneInfoList = anIter->second;
5799 if( !aClippingPlaneInfoList.empty() ) {
5800 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5801 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5803 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5804 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5806 QString aPropertyName( "ClippingPlane" );
5807 aPropertyName += gSeparator;
5808 aPropertyName += QString::number( vtkViewers );
5809 aPropertyName += gSeparator;
5810 aPropertyName += QString::number( anId );
5812 QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
5813 aPropertyValue += gDigitsSep;
5814 aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
5815 aPropertyValue += gDigitsSep;
5816 if ( aPlane->PlaneMode == SMESH::Absolute ) {
5817 aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
5818 aPropertyValue += gDigitsSep;
5819 aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
5820 aPropertyValue += gDigitsSep;
5821 aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
5822 aPropertyValue += gDigitsSep;
5823 aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
5824 aPropertyValue += gDigitsSep;
5825 aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
5826 aPropertyValue += gDigitsSep;
5827 aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
5828 aPropertyValue += gDigitsSep;
5829 aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
5831 else if ( aPlane->PlaneMode == SMESH::Relative ) {
5832 aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
5833 aPropertyValue += gDigitsSep;
5834 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5835 aPropertyValue += gDigitsSep;
5836 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5837 aPropertyValue += gDigitsSep;
5838 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5841 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5845 QVector<SUIT_ViewWindow*> views = vman->getViews();
5846 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5848 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5850 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5851 vtkActorCollection* allActors = aCopy.GetActors();
5852 allActors->InitTraversal();
5853 while (vtkActor* actor = allActors->GetNextActor())
5855 if (actor->GetVisibility()) // store only visible actors
5857 SMESH_Actor* aSmeshActor = 0;
5858 if (actor->IsA("SMESH_Actor"))
5859 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5860 if (aSmeshActor && aSmeshActor->hasIO())
5862 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5865 // entry is "encoded" = it does NOT contain component address,
5866 // since it is a subject to change on next component loading
5867 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5869 std::string param, vtkParam = vType.toLatin1().data();
5870 vtkParam += gSeparator;
5871 vtkParam += QString::number(vtkViewers).toLatin1().data();
5872 vtkParam += gSeparator;
5875 param = vtkParam + "Visibility";
5876 ip->setParameter(entry, param, "On");
5879 param = vtkParam + "Representation";
5880 ip->setParameter(entry, param, QString::number
5881 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5884 param = vtkParam + "IsShrunk";
5885 ip->setParameter(entry, param, QString::number
5886 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5888 // Displayed entities
5889 unsigned int aMode = aSmeshActor->GetEntityMode();
5890 bool isE = aMode & SMESH_Actor::eEdges;
5891 bool isF = aMode & SMESH_Actor::eFaces;
5892 bool isV = aMode & SMESH_Actor::eVolumes;
5893 bool is0d = aMode & SMESH_Actor::e0DElements;
5894 bool isB = aMode & SMESH_Actor::eBallElem;
5896 QString modeStr ("e");
5897 modeStr += gDigitsSep; modeStr += QString::number(isE);
5898 modeStr += gDigitsSep; modeStr += "f";
5899 modeStr += gDigitsSep; modeStr += QString::number(isF);
5900 modeStr += gDigitsSep; modeStr += "v";
5901 modeStr += gDigitsSep; modeStr += QString::number(isV);
5902 modeStr += gDigitsSep; modeStr += "0d";
5903 modeStr += gDigitsSep; modeStr += QString::number(is0d);
5904 modeStr += gDigitsSep; modeStr += "b";
5905 modeStr += gDigitsSep; modeStr += QString::number(isB);
5907 param = vtkParam + "Entities";
5908 ip->setParameter(entry, param, modeStr.toLatin1().data());
5914 aSmeshActor->GetSufaceColor(r, g, b, delta);
5915 QStringList colorStr;
5916 colorStr << "surface";
5917 colorStr << QString::number(r);
5918 colorStr << QString::number(g);
5919 colorStr << QString::number(b);
5921 colorStr << "backsurface";
5922 colorStr << QString::number(delta);
5924 aSmeshActor->GetVolumeColor(r, g, b, delta);
5925 colorStr << "volume";
5926 colorStr << QString::number(r);
5927 colorStr << QString::number(g);
5928 colorStr << QString::number(b);
5929 colorStr << QString::number(delta);
5931 aSmeshActor->GetEdgeColor(r, g, b);
5933 colorStr << QString::number(r);
5934 colorStr << QString::number(g);
5935 colorStr << QString::number(b);
5937 aSmeshActor->GetNodeColor(r, g, b);
5939 colorStr << QString::number(r);
5940 colorStr << QString::number(g);
5941 colorStr << QString::number(b);
5943 aSmeshActor->GetOutlineColor(r, g, b);
5944 colorStr << "outline";
5945 colorStr << QString::number(r);
5946 colorStr << QString::number(g);
5947 colorStr << QString::number(b);
5949 aSmeshActor->Get0DColor(r, g, b);
5950 colorStr << "elem0d";
5951 colorStr << QString::number(r);
5952 colorStr << QString::number(g);
5953 colorStr << QString::number(b);
5955 aSmeshActor->GetBallColor(r, g, b);
5957 colorStr << QString::number(r);
5958 colorStr << QString::number(g);
5959 colorStr << QString::number(b);
5961 aSmeshActor->GetFacesOrientationColor(r, g, b);
5962 colorStr << "orientation";
5963 colorStr << QString::number(r);
5964 colorStr << QString::number(g);
5965 colorStr << QString::number(b);
5967 param = vtkParam + "Colors";
5968 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
5971 QStringList sizeStr;
5973 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
5974 sizeStr << "outline";
5975 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
5976 sizeStr << "elem0d";
5977 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
5979 //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
5980 sizeStr << QString::number((double)aSmeshActor->GetBallSize());
5981 sizeStr << QString::number((double)aSmeshActor->GetBallScale());
5982 sizeStr << "shrink";
5983 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
5984 sizeStr << "orientation";
5985 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
5986 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
5988 param = vtkParam + "Sizes";
5989 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
5994 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5995 if( aMarkerType == VTK::MT_USER ) {
5996 markerStr += "custom";
5997 markerStr += gDigitsSep;
5998 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
6002 markerStr += gDigitsSep;
6003 markerStr += QString::number( (int)aMarkerType );
6004 markerStr += gDigitsSep;
6005 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
6008 param = vtkParam + "PointMarker";
6009 ip->setParameter(entry, param, markerStr.toLatin1().data());
6012 param = vtkParam + "Opacity";
6013 ip->setParameter(entry, param,
6014 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
6017 param = vtkParam + "ClippingPlane";
6019 if( !aClippingPlaneInfoList.empty() ) {
6020 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
6021 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
6023 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
6024 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
6025 SMESH::TActorList::iterator anIter2 = anActorList.begin();
6026 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
6027 if( aSmeshActor == *anIter2 ) {
6028 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
6029 QString::number( anId ).toLatin1().constData() );
6036 ip->setParameter( entry, param, "Off" );
6037 } // if (io->hasEntry())
6038 } // SMESH_Actor && hasIO
6040 } // while.. actors traversal
6044 } // if (SVTK view model)
6045 } // for (viewManagers)
6048 // data structures for clipping planes processing
6052 bool isOpenGLClipping;
6053 vtkIdType RelativeOrientation;
6056 int AbsoluteOrientation;
6057 double X, Y, Z, Dx, Dy, Dz;
6059 typedef std::list<TPlaneData> TPlaneDataList;
6060 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
6062 typedef std::list<vtkActor*> TActorList;
6065 TActorList ActorList;
6066 SUIT_ViewManager* ViewManager;
6068 typedef std::list<TPlaneInfo> TPlaneInfoList;
6069 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
6072 * \brief Restore visual parameters
6074 * This method is called after the study document is opened.
6075 * Restore visual parameters from AttributeParameter attribue(s)
6077 void SMESHGUI::restoreVisualParameters (int savePoint)
6080 Kernel_Utils::Localizer loc;
6082 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6083 if (!appStudy || !appStudy->studyDS())
6085 _PTR(Study) studyDS = appStudy->studyDS();
6087 // componentName is used for encoding of entries when storing them in IParameters
6088 std::string componentName = myComponentSMESH->ComponentDataType();
6089 //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
6090 //if (!aSComponent) return;
6093 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6094 componentName.c_str(),
6096 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6098 // restore map of custom markers and map of clipping planes
6099 VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
6100 TPlaneDataMap aPlaneDataMap;
6102 std::vector<std::string> properties = ip->getProperties();
6103 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
6105 std::string property = *propIt;
6106 QString aPropertyName( property.c_str() );
6107 QString aPropertyValue( ip->getProperty( property ).c_str() );
6109 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
6110 if( aPropertyNameList.isEmpty() )
6113 QString aPropertyType = aPropertyNameList[0];
6114 if( aPropertyType == "texture" )
6116 if( aPropertyNameList.size() != 2 )
6120 int anId = aPropertyNameList[1].toInt( &ok );
6121 if( !ok || anId < 1 )
6124 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
6125 if( aPropertyValueList.size() != 2 )
6128 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
6129 QString aMarkerTextureString = aPropertyValueList[1];
6130 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
6131 if( aMarkerTextureStringList.size() != 3 )
6135 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6140 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6144 VTK::MarkerTexture aMarkerTexture;
6145 aMarkerTexture.push_back( aWidth );
6146 aMarkerTexture.push_back( aHeight );
6148 QString aMarkerTextureData = aMarkerTextureStringList[2];
6149 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6151 QChar aChar = aMarkerTextureData.at( i );
6152 if( aChar.isDigit() )
6153 aMarkerTexture.push_back( aChar.digitValue() );
6156 aMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6158 else if( aPropertyType == "ClippingPlane" )
6160 if( aPropertyNameList.size() != 3 )
6164 int aViewId = aPropertyNameList[1].toInt( &ok );
6165 if( !ok || aViewId < 0 )
6169 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6170 if( !ok || aClippingPlaneId < 0 )
6173 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6174 if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6177 TPlaneData aPlaneData;
6178 aPlaneData.AbsoluteOrientation = false;
6179 aPlaneData.RelativeOrientation = 0;
6180 aPlaneData.Distance = aPlaneData.Angle[0] = aPlaneData.Angle[1] = 0;
6181 aPlaneData.X = aPlaneData.Y = aPlaneData.Z = 0;
6182 aPlaneData.Dx = aPlaneData.Dy = aPlaneData.Dz = 0;
6184 aPlaneData.Id = aClippingPlaneId;
6187 aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6192 aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6196 if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6199 aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6204 aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6209 aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6214 aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6219 aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6224 aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6229 aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6233 else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6235 aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6240 aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6245 aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6250 aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6255 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6256 aPlaneDataList.push_back( aPlaneData );
6260 TPlaneInfoMap aPlaneInfoMap;
6262 std::vector<std::string> entries = ip->getEntries();
6264 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6266 // entry is a normal entry - it should be "decoded" (setting base address of component)
6267 QString entry (ip->decodeEntry(*entIt).c_str());
6269 // Check that the entry corresponds to a real object in the Study
6270 // as the object may be deleted or modified after the visual state is saved.
6271 _PTR(SObject) so = studyDS->FindObjectID(entry.toLatin1().data());
6272 if (!so) continue; //Skip the not existent entry
6274 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6275 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6277 std::vector<std::string>::iterator namesIt = paramNames.begin();
6278 std::vector<std::string>::iterator valuesIt = paramValues.begin();
6280 // actors are stored in a map after displaying of them for
6281 // quicker access in the future: map < viewID to actor >
6282 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6284 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6286 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6287 // '_' is used as separator and should not be used in viewer type or parameter names.
6288 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6289 if (lst.size() != 3)
6292 QString viewerTypStr = lst[0];
6293 QString viewIndexStr = lst[1];
6294 QString paramNameStr = lst[2];
6297 int viewIndex = viewIndexStr.toUInt(&ok);
6298 if (!ok) // bad conversion of view index to integer
6302 if (viewerTypStr == SVTK_Viewer::Type())
6304 SMESH_Actor* aSmeshActor = 0;
6305 if (vtkActors.IsBound(viewIndex))
6306 aSmeshActor = vtkActors.Find(viewIndex);
6308 QList<SUIT_ViewManager*> lst;
6309 getApp()->viewManagers(viewerTypStr, lst);
6311 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6312 SUIT_ViewManager* vman = NULL;
6313 if (viewIndex >= 0 && viewIndex < lst.count())
6314 vman = lst.at(viewIndex);
6316 if (paramNameStr == "Visibility")
6318 if (!aSmeshActor && displayer() && vman)
6320 SUIT_ViewModel* vmodel = vman->getViewModel();
6321 // SVTK view model can be casted to SALOME_View
6322 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6324 // store displayed actor in a temporary map for quicker
6325 // access later when restoring other parameters
6326 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6327 vtkRenderer* Renderer = vtkView->getRenderer();
6328 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6329 vtkActorCollection* theActors = aCopy.GetActors();
6330 theActors->InitTraversal();
6331 bool isFound = false;
6332 vtkActor *ac = theActors->GetNextActor();
6333 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6334 if (ac->IsA("SMESH_Actor")) {
6335 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6336 if (aGeomAc->hasIO()) {
6337 Handle(SALOME_InteractiveObject) io = aGeomAc->getIO();
6338 if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) {
6340 vtkActors.Bind(viewIndex, aGeomAc);
6346 } // if (paramNameStr == "Visibility")
6349 // the rest properties "work" with SMESH_Actor
6352 QString val ((*valuesIt).c_str());
6355 if (paramNameStr == "Representation") {
6356 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6359 else if (paramNameStr == "IsShrunk") {
6361 if (!aSmeshActor->IsShrunk())
6362 aSmeshActor->SetShrink();
6365 if (aSmeshActor->IsShrunk())
6366 aSmeshActor->UnShrink();
6369 // Displayed entities
6370 else if (paramNameStr == "Entities") {
6371 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6372 int aEntityMode = SMESH_Actor::eAllEntity;
6373 for ( int i = 0; i < mode.count(); i+=2 ) {
6374 if ( i < mode.count()-1 ) {
6375 QString type = mode[i];
6376 bool val = mode[i+1].toInt();
6377 if ( type == "e" && !val )
6378 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6379 else if ( type == "f" && !val )
6380 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6381 else if ( type == "v" && !val )
6382 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6383 else if ( type == "0d" && !val )
6384 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6385 else if ( type == "b" && !val )
6386 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6389 aSmeshActor->SetEntityMode( aEntityMode );
6392 else if (paramNameStr == "Colors") {
6393 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6400 QColor outlineColor;
6401 QColor orientationColor;
6407 // below lines are required to get default values for delta coefficients
6408 // of backface color for faces and color of reversed volumes
6409 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
6410 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6411 for ( int i = 0; i < colors.count(); i++ ) {
6412 QString type = colors[i];
6413 if ( type == "surface" ) {
6414 // face color is set by 3 values r:g:b, where
6415 // - r,g,b - is rgb color components
6416 if ( i+1 >= colors.count() ) break; // format error
6417 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6418 if ( i+2 >= colors.count() ) break; // format error
6419 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6420 if ( i+3 >= colors.count() ) break; // format error
6421 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6422 faceColor.setRgbF( r, g, b );
6425 else if ( type == "backsurface" ) {
6426 // backface color can be defined in several ways
6427 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6428 // - in latest versions, it is set as delta coefficient
6429 bool rgbOk = false, deltaOk;
6430 if ( i+1 >= colors.count() ) break; // format error
6431 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6432 int delta = colors[i+1].toInt( &deltaOk );
6434 if ( i+1 < colors.count() ) // index is shifted to 1
6435 g = colors[i+1].toDouble( &rgbOk );
6436 if ( rgbOk ) i++; // shift index
6437 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6438 b = colors[i+1].toDouble( &rgbOk );
6440 // - as currently there's no way to set directly backsurface color as it was before,
6441 // we ignore old dump where r,g,b triple was set
6442 // - also we check that delta parameter is set properly
6443 if ( !rgbOk && deltaOk )
6446 else if ( type == "volume" ) {
6447 // volume color is set by 4 values r:g:b:delta, where
6448 // - r,g,b - is a normal volume rgb color components
6449 // - delta - is a reversed volume color delta coefficient
6450 if ( i+1 >= colors.count() ) break; // format error
6451 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6452 if ( i+2 >= colors.count() ) break; // format error
6453 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6454 if ( i+3 >= colors.count() ) break; // format error
6455 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6456 if ( i+4 >= colors.count() ) break; // format error
6457 int delta = colors[i+4].toInt( &bOk );
6458 if ( !bOk ) break; // format error
6459 volumeColor.setRgbF( r, g, b );
6463 else if ( type == "edge" ) {
6464 // edge color is set by 3 values r:g:b, where
6465 // - r,g,b - is rgb color components
6466 if ( i+1 >= colors.count() ) break; // format error
6467 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6468 if ( i+2 >= colors.count() ) break; // format error
6469 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6470 if ( i+3 >= colors.count() ) break; // format error
6471 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6472 edgeColor.setRgbF( r, g, b );
6475 else if ( type == "node" ) {
6476 // node color is set by 3 values r:g:b, where
6477 // - r,g,b - is rgb color components
6478 if ( i+1 >= colors.count() ) break; // format error
6479 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6480 if ( i+2 >= colors.count() ) break; // format error
6481 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6482 if ( i+3 >= colors.count() ) break; // format error
6483 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6484 nodeColor.setRgbF( r, g, b );
6487 else if ( type == "elem0d" ) {
6488 // 0d element color is set by 3 values r:g:b, where
6489 // - r,g,b - is rgb color components
6490 if ( i+1 >= colors.count() ) break; // format error
6491 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6492 if ( i+2 >= colors.count() ) break; // format error
6493 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6494 if ( i+3 >= colors.count() ) break; // format error
6495 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6496 elem0dColor.setRgbF( r, g, b );
6499 else if ( type == "ball" ) {
6500 // ball color is set by 3 values r:g:b, where
6501 // - r,g,b - is rgb color components
6502 if ( i+1 >= colors.count() ) break; // format error
6503 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6504 if ( i+2 >= colors.count() ) break; // format error
6505 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6506 if ( i+3 >= colors.count() ) break; // format error
6507 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6508 ballColor.setRgbF( r, g, b );
6511 else if ( type == "outline" ) {
6512 // outline color is set by 3 values r:g:b, where
6513 // - r,g,b - is rgb color components
6514 if ( i+1 >= colors.count() ) break; // format error
6515 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6516 if ( i+2 >= colors.count() ) break; // format error
6517 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6518 if ( i+3 >= colors.count() ) break; // format error
6519 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6520 outlineColor.setRgbF( r, g, b );
6523 else if ( type == "orientation" ) {
6524 // orientation color is set by 3 values r:g:b, where
6525 // - r,g,b - is rgb color components
6526 if ( i+1 >= colors.count() ) break; // format error
6527 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6528 if ( i+2 >= colors.count() ) break; // format error
6529 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6530 if ( i+3 >= colors.count() ) break; // format error
6531 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6532 orientationColor.setRgbF( r, g, b );
6537 if ( nodeColor.isValid() )
6538 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6540 if ( edgeColor.isValid() )
6541 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6543 if ( faceColor.isValid() )
6544 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6546 if ( volumeColor.isValid() )
6547 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6548 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6549 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6551 if ( elem0dColor.isValid() )
6552 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6554 if ( ballColor.isValid() )
6555 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6557 if ( outlineColor.isValid() )
6558 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6559 // orientation color
6560 if ( orientationColor.isValid() )
6561 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6564 else if (paramNameStr == "Sizes") {
6565 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6568 int outlineWidth = -1;
6569 int elem0dSize = -1;
6570 //int ballSize = -1;
6571 double ballDiameter = -1.0;
6572 double ballScale = -1.0;
6573 double shrinkSize = -1;
6574 double orientationSize = -1;
6575 bool orientation3d = false;
6576 for ( int i = 0; i < sizes.count(); i++ ) {
6577 QString type = sizes[i];
6578 if ( type == "line" ) {
6579 // line (wireframe) width is given as single integer value
6580 if ( i+1 >= sizes.count() ) break; // format error
6581 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6585 if ( type == "outline" ) {
6586 // outline width is given as single integer value
6587 if ( i+1 >= sizes.count() ) break; // format error
6588 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6592 else if ( type == "elem0d" ) {
6593 // 0d element size is given as single integer value
6594 if ( i+1 >= sizes.count() ) break; // format error
6595 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6599 else if ( type == "ball" ) {
6600 // balls are specified by two values: size:scale, where
6601 // - size - is a integer value specifying size
6602 // - scale - is a double value specifying scale factor
6603 if ( i+1 >= sizes.count() ) break; // format error
6604 //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6605 double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6606 if ( i+2 >= sizes.count() ) break; // format error
6607 double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6613 else if ( type == "shrink" ) {
6614 // shrink factor is given as single floating point value
6615 if ( i+1 >= sizes.count() ) break; // format error
6616 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6620 else if ( type == "orientation" ) {
6621 // orientation vectors are specified by two values size:3d, where
6622 // - size - is a floating point value specifying scale factor
6623 // - 3d - is a boolean
6624 if ( i+1 >= sizes.count() ) break; // format error
6625 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6626 if ( i+2 >= sizes.count() ) break; // format error
6627 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6628 orientationSize = v1;
6629 orientation3d = (bool)v2;
6633 // line (wireframe) width
6634 if ( lineWidth > 0 )
6635 aSmeshActor->SetLineWidth( lineWidth );
6637 if ( outlineWidth > 0 )
6638 aSmeshActor->SetOutlineWidth( outlineWidth );
6639 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6640 aSmeshActor->SetOutlineWidth( lineWidth );
6642 if ( elem0dSize > 0 )
6643 aSmeshActor->Set0DSize( elem0dSize );
6645 /*if ( ballSize > 0 )
6646 aSmeshActor->SetBallSize( ballSize );*/
6648 if ( ballDiameter > 0 )
6649 aSmeshActor->SetBallSize( ballDiameter );
6651 if ( ballScale > 0.0 )
6652 aSmeshActor->SetBallScale( ballScale );
6654 if ( shrinkSize > 0 )
6655 aSmeshActor->SetShrinkFactor( shrinkSize );
6656 // orientation vectors
6657 if ( orientationSize > 0 ) {
6658 aSmeshActor->SetFacesOrientationScale( orientationSize );
6659 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6663 else if (paramNameStr == "PointMarker") {
6664 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6665 if( data.count() >= 2 ) {
6667 int aParam1 = data[1].toInt( &ok );
6669 if( data[0] == "std" && data.count() == 3 ) {
6670 int aParam2 = data[2].toInt( &ok );
6671 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6673 else if( data[0] == "custom" ) {
6674 VTK::MarkerMap::const_iterator markerIt = aMarkerMap.find( aParam1 );
6675 if( markerIt != aMarkerMap.end() ) {
6676 VTK::MarkerData aMarkerData = markerIt->second;
6677 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6684 else if (paramNameStr == "Opacity") {
6685 aSmeshActor->SetOpacity(val.toFloat());
6688 else if (paramNameStr.startsWith("ClippingPlane")) {
6689 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6690 // old format - val looks like "Off" or "1:0:0:0.5:0:0"
6691 // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
6692 // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
6693 // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
6694 // new format - val looks like "Off" or "0" (plane id)
6695 // (note: in new format "Off" value is used only for consistency,
6696 // so it is processed together with values in old format)
6697 bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
6698 if( anIsOldFormat ) {
6699 if (paramNameStr == "ClippingPlane1" || val == "Off")
6700 aSmeshActor->RemoveAllClippingPlanes();
6702 QList<SUIT_ViewManager*> lst;
6703 getApp()->viewManagers(viewerTypStr, lst);
6704 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6705 if (viewIndex >= 0 && viewIndex < lst.count()) {
6706 SUIT_ViewManager* vman = lst.at(viewIndex);
6707 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6709 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6711 SMESH::TActorList anActorList;
6712 anActorList.push_back( aSmeshActor );
6713 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
6714 aPlane->myViewWindow = vtkView;
6715 SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
6716 aPlane->PlaneMode = aMode;
6717 bool isOpenGLClipping = ( bool )vals[1].toInt();
6718 aPlane->IsOpenGLClipping = isOpenGLClipping;
6719 if ( aMode == SMESH::Absolute ) {
6720 aPlane->myAbsoluteOrientation = vals[2].toInt();
6721 aPlane->X = vals[3].toFloat();
6722 aPlane->Y = vals[4].toFloat();
6723 aPlane->Z = vals[5].toFloat();
6724 aPlane->Dx = vals[6].toFloat();
6725 aPlane->Dy = vals[7].toFloat();
6726 aPlane->Dz = vals[8].toFloat();
6728 else if ( aMode == SMESH::Relative ) {
6729 aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
6730 aPlane->myDistance = vals[3].toFloat();
6731 aPlane->myAngle[0] = vals[4].toFloat();
6732 aPlane->myAngle[1] = vals[5].toFloat();
6736 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6737 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6738 aClippingPlaneInfo.Plane = aPlane;
6739 aClippingPlaneInfo.ActorList = anActorList;
6740 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6748 int aPlaneId = val.toInt( &ok );
6749 if( ok && aPlaneId >= 0 ) {
6750 bool anIsDefinedPlane = false;
6751 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6752 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6753 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6754 TPlaneInfo& aPlaneInfo = *anIter;
6755 if( aPlaneInfo.PlaneId == aPlaneId ) {
6756 aPlaneInfo.ActorList.push_back( aSmeshActor );
6757 anIsDefinedPlane = true;
6761 if( !anIsDefinedPlane ) {
6762 TPlaneInfo aPlaneInfo;
6763 aPlaneInfo.PlaneId = aPlaneId;
6764 aPlaneInfo.ActorList.push_back( aSmeshActor );
6765 aPlaneInfo.ViewManager = vman;
6767 // to make the list sorted by plane id
6768 anIter = aPlaneInfoList.begin();
6769 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6770 const TPlaneInfo& aPlaneInfoRef = *anIter;
6771 if( aPlaneInfoRef.PlaneId > aPlaneId )
6774 aPlaneInfoList.insert( anIter, aPlaneInfo );
6779 } // if (aSmeshActor)
6780 } // other parameters than Visibility
6782 } // for names/parameters iterator
6783 } // for entries iterator
6785 // take into account planes with empty list of actors referred to them
6786 QList<SUIT_ViewManager*> aVMList;
6787 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6789 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6790 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6791 int aViewId = aPlaneDataIter->first;
6792 if( aViewId >= 0 && aViewId < aVMList.count() ) {
6793 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6795 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6797 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6798 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6799 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6800 const TPlaneData& aPlaneData = *anIter2;
6801 int aPlaneId = aPlaneData.Id;
6803 bool anIsFound = false;
6804 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6805 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6806 const TPlaneInfo& aPlaneInfo = *anIter3;
6807 if( aPlaneInfo.PlaneId == aPlaneId ) {
6814 TPlaneInfo aPlaneInfo; // ActorList field is empty
6815 aPlaneInfo.PlaneId = aPlaneId;
6816 aPlaneInfo.ViewManager = aViewManager;
6818 // to make the list sorted by plane id
6819 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6820 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6821 const TPlaneInfo& aPlaneInfoRef = *anIter4;
6822 if( aPlaneInfoRef.PlaneId > aPlaneId )
6825 aPlaneInfoList.insert( anIter4, aPlaneInfo );
6831 // add clipping planes to actors according to the restored parameters
6832 // and update the clipping plane map
6833 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6834 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6835 int aViewId = anIter1->first;
6836 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6838 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6839 if( anIter2 == aPlaneDataMap.end() )
6841 const TPlaneDataList& aPlaneDataList = anIter2->second;
6843 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6844 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6845 const TPlaneInfo& aPlaneInfo = *anIter3;
6846 int aPlaneId = aPlaneInfo.PlaneId;
6847 const TActorList& anActorList = aPlaneInfo.ActorList;
6848 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6852 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6856 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6858 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6859 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6860 const TPlaneData& aPlaneData = *anIter4;
6861 if( aPlaneData.Id == aPlaneId ) {
6862 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
6863 aPlane->myViewWindow = aViewWindow;
6864 aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
6865 aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
6866 if ( aPlane->PlaneMode == SMESH::Absolute ) {
6867 aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
6868 aPlane->X = aPlaneData.X;
6869 aPlane->Y = aPlaneData.Y;
6870 aPlane->Z = aPlaneData.Z;
6871 aPlane->Dx = aPlaneData.Dx;
6872 aPlane->Dy = aPlaneData.Dy;
6873 aPlane->Dz = aPlaneData.Dz;
6875 else if ( aPlane->PlaneMode == SMESH::Relative ) {
6876 aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
6877 aPlane->myDistance = aPlaneData.Distance;
6878 aPlane->myAngle[0] = aPlaneData.Angle[0];
6879 aPlane->myAngle[1] = aPlaneData.Angle[1];
6882 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6883 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6884 aClippingPlaneInfo.Plane = aPlane;
6885 aClippingPlaneInfo.ActorList = anActorList;
6886 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6897 // update all VTK views
6898 QList<SUIT_ViewManager*> lst;
6899 getApp()->viewManagers(lst);
6900 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6901 SUIT_ViewModel* vmodel = (*it)->getViewModel();
6902 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6903 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6904 // set OpenGL clipping planes
6905 VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
6906 vtkActorCollection* anAllActors = aCopy.GetActors();
6907 anAllActors->InitTraversal();
6908 while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
6909 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
6910 anActor->SetOpenGLClippingPlane();
6912 vtkView->getRenderer()->ResetCameraClippingRange();
6919 \brief Adds preferences for dfont of VTK viewer
6921 \param pIf group identifier
6922 \param param parameter
6923 \return identifier of preferences
6925 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
6927 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6929 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6932 fam.append( tr( "SMESH_FONT_ARIAL" ) );
6933 fam.append( tr( "SMESH_FONT_COURIER" ) );
6934 fam.append( tr( "SMESH_FONT_TIMES" ) );
6936 setPreferenceProperty( tfont, "fonts", fam );
6938 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6939 if ( needSize ) f = f | QtxFontEdit::Size;
6940 setPreferenceProperty( tfont, "features", f );
6946 \brief Actions after hypothesis edition
6947 Updates object browser after hypothesis edition
6949 void SMESHGUI::onHypothesisEdit( int result )
6952 SMESHGUI::Modified();
6953 updateObjBrowser( true );
6957 \brief Actions after choosing menu of control modes
6958 Updates control mode actions according to current selection
6960 void SMESHGUI::onUpdateControlActions()
6962 SALOME_ListIO selected;
6963 if ( LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr() )
6964 aSel->selectedObjects( selected );
6966 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
6967 if ( selected.Extent() ) {
6968 if ( selected.First()->hasEntry() ) {
6969 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( selected.First()->getEntry() )) {
6970 aControl = anActor->GetControlMode();
6971 SALOME_ListIteratorOfListIO it(selected);
6972 for ( it.Next(); it.More(); it.Next() ) {
6973 Handle(SALOME_InteractiveObject) anIO = it.Value();
6974 if ( anIO->hasEntry() ) {
6975 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
6976 if ( aControl != anActor->GetControlMode() ) {
6977 aControl = SMESH_Actor::eNone;
6987 int anAction = ActionToControl( aControl, true );
6989 action( anAction )->setChecked( true );
6991 QMenu* send = (QMenu*)sender();
6992 QList<QAction*> actions = send->actions();
6993 for ( int i = 0; i < actions.size(); i++ )
6994 actions[i]->setChecked( false );
7000 \brief Signal handler closing(SUIT_ViewWindow*) of a view
7001 \param pview view being closed
7003 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
7004 #ifndef DISABLE_PLOT2DVIEWER
7005 //Crear all Plot2d Viewers if need.
7006 SMESH::ClearPlot2Viewers(pview);
7008 EmitSignalCloseView();
7011 void SMESHGUI::message( const QString& msg )
7014 QStringList data = msg.split("/");
7015 if ( data.count() > 0 ) {
7016 if ( data.first() == "mesh_loading" ) {
7018 QString entry = data.count() > 1 ? data[1] : QString();
7019 if ( entry.isEmpty() )
7022 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
7024 _PTR(SObject) obj = study->FindObjectID( entry.toLatin1().constData() );
7027 name = SMESH::fromUtf8(obj->GetName());
7028 if ( name.isEmpty() )
7031 if ( data.last() == "stop" )
7032 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
7034 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
7035 QApplication::processEvents();
7041 \brief Connects or disconnects signals about activating and cloning view on the module slots
7042 \param pview view which is connected/disconnected
7044 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
7048 SUIT_ViewManager* viewMgr = pview->getViewManager();
7050 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7051 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7053 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7054 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7059 \brief Return \c true if object can be renamed
7061 bool SMESHGUI::renameAllowed( const QString& entry) const {
7062 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7066 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7070 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
7075 if(appStudy->isComponent(entry) || obj->isReference())
7078 // check type to prevent renaming of inappropriate objects
7079 int aType = SMESHGUI_Selection::type(qPrintable(entry), SMESH::GetActiveStudyDocument());
7080 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7081 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7082 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7083 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7084 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
7091 Rename object by entry.
7092 \param entry entry of the object
7093 \param name new name of the object
7094 \brief Return \c true if rename operation finished successfully, \c false otherwise.
7096 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
7098 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7102 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7107 _PTR(Study) aStudy = appStudy->studyDS();
7112 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
7114 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
7119 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
7120 _PTR(GenericAttribute) anAttr;
7121 _PTR(AttributeName) aName;
7123 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
7125 // check type to prevent renaming of inappropriate objects
7126 int aType = SMESHGUI_Selection::type( qPrintable(entry), SMESH::GetActiveStudyDocument() );
7127 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7128 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7129 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7130 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7131 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
7132 if ( !name.isEmpty() ) {
7133 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
7135 // update name of group object and its actor
7136 Handle(SALOME_InteractiveObject) IObject =
7137 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
7139 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
7140 if( !aGroupObject->_is_nil() ) {
7141 aGroupObject->SetName( qPrintable(name) );
7142 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
7143 anActor->setName( qPrintable(name) );
7153 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
7155 static QList<QColor> colors;
7157 if ( colors.isEmpty() ) {
7159 for (int s = 0; s < 2 ; s++)
7161 for (int v = 100; v >= 40; v = v - 20)
7163 for (int h = 0; h < 359 ; h = h + 60)
7165 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
7170 static int currentColor = randomize( colors.size() );
7172 SALOMEDS::Color color;
7173 color.R = (double)colors[currentColor].red() / 255.0;
7174 color.G = (double)colors[currentColor].green() / 255.0;
7175 color.B = (double)colors[currentColor].blue() / 255.0;
7177 currentColor = (currentColor+1) % colors.count();