1 // Copyright (C) 2007-2020 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_AdaptDlg.h"
34 #include "SMESHGUI_Add0DElemsOnAllNodesDlg.h"
35 #include "SMESHGUI_AddMeshElementDlg.h"
36 #include "SMESHGUI_AddQuadraticElementDlg.h"
37 #include "SMESHGUI_BuildCompoundDlg.h"
38 #include "SMESHGUI_ClippingDlg.h"
39 #include "SMESHGUI_ComputeDlg.h"
40 #include "SMESHGUI_ConvToQuadOp.h"
41 #include "SMESHGUI_CopyMeshDlg.h"
42 #include "SMESHGUI_CreatePolyhedralVolumeDlg.h"
43 #include "SMESHGUI_DeleteGroupDlg.h"
44 #include "SMESHGUI_DisplayEntitiesDlg.h"
45 #include "SMESHGUI_Displayer.h"
46 #include "SMESHGUI_DuplicateNodesDlg.h"
47 #include "SMESHGUI_ExtrusionAlongPathDlg.h"
48 #include "SMESHGUI_ExtrusionDlg.h"
49 #include "SMESHGUI_FaceGroupsSeparatedByEdgesDlg.h"
50 #include "SMESHGUI_FieldSelectorWdg.h"
51 #include "SMESHGUI_FileInfoDlg.h"
52 #include "SMESHGUI_FileValidator.h"
53 #include "SMESHGUI_FilterDlg.h"
54 #include "SMESHGUI_FilterLibraryDlg.h"
55 #include "SMESHGUI_FilterUtils.h"
56 #include "SMESHGUI_FindElemByPointDlg.h"
57 #include "SMESHGUI_GEOMGenUtils.h"
58 #include "SMESHGUI_GroupDlg.h"
59 #include "SMESHGUI_GroupOnShapeDlg.h"
60 #include "SMESHGUI_GroupOpDlg.h"
61 #include "SMESHGUI_GroupUtils.h"
62 #include "SMESHGUI_Hypotheses.h"
63 #include "SMESHGUI_HypothesesUtils.h"
64 #include "SMESHGUI_Make2DFrom3DOp.h"
65 #include "SMESHGUI_MakeNodeAtPointDlg.h"
66 #include "SMESHGUI_Measurements.h"
67 #include "SMESHGUI_MergeDlg.h"
68 #include "SMESHGUI_MeshInfo.h"
69 #include "SMESHGUI_MeshOp.h"
70 #include "SMESHGUI_MeshOrderOp.h"
71 #include "SMESHGUI_MeshPatternDlg.h"
72 #include "SMESHGUI_MeshUtils.h"
73 #include "SMESHGUI_MultiEditDlg.h"
74 #include "SMESHGUI_NodesDlg.h"
75 #include "SMESHGUI_OffsetDlg.h"
76 #include "SMESHGUI_Operations.h"
77 #include "SMESHGUI_PatternUtils.h"
78 #include "SMESHGUI_Preferences_ScalarBarDlg.h"
79 #include "SMESHGUI_PropertiesDlg.h"
80 #include "SMESHGUI_RemoveElementsDlg.h"
81 #include "SMESHGUI_RemoveNodesDlg.h"
82 #include "SMESHGUI_RenumberingDlg.h"
83 #include "SMESHGUI_ReorientFacesDlg.h"
84 #include "SMESHGUI_RevolutionDlg.h"
85 #include "SMESHGUI_RotationDlg.h"
86 #include "SMESHGUI_ScaleDlg.h"
87 #include "SMESHGUI_Selection.h"
88 #include "SMESHGUI_SewingDlg.h"
89 #include "SMESHGUI_SingleEditDlg.h"
90 #include "SMESHGUI_SmoothingDlg.h"
91 #include "SMESHGUI_SpinBox.h"
92 #include "SMESHGUI_SplitBiQuad.h"
93 #include "SMESHGUI_SymmetryDlg.h"
94 #include "SMESHGUI_TranslationDlg.h"
95 #include "SMESHGUI_TransparencyDlg.h"
96 #include "SMESHGUI_Utils.h"
97 #include "SMESHGUI_VTKUtils.h"
99 #include "SMESH_version.h"
101 #include "SMESH_Actor.h"
102 #include "SMESH_ActorUtils.h"
103 #include "SMESH_Client.hxx"
104 #include "SMESH_Comment.hxx"
105 #include "SMESH_ControlsDef.hxx"
106 #include "SMESH_ScalarBarActor.h"
107 #include "SMESH_TypeFilter.hxx"
109 // SALOME GUI includes
110 #include <LightApp_DataOwner.h>
111 #include <LightApp_NameDlg.h>
112 #include <LightApp_Preferences.h>
113 #include <LightApp_SelectionMgr.h>
114 #include <LightApp_UpdateFlags.h>
115 #include <QtxFontEdit.h>
116 #include <QtxPopupMgr.h>
117 #include <QtxInfoPanel.h>
118 #include <SALOME_ListIO.hxx>
119 #include <SUIT_Desktop.h>
120 #include <SUIT_FileDlg.h>
121 #include <SUIT_MessageBox.h>
122 #include <SUIT_OverrideCursor.h>
123 #include <SUIT_ResourceMgr.h>
124 #include <SUIT_Session.h>
125 #include <SVTK_Renderer.h>
126 #include <SVTK_ViewManager.h>
127 #include <SVTK_ViewModel.h>
128 #include <SVTK_ViewWindow.h>
129 #include <SalomeApp_Application.h>
130 #include <SalomeApp_CheckFileDlg.h>
131 #include <SalomeApp_DataObject.h>
132 #include <SalomeApp_Study.h>
133 #include <SalomeApp_Tools.h>
134 #include <VTKViewer_Algorithm.h>
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 <QDialogButtonBox>
156 #include <QTextStream>
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"
177 #include <SALOME_LifeCycleCORBA.hxx>
180 #include <Standard_ErrorHandler.hxx>
181 #include <NCollection_DataMap.hxx>
182 #include <NCollection_DoubleMap.hxx>
184 #include <Basics_Utils.hxx>
186 // Below macro, when uncommented, switches on simplified (more performant) algorithm
187 // of auto-color picking up
188 #define SIMPLE_AUTOCOLOR
193 //=============================================================
194 void ImportMeshesFromFile(SMESH::SMESH_Gen_ptr theComponentMesh,
197 void ExportMeshToFile(int theCommandID);
199 void SetDisplayMode(int theCommandID, VTK::MarkerMap& theMarkerMap);
201 void SetDisplayEntity(int theCommandID);
203 int ActionToControl( int theID, bool theReversed = false );
205 void Control( int theCommandID );
208 //================================================================================
210 * \brief Reads meshes from file
212 //================================================================================
214 void ImportMeshesFromFile( SMESH::SMESH_Gen_ptr theComponentMesh,
218 std::string myExtension;
220 if ( theCommandID == SMESHOp::OpImportMED ||
221 theCommandID == SMESHOp::OpPopupImportMED ) {
222 filter.append( QObject::tr( "MED_FILES_FILTER" ) + " (*.*med)" );
223 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
225 else if ( theCommandID == SMESHOp::OpImportUNV ||
226 theCommandID == SMESHOp::OpPopupImportUNV ) {
227 filter.append( QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)" );
229 else if ( theCommandID == SMESHOp::OpImportDAT ||
230 theCommandID == SMESHOp::OpPopupImportDAT ) {
231 filter.append( QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)" );
233 else if ( theCommandID == SMESHOp::OpImportSTL ||
234 theCommandID == SMESHOp::OpPopupImportSTL ) {
235 filter.append( QObject::tr( "STL_FILES_FILTER" ) + " (*.stl)" );
237 else if ( theCommandID == SMESHOp::OpImportCGNS ||
238 theCommandID == SMESHOp::OpPopupImportCGNS ) {
239 filter.append( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
241 else if ( theCommandID == SMESHOp::OpImportSAUV ||
242 theCommandID == SMESHOp::OpPopupImportSAUV ) {
243 filter.append( QObject::tr( "SAUV_FILES_FILTER" ) + " (*.sauv *.sauve)" );
244 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
246 else if ( theCommandID == SMESHOp::OpImportGMF ||
247 theCommandID == SMESHOp::OpPopupImportGMF ) {
248 filter.append( QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" );
249 filter.append( QObject::tr( "GMF_BINARY_FILES_FILTER") + " (*.meshb)" );
252 QString anInitialPath = "";
253 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
254 anInitialPath = QDir::currentPath();
256 QStringList filenames;
257 bool toCreateGroups = true;
259 // if ( theCommandID == SMESHOp::OpImportGMF ) { // GMF
260 // SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg
261 // ( SMESHGUI::desktop(), true, QObject::tr("SMESH_REQUIRED_GROUPS"), true, true );
262 // fd->setWindowTitle( QObject::tr( "SMESH_IMPORT_MESH" ) );
263 // fd->setNameFilters( filter );
264 // fd->SetChecked( true );
266 // filenames << fd->selectedFile();
267 // toCreateGroups = fd->IsChecked();
273 filenames = SUIT_FileDlg::getOpenFileNames( SMESHGUI::desktop(),
276 QObject::tr( "SMESH_IMPORT_MESH" ) );
278 if ( filenames.count() > 0 )
280 SUIT_OverrideCursor wc;
281 _PTR(Study) aStudy = SMESH::getStudy();
284 QStringList anEntryList;
285 bool isEmpty = false;
286 for ( QStringList::ConstIterator it = filenames.begin(); it != filenames.end(); ++it )
288 QString filename = *it;
289 SMESH::mesh_array_var aMeshes = new SMESH::mesh_array;
291 switch ( theCommandID ) {
292 case SMESHOp::OpImportDAT:
293 case SMESHOp::OpPopupImportDAT:
295 // DAT format (currently unsupported)
296 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
297 arg( QObject::tr( "SMESH_ERR_NOT_SUPPORTED_FORMAT" ) ) );
300 case SMESHOp::OpImportUNV:
301 case SMESHOp::OpPopupImportUNV:
304 aMeshes->length( 1 );
305 aMeshes[0] = theComponentMesh->CreateMeshesFromUNV( filename.toUtf8().constData() );
306 if ( aMeshes[0]->_is_nil() )
307 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
308 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
311 case SMESHOp::OpImportMED:
312 case SMESHOp::OpPopupImportMED:
315 SMESH::DriverMED_ReadStatus res;
316 aMeshes = theComponentMesh->CreateMeshesFromMED( filename.toUtf8().constData(), res );
317 if ( res != SMESH::DRS_OK ) {
318 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
319 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
323 case SMESHOp::OpImportSTL:
324 case SMESHOp::OpPopupImportSTL:
327 aMeshes->length( 1 );
328 aMeshes[0] = theComponentMesh->CreateMeshesFromSTL( filename.toUtf8().constData() );
329 if ( aMeshes[0]->_is_nil() ) {
330 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
331 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
335 case SMESHOp::OpImportCGNS:
336 case SMESHOp::OpPopupImportCGNS:
339 SMESH::DriverMED_ReadStatus res;
340 aMeshes = theComponentMesh->CreateMeshesFromCGNS( filename.toUtf8().constData(), res );
341 if ( res != SMESH::DRS_OK ) {
342 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
343 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
347 case SMESHOp::OpImportSAUV:
348 case SMESHOp::OpPopupImportSAUV:
351 SMESH::DriverMED_ReadStatus res;
352 aMeshes = theComponentMesh->CreateMeshesFromSAUV( filename.toUtf8().constData(), res );
353 if ( res != SMESH::DRS_OK ) {
354 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
355 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
359 case SMESHOp::OpImportGMF:
360 case SMESHOp::OpPopupImportGMF:
363 SMESH::ComputeError_var res;
364 aMeshes->length( 1 );
365 aMeshes[0] = theComponentMesh->CreateMeshesFromGMF( filename.toUtf8().constData(),
368 if ( res->code != SMESH::DRS_OK ) {
369 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
370 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res->code ).toLatin1().data() ) ) );
371 if ( strlen( res->comment.in() ) > 0 ) {
372 errors.back() += ": ";
373 errors.back() += res->comment.in();
380 catch ( const SALOME::SALOME_Exception& S_ex ) {
381 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
382 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
385 for ( int i = 0, iEnd = aMeshes->length(); i < iEnd; i++ )
387 _PTR(SObject) aMeshSO = SMESH::FindSObject( aMeshes[i] );
389 _PTR(StudyBuilder) aBuilder = aStudy->NewBuilder();
390 _PTR(AttributePixMap) aPixmap = aBuilder->FindOrCreateAttribute( aMeshSO, "AttributePixMap" );
391 aPixmap->SetPixMap( "ICON_SMESH_TREE_MESH_IMPORTED" );
392 if ( theCommandID == SMESHOp::OpImportUNV ) // mesh names aren't taken from the file for UNV import
393 SMESH::SetName( aMeshSO, QFileInfo(filename).fileName() );
395 anEntryList.append( aMeshSO->GetID().c_str() );
403 // update Object browser
404 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
406 // browse to the published meshes
407 if( LightApp_Application* anApp =
408 dynamic_cast<LightApp_Application*>( SUIT_Session::session()->activeApplication() ) )
409 anApp->browseObjects( anEntryList );
411 // show Error message box if there were errors
412 if ( errors.count() > 0 ) {
413 SUIT_MessageBox::critical( SMESHGUI::desktop(),
414 QObject::tr( "SMESH_ERROR" ),
415 QObject::tr( "SMESH_IMPORT_ERRORS" ) + "\n" + errors.join( "\n" ) );
418 // show warning message box, if some imported mesh is empty
420 SUIT_MessageBox::warning( SMESHGUI::desktop(),
421 QObject::tr( "SMESH_WRN_WARNING" ),
422 QObject::tr( "SMESH_DRS_SOME_EMPTY" ) );
427 //================================================================================
429 * \brief Export selected meshes or groups into a file
431 //================================================================================
433 void ExportMeshToFile( int theCommandID )
435 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
436 SALOME_ListIO selected;
438 aSel->selectedObjects( selected );
440 const bool isDAT = ( theCommandID == SMESHOp::OpExportDAT ||
441 theCommandID == SMESHOp::OpPopupExportDAT );
442 const bool isMED = ( theCommandID == SMESHOp::OpExportMED ||
443 theCommandID == SMESHOp::OpPopupExportMED );
444 const bool isUNV = ( theCommandID == SMESHOp::OpExportUNV ||
445 theCommandID == SMESHOp::OpPopupExportUNV );
446 const bool isSTL = ( theCommandID == SMESHOp::OpExportSTL ||
447 theCommandID == SMESHOp::OpPopupExportSTL );
448 const bool isCGNS= ( theCommandID == SMESHOp::OpExportCGNS ||
449 theCommandID == SMESHOp::OpPopupExportCGNS );
450 const bool isSAUV= ( theCommandID == SMESHOp::OpExportSAUV ||
451 theCommandID == SMESHOp::OpPopupExportSAUV );
452 const bool isGMF = ( theCommandID == SMESHOp::OpExportGMF ||
453 theCommandID == SMESHOp::OpPopupExportGMF );
455 const bool multiMeshSupported = ( isMED || isCGNS ); // file can hold several meshes
456 if ( selected.Extent() == 0 || ( selected.Extent() > 1 && !multiMeshSupported ))
458 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
459 bool aCheckWarn = true;
461 aCheckWarn = resMgr->booleanValue( "SMESH", "show_warning", false );
462 // get mesh object from selection and check duplication of their names
463 bool hasDuplicatedMeshNames = false;
464 QList< QPair< SMESH::SMESH_IDSource_var, QString > > aMeshList;
465 QList< QPair< SMESH::SMESH_IDSource_var, QString > >::iterator aMeshIter;
466 SALOME_ListIteratorOfListIO It( selected );
467 for( ; It.More(); It.Next() )
469 Handle(SALOME_InteractiveObject) anIObject = It.Value();
470 SMESH::SMESH_IDSource_var aMeshItem =
471 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIObject);
472 if ( aMeshItem->_is_nil() ) {
473 SUIT_MessageBox::warning( SMESHGUI::desktop(),
474 QObject::tr( "SMESH_WRN_WARNING" ),
475 QObject::tr( "SMESH_BAD_MESH_SELECTION" ));
478 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( aMeshItem );
479 if ( aCheckWarn && !aGroup->_is_nil() )
481 QMessageBox msgBox(SUIT_MessageBox::Warning,
482 QObject::tr("SMESH_WRN_WARNING"),
483 QObject::tr("SMESH_EXPORT_ONLY_GPOUP"),
484 QMessageBox::StandardButton::NoButton,
485 SMESHGUI::desktop());
486 QCheckBox dontShowCheckBox(QObject::tr("SMESH_WRN_SHOW_DLG_CHECKBOX"));
487 msgBox.addButton(QMessageBox::Ok);
488 msgBox.addButton(QMessageBox::Cancel);
489 msgBox.setDefaultButton(QMessageBox::Cancel);
490 QGridLayout* lt = qobject_cast<QGridLayout*>(msgBox.layout());
491 QDialogButtonBox* btnbox = msgBox.findChild<QDialogButtonBox*>();
492 lt->addWidget(&dontShowCheckBox, lt->rowCount(), lt->columnCount()-1, lt->rowCount(), lt->columnCount());
493 lt->addWidget(btnbox, lt->rowCount(), 0, lt->rowCount(), lt->columnCount());
494 if ( msgBox.exec() != QMessageBox::Ok )
497 if ( dontShowCheckBox.checkState() == Qt::Checked && resMgr )
498 resMgr->setValue( "SMESH", "show_warning", false);
501 QString aMeshName = anIObject->getName();
503 // check for name duplications
504 if ( !hasDuplicatedMeshNames )
505 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
506 if( aMeshName == (*aMeshIter).second ) {
507 hasDuplicatedMeshNames = true;
512 aMeshList.append( QPair< SMESH::SMESH_IDSource_var, QString >( aMeshItem, aMeshName ) );
515 if( hasDuplicatedMeshNames && isMED ) {
516 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
517 QObject::tr("SMESH_WRN_WARNING"),
518 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_MESH_NAMES"),
519 QObject::tr("SMESH_BUT_YES"),
520 QObject::tr("SMESH_BUT_NO"), 0, 1);
525 aMeshIter = aMeshList.begin();
526 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
527 SMESH::SMESH_Mesh_var aMesh = aMeshOrGroup->GetMesh();
528 QString aMeshName = (*aMeshIter).second;
530 if ( isMED || isCGNS || isSAUV ) // formats where group names must be unique
532 // check for equal group names within each mesh
533 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
534 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
535 if ( !aMeshItem->_is_nil() && aMeshItem->HasDuplicatedGroupNamesMED()) {
536 int aRet = SUIT_MessageBox::warning
537 (SMESHGUI::desktop(),
538 QObject::tr("SMESH_WRN_WARNING"),
539 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_GRP").arg((*aMeshIter).second),
540 QObject::tr("SMESH_BUT_YES"),
541 QObject::tr("SMESH_BUT_NO"), 0, 1);
548 // Warn the user about presence of not supported elements
550 std::vector< SMESH::EntityType > notSupportedElemTypes, presentNotSupported;
554 notSupportedElemTypes.push_back( SMESH::Entity_0D );
555 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
560 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
561 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
562 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
563 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
564 notSupportedElemTypes.push_back( SMESH::Entity_Pyramid );
565 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
566 notSupportedElemTypes.push_back( SMESH::Entity_0D );
567 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
572 notSupportedElemTypes.push_back( SMESH::Entity_Edge );
573 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Edge );
574 notSupportedElemTypes.push_back( SMESH::Entity_0D );
575 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
580 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
585 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
586 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Triangle );
587 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Quadrangle );
588 notSupportedElemTypes.push_back( SMESH::Entity_TriQuad_Hexa );
589 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
590 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
591 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
592 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
597 notSupportedElemTypes.push_back( SMESH::Entity_0D );
598 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
599 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
600 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Pyramid );
601 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Penta );
602 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Penta );
603 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
604 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
605 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
606 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
608 if ( ! notSupportedElemTypes.empty() )
610 SMESH::long_array_var nbElems = aMeshOrGroup->GetMeshInfo();
611 for ( size_t iType = 0; iType < notSupportedElemTypes.size(); ++iType )
612 if ( nbElems[ notSupportedElemTypes[ iType ]] > 0 )
613 presentNotSupported.push_back( notSupportedElemTypes[ iType ]);
615 if ( !presentNotSupported.empty() )
618 const char* typeMsg[] = {
619 "SMESH_NODES", "SMESH_ELEMS0D","SMESH_EDGES","SMESH_QUADRATIC_EDGES",
620 "SMESH_TRIANGLES", "SMESH_QUADRATIC_TRIANGLES", "SMESH_BIQUADRATIC_TRIANGLES",
621 "SMESH_QUADRANGLES","SMESH_QUADRATIC_QUADRANGLES", "SMESH_BIQUADRATIC_QUADRANGLES",
622 "SMESH_POLYGONS","SMESH_QUADRATIC_POLYGONS",
623 "SMESH_TETRAHEDRA","SMESH_QUADRATIC_TETRAHEDRONS","SMESH_PYRAMIDS",
624 "SMESH_QUADRATIC_PYRAMIDS","SMESH_HEXAHEDRA","SMESH_QUADRATIC_HEXAHEDRONS",
625 "SMESH_TRIQUADRATIC_HEXAHEDRONS","SMESH_PENTAHEDRA","SMESH_QUADRATIC_PENTAHEDRONS",
626 "SMESH_BIQUADRATIC_PENTAHEDRONS",
627 "SMESH_OCTAHEDRA","SMESH_POLYEDRONS","SMESH_QUADRATIC_POLYEDRONS","SMESH_BALLS"
629 // is typeMsg complete? (compilation failure mains that enum SMDSAbs_EntityType changed)
630 const int nbTypes = sizeof( typeMsg ) / sizeof( const char* );
631 int _assert[( nbTypes == SMESH::Entity_Last ) ? 2 : -1 ]; _assert[0]=_assert[1]=0;
633 QString andStr = " " + QObject::tr("SMESH_AND") + " ", comma(", ");
634 for ( size_t iType = 0; iType < presentNotSupported.size(); ++iType ) {
635 typeNames += QObject::tr( typeMsg[ presentNotSupported[ iType ]]);
636 if ( iType != presentNotSupported.size() - 1 )
637 typeNames += ( iType == presentNotSupported.size() - 2 ) ? andStr : comma;
639 int aRet = SUIT_MessageBox::warning
640 (SMESHGUI::desktop(),
641 QObject::tr("SMESH_WRN_WARNING"),
642 QObject::tr("EXPORT_NOT_SUPPORTED").arg(aMeshName).arg(format).arg(typeNames),
643 QObject::tr("SMESH_BUT_YES"),
644 QObject::tr("SMESH_BUT_NO"), 0, 1);
649 // Get parameters of export operation
652 int aFormat =-1; // for MED version used for write
653 bool isOkToWrite = true; // to check MED file version compatibility before adding a mesh in an existing file
655 // Init the parameters with the default values
656 bool aIsASCII_STL = true;
657 bool toCreateGroups = false;
659 toCreateGroups = resMgr->booleanValue( "SMESH", "auto_groups", false );
660 bool toOverwrite = true;
661 bool toFindOutDim = true;
662 double zTol = resMgr ? resMgr->doubleValue( "SMESH", "med_ztolerance", 0. ) : 0.;
664 QString aFilter, aTitle = QObject::tr("SMESH_EXPORT_MESH");
665 QString anInitialPath = "";
666 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
667 anInitialPath = QDir::currentPath();
669 QList< QPair< GEOM::ListOfFields_var, QString > > aFieldList;
671 // Get a file name to write in and additional options
672 if ( isUNV || isDAT || isGMF ) // Export w/o options
675 aFilter = QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)";
677 aFilter = QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)";
679 aFilter = QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" +
680 ";;" + QObject::tr( "GMF_BINARY_FILES_FILTER" ) + " (*.meshb)";
681 if ( anInitialPath.isEmpty() ) anInitialPath = SUIT_FileDlg::getLastVisitedPath();
682 aFilename = SUIT_FileDlg::getFileName(SMESHGUI::desktop(),
683 anInitialPath + QString("/") + aMeshName,
684 aFilter, aTitle, false);
686 else if ( isCGNS )// Export to CGNS
688 const char* theByTypeResource = "cgns_group_elems_by_type";
689 toCreateGroups = SMESHGUI::resourceMgr()->booleanValue( "SMESH", theByTypeResource, false );
691 QStringList checkBoxes;
692 checkBoxes << QObject::tr("CGNS_EXPORT_ELEMS_BY_TYPE");
694 SalomeApp_CheckFileDlg* fd =
695 new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true );
696 fd->setWindowTitle( aTitle );
697 fd->setNameFilter( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
698 if ( !anInitialPath.isEmpty() )
699 fd->setDirectory( anInitialPath );
700 fd->selectFile(aMeshName);
701 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
702 fd->setValidator( fv );
703 fd->SetChecked( toCreateGroups, 0 );
706 aFilename = fd->selectedFile();
707 toOverwrite = fv->isOverwrite(aFilename);
708 toCreateGroups = fd->IsChecked(0);
709 SMESHGUI::resourceMgr()->setValue("SMESH", theByTypeResource, toCreateGroups );
713 else if ( isSTL ) // Export to STL
715 QMap<QString, int> aFilterMap;
716 aFilterMap.insert( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)", 1 );
717 aFilterMap.insert( QObject::tr( "STL_BIN_FILES_FILTER" ) + " (*.stl)", 0 );
720 QMap<QString, int>::const_iterator it = aFilterMap.begin();
721 for ( ; it != aFilterMap.end(); ++it )
722 filters.push_back( it.key() );
724 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
725 fd->setWindowTitle( aTitle );
726 fd->setNameFilters( filters );
727 fd->selectNameFilter( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
728 if ( !anInitialPath.isEmpty() )
729 fd->setDirectory( anInitialPath );
730 fd->selectFile(aMeshName);
734 aFilename = fd->selectedFile();
735 aIsASCII_STL = (aFilterMap[fd->selectedNameFilter()]) == 1 ? true: false;
740 else if ( isMED || isSAUV ) // Export to MED or SAUV
742 int defaultVersion = 0;
743 QMap<QString, int> aFilterMap;
745 //filters << QObject::tr( "MED_FILES_FILTER" ) + " (*.med)";
746 //QString vmed (aMesh->GetVersionString(-1, 2));
747 SMESH::long_array_var mvok = aMesh->GetMEDVersionsCompatibleForAppend();
748 if ( mvok->length() > 0)
749 defaultVersion = mvok[0]; // the current version to set the default filter on it
750 for ( CORBA::ULong i = 0; i < mvok->length(); ++i )
752 QString vs = (char*)( SMESH_Comment( mvok[i]/10 ) << "." << mvok[i]%10 );
753 MESSAGE("MED version: " << vs.toStdString());
754 aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( vs ) + " (*.med)", mvok[i]);
758 aFilterMap.insert("All files (*)", -1 );
759 aFilterMap.insert("SAUV files (*.sauv)", defaultVersion ); // 0 = default filter (defaultVersion)
760 aFilterMap.insert("SAUV files (*.sauve)", -1 );
763 QMap<QString, int>::const_iterator it = aFilterMap.begin();
764 QString aDefaultFilter = it.key();
765 for ( ; it != aFilterMap.end(); ++it ) {
766 filters.push_back( it.key() );
767 if (it.value() == defaultVersion) // explicit default for MED = current MED version
768 aDefaultFilter = it.key();
770 QStringList checkBoxes;
771 checkBoxes << QObject::tr("SMESH_AUTO_GROUPS") << QObject::tr("SMESH_AUTO_DIM");
773 SMESHGUI_FieldSelectorWdg* fieldSelWdg = new SMESHGUI_FieldSelectorWdg();
774 QList< QWidget* > wdgList;
775 if ( fieldSelWdg->GetAllFields( aMeshList, aFieldList ))
776 wdgList.append( fieldSelWdg );
778 QWidget* zTolWdg = new QWidget();
779 QCheckBox* zTolCheck = new QCheckBox( QObject::tr( "SMESH_ZTOLERANCE" ), zTolWdg );
780 SMESHGUI_SpinBox* zTolSpin = new SMESHGUI_SpinBox( zTolWdg );
781 QHBoxLayout* zTolLayout = new QHBoxLayout( zTolWdg );
782 zTolLayout->addWidget( zTolCheck );
783 zTolLayout->addWidget( zTolSpin );
784 zTolLayout->setMargin( 0 );
785 zTolSpin->RangeStepAndValidator( 0, 1e+100, 1., "length_precision" );
786 zTolSpin->setValue( zTol );
787 QObject::connect( zTolCheck, SIGNAL( toggled(bool)), zTolSpin, SLOT( setEnabled(bool)));
788 zTolCheck->setChecked( resMgr->booleanValue( "SMESH", "enable_ztolerance", false ));
789 zTolSpin ->setEnabled( zTolCheck->isChecked() );
790 wdgList.append( zTolWdg );
792 SalomeApp_CheckFileDlg* fd =
793 new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true, wdgList );
794 fd->setWindowTitle( aTitle );
795 fd->setNameFilters( filters );
796 fd->selectNameFilter( aDefaultFilter );
797 fd->SetChecked( toCreateGroups, 0 );
798 fd->SetChecked( toFindOutDim, 1 );
799 if ( !anInitialPath.isEmpty() )
800 fd->setDirectory( anInitialPath );
801 fd->selectFile(aMeshName);
804 QListView *lview = fd->findChild<QListView*>("listView");
806 lview->setMinimumHeight(200);
808 QTreeView *tview = fd->findChild<QTreeView*>("treeView");
810 tview->setMinimumHeight(200);
813 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
814 fd->setValidator( fv );
819 //MESSAGE("******* Loop on file dialog ***********");
822 aFilename = fd->selectedFile();
824 aFilename = QString::null;
827 aFormat = aFilterMap[fd->selectedNameFilter()];
828 //MESSAGE("selected version: " << aFormat << " file: " << aFilename.toUtf8().constData());
829 toOverwrite = fv->isOverwrite(aFilename);
830 //MESSAGE("toOverwrite:" << toOverwrite);
832 if ( !aFilename.isEmpty() ) {
834 // append is only possible if the existing file format is compatible
835 bool isVersionOk = SMESHGUI::GetSMESHGen()->CheckWriteCompatibility( aFilename.toUtf8().constData() );
836 MESSAGE("Append check, isVersionOk:" << isVersionOk);
837 if ( !isVersionOk ) {
838 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
839 QObject::tr("SMESH_WRN_WARNING"),
840 QObject::tr("SMESH_EXPORT_MED_VERSION_COLLISION").arg(aFilename),
841 QObject::tr("SMESH_BUT_YES"),
842 QObject::tr("SMESH_BUT_NO"), 0, 1);
846 //MESSAGE("incompatible MED file version for add, overwrite accepted");
852 //MESSAGE("incompatible MED file version for add, overwrite refused");
855 QStringList aMeshNamesCollisionList;
856 SMESH::string_array_var aMeshNames = SMESHGUI::GetSMESHGen()->GetMeshNames( aFilename.toUtf8().constData() );
857 for( int i = 0, n = aMeshNames->length(); i < n; i++ ) {
858 QString anExistingMeshName( aMeshNames[ i ] );
859 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
860 QString anExportMeshName = (*aMeshIter).second;
861 if( anExportMeshName == anExistingMeshName ) {
862 aMeshNamesCollisionList.append( anExportMeshName );
867 if( !aMeshNamesCollisionList.isEmpty() ) {
869 QString aMeshNamesCollisionString = aMeshNamesCollisionList.join( ", " );
870 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
871 QObject::tr("SMESH_WRN_WARNING"),
872 QObject::tr("SMESH_EXPORT_MED_MESH_NAMES_COLLISION").arg(aMeshNamesCollisionString),
873 QObject::tr("SMESH_BUT_YES"),
874 QObject::tr("SMESH_BUT_NO"),
875 QObject::tr("SMESH_BUT_CANCEL"), 0, 2);
876 MESSAGE("answer collision name " << aRet);
887 toCreateGroups = fd->IsChecked(0);
888 toFindOutDim = fd->IsChecked(1);
889 zTol = zTolCheck->isChecked() ? zTolSpin->value() : -1;
890 fieldSelWdg->GetSelectedFields();
891 if ( resMgr ) resMgr->setValue( "SMESH", "enable_ztolerance", zTolCheck->isChecked() );
893 if ( !fieldSelWdg->parent() )
895 if ( !zTolWdg->parent() )
906 if ( !aFilename.isEmpty() ) {
907 // Check whether the file already exists and delete it if yes
908 QFile aFile( aFilename );
909 if ( aFile.exists() && toOverwrite )
911 SUIT_OverrideCursor wc;
914 // Renumbering is not needed since SMDS redesign in V6.2.0 (Nov 2010)
915 // bool Renumber = false;
916 // // PAL 14172 : Check of we have to renumber or not from the preferences before export
918 // Renumber= resMgr->booleanValue("renumbering");
920 // SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
921 // aMeshEditor->RenumberNodes();
922 // aMeshEditor->RenumberElements();
923 // if ( SMESHGUI::automaticUpdate() )
924 // SMESH::UpdateView();
926 if ( isMED && isOkToWrite)
928 MESSAGE("OK to write MED file "<< aFilename.toUtf8().constData());
929 aMeshIter = aMeshList.begin();
930 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
932 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
933 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
934 const GEOM::ListOfFields& fields = aFieldList[ aMeshIndex ].first.in();
935 const QString& geoAssFields = aFieldList[ aMeshIndex ].second;
936 const bool hasFields = ( fields.length() || !geoAssFields.isEmpty() );
937 if ( !hasFields && aMeshOrGroup->_is_equivalent( aMeshItem ) && zTol < 0 )
938 aMeshItem->ExportMED( aFilename.toUtf8().data(), toCreateGroups, aFormat,
939 toOverwrite && aMeshIndex == 0, toFindOutDim );
941 aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toUtf8().data(),
942 toCreateGroups, aFormat,
943 toOverwrite && aMeshIndex == 0, toFindOutDim,
944 fields, geoAssFields.toLatin1().data(), zTol );
949 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ )
951 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
952 if( !aMeshItem->_is_nil() )
953 aMeshItem->ExportSAUV( aFilename.toUtf8().data(), toCreateGroups );
958 if ( aMeshOrGroup->_is_equivalent( aMesh ))
959 aMesh->ExportDAT( aFilename.toUtf8().data() );
961 aMesh->ExportPartToDAT( aMeshOrGroup, aFilename.toUtf8().data() );
965 if ( aMeshOrGroup->_is_equivalent( aMesh ))
966 aMesh->ExportUNV( aFilename.toUtf8().data() );
968 aMesh->ExportPartToUNV( aMeshOrGroup, aFilename.toUtf8().data() );
972 if ( aMeshOrGroup->_is_equivalent( aMesh ))
973 aMesh->ExportSTL( aFilename.toUtf8().data(), aIsASCII_STL );
975 aMesh->ExportPartToSTL( aMeshOrGroup, aFilename.toUtf8().data(), aIsASCII_STL );
979 aMeshIter = aMeshList.begin();
980 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
982 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
983 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
984 aMeshItem->ExportCGNS( aMeshOrGroup,
985 aFilename.toUtf8().data(),
986 toOverwrite && aMeshIndex == 0,
992 toCreateGroups = true;
993 aMesh->ExportGMF( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups );
996 catch (const SALOME::SALOME_Exception& S_ex){
998 SUIT_MessageBox::warning(SMESHGUI::desktop(),
999 QObject::tr("SMESH_WRN_WARNING"),
1000 QObject::tr("SMESH_EXPORT_FAILED") + SalomeApp_Tools::ExceptionToString(S_ex));
1006 inline void InverseEntityMode(unsigned int& theOutputMode,
1007 unsigned int theMode)
1009 bool anIsNotPresent = ~theOutputMode & theMode;
1011 theOutputMode |= theMode;
1013 theOutputMode &= ~theMode;
1016 void SetDisplayEntity(int theCommandID)
1018 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1019 SALOME_ListIO selected;
1021 aSel->selectedObjects( selected );
1023 if ( selected.Extent() >= 1 ) {
1024 SUIT_OverrideCursor wc;
1025 SALOME_ListIteratorOfListIO It( selected );
1026 for( ; It.More(); It.Next()){
1027 Handle(SALOME_InteractiveObject) IObject = It.Value();
1028 if(IObject->hasEntry()){
1029 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1030 unsigned int aMode = anActor->GetEntityMode();
1031 switch(theCommandID){
1032 case SMESHOp::OpDE0DElements: InverseEntityMode(aMode,SMESH_Actor::e0DElements); break;
1033 case SMESHOp::OpDEEdges: InverseEntityMode(aMode,SMESH_Actor::eEdges); break;
1034 case SMESHOp::OpDEFaces: InverseEntityMode(aMode,SMESH_Actor::eFaces); break;
1035 case SMESHOp::OpDEVolumes: InverseEntityMode(aMode,SMESH_Actor::eVolumes); break;
1036 case SMESHOp::OpDEBalls: InverseEntityMode(aMode,SMESH_Actor::eBallElem); break;
1037 case SMESHOp::OpDEAllEntity: aMode = SMESH_Actor::eAllEntity; break;
1040 anActor->SetEntityMode(aMode);
1049 SalomeApp_Application* app =
1050 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1054 LightApp_SelectionMgr* aSel = app->selectionMgr();
1055 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1056 if ( !aSel || !appStudy )
1059 SALOME_ListIO selected;
1060 aSel->selectedObjects( selected );
1061 if ( selected.IsEmpty() )
1064 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1066 _PTR(Study) aStudy = appStudy->studyDS();
1067 _PTR(SObject) aMainSObject = aStudy->FindObjectID( anIObject->getEntry() );
1068 SMESH::SMESH_Mesh_var aMainObject = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1069 if ( aMainObject->_is_nil() )
1072 SUIT_OverrideCursor wc;
1074 aMainObject->SetAutoColor( true ); // mesh groups are re-colored here
1076 QList<SALOMEDS::Color> aReservedColors;
1078 SMESH::ListOfGroups aListOfGroups = *aMainObject->GetGroups();
1079 for ( int i = 0, n = aListOfGroups.length(); i < n; i++ )
1081 SMESH::SMESH_GroupBase_var aGroupObject = aListOfGroups[i];
1083 #ifdef SIMPLE_AUTOCOLOR // simplified algorithm for auto-colors
1084 SALOMEDS::Color aColor = SMESHGUI::getPredefinedUniqueColor();
1085 #else // old algorithm for auto-colors
1086 SALOMEDS::Color aColor = SMESHGUI::getUniqueColor( aReservedColors );
1087 aReservedColors.append( aColor );
1088 #endif // SIMPLE_AUTOCOLOR
1089 aGroupObject->SetColor( aColor );
1091 _PTR(SObject) aGroupSObject = SMESH::FindSObject(aGroupObject);
1092 if ( aGroupSObject ) {
1095 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry(aGroupSObject->GetID().c_str())) {
1096 switch ( aGroupObject->GetType ()) {
1098 anActor->SetNodeColor( aColor.R, aColor.G, aColor.B ); break;
1100 anActor->SetEdgeColor( aColor.R, aColor.G, aColor.B ); break;
1102 anActor->Set0DColor( aColor.R, aColor.G, aColor.B ); break;
1104 anActor->SetBallColor( aColor.R, aColor.G, aColor.B ); break;
1106 SMESH::GetColor("SMESH", "volume_color", c, delta, "255,0,170|-100");
1107 anActor->SetVolumeColor( aColor.R, aColor.G, aColor.B, delta ); break;
1110 SMESH::GetColor("SMESH", "fill_color", c, delta, "0,170,255|-100");
1111 anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B, delta );
1117 SMESH::RepaintCurrentView();
1120 void OverallMeshQuality()
1122 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1123 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1124 SALOME_ListIO selected;
1126 aSel->selectedObjects( selected );
1128 if ( selected.IsEmpty() ) return;
1129 SALOME_ListIteratorOfListIO It( selected );
1130 for ( ; It.More(); It.Next() ) {
1131 SMESHGUI_CtrlInfoDlg* ctrlDlg = new SMESHGUI_CtrlInfoDlg( SMESHGUI::desktop() );
1132 ctrlDlg->showInfo( It.Value() );
1137 QString functorToString( SMESH::Controls::FunctorPtr f )
1139 QString type = QObject::tr( "UNKNOWN_CONTROL" );
1140 if ( dynamic_cast< SMESH::Controls::Volume* >( f.get() ) )
1141 type = QObject::tr( "VOLUME_3D_ELEMENTS" );
1142 else if ( dynamic_cast< SMESH::Controls::MaxElementLength2D* >( f.get() ) )
1143 type = QObject::tr( "MAX_ELEMENT_LENGTH_2D" );
1144 else if ( dynamic_cast< SMESH::Controls::MaxElementLength3D* >( f.get() ) )
1145 type = QObject::tr( "MAX_ELEMENT_LENGTH_3D" );
1146 else if ( dynamic_cast< SMESH::Controls::MinimumAngle* >( f.get() ) )
1147 type = QObject::tr( "MINIMUMANGLE_ELEMENTS" );
1148 else if ( dynamic_cast< SMESH::Controls::AspectRatio* >( f.get() ) )
1149 type = QObject::tr( "ASPECTRATIO_ELEMENTS" );
1150 else if ( dynamic_cast< SMESH::Controls::AspectRatio3D* >( f.get() ) )
1151 type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" );
1152 else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) )
1153 type = QObject::tr( "WARP_ELEMENTS" );
1154 else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) )
1155 type = QObject::tr( "TAPER_ELEMENTS" );
1156 else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) )
1157 type = QObject::tr( "SKEW_ELEMENTS" );
1158 else if ( dynamic_cast< SMESH::Controls::Area* >( f.get() ) )
1159 type = QObject::tr( "AREA_ELEMENTS" );
1160 else if ( dynamic_cast< SMESH::Controls::Length* >( f.get() ) )
1161 type = QObject::tr( "LENGTH_EDGES" );
1162 else if ( dynamic_cast< SMESH::Controls::Length2D* >( f.get() ) )
1163 type = QObject::tr( "LENGTH2D_EDGES" );
1164 else if ( dynamic_cast< SMESH::Controls::Deflection2D* >( f.get() ) )
1165 type = QObject::tr( "DEFLECTION2D_FACES" );
1166 else if ( dynamic_cast< SMESH::Controls::MultiConnection* >( f.get() ) )
1167 type = QObject::tr( "MULTI_BORDERS" );
1168 else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) )
1169 type = QObject::tr( "MULTI2D_BORDERS" );
1170 else if ( dynamic_cast< SMESH::Controls::FreeNodes* >( f.get() ) )
1171 type = QObject::tr( "FREE_NODES" );
1172 else if ( dynamic_cast< SMESH::Controls::FreeEdges* >( f.get() ) )
1173 type = QObject::tr( "FREE_EDGES" );
1174 else if ( dynamic_cast< SMESH::Controls::FreeBorders* >( f.get() ) )
1175 type = QObject::tr( "FREE_BORDERS" );
1176 else if ( dynamic_cast< SMESH::Controls::FreeFaces* >( f.get() ) )
1177 type = QObject::tr( "FREE_FACES" );
1178 else if ( dynamic_cast< SMESH::Controls::BareBorderVolume* >( f.get() ) )
1179 type = QObject::tr( "BARE_BORDER_VOLUME" );
1180 else if ( dynamic_cast< SMESH::Controls::BareBorderFace* >( f.get() ) )
1181 type = QObject::tr( "BARE_BORDER_FACE" );
1182 else if ( dynamic_cast< SMESH::Controls::OverConstrainedVolume* >( f.get() ) )
1183 type = QObject::tr( "OVER_CONSTRAINED_VOLUME" );
1184 else if ( dynamic_cast< SMESH::Controls::OverConstrainedFace* >( f.get() ) )
1185 type = QObject::tr( "OVER_CONSTRAINED_FACE" );
1186 else if ( dynamic_cast< SMESH::Controls::CoincidentNodes* >( f.get() ) )
1187 type = QObject::tr( "EQUAL_NODE" );
1188 else if ( dynamic_cast< SMESH::Controls::CoincidentElements1D* >( f.get() ) )
1189 type = QObject::tr( "EQUAL_EDGE" );
1190 else if ( dynamic_cast< SMESH::Controls::CoincidentElements2D* >( f.get() ) )
1191 type = QObject::tr( "EQUAL_FACE" );
1192 else if ( dynamic_cast< SMESH::Controls::CoincidentElements3D* >( f.get() ) )
1193 type = QObject::tr( "EQUAL_VOLUME" );
1194 else if ( dynamic_cast< SMESH::Controls::NodeConnectivityNumber* >( f.get() ) )
1195 type = QObject::tr( "NODE_CONNECTIVITY_NB" );
1199 void SaveDistribution()
1201 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1202 SALOME_ListIO selected;
1204 aSel->selectedObjects( selected );
1206 if ( selected.Extent() == 1 ) {
1207 Handle(SALOME_InteractiveObject) anIO = selected.First();
1208 if ( anIO->hasEntry() ) {
1209 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1211 anActor->GetScalarBarActor() &&
1212 anActor->GetControlMode() != SMESH_Actor::eNone )
1214 SMESH_ScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor();
1215 SMESH::Controls::FunctorPtr aFunctor = anActor->GetFunctor();
1216 if ( aScalarBarActor && aFunctor ) {
1217 SMESH::Controls::NumericalFunctor* aNumFun =
1218 dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
1220 std::vector<int> elements;
1221 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
1222 if ( mesh->_is_nil() ) {
1223 SMESH::SMESH_IDSource_var idSource =
1224 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
1225 if ( !idSource->_is_nil() )
1227 SMESH::long_array_var ids = idSource->GetIDs();
1228 elements.resize( ids->length() );
1229 for ( unsigned i = 0; i < elements.size(); ++i )
1230 elements[i] = ids[i];
1233 int nbIntervals = aScalarBarActor->GetMaximumNumberOfColors();
1234 vtkLookupTable* lookupTable =
1235 static_cast<vtkLookupTable*>(aScalarBarActor->GetLookupTable());
1236 double * minmax = lookupTable->GetRange();
1237 bool isLogarithmic = lookupTable->GetScale() == VTK_SCALE_LOG10;
1238 std::vector<int> nbEvents;
1239 std::vector<double> funValues;
1240 aNumFun->GetHistogram( nbIntervals, nbEvents, funValues,
1241 elements, minmax, isLogarithmic );
1242 QString anInitialPath = "";
1243 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
1244 anInitialPath = QDir::currentPath();
1245 QString aMeshName = anIO->getName();
1247 filter.append( QObject::tr( "TEXT_FILES_FILTER" ) + " (*.txt)" );
1248 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
1249 QString aFilename = anInitialPath + "/" + aMeshName + "_" +
1250 functorToString( aFunctor ).toLower().simplified().replace( QRegExp( " |-" ), "_" ) + ".txt";
1251 aFilename = SUIT_FileDlg::getFileName( SMESHGUI::desktop(),
1254 QObject::tr( "SMESH_SAVE_DISTRIBUTION" ),
1256 if ( !aFilename.isEmpty() ) {
1257 QFile f( aFilename );
1258 if ( f.open( QFile::WriteOnly | QFile::Truncate ) ) {
1259 QTextStream out( &f );
1260 out << "# Mesh: " << aMeshName << endl;
1261 out << "# Control: " << functorToString( aFunctor ) << endl;
1263 out.setFieldWidth( 10 );
1264 for ( int i = 0; i < (int)qMin( nbEvents.size(), funValues.size()-1 ); i++ )
1265 out << funValues[i] << "\t" << funValues[i+1] << "\t" << nbEvents[i] << endl;
1276 void ShowElement( int theCommandID )
1278 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1279 SALOME_ListIO selected;
1281 aSel->selectedObjects( selected );
1283 if ( selected.Extent() == 1 ) {
1284 Handle(SALOME_InteractiveObject) anIO = selected.First();
1285 if ( anIO->hasEntry() ) {
1286 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1288 anActor->GetScalarBarActor() &&
1289 anActor->GetControlMode() != SMESH_Actor::eNone )
1291 SMESH_ScalarBarActor *aScalarBarActor = anActor->GetScalarBarActor();
1292 if ( theCommandID == SMESHOp::OpShowDistribution ) {
1293 aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility());
1295 else if ( theCommandID == SMESHOp::OpShowScalarBar ) {
1296 aScalarBarActor->SetVisibility( !aScalarBarActor->GetVisibility());
1303 #ifndef DISABLE_PLOT2DVIEWER
1304 void PlotDistribution()
1306 SalomeApp_Application* app =
1307 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1311 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1312 SALOME_ListIO selected;
1314 aSel->selectedObjects( selected );
1316 if ( selected.Extent() == 1 ) {
1317 Handle(SALOME_InteractiveObject) anIO = selected.First();
1318 if ( anIO->hasEntry() ) {
1319 //Find Actor by entry before getting Plot2d viewer,
1320 //because after call getViewManager( Plot2d_Viewer::Type(), true ) active window is Plot2d Viewer
1321 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1323 SUIT_ViewManager* aViewManager =
1324 app->getViewManager( Plot2d_Viewer::Type(), true ); // create if necessary
1328 SPlot2d_Viewer* aView = dynamic_cast<SPlot2d_Viewer*>(aViewManager->getViewModel());
1332 Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
1336 if ( anActor && anActor->GetControlMode() != SMESH_Actor::eNone )
1338 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1339 QString functorName = functorToString( anActor->GetFunctor());
1340 QString aHistogramName("%1 : %2");
1341 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1342 aHistogram->setName(aHistogramName);
1343 aHistogram->setHorTitle(functorName);
1344 aHistogram->setVerTitle(QObject::tr("DISTRIBUTION_NB_ENT"));
1345 aPlot->displayObject(aHistogram, true);
1350 #endif //DISABLE_PLOT2DVIEWER
1352 void DisableAutoColor()
1354 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1355 SALOME_ListIO selected;
1357 aSel->selectedObjects( selected );
1359 if ( selected.Extent() ) {
1360 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1361 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1362 if ( !aMesh->_is_nil() ) {
1363 aMesh->SetAutoColor( false );
1370 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1371 SALOME_ListIO selected;
1373 aSel->selectedObjects( selected );
1374 if ( selected.Extent() )
1376 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1377 _PTR(Study) aStudy = SMESH::getStudy();
1378 _PTR(SObject) aSObj = aStudy->FindObjectID(anIObject->getEntry());
1380 if ( aStudy->GetUseCaseBuilder()->SortChildren( aSObj, true/*AscendingOrder*/ ) ) {
1381 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1388 // Break link with Shaper model
1389 void breakShaperLink()
1391 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1392 SALOME_ListIO selected;
1394 aSel->selectedObjects(selected);
1395 if (selected.Extent()) {
1396 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1397 _PTR(Study) aStudy = SMESH::getStudy();
1398 std::string aEntry = anIObject->getEntry();
1399 _PTR(SObject) aSObj = aStudy->FindObjectID(aEntry);
1401 std::string aName = aSObj->GetName();
1402 QMessageBox::StandardButton aRes = SUIT_MessageBox::warning(SMESHGUI::desktop(),
1403 QObject::tr("SMESH_WRN_WARNING"),
1404 QObject::tr("MSG_BREAK_SHAPER_LINK").arg(aName.c_str()),
1405 SUIT_MessageBox::Yes | SUIT_MessageBox::No, SUIT_MessageBox::No);
1406 if (aRes == SUIT_MessageBox::Yes) {
1407 SUIT_DataOwnerPtrList aList;
1408 aSel->selected(aList, "ObjectBrowser", true);
1409 SUIT_DataOwner* aOwn = aList.first();
1410 LightApp_DataOwner* sowner = dynamic_cast<LightApp_DataOwner*>(aOwn);
1411 QString aREntry = sowner->entry();
1413 static GEOM::GEOM_Gen_var geomGen;
1414 if (CORBA::is_nil(geomGen)) {
1415 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>
1416 (SUIT_Session::session()->activeApplication());
1418 SALOME_LifeCycleCORBA* ls = new SALOME_LifeCycleCORBA(app->namingService());
1419 Engines::EngineComponent_var comp =
1420 ls->FindOrLoad_Component("FactoryServer", "SHAPERSTUDY");
1421 geomGen = GEOM::GEOM_Gen::_narrow(comp);
1424 if (!CORBA::is_nil(geomGen))
1426 geomGen->BreakLink(aREntry.toStdString().c_str());
1427 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1429 // remove actors whose objects are removed by BreakLink()
1430 QList<SUIT_ViewWindow*> wndList = SMESHGUI::desktop()->windows();
1431 SUIT_ViewWindow* wnd;
1432 foreach(wnd, wndList)
1433 SMESH::UpdateActorsAfterUpdateStudy(wnd);
1441 //================================================================================
1443 * \brief Return true if a mesh icon == ICON_SMESH_TREE_GEOM_MODIF
1444 * which means that the mesh can't be modified. It should be either re-computed
1445 * or breakShaperLink()'ed. Warn the user about it.
1447 //================================================================================
1449 bool warnOnGeomModif()
1451 SALOME_ListIO selected;
1452 if ( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
1453 aSel->selectedObjects(selected,"",/*convertReferences=*/false);
1455 SALOME_ListIteratorOfListIO It( selected );
1456 for ( ; It.More(); It.Next() )
1458 Handle(SALOME_InteractiveObject) io = It.Value();
1459 if ( !io->hasEntry() ) continue;
1460 _PTR(SObject) so = SMESH::getStudy()->FindObjectID( io->getEntry() );
1461 SMESH::SMESH_Mesh_var mesh;
1462 while ( mesh->_is_nil() && so && so->GetID() != "0:" )
1464 CORBA::Object_var obj = SMESH::SObjectToObject( so );
1465 SMESH::SMESH_IDSource_var isrc = SMESH::SMESH_IDSource::_narrow( obj );
1466 if ( isrc->_is_nil() )
1467 so = so->GetFather();
1469 mesh = isrc->GetMesh();
1471 if ( mesh->_is_nil() ) continue;
1472 so = SMESH::FindSObject( mesh );
1473 if ( !so ) continue;
1474 _PTR(GenericAttribute) attr;
1475 so->FindAttribute( attr, "AttributePixMap" );
1476 _PTR(AttributePixMap) pixmap = attr;
1477 if ( !pixmap ) continue;
1479 if ( pixmap->GetPixMap() == "ICON_SMESH_TREE_GEOM_MODIF" )
1481 SUIT_MessageBox::warning(SMESHGUI::desktop(),
1482 QObject::tr("SMESH_WRN_WARNING"),
1483 QObject::tr("MSG_WARN_ON_GEOM_MODIF"));
1490 void SetDisplayMode(int theCommandID, VTK::MarkerMap& theMarkerMap)
1492 SALOME_ListIO selected;
1493 SalomeApp_Application* app =
1494 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1498 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1499 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1500 if ( !aSel || !appStudy )
1503 if ( theCommandID == SMESHOp::OpClipping ) { // Clipping dialog can be activated without selection
1504 if ( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
1505 aModule->EmitSignalDeactivateDialog();
1506 if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
1507 (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
1512 aSel->selectedObjects( selected );
1514 if ( selected.Extent() >= 1 )
1516 switch ( theCommandID ) {
1517 case SMESHOp::OpTransparency:
1519 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1520 (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
1523 case SMESHOp::OpProperties:
1526 QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
1527 QColor orientationColor, outlineColor, volumeColor;
1528 int deltaF = 0, deltaV = 0;
1531 double ballScale = 1.0;
1533 int outlineWidth = 1;
1534 double shrinkCoef = 0.0;
1535 double orientationScale = 0.0;
1536 bool orientation3d = false;
1537 VTK::MarkerType markerType = VTK::MT_NONE;
1538 VTK::MarkerScale markerScale = VTK::MS_NONE;
1540 bool hasNodes = false;
1541 int presentEntities = 0;
1542 bool firstTime = true;
1544 SALOME_ListIteratorOfListIO It( selected );
1545 for ( ; It.More(); It.Next() ) {
1546 Handle(SALOME_InteractiveObject) IObject = It.Value();
1547 if ( !IObject->hasEntry() ) continue;
1548 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1549 if ( !anActor || !anActor->GetObject() ) continue;
1552 // nodes: color, marker
1553 anActor->GetNodeColor( color[0], color[1], color[2] );
1554 nodeColor.setRgbF( color[0], color[1], color[2] );
1555 markerType = anActor->GetMarkerType();
1556 markerScale = anActor->GetMarkerScale();
1557 markerId = anActor->GetMarkerTexture();
1558 // edges: color, width
1559 anActor->GetEdgeColor( color[0], color[1], color[2] );
1560 edgeColor.setRgbF( color[0], color[1], color[2] );
1561 edgeWidth = qMax( (int)anActor->GetLineWidth(), 1 ); // minimum allowed width is 1
1562 // faces: front color, back color (delta)
1563 anActor->GetSufaceColor( color[0], color[1], color[2], deltaF );
1564 faceColor.setRgbF( color[0], color[1], color[2] );
1565 // faces: front color, back color (delta)
1566 anActor->GetVolumeColor( color[0], color[1], color[2], deltaV );
1567 volumeColor.setRgbF( color[0], color[1], color[2] );
1568 // 0d elements: color, size
1569 anActor->Get0DColor( color[0], color[1], color[2] );
1570 elem0dColor.setRgbF( color[0], color[1], color[2] );
1571 elem0dSize = qMax( (int)anActor->Get0DSize(), 1 ); // minimum allowed size is 1
1572 // balls: color, size
1573 anActor->GetBallColor( color[0], color[1], color[2] );
1574 ballColor.setRgbF( color[0], color[1], color[2] );
1575 //ballSize = qMax( (int)anActor->GetBallSize(), 1 ); // minimum allowed size is 1
1576 ballScale = qMax( (double)anActor->GetBallScale(), 1e-2 ); // minimum allowed scale is 1e-2
1578 anActor->GetOutlineColor( color[0], color[1], color[2] );
1579 outlineColor.setRgbF( color[0], color[1], color[2] );
1580 outlineWidth = qMax( (int)anActor->GetOutlineWidth(), 1 ); // minimum allowed width is 1
1581 // orientation vectors: color, scale, 3d flag
1582 anActor->GetFacesOrientationColor( color[0], color[1], color[2] );
1583 orientationColor.setRgbF( color[0], color[1], color[2] );
1584 orientationScale = anActor->GetFacesOrientationScale();
1585 orientation3d = anActor->GetFacesOrientation3DVectors();
1587 shrinkCoef = anActor->GetShrinkFactor();
1590 firstTime = false; // we only take properties from first object (for performance reasons)
1593 hasNodes = anActor->GetObject()->GetNbEntities( SMDSAbs_Node );
1594 if ( !(presentEntities & SMESH_Actor::eEdges) && anActor->GetObject()->GetNbEntities( SMDSAbs_Edge ) )
1595 presentEntities = presentEntities | SMESH_Actor::eEdges;
1596 if ( !(presentEntities & SMESH_Actor::eFaces) && anActor->GetObject()->GetNbEntities( SMDSAbs_Face ) )
1597 presentEntities = presentEntities | SMESH_Actor::eFaces;
1598 if ( !(presentEntities & SMESH_Actor::eVolumes) && anActor->GetObject()->GetNbEntities( SMDSAbs_Volume ) )
1599 presentEntities = presentEntities | SMESH_Actor::eVolumes;
1600 if ( !(presentEntities & SMESH_Actor::e0DElements) && anActor->GetObject()->GetNbEntities( SMDSAbs_0DElement ) )
1601 presentEntities = presentEntities | SMESH_Actor::e0DElements;
1602 if ( !(presentEntities & SMESH_Actor::eBallElem) && anActor->GetObject()->GetNbEntities( SMDSAbs_Ball ) )
1603 presentEntities = presentEntities | SMESH_Actor::eBallElem;
1605 // as we know that all types of elements are present, we can exit the loop
1606 if ( presentEntities == SMESH_Actor::eAllEntity )
1610 SMESHGUI_PropertiesDlg dlg( theMarkerMap, SMESHGUI::desktop() );
1611 // nodes: color, marker
1612 dlg.setNodeColor( nodeColor );
1613 if( markerType != VTK::MT_USER )
1614 dlg.setNodeMarker( markerType, markerScale );
1616 dlg.setNodeCustomMarker( markerId );
1617 // edges: color, line width
1618 dlg.setEdgeColor( edgeColor );
1619 dlg.setEdgeWidth( edgeWidth );
1620 // faces: front color, back color
1621 dlg.setFaceColor( faceColor, deltaF );
1622 // volumes: normal color, reversed color
1623 dlg.setVolumeColor( volumeColor, deltaV );
1624 // outlines: color, line width
1625 dlg.setOutlineColor( outlineColor );
1626 dlg.setOutlineWidth( outlineWidth );
1627 // 0d elements: color, size
1628 dlg.setElem0dColor( elem0dColor );
1629 dlg.setElem0dSize( elem0dSize );
1630 // balls: color, size
1631 dlg.setBallColor( ballColor );
1632 //dlg.setBallSize( ballSize );
1633 dlg.setBallScale( ballScale );
1634 // orientation: color, scale, 3d flag
1635 dlg.setOrientationColor( orientationColor );
1636 dlg.setOrientationSize( int( orientationScale * 100. ) );
1637 dlg.setOrientation3d( orientation3d );
1638 // shrink: scale factor
1639 dlg.setShrinkCoef( int( shrinkCoef * 100. ) );
1640 // hide unused controls
1641 dlg.showControls( presentEntities, hasNodes );
1644 nodeColor = dlg.nodeColor();
1645 markerType = dlg.nodeMarkerType();
1646 markerScale = dlg.nodeMarkerScale();
1647 markerId = dlg.nodeMarkerId();
1648 edgeColor = dlg.edgeColor();
1649 edgeWidth = dlg.edgeWidth();
1650 faceColor = dlg.faceColor();
1651 deltaF = dlg.faceColorDelta();
1652 volumeColor = dlg.volumeColor();
1653 deltaV = dlg.volumeColorDelta();
1654 outlineColor = dlg.outlineColor();
1655 outlineWidth = dlg.outlineWidth();
1656 elem0dColor = dlg.elem0dColor();
1657 elem0dSize = dlg.elem0dSize();
1658 ballColor = dlg.ballColor();
1659 // ballSize = dlg.ballSize();
1660 ballScale = dlg.ballScale();
1661 orientationColor = dlg.orientationColor();
1662 orientationScale = dlg.orientationSize() / 100.;
1663 orientation3d = dlg.orientation3d();
1664 shrinkCoef = dlg.shrinkCoef() / 100.;
1666 // store point markers that might be changed by the user
1667 theMarkerMap = dlg.customMarkers();
1669 // set properties from dialog box to the presentations
1670 SALOME_ListIteratorOfListIO It( selected );
1671 for ( ; It.More(); It.Next() ) {
1672 Handle(SALOME_InteractiveObject) IObject = It.Value();
1673 if ( !IObject->hasEntry() ) continue;
1674 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1675 if ( !anActor ) continue;
1677 // nodes: color, marker
1678 anActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
1679 if ( markerType != VTK::MT_USER ) {
1680 anActor->SetMarkerStd( markerType, markerScale );
1683 VTK::MarkerMap::const_iterator iter = theMarkerMap.find( markerId );
1684 if ( iter != theMarkerMap.end() )
1685 anActor->SetMarkerTexture( markerId, iter->second.second );
1687 // volumes: normal color, reversed color (delta)
1688 anActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
1689 // faces: front color, back color (delta)
1690 anActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
1691 // edges: color, width
1692 anActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
1693 anActor->SetLineWidth( edgeWidth );
1695 anActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
1696 anActor->SetOutlineWidth( outlineWidth );
1697 // 0D elements: color, size
1698 anActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
1699 anActor->Set0DSize( elem0dSize );
1700 // balls: color, size
1701 anActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
1702 // anActor->SetBallSize( ballSize );
1703 anActor->SetBallScale( ballScale );
1704 // orientation: color, scale, 3d flag
1705 anActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
1706 anActor->SetFacesOrientationScale( orientationScale );
1707 anActor->SetFacesOrientation3DVectors( orientation3d );
1709 anActor->SetShrinkFactor( shrinkCoef );
1711 // for groups, set also proper color
1712 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1713 if ( !aGroupObject->_is_nil() ) {
1714 SMESH::ElementType anElementType = aGroupObject->GetType();
1716 switch( anElementType ) {
1718 aColor = nodeColor; break;
1720 aColor = edgeColor; break;
1722 aColor = faceColor; break;
1724 aColor = volumeColor; break;
1726 aColor = elem0dColor; break;
1728 aColor = ballColor; break;
1732 if ( aColor.isValid() ) {
1733 SALOMEDS::Color aGroupColor;
1734 aGroupColor.R = aColor.redF();
1735 aGroupColor.G = aColor.greenF();
1736 aGroupColor.B = aColor.blueF();
1737 aGroupObject->SetColor( aGroupColor );
1739 } // if ( !aGroupObject->_is_nil() )
1740 } // for ( ; It.More(); It.Next() )
1741 SMESH::RepaintCurrentView();
1742 } // if ( dlg.exec() )
1744 } // case SMESHOp::OpProperties:
1745 } // switch(theCommandID)
1746 SUIT_OverrideCursor wc;
1747 SALOME_ListIteratorOfListIO It( selected );
1748 for( ; It.More(); It.Next()){
1749 Handle(SALOME_InteractiveObject) IObject = It.Value();
1750 if(IObject->hasEntry()){
1751 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1752 switch(theCommandID){
1753 case SMESHOp::OpDMWireframe:
1754 anActor->SetRepresentation(SMESH_Actor::eEdge);
1756 case SMESHOp::OpDMShading:
1757 anActor->SetRepresentation(SMESH_Actor::eSurface);
1759 case SMESHOp::OpDMShrink:
1760 if(anActor->IsShrunk())
1761 anActor->UnShrink();
1763 anActor->SetShrink();
1765 case SMESHOp::OpDMNodes:
1766 anActor->SetRepresentation(SMESH_Actor::ePoint);
1768 case SMESHOp::OpRepresentationLines:
1769 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1770 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1772 case SMESHOp::OpRepresentationArcs:
1773 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1774 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1780 SMESH::RepaintCurrentView();
1784 int ActionToControl( int theID, bool theReversed )
1786 NCollection_DoubleMap<int,int> ActionControl;
1787 ActionControl.Bind( 0, SMESH_Actor::eNone );
1788 ActionControl.Bind( SMESHOp::OpFreeNode, SMESH_Actor::eFreeNodes );
1789 ActionControl.Bind( SMESHOp::OpEqualNode, SMESH_Actor::eCoincidentNodes );
1790 ActionControl.Bind( SMESHOp::OpNodeConnectivityNb, SMESH_Actor::eNodeConnectivityNb );
1791 ActionControl.Bind( SMESHOp::OpFreeEdge, SMESH_Actor::eFreeEdges );
1792 ActionControl.Bind( SMESHOp::OpFreeBorder, SMESH_Actor::eFreeBorders );
1793 ActionControl.Bind( SMESHOp::OpLength, SMESH_Actor::eLength );
1794 ActionControl.Bind( SMESHOp::OpConnection, SMESH_Actor::eMultiConnection );
1795 ActionControl.Bind( SMESHOp::OpEqualEdge, SMESH_Actor::eCoincidentElems1D );
1796 ActionControl.Bind( SMESHOp::OpFreeFace, SMESH_Actor::eFreeFaces );
1797 ActionControl.Bind( SMESHOp::OpBareBorderFace, SMESH_Actor::eBareBorderFace );
1798 ActionControl.Bind( SMESHOp::OpOverConstrainedFace, SMESH_Actor::eOverConstrainedFace );
1799 ActionControl.Bind( SMESHOp::OpLength2D, SMESH_Actor::eLength2D );
1800 ActionControl.Bind( SMESHOp::OpDeflection2D, SMESH_Actor::eDeflection2D );
1801 ActionControl.Bind( SMESHOp::OpConnection2D, SMESH_Actor::eMultiConnection2D );
1802 ActionControl.Bind( SMESHOp::OpArea, SMESH_Actor::eArea );
1803 ActionControl.Bind( SMESHOp::OpTaper, SMESH_Actor::eTaper );
1804 ActionControl.Bind( SMESHOp::OpAspectRatio, SMESH_Actor::eAspectRatio );
1805 ActionControl.Bind( SMESHOp::OpMinimumAngle, SMESH_Actor::eMinimumAngle );
1806 ActionControl.Bind( SMESHOp::OpWarpingAngle, SMESH_Actor::eWarping );
1807 ActionControl.Bind( SMESHOp::OpSkew, SMESH_Actor::eSkew );
1808 ActionControl.Bind( SMESHOp::OpMaxElementLength2D, SMESH_Actor::eMaxElementLength2D );
1809 ActionControl.Bind( SMESHOp::OpEqualFace, SMESH_Actor::eCoincidentElems2D );
1810 ActionControl.Bind( SMESHOp::OpAspectRatio3D, SMESH_Actor::eAspectRatio3D );
1811 ActionControl.Bind( SMESHOp::OpVolume, SMESH_Actor::eVolume3D );
1812 ActionControl.Bind( SMESHOp::OpMaxElementLength3D, SMESH_Actor::eMaxElementLength3D );
1813 ActionControl.Bind( SMESHOp::OpBareBorderVolume, SMESH_Actor::eBareBorderVolume );
1814 ActionControl.Bind( SMESHOp::OpOverConstrainedVolume, SMESH_Actor::eOverConstrainedVolume );
1815 ActionControl.Bind( SMESHOp::OpEqualVolume, SMESH_Actor::eCoincidentElems3D );
1818 return ActionControl.IsBound2( theID ) ? ActionControl.Find2( theID ) : 0;
1819 return ActionControl.IsBound1( theID ) ? ActionControl.Find1( theID ) : 0;
1822 void Control( int theCommandID )
1824 SMESH_Actor::eControl aControl = SMESH_Actor::eControl( ActionToControl( theCommandID ));
1825 _PTR(Study) aStudy = SMESH::getStudy();
1827 SALOME_ListIO selected;
1828 if ( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
1829 aSel->selectedObjects( selected );
1831 if ( !selected.IsEmpty() ) {
1832 SALOME_ListIteratorOfListIO It(selected);
1833 for ( ; It.More(); It.Next())
1835 Handle(SALOME_InteractiveObject) anIO = It.Value();
1836 if ( !anIO.IsNull() ) {
1837 _PTR(SObject) SO = aStudy->FindObjectID( It.Value()->getEntry() );
1839 CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
1840 SMESH::SMESH_IDSource_var anIDSrc = SMESH::SMESH_IDSource::_narrow( aObject );
1841 if ( !anIDSrc->_is_nil() ) {
1842 SMESH_Actor *anActor = SMESH::FindActorByEntry( anIO->getEntry());
1843 if (( !anActor && selected.Extent() == 1 ) &&
1844 ( anActor = SMESH::CreateActor( anIO->getEntry() )))
1846 anActor->SetControlMode( aControl );
1847 SMESH::DisplayActor( SMESH::GetCurrentVtkView(), anActor );
1848 SMESH::UpdateView ( SMESH::eDisplay, anIO->getEntry() );
1852 if ( anActor->GetControlMode() != aControl )
1853 anActor->SetControlMode( aControl );
1854 QString functorName = functorToString( anActor->GetFunctor() );
1855 int anEntitiesCount = anActor->GetNumberControlEntities();
1856 if (anEntitiesCount >= 0)
1857 functorName = functorName + ": " + QString::number(anEntitiesCount);
1858 anActor->GetScalarBarActor()->SetTitle( functorName.toUtf8().constData() );
1859 SMESH::RepaintCurrentView();
1860 #ifndef DISABLE_PLOT2DVIEWER
1861 if ( anActor->GetPlot2Histogram() ) {
1862 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1863 QString aHistogramName("%1 : %2");
1864 aHistogramName = aHistogramName.arg( anIO->getName() ).arg( functorName );
1865 aHistogram->setName( aHistogramName );
1866 aHistogram->setHorTitle( functorName );
1867 SMESH::ProcessIn2DViewers( anActor );
1879 bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1880 SMESH::MeshObjectType theType,
1881 const QString theInTypeName,
1882 QString & theOutTypeName)
1884 SMESH_TypeFilter aTypeFilter( theType );
1886 if ( !theIO.IsNull() )
1888 entry = theIO->getEntry();
1889 LightApp_DataOwner owner( entry );
1890 if ( aTypeFilter.isOk( &owner )) {
1891 theOutTypeName = theInTypeName;
1899 QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1901 _PTR(Study) aStudy = SMESH::getStudy();
1902 _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1904 _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1905 CORBA::String_var anID = aSComp->GetID().c_str();
1906 if ( !strcmp(anID.in(),theIO->getEntry()) )
1912 CheckOIType ( theIO, SMESH::HYPOTHESIS, "Hypothesis", aTypeName ) ||
1913 CheckOIType ( theIO, SMESH::ALGORITHM, "Algorithm", aTypeName ) ||
1914 CheckOIType ( theIO, SMESH::MESH, "Mesh", aTypeName ) ||
1915 CheckOIType ( theIO, SMESH::SUBMESH, "SubMesh", aTypeName ) ||
1916 CheckOIType ( theIO, SMESH::GROUP, "Group", aTypeName )
1924 // QString CheckHomogeneousSelection()
1926 // LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1927 // SALOME_ListIO selected;
1929 // aSel->selectedObjects( selected );
1931 // QString RefType = CheckTypeObject(selected.First());
1932 // SALOME_ListIteratorOfListIO It(selected);
1933 // for ( ; It.More(); It.Next())
1935 // Handle(SALOME_InteractiveObject) IObject = It.Value();
1936 // QString Type = CheckTypeObject(IObject);
1937 // if ( Type.compare(RefType) != 0 )
1938 // return "Heterogeneous Selection";
1944 uint randomize( uint size )
1946 static bool initialized = false;
1947 if ( !initialized ) {
1948 qsrand( QDateTime::currentDateTime().toTime_t() );
1952 v = uint( (double)( v ) / RAND_MAX * size );
1953 v = qMax( uint(0), qMin ( v, size-1 ) );
1959 void SMESHGUI::OnEditDelete()
1961 // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1962 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1963 SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1965 _PTR(Study) aStudy = SMESH::getStudy();
1966 _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1967 _PTR(GenericAttribute) anAttr;
1968 _PTR(AttributeIOR) anIOR;
1970 const int objectCountLimit = 30; // PAL23599
1971 int objectCount = 0;
1973 QString aParentComponent = QString::null;
1975 for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1977 Handle(SALOME_InteractiveObject) anIO = anIt.Value();
1978 if ( anIO.IsNull() ) continue;
1980 QString father = "unknown", name;
1982 _PTR(SObject) aSO = aStudy->FindObjectID( anIO->getEntry() );
1984 father = QString::fromStdString( aSO->GetFatherComponent()->ComponentDataType() );
1985 // check if object is reference
1986 _PTR(SObject) aRefSObj;
1987 if ( aSO->ReferencedObject( aRefSObj ) ) {
1988 name = QString::fromStdString ( aRefSObj->GetName() );
1989 father = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1992 name = anIO->getName();
1995 if ( objectCount < objectCountLimit ) { // avoid occupying the whole screen
1996 aNameList.append("\n - ");
1997 aNameList.append( name );
2000 if( aParentComponent.isNull() )
2001 aParentComponent = father;
2002 else if( !aParentComponent.isEmpty() && aParentComponent!=father )
2003 aParentComponent = "";
2005 if ( objectCount >= objectCountLimit )
2006 aNameList.append("\n - ...");
2008 if ( objectCount == 0 )
2009 return; // No Valid Objects Selected
2011 if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
2012 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2013 QObject::tr("ERR_ERROR"),
2014 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
2017 // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
2018 if (SUIT_MessageBox::warning
2019 (SMESHGUI::desktop(),
2020 QObject::tr("SMESH_WRN_WARNING"),
2021 QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
2022 SUIT_MessageBox::Yes | SUIT_MessageBox::No,
2023 SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
2026 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2028 // Put one level of sub-objects of the selected SO's into a list
2029 // in order to get objects inside folders like "Assigned Algorithms"
2030 std::list< _PTR(SObject) > listSO;
2031 SALOME_ListIteratorOfListIO It(selected);
2032 for( ; It.More(); It.Next()) // loop on selected IO's
2034 Handle(SALOME_InteractiveObject) IObject = It.Value();
2035 if(IObject->hasEntry()) {
2036 _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
2038 // disable removal of "SMESH" component object
2039 if(aSO->FindAttribute(anAttr, "AttributeIOR")){
2041 if ( engineIOR() == anIOR->Value().c_str() )
2044 //Check the referenced object
2045 _PTR(SObject) aRefSObject;
2046 if ( aSO && aSO->ReferencedObject( aRefSObject ) )
2047 aSO = aRefSObject; // Delete main Object instead of reference
2049 listSO.push_back( aSO );
2051 _PTR(ChildIterator) it = aStudy->NewChildIterator( aSO );
2052 for (it->InitEx(false); it->More(); it->Next())
2053 listSO.push_back( it->Value() );
2056 // Check if none of objects to delete is referred from outside
2057 std::list< _PTR(SObject) >::reverse_iterator ritSO;
2058 std::vector< _PTR(SObject) > subSO;
2059 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
2061 _PTR(SObject) SO = *ritSO;
2062 if ( !SO ) continue;
2064 int nbChildren = SO->GetLastChildTag();
2066 subSO.reserve( 1 + nbChildren );
2067 subSO.push_back( SO );
2068 if ( nbChildren > 0 )
2070 _PTR(ChildIterator) it = aStudy->NewChildIterator( SO );
2071 for ( it->InitEx( true ); it->More(); it->Next() )
2072 subSO.push_back( it->Value() );
2074 for ( size_t i = 0; i < subSO.size(); ++i )
2076 std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( subSO[i] );
2077 for ( size_t j = 0; j < aReferences.size(); j++ ) {
2078 _PTR(SComponent) aComponent = aReferences[j]->GetFatherComponent();
2079 std::string type = aComponent->ComponentDataType();
2080 if ( type != "SMESH" )
2082 SUIT_MessageBox::warning( anApp->desktop(),
2083 QObject::tr("WRN_WARNING"),
2084 QObject::tr("DEP_OBJECT") );
2085 return; // outside SMESH, there is an object depending on a SMESH object
2091 // Treat SO's in the list starting from the back
2092 aStudyBuilder->NewCommand(); // There is a transaction
2093 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
2095 _PTR(SObject) SO = *ritSO;
2096 if ( !SO ) continue;
2097 std::string anEntry = SO->GetID();
2099 /** Erase graphical object and remove all its data **/
2100 if ( SO->FindAttribute( anAttr, "AttributeIOR" )) {
2101 SMESH::RemoveVisualObjectWithActors( anEntry.c_str(), true);
2103 /** Remove an object from data structures **/
2104 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
2105 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
2106 if ( !aGroup->_is_nil() ) { // DELETE GROUP
2107 SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
2108 aMesh->RemoveGroup( aGroup );
2110 else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
2111 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2112 aMesh->RemoveSubMesh( aSubMesh );
2115 Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
2116 ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
2117 QString objType = CheckTypeObject(IObject);
2118 if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
2119 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
2120 aStudyBuilder->RemoveObjectWithChildren( SO );
2122 else {// default action: remove SObject from the study
2123 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
2124 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
2126 aStudyBuilder->RemoveObjectWithChildren( SO );
2130 } /* listSO back loop */
2132 aStudyBuilder->CommitCommand();
2134 /* Clear any previous selection */
2136 aSel->setSelectedObjects( l1 );
2138 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
2142 SMESHGUI_EXPORT CAM_Module* createModule()
2144 return new SMESHGUI();
2147 SMESHGUI_EXPORT char* getModuleVersion() {
2148 return (char*)SMESH_VERSION_STR;
2152 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
2154 //=============================================================================
2158 //=============================================================================
2159 SMESHGUI::SMESHGUI() :
2160 SalomeApp_Module( "SMESH" )
2162 if ( CORBA::is_nil( myComponentSMESH ) )
2164 CORBA::Boolean anIsEmbeddedMode;
2165 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
2166 //MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
2168 // 0019923: EDF 765 SMESH : default values of hypothesis
2169 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
2170 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
2171 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
2172 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
2173 myComponentSMESH->SetDefaultNbSegments( nbSeg );
2175 const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif", "default_grp_color" };
2176 for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
2177 if ( aResourceMgr->hasValue( "SMESH", options[i] ))
2179 QString val = aResourceMgr->stringValue( "SMESH", options[i] );
2180 myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
2184 myActiveDialogBox = 0;
2185 myFilterLibraryDlg = 0;
2189 myEventCallbackCommand = vtkCallbackCommand::New();
2190 myEventCallbackCommand->Delete();
2191 myEventCallbackCommand->SetClientData( this );
2192 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
2195 /* load resources for all available meshers */
2196 SMESH::InitAvailableHypotheses();
2199 //=============================================================================
2203 //=============================================================================
2204 SMESHGUI::~SMESHGUI()
2208 //=============================================================================
2212 //=============================================================================
2213 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
2215 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2217 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
2222 //=============================================================================
2226 //=============================================================================
2227 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
2229 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2233 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2234 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2235 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2236 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2237 return autoUpdate && !exceeded;
2240 //=============================================================================
2244 //=============================================================================
2245 bool SMESHGUI::automaticUpdate( SMESH::SMESH_IDSource_ptr theMesh,
2246 int* entities, bool* limitExceeded, int* hidden, long* nbElements )
2248 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2252 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2253 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2254 bool incrementalLimit = resMgr->booleanValue( "SMESH", "incremental_limit", false );
2256 SMESH::long_array_var info = theMesh->GetMeshInfo();
2257 long nbOdElems = info[SMDSEntity_0D];
2258 long nbEdges = info[SMDSEntity_Edge] + info[SMDSEntity_Quad_Edge];
2259 long nbFaces = info[SMDSEntity_Triangle] + info[SMDSEntity_Quad_Triangle] + info[SMDSEntity_BiQuad_Triangle] +
2260 info[SMDSEntity_Quadrangle] + info[SMDSEntity_Quad_Quadrangle] + info[SMDSEntity_BiQuad_Quadrangle] +
2261 info[SMDSEntity_Polygon] + info[SMDSEntity_Quad_Polygon];
2262 long nbVolumes = info[SMDSEntity_Tetra] + info[SMDSEntity_Quad_Tetra] +
2263 info[SMDSEntity_Hexa] + info[SMDSEntity_Quad_Hexa] + info[SMDSEntity_TriQuad_Hexa] +
2264 info[SMDSEntity_Pyramid] + info[SMDSEntity_Quad_Pyramid] +
2265 info[SMDSEntity_Penta] + info[SMDSEntity_Quad_Penta] + info[SMDSEntity_BiQuad_Penta] +
2266 info[SMDSEntity_Polyhedra] +
2267 info[SMDSEntity_Hexagonal_Prism];
2268 long nbBalls = info[SMDSEntity_Ball];
2270 long requestedSize = nbOdElems + nbBalls + nbEdges + nbFaces + nbVolumes;
2271 *nbElements = requestedSize;
2273 *entities = SMESH_Actor::eAllEntity;
2276 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2278 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2280 if ( incrementalLimit ) {
2283 if ( nbOdElems > 0 ) {
2284 if ( total + nbOdElems > updateLimit ) {
2285 *entities = *entities & ~SMESH_Actor::e0DElements;
2286 *hidden = *hidden | SMESH_Actor::e0DElements;
2293 if ( nbEdges > 0 ) {
2294 if ( total + nbEdges > updateLimit ) {
2295 *entities = *entities & ~SMESH_Actor::eEdges;
2296 *hidden = *hidden | SMESH_Actor::eEdges;
2303 if ( nbFaces > 0 ) {
2304 if ( total + nbFaces > updateLimit ) {
2305 *entities = *entities & ~SMESH_Actor::eFaces;
2306 *hidden = *hidden | SMESH_Actor::eFaces;
2313 if ( nbVolumes > 0 ) {
2314 if ( total + nbVolumes > updateLimit ) {
2315 *entities = *entities & ~SMESH_Actor::eVolumes;
2316 *hidden = *hidden | SMESH_Actor::eVolumes;
2323 if ( nbBalls > 0 ) {
2324 if ( total + nbBalls > updateLimit ) {
2325 *entities = *entities & ~SMESH_Actor::eBallElem;
2326 *hidden = *hidden | SMESH_Actor::eBallElem;
2334 return autoUpdate && !exceeded;
2337 //=============================================================================
2341 //=============================================================================
2342 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
2344 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
2347 //=============================================================================
2351 //=============================================================================
2352 SMESHGUI* SMESHGUI::GetSMESHGUI()
2354 SMESHGUI* smeshMod = 0;
2355 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
2358 CAM_Module* module = app->module( "Mesh" );
2359 smeshMod = dynamic_cast<SMESHGUI*>( module );
2367 Standard_EXPORT SMESHGUI* GetComponentGUI()
2369 return SMESHGUI::GetSMESHGUI();
2373 //=============================================================================
2377 //=============================================================================
2378 void SMESHGUI::SetState(int aState)
2383 //=============================================================================
2387 //=============================================================================
2388 void SMESHGUI::ResetState()
2393 //=============================================================================
2397 //=============================================================================
2398 void SMESHGUI::EmitSignalDeactivateDialog()
2400 emit SignalDeactivateActiveDialog();
2403 //=============================================================================
2407 //=============================================================================
2408 void SMESHGUI::EmitSignalStudyFrameChanged()
2410 emit SignalStudyFrameChanged();
2413 //=============================================================================
2417 //=============================================================================
2418 void SMESHGUI::EmitSignalCloseAllDialogs()
2420 emit SignalCloseAllDialogs();
2423 //=============================================================================
2427 //=============================================================================
2428 void SMESHGUI::EmitSignalVisibilityChanged()
2430 emit SignalVisibilityChanged();
2433 //=============================================================================
2437 //=============================================================================
2438 void SMESHGUI::EmitSignalCloseView()
2440 emit SignalCloseView();
2443 //=============================================================================
2447 //=============================================================================
2448 void SMESHGUI::EmitSignalActivatedViewManager()
2450 emit SignalActivatedViewManager();
2453 //=============================================================================
2457 //=============================================================================
2458 QDialog *SMESHGUI::GetActiveDialogBox()
2460 return myActiveDialogBox;
2463 //=============================================================================
2467 //=============================================================================
2468 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2470 myActiveDialogBox = (QDialog *) aDlg;
2474 //=============================================================================
2478 //=============================================================================
2479 SUIT_Desktop* SMESHGUI::desktop()
2481 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2483 return app->desktop();
2488 //=============================================================================
2492 //=============================================================================
2493 SalomeApp_Study* SMESHGUI::activeStudy()
2495 SUIT_Application* app = SUIT_Session::session()->activeApplication();
2497 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2502 //=============================================================================
2506 //=============================================================================
2507 void SMESHGUI::Modified( bool theIsUpdateActions )
2509 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2510 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2511 appStudy->Modified();
2512 if( theIsUpdateActions )
2513 app->updateActions();
2518 //=============================================================================
2522 //=============================================================================
2523 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2525 /* Here the position is on the bottom right corner - 10 */
2526 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2528 SUIT_Desktop *PP = desktop();
2529 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2530 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2535 * \brief Verifies whether study of operation is locked
2536 * \param theMess - specifies whether message box must be shown if study is locked
2537 * \return State of study.
2539 * Verifies whether study of operation is locked. If second parameter is TRUE and study
2540 * is locked when corresponding message box appears
2542 bool SMESHGUI::isStudyLocked( bool theMessage )
2544 if ( SMESH::getStudy()->GetProperties()->IsLocked() )
2547 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2548 QObject::tr( "WRN_WARNING" ),
2549 QObject::tr( "WRN_STUDY_LOCKED" ) );
2555 //=============================================================================
2559 //=============================================================================
2560 bool SMESHGUI::OnGUIEvent( int theCommandID )
2562 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2566 SUIT_ResourceMgr* mgr = resourceMgr();
2570 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2571 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2573 //QAction* act = action( theCommandID );
2575 switch (theCommandID) {
2576 case SMESHOp::OpDelete:
2577 if(isStudyLocked()) break;
2580 case SMESHOp::OpImportDAT:
2581 case SMESHOp::OpImportUNV:
2582 case SMESHOp::OpImportMED:
2583 case SMESHOp::OpImportSTL:
2584 case SMESHOp::OpImportCGNS:
2585 case SMESHOp::OpImportSAUV:
2586 case SMESHOp::OpImportGMF:
2587 case SMESHOp::OpPopupImportDAT:
2588 case SMESHOp::OpPopupImportUNV:
2589 case SMESHOp::OpPopupImportMED:
2590 case SMESHOp::OpPopupImportSTL:
2591 case SMESHOp::OpPopupImportCGNS:
2592 case SMESHOp::OpPopupImportSAUV:
2593 case SMESHOp::OpPopupImportGMF:
2595 if(isStudyLocked()) break;
2596 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2600 case SMESHOp::OpFileInformation:
2602 SALOME_ListIO selected;
2603 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2605 aSel->selectedObjects( selected );
2606 if( selected.Extent() )
2608 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2609 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2610 if ( !aMesh->_is_nil() )
2612 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2618 case SMESHOp::OpExportDAT:
2619 case SMESHOp::OpExportMED:
2620 case SMESHOp::OpExportUNV:
2621 case SMESHOp::OpExportSTL:
2622 case SMESHOp::OpExportCGNS:
2623 case SMESHOp::OpExportSAUV:
2624 case SMESHOp::OpExportGMF:
2625 case SMESHOp::OpPopupExportDAT:
2626 case SMESHOp::OpPopupExportMED:
2627 case SMESHOp::OpPopupExportUNV:
2628 case SMESHOp::OpPopupExportSTL:
2629 case SMESHOp::OpPopupExportCGNS:
2630 case SMESHOp::OpPopupExportSAUV:
2631 case SMESHOp::OpPopupExportGMF:
2633 ::ExportMeshToFile(theCommandID);
2637 case SMESHOp::OpReset: // SCALAR BAR
2639 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2640 SALOME_ListIO selected;
2642 aSel->selectedObjects( selected );
2644 SALOME_ListIteratorOfListIO it(selected);
2645 for( ; it.More(); it.Next()) {
2646 Handle(SALOME_InteractiveObject) anIO = it.Value();
2647 if( anIO->hasEntry() ) {
2648 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2649 anActor->SetControlMode( SMESH_Actor::eNone );
2650 #ifndef DISABLE_PLOT2DVIEWER
2651 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2653 anActor->UpdateFilter();
2657 SMESH::UpdateView();
2660 case SMESHOp::OpScalarBarProperties:
2662 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2665 case SMESHOp::OpShowScalarBar:
2667 // show/hide scalar bar
2668 ::ShowElement(theCommandID);
2671 case SMESHOp::OpSaveDistribution:
2673 // dump control distribution data to the text file
2674 ::SaveDistribution();
2678 case SMESHOp::OpShowDistribution:
2680 // show/hide distribution
2681 ::ShowElement(theCommandID);
2685 #ifndef DISABLE_PLOT2DVIEWER
2686 case SMESHOp::OpPlotDistribution:
2688 // plot distribution
2689 ::PlotDistribution();
2695 case SMESHOp::OpAutoColor:
2699 case SMESHOp::OpDisableAutoColor:
2700 ::DisableAutoColor();
2703 case SMESHOp::OpClipping:
2704 case SMESHOp::OpTransparency:
2705 case SMESHOp::OpProperties: // Display preferences (colors, shrink size, line width, ...)
2708 case SMESHOp::OpDMWireframe:
2709 case SMESHOp::OpDMShading:
2710 case SMESHOp::OpDMNodes:
2711 case SMESHOp::OpDMShrink:
2712 ::SetDisplayMode(theCommandID, myMarkerMap);
2715 //2D quadratic representation
2716 case SMESHOp::OpRepresentationLines:
2717 case SMESHOp::OpRepresentationArcs:
2718 ::SetDisplayMode(theCommandID, myMarkerMap);
2722 case SMESHOp::OpDE0DElements:
2723 case SMESHOp::OpDEEdges:
2724 case SMESHOp::OpDEFaces:
2725 case SMESHOp::OpDEVolumes:
2726 case SMESHOp::OpDEBalls:
2727 case SMESHOp::OpDEAllEntity:
2728 ::SetDisplayEntity(theCommandID);
2731 // Choose entities to be displayed
2732 case SMESHOp::OpDEChoose:
2734 ( new SMESHGUI_DisplayEntitiesDlg( SMESHGUI::desktop() ) )->exec();
2738 case SMESHOp::OpOrientationOnFaces:
2740 SUIT_OverrideCursor wc;
2741 LightApp_SelectionMgr* mgr = selectionMgr();
2742 SALOME_ListIO selected; mgr->selectedObjects( selected );
2744 SALOME_ListIteratorOfListIO it(selected);
2745 for( ; it.More(); it.Next()) {
2746 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2747 if(anIObject->hasEntry()) {
2748 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2749 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2756 case SMESHOp::OpUpdate:
2758 if(isStudyLocked()) break;
2759 SUIT_OverrideCursor wc;
2762 SMESH::UpdateView();
2764 catch (std::bad_alloc&) { // PAL16774 (Crash after display of many groups)
2765 SMESH::OnVisuException();
2767 catch (...) { // PAL16774 (Crash after display of many groups)
2768 SMESH::OnVisuException();
2772 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2773 aSel->selectedObjects( l );
2774 aSel->setSelectedObjects( l );
2778 case SMESHOp::OpHide:
2779 case SMESHOp::OpShow:
2780 case SMESHOp::OpShowOnly:
2782 SUIT_OverrideCursor wc;
2783 SMESH::EDisplaing anAction;
2784 switch (theCommandID) {
2785 case SMESHOp::OpHide: anAction = SMESH::eErase; break;
2786 case SMESHOp::OpShow: anAction = SMESH::eDisplay; break;
2787 case SMESHOp::OpShowOnly: anAction = SMESH::eDisplayOnly; break;
2790 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2791 SALOME_ListIO sel_objects, to_process;
2793 aSel->selectedObjects( sel_objects );
2795 if ( theCommandID==SMESHOp::OpShowOnly )
2797 //MESSAGE("anAction = SMESH::eDisplayOnly");
2798 startOperation( myEraseAll );
2801 extractContainers( sel_objects, to_process );
2806 SALOME_ListIteratorOfListIO It( to_process );
2807 for ( ; It.More(); It.Next())
2809 Handle(SALOME_InteractiveObject) IOS = It.Value();
2810 if ( IOS->hasEntry() )
2812 if ( !SMESH::UpdateView( anAction, IOS->getEntry() )) {
2813 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2814 break; // PAL16774 (Crash after display of many groups)
2816 if (anAction == SMESH::eDisplayOnly)
2817 anAction = SMESH::eDisplay;
2822 // PAL13338 + PAL15161 -->
2823 if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !isStudyLocked()) {
2824 SMESH::UpdateView();
2825 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2827 // PAL13338 + PAL15161 <--
2829 catch (...) { // PAL16774 (Crash after display of many groups)
2830 SMESH::OnVisuException();
2833 if (anAction == SMESH::eErase) {
2835 aSel->setSelectedObjects( l1 );
2838 aSel->setSelectedObjects( to_process );
2840 if ( vtkwnd && vtkwnd->GetRenderer() && !isStudyLocked() &&
2841 ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) )
2842 vtkwnd->GetRenderer()->AdjustActors();
2847 case SMESHOp::OpNode:
2849 if(isStudyLocked()) break;
2852 EmitSignalDeactivateDialog();
2854 ( new SMESHGUI_NodesDlg( this ) )->show();
2857 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"),tr("SMESH_WRN_VIEWER_VTK"));
2862 case SMESHOp::OpEditMeshOrSubMesh:
2863 case SMESHOp::OpEditMesh:
2864 case SMESHOp::OpEditSubMesh:
2865 case SMESHOp::OpMeshOrder:
2866 case SMESHOp::OpCreateSubMesh:
2867 if ( warnOnGeomModif() )
2868 break; // action forbidden as geometry modified
2870 case SMESHOp::OpCreateMesh:
2871 case SMESHOp::OpCompute:
2872 case SMESHOp::OpComputeSubMesh:
2873 case SMESHOp::OpPreCompute:
2874 case SMESHOp::OpEvaluate:
2875 case SMESHOp::OpShowErrors:
2876 startOperation( theCommandID );
2878 case SMESHOp::OpRecompute:
2880 if ( isStudyLocked() )
2882 SALOME_ListIO selected;
2883 if ( LightApp_SelectionMgr *sel = selectionMgr() )
2884 sel->selectedObjects( selected );
2885 if ( selected.Extent() == 1 ) {
2886 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO( selected.First() );
2887 if ( !aMesh->_is_nil() )
2889 startOperation( SMESHOp::OpCompute );
2893 case SMESHOp::OpCopyMesh:
2895 if (isStudyLocked()) break;
2896 EmitSignalDeactivateDialog();
2897 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2900 case SMESHOp::OpBuildCompoundMesh:
2902 if (isStudyLocked()) break;
2903 EmitSignalDeactivateDialog();
2904 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2908 case SMESHOp::OpDiagonalInversion:
2909 case SMESHOp::OpUnionOfTwoTriangle:
2913 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2917 if ( isStudyLocked() )
2919 if ( warnOnGeomModif() )
2920 break; // action forbidden as geometry modified
2922 /*Standard_Boolean aRes;
2923 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2924 if ( aMesh->_is_nil() )
2926 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2927 tr( "SMESH_BAD_SELECTION" ) );
2931 EmitSignalDeactivateDialog();
2932 if ( theCommandID == SMESHOp::OpDiagonalInversion )
2933 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2935 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2938 case SMESHOp::OpOrientation:
2939 case SMESHOp::OpUnionOfTriangles:
2940 case SMESHOp::OpCuttingOfQuadrangles:
2941 case SMESHOp::OpSplitVolumes:
2945 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2949 if ( isStudyLocked() )
2951 if ( warnOnGeomModif() )
2952 break; // action forbidden as geometry modified
2954 EmitSignalDeactivateDialog();
2955 SMESHGUI_MultiEditDlg* aDlg = NULL;
2956 if ( theCommandID == SMESHOp::OpOrientation )
2957 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2958 else if ( theCommandID == SMESHOp::OpUnionOfTriangles )
2959 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2960 else if ( theCommandID == SMESHOp::OpSplitVolumes )
2961 aDlg = new SMESHGUI_SplitVolumesDlg(this);
2963 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2968 case SMESHOp::OpSmoothing:
2970 if(isStudyLocked()) break;
2971 if ( warnOnGeomModif() )
2972 break; // action forbidden as geometry modified
2974 EmitSignalDeactivateDialog();
2975 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2978 SUIT_MessageBox::warning(desktop(), tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2982 case SMESHOp::OpExtrusion:
2984 if (isStudyLocked()) break;
2985 if ( warnOnGeomModif() )
2986 break; // action forbidden as geometry modified
2988 EmitSignalDeactivateDialog();
2989 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2991 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2995 case SMESHOp::OpExtrusionAlongAPath:
2997 if (isStudyLocked()) break;
2998 if ( warnOnGeomModif() )
2999 break; // action forbidden as geometry modified
3001 EmitSignalDeactivateDialog();
3002 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
3004 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3008 case SMESHOp::OpRevolution:
3010 if(isStudyLocked()) break;
3011 if ( warnOnGeomModif() )
3012 break; // action forbidden as geometry modified
3014 EmitSignalDeactivateDialog();
3015 ( new SMESHGUI_RevolutionDlg( this ) )->show();
3018 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3022 case SMESHOp::OpPatternMapping:
3024 if ( isStudyLocked() )
3026 if ( warnOnGeomModif() )
3027 break; // action forbidden as geometry modified
3030 EmitSignalDeactivateDialog();
3031 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
3034 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3038 // Adaptation - begin
3039 case SMESHOp::OpUniformRefinement:
3040 case SMESHOp::OpHONewCase:
3041 case SMESHOp::OpHOCaseFollow:
3042 case SMESHOp::OpHONewIter:
3043 case SMESHOp::OpHOIterCompute:
3044 case SMESHOp::OpHOIterComputePublish:
3045 case SMESHOp::OpHOEdit:
3046 case SMESHOp::OpHODelete:
3047 case SMESHOp::OpMGAdapt:
3049 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
3050 SMESHGUI_AdaptDlg *objet = new SMESHGUI_AdaptDlg( this, theCommandID, aMesh);
3053 case SMESHOp::OpSplitBiQuadratic:
3054 case SMESHOp::OpConvertMeshToQuadratic:
3055 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
3056 case SMESHOp::OpReorientFaces:
3057 case SMESHOp::OpCreateGeometryGroup:
3059 if ( warnOnGeomModif() )
3060 break; // action forbidden as geometry modified
3061 startOperation( theCommandID );
3064 case SMESHOp::OpCreateGroup:
3068 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3072 if(isStudyLocked()) break;
3073 if ( warnOnGeomModif() )
3074 break; // action forbidden as geometry modified
3075 EmitSignalDeactivateDialog();
3076 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
3078 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3079 SALOME_ListIO selected;
3081 aSel->selectedObjects( selected );
3083 int nbSel = selected.Extent();
3085 // check if mesh is selected
3086 aMesh = SMESH::GetMeshByIO( selected.First() );
3088 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
3093 case SMESHOp::OpConstructGroup:
3097 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3101 if(isStudyLocked()) break;
3102 if ( warnOnGeomModif() )
3103 break; // action forbidden as geometry modified
3104 EmitSignalDeactivateDialog();
3106 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3107 SALOME_ListIO selected;
3109 aSel->selectedObjects( selected );
3111 int nbSel = selected.Extent();
3113 // check if submesh is selected
3114 Handle(SALOME_InteractiveObject) IObject = selected.First();
3115 if (IObject->hasEntry()) {
3116 _PTR(SObject) aSObj = SMESH::getStudy()->FindObjectID(IObject->getEntry());
3118 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
3119 if (!aSubMesh->_is_nil()) {
3121 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
3122 // get submesh elements list by types
3123 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
3124 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
3125 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
3126 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
3127 // create group for each type o elements
3128 QString aName = IObject->getName();
3129 QStringList anEntryList;
3130 if (aNodes->length() > 0) {
3131 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
3132 aGroup->Add(aNodes.inout());
3133 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3134 anEntryList.append( aSObject->GetID().c_str() );
3136 if (aEdges->length() > 0) {
3137 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
3138 aGroup->Add(aEdges.inout());
3139 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3140 anEntryList.append( aSObject->GetID().c_str() );
3142 if (aFaces->length() > 0) {
3143 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
3144 aGroup->Add(aFaces.inout());
3145 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3146 anEntryList.append( aSObject->GetID().c_str() );
3148 if (aVolumes->length() > 0) {
3149 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
3150 aGroup->Add(aVolumes.inout());
3151 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3152 anEntryList.append( aSObject->GetID().c_str() );
3155 anApp->browseObjects( anEntryList );
3157 catch(const SALOME::SALOME_Exception & S_ex){
3158 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3165 SUIT_MessageBox::warning(desktop(),
3166 tr("SMESH_WRN_WARNING"),
3167 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
3172 case SMESHOp::OpEditGroup:
3176 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3180 if(isStudyLocked()) break;
3181 if ( warnOnGeomModif() )
3182 break; // action forbidden as geometry modified
3183 EmitSignalDeactivateDialog();
3185 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3186 SALOME_ListIO selected;
3188 aSel->selectedObjects( selected );
3190 SALOME_ListIteratorOfListIO It (selected);
3191 int nbSelectedGroups = 0;
3192 for ( ; It.More(); It.Next() )
3194 SMESH::SMESH_GroupBase_var aGroup =
3195 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
3196 if (!aGroup->_is_nil()) {
3198 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
3202 if (nbSelectedGroups == 0)
3204 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
3210 case SMESHOp::OpAddElemGroupPopup: // Add elements to group
3212 if(isStudyLocked()) break;
3213 if (myState == 800) {
3214 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3215 if (aDlg) aDlg->onAdd();
3220 case SMESHOp::OpRemoveElemGroupPopup: // Remove elements from group
3222 if(isStudyLocked()) break;
3223 if (myState == 800) {
3224 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3225 if (aDlg) aDlg->onRemove();
3230 case SMESHOp::OpEditGeomGroupAsGroup:
3234 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3238 if(isStudyLocked()) break;
3239 EmitSignalDeactivateDialog();
3241 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3242 SALOME_ListIO selected;
3244 aSel->selectedObjects( selected );
3246 SALOME_ListIteratorOfListIO It (selected);
3247 for ( ; It.More(); It.Next() )
3249 SMESH::SMESH_GroupOnGeom_var aGroup =
3250 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
3251 if (!aGroup->_is_nil()) {
3252 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3257 SMESH::SMESH_GroupOnFilter_var aGroup =
3258 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
3259 if (!aGroup->_is_nil()) {
3260 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3268 case SMESHOp::OpUnionGroups:
3269 case SMESHOp::OpIntersectGroups:
3270 case SMESHOp::OpCutGroups:
3274 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3278 if ( isStudyLocked() )
3280 if ( warnOnGeomModif() )
3281 break; // action forbidden as geometry modified
3283 EmitSignalDeactivateDialog();
3285 SMESHGUI_GroupOpDlg* aDlg = 0;
3286 if ( theCommandID == SMESHOp::OpUnionGroups )
3287 aDlg = new SMESHGUI_UnionGroupsDlg( this );
3288 else if ( theCommandID == SMESHOp::OpIntersectGroups )
3289 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3291 aDlg = new SMESHGUI_CutGroupsDlg( this );
3298 case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
3300 if ( isStudyLocked() )
3302 if ( warnOnGeomModif() )
3303 break; // action forbidden as geometry modified
3305 EmitSignalDeactivateDialog();
3306 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3312 case SMESHOp::OpFaceGroupsByEdges: // Create face groups separated by sharp edges
3314 if ( isStudyLocked() )
3316 if ( warnOnGeomModif() )
3317 break; // action forbidden as geometry modified
3319 EmitSignalDeactivateDialog();
3320 SMESHGUI_FaceGroupsSeparatedByEdgesDlg* aDlg = new SMESHGUI_FaceGroupsSeparatedByEdgesDlg( this );
3326 case SMESHOp::OpDeleteGroup: // Delete groups with their contents
3330 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3334 if ( isStudyLocked() )
3337 EmitSignalDeactivateDialog();
3339 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3343 case SMESHOp::OpMeshInformation:
3344 case SMESHOp::OpWhatIs:
3346 int page = theCommandID == SMESHOp::OpMeshInformation ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3347 EmitSignalDeactivateDialog();
3348 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3349 SALOME_ListIO selected;
3351 aSel->selectedObjects( selected );
3353 if ( selected.Extent() > 1 ) { // a dlg for each IO
3354 SALOME_ListIteratorOfListIO It( selected );
3355 for ( ; It.More(); It.Next() ) {
3356 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3357 dlg->showInfo( It.Value() );
3362 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3368 case SMESHOp::OpFindElementByPoint:
3370 startOperation( theCommandID );
3374 case SMESHOp::OpEditHypothesis:
3376 if(isStudyLocked()) break;
3377 if ( warnOnGeomModif() )
3378 break; // action forbidden as geometry modified
3380 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3381 SALOME_ListIO selected;
3383 aSel->selectedObjects( selected );
3385 int nbSel = selected.Extent();
3388 Handle(SALOME_InteractiveObject) anIObject = selected.First();
3389 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3391 if ( !aHypothesis->_is_nil() )
3393 SMESHGUI_GenericHypothesisCreator* aCreator =
3394 SMESH::GetHypothesisCreator( SMESH::toQStr( aHypothesis->GetName() ));
3397 // set geometry of mesh and sub-mesh to aCreator
3398 aSel->selectedObjects( selected, "", /*convertReferences=*/false);
3399 if ( selected.Extent() == 1 )
3401 QString subGeomID, meshGeomID;
3402 Handle(SALOME_InteractiveObject) hypIO = selected.First();
3403 if ( SMESH::GetGeomEntries( hypIO, subGeomID, meshGeomID ))
3405 if ( subGeomID.isEmpty() ) subGeomID = meshGeomID;
3406 aCreator->setShapeEntry( subGeomID );
3407 aCreator->setMainShapeEntry( meshGeomID );
3411 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3421 case SMESHOp::OpUnassign: // REMOVE HYPOTHESIS / ALGORITHMS
3423 if(isStudyLocked()) break;
3424 if ( warnOnGeomModif() )
3425 break; // action forbidden as geometry modified
3426 SUIT_OverrideCursor wc;
3428 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3429 SALOME_ListIO selected;
3431 aSel->selectedObjects( selected, QString::null, false );
3433 SALOME_ListIteratorOfListIO It(selected);
3434 for (int i = 0; It.More(); It.Next(), i++) {
3435 Handle(SALOME_InteractiveObject) IObject = It.Value();
3436 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3439 aSel->setSelectedObjects( l1 );
3444 case SMESHOp::OpElem0D:
3445 case SMESHOp::OpBall:
3446 case SMESHOp::OpEdge:
3447 case SMESHOp::OpTriangle:
3448 case SMESHOp::OpQuadrangle:
3449 case SMESHOp::OpPolygon:
3450 case SMESHOp::OpTetrahedron:
3451 case SMESHOp::OpHexahedron:
3452 case SMESHOp::OpPentahedron:
3453 case SMESHOp::OpPyramid:
3454 case SMESHOp::OpHexagonalPrism:
3456 if(isStudyLocked()) break;
3457 if ( warnOnGeomModif() )
3458 break; // action forbidden as geometry modified
3460 EmitSignalDeactivateDialog();
3461 SMDSAbs_EntityType type = SMDSEntity_Edge;
3462 switch (theCommandID) {
3463 case SMESHOp::OpElem0D: type = SMDSEntity_0D; break;
3464 case SMESHOp::OpBall: type = SMDSEntity_Ball; break;
3465 case SMESHOp::OpTriangle: type = SMDSEntity_Triangle; break;
3466 case SMESHOp::OpQuadrangle: type = SMDSEntity_Quadrangle; break;
3467 case SMESHOp::OpTetrahedron: type = SMDSEntity_Tetra; break;
3468 case SMESHOp::OpPolygon: type = SMDSEntity_Polygon; break;
3469 case SMESHOp::OpHexahedron: type = SMDSEntity_Hexa; break;
3470 case SMESHOp::OpPentahedron: type = SMDSEntity_Penta; break;
3471 case SMESHOp::OpPyramid: type = SMDSEntity_Pyramid; break;
3472 case SMESHOp::OpHexagonalPrism: type = SMDSEntity_Hexagonal_Prism; break;
3475 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3478 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3482 case SMESHOp::OpPolyhedron:
3484 if(isStudyLocked()) break;
3485 if ( warnOnGeomModif() )
3486 break; // action forbidden as geometry modified
3488 EmitSignalDeactivateDialog();
3489 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3492 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3496 case SMESHOp::OpQuadraticEdge:
3497 case SMESHOp::OpQuadraticTriangle:
3498 case SMESHOp::OpBiQuadraticTriangle:
3499 case SMESHOp::OpQuadraticQuadrangle:
3500 case SMESHOp::OpBiQuadraticQuadrangle:
3501 case SMESHOp::OpQuadraticPolygon:
3502 case SMESHOp::OpQuadraticTetrahedron:
3503 case SMESHOp::OpQuadraticPyramid:
3504 case SMESHOp::OpQuadraticPentahedron:
3505 case SMESHOp::OpBiQuadraticPentahedron:
3506 case SMESHOp::OpQuadraticHexahedron:
3507 case SMESHOp::OpTriQuadraticHexahedron:
3509 if(isStudyLocked()) break;
3510 if ( warnOnGeomModif() )
3511 break; // action forbidden as geometry modified
3513 EmitSignalDeactivateDialog();
3514 SMDSAbs_EntityType type = SMDSEntity_Last;
3516 switch (theCommandID) {
3517 case SMESHOp::OpQuadraticEdge: type = SMDSEntity_Quad_Edge; break;
3518 case SMESHOp::OpQuadraticTriangle: type = SMDSEntity_Quad_Triangle; break;
3519 case SMESHOp::OpBiQuadraticTriangle: type = SMDSEntity_BiQuad_Triangle; break;
3520 case SMESHOp::OpQuadraticQuadrangle: type = SMDSEntity_Quad_Quadrangle; break;
3521 case SMESHOp::OpBiQuadraticQuadrangle: type = SMDSEntity_BiQuad_Quadrangle; break;
3522 case SMESHOp::OpQuadraticPolygon: type = SMDSEntity_Quad_Polygon; break;
3523 case SMESHOp::OpQuadraticTetrahedron: type = SMDSEntity_Quad_Tetra; break;
3524 case SMESHOp::OpQuadraticPyramid: type = SMDSEntity_Quad_Pyramid; break;
3525 case SMESHOp::OpQuadraticPentahedron: type = SMDSEntity_Quad_Penta; break;
3526 case SMESHOp::OpBiQuadraticPentahedron: type = SMDSEntity_BiQuad_Penta; break;
3527 case SMESHOp::OpQuadraticHexahedron: type = SMDSEntity_Quad_Hexa; break;
3528 case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
3531 if ( type != SMDSEntity_Last )
3532 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3535 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3536 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3540 case SMESHOp::OpRemoveNodes:
3542 if(isStudyLocked()) break;
3543 if ( warnOnGeomModif() )
3544 break; // action forbidden as geometry modified
3546 EmitSignalDeactivateDialog();
3547 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3550 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3551 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3555 case SMESHOp::OpRemoveElements: // REMOVES ELEMENTS
3557 if(isStudyLocked()) break;
3558 if ( warnOnGeomModif() )
3559 break; // action forbidden as geometry modified
3561 EmitSignalDeactivateDialog();
3562 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3566 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3567 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3571 case SMESHOp::OpClearMesh: {
3573 if(isStudyLocked()) break;
3574 if ( warnOnGeomModif() )
3575 break; // action forbidden as geometry modified
3577 SALOME_ListIO selected;
3578 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3579 aSel->selectedObjects( selected );
3581 SUIT_OverrideCursor wc;
3582 SALOME_ListIteratorOfListIO It (selected);
3583 for ( ; It.More(); It.Next() )
3585 Handle(SALOME_InteractiveObject) IOS = It.Value();
3586 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3587 if ( aMesh->_is_nil()) continue;
3590 if ( aMesh->NbNodes() == 0 ) // imported mesh is not empty
3591 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3592 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3593 // hide groups and submeshes
3594 _PTR(ChildIterator) anIter =
3595 SMESH::getStudy()->NewChildIterator( aMeshSObj );
3596 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3598 _PTR(SObject) so = anIter->Value();
3599 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3602 catch (const SALOME::SALOME_Exception& S_ex){
3604 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3608 SMESH::UpdateView();
3612 case SMESHOp::OpRemoveOrphanNodes:
3614 if(isStudyLocked()) break;
3615 if ( warnOnGeomModif() )
3616 break; // action forbidden as geometry modified
3617 SALOME_ListIO selected;
3618 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3619 aSel->selectedObjects( selected );
3620 if ( selected.Extent() == 1 ) {
3621 Handle(SALOME_InteractiveObject) anIO = selected.First();
3622 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3623 if ( !aMesh->_is_nil() ) {
3624 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3625 tr( "SMESH_WARNING" ),
3626 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3627 SUIT_MessageBox::Yes |
3628 SUIT_MessageBox::No,
3629 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3632 SUIT_OverrideCursor wc;
3633 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3634 int removed = aMeshEditor->RemoveOrphanNodes();
3635 SUIT_MessageBox::information(SMESHGUI::desktop(),
3636 tr("SMESH_INFORMATION"),
3637 tr("NB_NODES_REMOVED").arg(removed));
3638 if ( removed > 0 ) {
3639 SMESH::UpdateView();
3640 SMESHGUI::Modified();
3643 catch (const SALOME::SALOME_Exception& S_ex) {
3644 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3653 case SMESHOp::OpRenumberingNodes:
3655 if(isStudyLocked()) break;
3656 if ( warnOnGeomModif() )
3657 break; // action forbidden as geometry modified
3659 EmitSignalDeactivateDialog();
3660 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3664 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3665 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3669 case SMESHOp::OpRenumberingElements:
3671 if(isStudyLocked()) break;
3672 if ( warnOnGeomModif() )
3673 break; // action forbidden as geometry modified
3675 EmitSignalDeactivateDialog();
3676 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3680 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3681 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3685 case SMESHOp::OpTranslation:
3687 if(isStudyLocked()) break;
3688 if ( warnOnGeomModif() )
3689 break; // action forbidden as geometry modified
3691 EmitSignalDeactivateDialog();
3692 ( new SMESHGUI_TranslationDlg( this ) )->show();
3695 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3696 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3700 case SMESHOp::OpRotation:
3702 if(isStudyLocked()) break;
3703 if ( warnOnGeomModif() )
3704 break; // action forbidden as geometry modified
3706 EmitSignalDeactivateDialog();
3707 ( new SMESHGUI_RotationDlg( this ) )->show();
3710 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3711 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3715 case SMESHOp::OpSymmetry:
3717 if(isStudyLocked()) break;
3718 if ( warnOnGeomModif() )
3719 break; // action forbidden as geometry modified
3721 EmitSignalDeactivateDialog();
3722 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3725 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3726 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3730 case SMESHOp::OpScale:
3732 if(isStudyLocked()) break;
3733 if ( warnOnGeomModif() )
3734 break; // action forbidden as geometry modified
3736 EmitSignalDeactivateDialog();
3737 ( new SMESHGUI_ScaleDlg( this ) )->show();
3740 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3741 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3746 case SMESHOp::OpOffset:
3748 if(isStudyLocked()) break;
3749 if ( warnOnGeomModif() )
3750 break; // action forbidden as geometry modified
3752 EmitSignalDeactivateDialog();
3753 ( new SMESHGUI_OffsetDlg( this ) )->show();
3756 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3757 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3762 case SMESHOp::OpSewing:
3764 if(isStudyLocked()) break;
3765 if ( warnOnGeomModif() )
3766 break; // action forbidden as geometry modified
3768 EmitSignalDeactivateDialog();
3769 ( new SMESHGUI_SewingDlg( this ) )->show();
3772 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3773 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3777 case SMESHOp::OpMergeNodes:
3779 if(isStudyLocked()) break;
3780 if ( warnOnGeomModif() )
3781 break; // action forbidden as geometry modified
3783 EmitSignalDeactivateDialog();
3784 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3787 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3788 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3792 case SMESHOp::OpMergeElements:
3794 if (isStudyLocked()) break;
3795 if ( warnOnGeomModif() )
3796 break; // action forbidden as geometry modified
3798 EmitSignalDeactivateDialog();
3799 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3801 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3802 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3807 case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
3808 if ( warnOnGeomModif() )
3809 break; // action forbidden as geometry modified
3810 startOperation( SMESHOp::OpMoveNode );
3813 case SMESHOp::OpDuplicateNodes:
3815 if(isStudyLocked()) break;
3816 if ( warnOnGeomModif() )
3817 break; // action forbidden as geometry modified
3819 EmitSignalDeactivateDialog();
3820 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3823 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3824 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3829 case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
3830 if ( warnOnGeomModif() )
3831 break; // action forbidden as geometry modified
3832 startOperation( SMESHOp::OpElem0DOnElemNodes );
3835 case SMESHOp::OpSelectFiltersLibrary: // Library of selection filters
3837 static QList<int> aTypes;
3838 if ( aTypes.isEmpty() )
3840 aTypes.append( SMESH::NODE );
3841 aTypes.append( SMESH::EDGE );
3842 aTypes.append( SMESH::FACE );
3843 aTypes.append( SMESH::VOLUME );
3845 if (!myFilterLibraryDlg)
3846 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3847 else if (myFilterLibraryDlg->isHidden())
3848 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3849 myFilterLibraryDlg->raise();
3853 case SMESHOp::OpFreeNode:
3854 case SMESHOp::OpEqualNode:
3855 case SMESHOp::OpNodeConnectivityNb:
3856 case SMESHOp::OpFreeEdge:
3857 case SMESHOp::OpFreeBorder:
3858 case SMESHOp::OpLength:
3859 case SMESHOp::OpConnection:
3860 case SMESHOp::OpEqualEdge:
3861 case SMESHOp::OpFreeFace:
3862 case SMESHOp::OpBareBorderFace:
3863 case SMESHOp::OpOverConstrainedFace:
3864 case SMESHOp::OpLength2D:
3865 case SMESHOp::OpDeflection2D:
3866 case SMESHOp::OpConnection2D:
3867 case SMESHOp::OpArea:
3868 case SMESHOp::OpTaper:
3869 case SMESHOp::OpAspectRatio:
3870 case SMESHOp::OpMinimumAngle:
3871 case SMESHOp::OpWarpingAngle:
3872 case SMESHOp::OpSkew:
3873 case SMESHOp::OpMaxElementLength2D:
3874 case SMESHOp::OpEqualFace:
3875 case SMESHOp::OpAspectRatio3D:
3876 case SMESHOp::OpVolume:
3877 case SMESHOp::OpMaxElementLength3D:
3878 case SMESHOp::OpBareBorderVolume:
3879 case SMESHOp::OpOverConstrainedVolume:
3880 case SMESHOp::OpEqualVolume:
3883 LightApp_SelectionMgr* mgr = selectionMgr();
3884 SALOME_ListIO selected; mgr->selectedObjects( selected );
3886 if( !selected.IsEmpty() ) {
3887 SUIT_OverrideCursor wc;
3888 ::Control( theCommandID );
3891 SUIT_MessageBox::warning(desktop(),
3892 tr( "SMESH_WRN_WARNING" ),
3893 tr( "SMESH_BAD_SELECTION" ) );
3897 SUIT_MessageBox::warning(desktop(),
3898 tr( "SMESH_WRN_WARNING" ),
3899 tr( "NOT_A_VTK_VIEWER" ) );
3902 case SMESHOp::OpOverallMeshQuality:
3903 OverallMeshQuality();
3905 case SMESHOp::OpNumberingNodes:
3907 SUIT_OverrideCursor wc;
3908 LightApp_SelectionMgr* mgr = selectionMgr();
3909 SALOME_ListIO selected; mgr->selectedObjects( selected );
3911 SALOME_ListIteratorOfListIO it(selected);
3912 for( ; it.More(); it.Next()) {
3913 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3914 if(anIObject->hasEntry()) {
3915 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3916 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3922 case SMESHOp::OpNumberingElements:
3924 SUIT_OverrideCursor wc;
3925 LightApp_SelectionMgr* mgr = selectionMgr();
3926 SALOME_ListIO selected; mgr->selectedObjects( selected );
3928 SALOME_ListIteratorOfListIO it(selected);
3929 for( ; it.More(); it.Next()) {
3930 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3931 if(anIObject->hasEntry())
3932 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3933 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3938 case SMESHOp::OpPropertiesLength:
3939 case SMESHOp::OpPropertiesArea:
3940 case SMESHOp::OpPropertiesVolume:
3941 case SMESHOp::OpMinimumDistance:
3942 case SMESHOp::OpBoundingBox:
3943 case SMESHOp::OpAngle:
3945 int page = SMESHGUI_MeasureDlg::MinDistance;
3946 if ( theCommandID == SMESHOp::OpBoundingBox )
3947 page = SMESHGUI_MeasureDlg::BoundingBox;
3948 else if ( theCommandID == SMESHOp::OpPropertiesLength )
3949 page = SMESHGUI_MeasureDlg::Length;
3950 else if ( theCommandID == SMESHOp::OpPropertiesArea )
3951 page = SMESHGUI_MeasureDlg::Area;
3952 else if ( theCommandID == SMESHOp::OpPropertiesVolume )
3953 page = SMESHGUI_MeasureDlg::Volume;
3954 else if ( theCommandID == SMESHOp::OpAngle )
3955 page = SMESHGUI_MeasureDlg::Angle;
3957 EmitSignalDeactivateDialog();
3958 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3962 case SMESHOp::OpSortChild:
3965 case SMESHOp::OpBreakLink:
3966 ::breakShaperLink();
3971 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3972 //updateObjBrowser();
3976 //=============================================================================
3980 //=============================================================================
3981 bool SMESHGUI::OnMousePress( QMouseEvent * /*pe*/, SUIT_ViewWindow * /*wnd*/ )
3986 //=============================================================================
3990 //=============================================================================
3991 bool SMESHGUI::OnMouseMove( QMouseEvent * /*pe*/, SUIT_ViewWindow * /*wnd*/ )
3996 //=============================================================================
4000 //=============================================================================
4001 bool SMESHGUI::OnKeyPress( QKeyEvent * /*pe*/, SUIT_ViewWindow * /*wnd*/ )
4006 //=============================================================================
4007 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
4008 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
4010 //=============================================================================
4011 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
4012 SUIT_ViewWindow* wnd )
4014 if(theIO->hasEntry()){
4015 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
4016 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
4020 //=======================================================================
4021 // function : createSMESHAction
4023 //=======================================================================
4024 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
4025 const int key, const bool toggle, const QString& shortcutAction )
4028 QWidget* parent = application()->desktop();
4029 SUIT_ResourceMgr* resMgr = resourceMgr();
4031 if ( !icon_id.isEmpty() )
4032 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
4034 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICON_%1" ).arg( po_id ).toLatin1().data() ), false );
4035 if ( !pix.isNull() )
4036 icon = QIcon( pix );
4038 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
4039 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
4040 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
4042 createAction( id, tooltip, icon, menu, status_bar, key, parent,
4043 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
4046 //=======================================================================
4047 // function : createPopupItem
4049 //=======================================================================
4050 void SMESHGUI::createPopupItem( const int id,
4051 const QString& clients,
4052 const QString& types,
4053 const QString& theRule,
4056 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
4057 popupMgr()->insert( action( id ), pId, 0 );
4059 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4060 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4061 QString rule = "(%1) and (%2) and (%3)";
4062 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
4063 if( clients.isEmpty() )
4064 rule = rule.arg( QString( "true" ) );
4066 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
4067 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
4070 bool cont = myRules.contains( id );
4072 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
4074 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
4075 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
4078 //=======================================================================
4079 // function : initialize
4081 //=======================================================================
4082 void SMESHGUI::initialize( CAM_Application* app )
4084 SalomeApp_Module::initialize( app );
4086 // SUIT_ResourceMgr* mgr = app->resourceMgr();
4088 /* Automatic Update flag */
4089 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
4091 // ----- create actions --------------
4093 //createSMESHAction( SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
4094 createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_I) );
4095 createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
4096 createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL" );
4098 createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
4100 createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
4101 createSMESHAction( SMESHOp::OpImportGMF, "IMPORT_GMF" );
4102 createSMESHAction( SMESHOp::OpPopupImportUNV, "IMPORT_UNV");
4103 createSMESHAction( SMESHOp::OpPopupImportMED, "IMPORT_MED");
4104 createSMESHAction( SMESHOp::OpPopupImportSTL, "IMPORT_STL" );
4106 createSMESHAction( SMESHOp::OpPopupImportCGNS, "IMPORT_CGNS" );
4108 createSMESHAction( SMESHOp::OpPopupImportSAUV, "IMPORT_SAUV" );
4109 createSMESHAction( SMESHOp::OpPopupImportGMF, "IMPORT_GMF" );
4111 createSMESHAction( SMESHOp::OpExportDAT, "DAT" );
4112 createSMESHAction( SMESHOp::OpExportMED, "MED" );
4113 createSMESHAction( SMESHOp::OpExportUNV, "UNV" );
4114 createSMESHAction( SMESHOp::OpExportSTL, "STL" );
4116 createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
4118 createSMESHAction( SMESHOp::OpExportSAUV, "SAUV");
4119 createSMESHAction( SMESHOp::OpExportGMF, "GMF" );
4120 createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
4121 createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
4122 createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
4123 createSMESHAction( SMESHOp::OpPopupExportSTL, "STL" );
4125 createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
4127 createSMESHAction( SMESHOp::OpPopupExportSAUV, "SAUV");
4128 createSMESHAction( SMESHOp::OpPopupExportGMF, "GMF" );
4129 createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
4130 createSMESHAction( SMESHOp::OpDelete, "DELETE", "ICON_DELETE", Qt::Key_Delete );
4131 createSMESHAction( SMESHOp::OpSelectFiltersLibrary, "SEL_FILTER_LIB" );
4132 createSMESHAction( SMESHOp::OpCreateMesh, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
4133 createSMESHAction( SMESHOp::OpCreateSubMesh, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
4134 createSMESHAction( SMESHOp::OpEditMeshOrSubMesh, "EDIT_MESHSUBMESH", "ICON_DLG_EDIT_MESH" );
4135 createSMESHAction( SMESHOp::OpEditMesh, "EDIT_MESH", "ICON_DLG_EDIT_MESH" );
4136 createSMESHAction( SMESHOp::OpEditSubMesh, "EDIT_SUBMESH", "ICON_DLG_EDIT_MESH" );
4137 createSMESHAction( SMESHOp::OpBuildCompoundMesh, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
4138 createSMESHAction( SMESHOp::OpCopyMesh, "COPY_MESH", "ICON_COPY_MESH" );
4139 createSMESHAction( SMESHOp::OpCompute, "COMPUTE", "ICON_COMPUTE" );
4140 createSMESHAction( SMESHOp::OpComputeSubMesh, "COMPUTE_SUBMESH", "ICON_COMPUTE" );
4141 createSMESHAction( SMESHOp::OpRecompute, "RE_COMPUTE", "ICON_COMPUTE" );
4142 createSMESHAction( SMESHOp::OpPreCompute, "PRECOMPUTE", "ICON_PRECOMPUTE" );
4143 createSMESHAction( SMESHOp::OpShowErrors, "SHOW_ERRORS", "ICON_SHOW_ERRORS" );
4144 createSMESHAction( SMESHOp::OpEvaluate, "EVALUATE", "ICON_EVALUATE" );
4145 createSMESHAction( SMESHOp::OpMeshOrder, "MESH_ORDER", "ICON_MESH_ORDER");
4146 createSMESHAction( SMESHOp::OpCreateGroup, "CREATE_GROUP", "ICON_CREATE_GROUP" );
4147 createSMESHAction( SMESHOp::OpCreateGeometryGroup, "CREATE_GEO_GROUP", "ICON_CREATE_GEO_GROUP" );
4148 createSMESHAction( SMESHOp::OpConstructGroup, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
4149 createSMESHAction( SMESHOp::OpEditGroup, "EDIT_GROUP", "ICON_EDIT_GROUP" );
4150 createSMESHAction( SMESHOp::OpEditGeomGroupAsGroup, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
4151 createSMESHAction( SMESHOp::OpUnionGroups, "UN_GROUP", "ICON_UNION" );
4152 createSMESHAction( SMESHOp::OpIntersectGroups, "INT_GROUP", "ICON_INTERSECT" );
4153 createSMESHAction( SMESHOp::OpCutGroups, "CUT_GROUP", "ICON_CUT" );
4154 createSMESHAction( SMESHOp::OpGroupUnderlyingElem, "UNDERLYING_ELEMS", "ICON_UNDERLYING_ELEMS" );
4155 createSMESHAction( SMESHOp::OpFaceGroupsByEdges, "FACE_GROUPS_BY_EDGES", "ICON_FACE_GROUPS_BY_EDGES" );
4156 createSMESHAction( SMESHOp::OpAddElemGroupPopup, "ADD_TO_GROUP" );
4157 createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE_FROM_GROUP" );
4158 createSMESHAction( SMESHOp::OpDeleteGroup, "DEL_GROUP", "ICON_DEL_GROUP" );
4159 createSMESHAction( SMESHOp::OpMeshInformation , "ADV_INFO", "ICON_ADV_INFO" );
4160 //createSMESHAction( SMESHOp::OpStdInfo, "STD_INFO", "ICON_STD_INFO" );
4161 //createSMESHAction( SMESHOp::OpWhatIs, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4162 createSMESHAction( SMESHOp::OpFindElementByPoint, "FIND_ELEM", "ICON_FIND_ELEM" );
4164 createSMESHAction( SMESHOp::OpFreeNode, "FREE_NODE", "ICON_FREE_NODE", 0, true );
4165 createSMESHAction( SMESHOp::OpEqualNode, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
4166 createSMESHAction( SMESHOp::OpNodeConnectivityNb, "NODE_CONNECTIVITY_NB", "ICON_NODE_CONN_NB", 0, true );
4167 createSMESHAction( SMESHOp::OpFreeEdge, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
4168 createSMESHAction( SMESHOp::OpFreeBorder, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
4169 createSMESHAction( SMESHOp::OpLength, "LENGTH", "ICON_LENGTH", 0, true );
4170 createSMESHAction( SMESHOp::OpConnection, "CONNECTION", "ICON_CONNECTION", 0, true );
4171 createSMESHAction( SMESHOp::OpEqualEdge, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
4172 createSMESHAction( SMESHOp::OpFreeFace, "FREE_FACES", "ICON_FREE_FACES", 0, true );
4173 createSMESHAction( SMESHOp::OpBareBorderFace, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
4174 createSMESHAction( SMESHOp::OpOverConstrainedFace, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
4175 createSMESHAction( SMESHOp::OpLength2D, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
4176 createSMESHAction( SMESHOp::OpDeflection2D, "DEFLECTION_2D", "ICON_DEFLECTION_2D", 0, true );
4177 createSMESHAction( SMESHOp::OpConnection2D, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
4178 createSMESHAction( SMESHOp::OpArea, "AREA", "ICON_AREA", 0, true );
4179 createSMESHAction( SMESHOp::OpTaper, "TAPER", "ICON_TAPER", 0, true );
4180 createSMESHAction( SMESHOp::OpAspectRatio, "ASPECT", "ICON_ASPECT", 0, true );
4181 createSMESHAction( SMESHOp::OpMinimumAngle, "MIN_ANG", "ICON_ANGLE", 0, true );
4182 createSMESHAction( SMESHOp::OpWarpingAngle, "WARP", "ICON_WARP", 0, true );
4183 createSMESHAction( SMESHOp::OpSkew, "SKEW", "ICON_SKEW", 0, true );
4184 createSMESHAction( SMESHOp::OpMaxElementLength2D, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
4185 createSMESHAction( SMESHOp::OpEqualFace, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
4186 createSMESHAction( SMESHOp::OpAspectRatio3D, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
4187 createSMESHAction( SMESHOp::OpVolume, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
4188 createSMESHAction( SMESHOp::OpMaxElementLength3D, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
4189 createSMESHAction( SMESHOp::OpBareBorderVolume, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
4190 createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
4191 createSMESHAction( SMESHOp::OpEqualVolume, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
4192 createSMESHAction( SMESHOp::OpOverallMeshQuality, "OVERALL_MESH_QUALITY", "ICON_OVL_MESH_QUALITY" );
4194 createSMESHAction( SMESHOp::OpNode, "NODE", "ICON_DLG_NODE" );
4195 createSMESHAction( SMESHOp::OpElem0D, "ELEM0D", "ICON_DLG_ELEM0D" );
4196 createSMESHAction( SMESHOp::OpElem0DOnElemNodes, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
4197 createSMESHAction( SMESHOp::OpBall, "BALL", "ICON_DLG_BALL" );
4198 createSMESHAction( SMESHOp::OpEdge, "EDGE", "ICON_DLG_EDGE" );
4199 createSMESHAction( SMESHOp::OpTriangle, "TRIANGLE", "ICON_DLG_TRIANGLE" );
4200 createSMESHAction( SMESHOp::OpQuadrangle, "QUAD", "ICON_DLG_QUADRANGLE" );
4201 createSMESHAction( SMESHOp::OpPolygon, "POLYGON", "ICON_DLG_POLYGON" );
4202 createSMESHAction( SMESHOp::OpTetrahedron, "TETRA", "ICON_DLG_TETRAS" );
4203 createSMESHAction( SMESHOp::OpHexahedron, "HEXA", "ICON_DLG_HEXAS" );
4204 createSMESHAction( SMESHOp::OpPentahedron, "PENTA", "ICON_DLG_PENTA" );
4205 createSMESHAction( SMESHOp::OpPyramid , "PYRAMID", "ICON_DLG_PYRAMID" );
4206 createSMESHAction( SMESHOp::OpHexagonalPrism, "OCTA", "ICON_DLG_OCTA" );
4207 createSMESHAction( SMESHOp::OpPolyhedron, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
4208 createSMESHAction( SMESHOp::OpQuadraticEdge, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
4209 createSMESHAction( SMESHOp::OpQuadraticTriangle, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
4210 createSMESHAction( SMESHOp::OpBiQuadraticTriangle, "BIQUADRATIC_TRIANGLE", "ICON_DLG_BIQUADRATIC_TRIANGLE" );
4211 createSMESHAction( SMESHOp::OpQuadraticQuadrangle, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
4212 createSMESHAction( SMESHOp::OpBiQuadraticQuadrangle, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
4213 createSMESHAction( SMESHOp::OpQuadraticPolygon, "QUADRATIC_POLYGON", "ICON_DLG_QUADRATIC_POLYGON" );
4214 createSMESHAction( SMESHOp::OpQuadraticTetrahedron, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
4215 createSMESHAction( SMESHOp::OpQuadraticPyramid, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
4216 createSMESHAction( SMESHOp::OpQuadraticPentahedron, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
4217 createSMESHAction( SMESHOp::OpBiQuadraticPentahedron, "BIQUADRATIC_PENTAHEDRON", "ICON_DLG_BIQUADRATIC_PENTAHEDRON" );
4218 createSMESHAction( SMESHOp::OpQuadraticHexahedron, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
4219 createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
4221 createSMESHAction( SMESHOp::OpRemoveNodes, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
4222 createSMESHAction( SMESHOp::OpRemoveElements, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
4223 createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
4224 createSMESHAction( SMESHOp::OpClearMesh, "CLEAR_MESH", "ICON_CLEAR_MESH" );
4226 //createSMESHAction( SMESHOp::OpRenumberingNodes, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
4227 //createSMESHAction( SMESHOp::OpRenumberingElements, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
4229 createSMESHAction( SMESHOp::OpTranslation, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
4230 createSMESHAction( SMESHOp::OpRotation, "ROT", "ICON_DLG_MESH_ROTATION" );
4231 createSMESHAction( SMESHOp::OpSymmetry, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
4232 createSMESHAction( SMESHOp::OpScale, "SCALE", "ICON_DLG_MESH_SCALE" );
4233 createSMESHAction( SMESHOp::OpOffset, "OFFSET", "ICON_DLG_MESH_OFFSET" );
4234 createSMESHAction( SMESHOp::OpSewing, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
4235 createSMESHAction( SMESHOp::OpMergeNodes, "MERGE", "ICON_SMESH_MERGE_NODES" );
4236 createSMESHAction( SMESHOp::OpMergeElements, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
4237 createSMESHAction( SMESHOp::OpMoveNode, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
4238 createSMESHAction( SMESHOp::OpDuplicateNodes, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
4239 createSMESHAction( SMESHOp::OpDiagonalInversion, "INV", "ICON_DLG_MESH_DIAGONAL" );
4240 createSMESHAction( SMESHOp::OpUnionOfTwoTriangle, "UNION2", "ICON_UNION2TRI" );
4241 createSMESHAction( SMESHOp::OpOrientation, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
4242 createSMESHAction( SMESHOp::OpReorientFaces, "REORIENT_2D", "ICON_REORIENT_2D" );
4243 createSMESHAction( SMESHOp::OpUnionOfTriangles, "UNION", "ICON_UNIONTRI" );
4244 createSMESHAction( SMESHOp::OpCuttingOfQuadrangles, "CUT", "ICON_CUTQUAD" );
4245 createSMESHAction( SMESHOp::OpSplitVolumes, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
4246 createSMESHAction( SMESHOp::OpSplitBiQuadratic, "SPLIT_BIQUAD", "ICON_SPLIT_BIQUAD" );
4247 createSMESHAction( SMESHOp::OpSmoothing, "SMOOTH", "ICON_DLG_SMOOTHING" );
4248 createSMESHAction( SMESHOp::OpExtrusion, "EXTRUSION", "ICON_EXTRUSION" );
4249 createSMESHAction( SMESHOp::OpExtrusionAlongAPath, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
4250 createSMESHAction( SMESHOp::OpRevolution, "REVOLUTION", "ICON_REVOLUTION" );
4251 createSMESHAction( SMESHOp::OpPatternMapping, "MAP", "ICON_MAP" );
4252 createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
4253 createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D", "ICON_2D_FROM_3D" );
4255 createSMESHAction( SMESHOp::OpReset, "RESET" );
4256 createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
4257 createSMESHAction( SMESHOp::OpShowScalarBar, "SHOW_SCALAR_BAR","",0, true );
4258 createSMESHAction( SMESHOp::OpSaveDistribution, "SAVE_DISTRIBUTION" );
4259 createSMESHAction( SMESHOp::OpShowDistribution, "SHOW_DISTRIBUTION","",0, true );
4260 #ifndef DISABLE_PLOT2DVIEWER
4261 createSMESHAction( SMESHOp::OpPlotDistribution, "PLOT_DISTRIBUTION" );
4263 createSMESHAction( SMESHOp::OpDMWireframe, "WIRE", "ICON_WIRE", 0, true );
4264 createSMESHAction( SMESHOp::OpDMShading, "SHADE", "ICON_SHADE", 0, true );
4265 createSMESHAction( SMESHOp::OpDMNodes, "NODES", "ICON_POINTS", 0, true );
4266 createSMESHAction( SMESHOp::OpDMShrink, "SHRINK", "ICON_SHRINK", 0, true );
4267 createSMESHAction( SMESHOp::OpUpdate, "UPDATE", "ICON_UPDATE" );
4268 createSMESHAction( SMESHOp::OpDE0DElements, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
4269 createSMESHAction( SMESHOp::OpDEEdges, "EDGES", "ICON_DLG_EDGE", 0, true );
4270 createSMESHAction( SMESHOp::OpDEFaces, "FACES", "ICON_DLG_TRIANGLE", 0, true );
4271 createSMESHAction( SMESHOp::OpDEVolumes, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
4272 createSMESHAction( SMESHOp::OpDEBalls, "BALLS", "ICON_DLG_BALL", 0, true );
4273 createSMESHAction( SMESHOp::OpDEChoose, "CHOOSE", "ICON_DLG_CHOOSE", 0, false );
4274 createSMESHAction( SMESHOp::OpDEAllEntity, "ALL", "ICON_DLG_CHOOSE_ALL", 0, false );
4275 createSMESHAction( SMESHOp::OpOrientationOnFaces, "FACE_ORIENTATION", "", 0, true );
4277 createSMESHAction( SMESHOp::OpRepresentationLines, "LINE_REPRESENTATION", "", 0, true );
4278 createSMESHAction( SMESHOp::OpRepresentationArcs, "ARC_REPRESENTATION", "", 0, true );
4280 createSMESHAction( SMESHOp::OpEditHypothesis, "EDIT_HYPO" );
4281 createSMESHAction( SMESHOp::OpUnassign, "UNASSIGN" );
4282 createSMESHAction( SMESHOp::OpNumberingNodes, "NUM_NODES", "", 0, true );
4283 createSMESHAction( SMESHOp::OpNumberingElements, "NUM_ELEMENTS", "", 0, true );
4284 createSMESHAction( SMESHOp::OpProperties, "COLORS" );
4285 createSMESHAction( SMESHOp::OpTransparency, "TRANSP" );
4286 createSMESHAction( SMESHOp::OpClipping, "CLIP" );
4287 createSMESHAction( SMESHOp::OpAutoColor, "AUTO_COLOR" );
4288 createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
4290 // Adaptation - begin
4291 createSMESHAction( SMESHOp::OpUniformRefinement, "REF_ALL", "ICON_REF_ALL" );
4292 createSMESHAction( SMESHOp::OpHONewCase, "HOMARD_CREATE_CASE", "ICON_HOMARD_CREATE_CASE" );
4293 createSMESHAction( SMESHOp::OpHOCaseFollow, "HOMARD_FOLLOW_ITERATION", "ICON_HOMARD_FOLLOW_ITERATION" );
4294 createSMESHAction( SMESHOp::OpHONewIter, "HOMARD_NEW_ITERATION", "ICON_HOMARD_NEW_ITERATION" );
4295 createSMESHAction( SMESHOp::OpHOIterCompute, "HOMARD_COMPUTE", "ICON_HOMARD_COMPUTE" );
4296 createSMESHAction( SMESHOp::OpHOIterComputePublish, "HOMARD_COMPUTE_PUBLISH", "ICON_HOMARD_COMPUTE_PUBLISH" );
4297 createSMESHAction( SMESHOp::OpHOEdit, "EDIT", "ICON_DLG_EDIT_MESH" );
4298 createSMESHAction( SMESHOp::OpHODelete, "DELETE", "ICON_DELETE" );
4299 createSMESHAction( SMESHOp::OpMGAdapt, "MG_ADAPT", "ICON_MG_ADAPT" );
4302 createSMESHAction( SMESHOp::OpMinimumDistance, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
4303 createSMESHAction( SMESHOp::OpBoundingBox, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
4304 createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH", "ICON_MEASURE_LENGTH" );
4305 createSMESHAction( SMESHOp::OpPropertiesArea, "MEASURE_AREA", "ICON_MEASURE_AREA" );
4306 createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME", "ICON_MEASURE_VOLUME" );
4307 createSMESHAction( SMESHOp::OpAngle, "MEASURE_ANGLE", "ICON_MEASURE_ANGLE" );
4309 createSMESHAction( SMESHOp::OpHide, "HIDE", "ICON_HIDE" );
4310 createSMESHAction( SMESHOp::OpShow, "SHOW", "ICON_SHOW" );
4311 createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
4313 createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
4315 createSMESHAction( SMESHOp::OpBreakLink, "BREAK_SHAPER_LINK" );
4317 QList<int> aCtrlActions;
4318 aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode
4319 << SMESHOp::OpNodeConnectivityNb // node controls
4320 << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
4321 << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge // edge controls
4322 << SMESHOp::OpDeflection2D
4323 << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
4324 << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
4325 << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
4326 << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
4327 << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace // face controls
4328 << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
4329 << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
4330 << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume; // volume controls
4331 QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
4332 aCtrlGroup->setExclusive( true );
4333 for( int i = 0; i < aCtrlActions.size(); i++ )
4334 aCtrlGroup->addAction( action( aCtrlActions[i] ) );
4336 // ----- create menu --------------
4337 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
4338 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
4339 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
4340 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
4341 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
4342 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
4343 adaptId = createMenu( tr( "MEN_ADAPT" ), -1, 80, 10 ),
4344 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
4345 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
4347 createMenu( separator(), fileId );
4349 QMenu* nodeMenu = new QMenu(); QMenu* edgeMenu = new QMenu();
4350 QMenu* faceMenu = new QMenu(); QMenu* volumeMenu = new QMenu();
4351 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
4352 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
4353 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10, -1, nodeMenu ),
4354 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10, -1, edgeMenu ),
4355 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10, -1, faceMenu ),
4356 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10, -1, volumeMenu ),
4357 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
4358 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
4359 //renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
4360 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
4361 refHomardId = createMenu( tr( "MEN_REF_HOMARD" ), adaptId, -1, 10 ),
4362 basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
4364 //createMenu( SMESHOp::OpImportDAT, importId, -1 );
4365 createMenu( SMESHOp::OpImportUNV, importId, -1 );
4366 createMenu( SMESHOp::OpImportMED, importId, -1 );
4367 createMenu( SMESHOp::OpImportSTL, importId, -1 );
4369 createMenu( SMESHOp::OpImportCGNS, importId, -1 );
4371 createMenu( SMESHOp::OpImportSAUV, importId, -1 );
4372 createMenu( SMESHOp::OpImportGMF, importId, -1 );
4373 createMenu( SMESHOp::OpExportDAT, exportId, -1 );
4374 createMenu( SMESHOp::OpExportMED, exportId, -1 );
4375 createMenu( SMESHOp::OpExportUNV, exportId, -1 );
4376 createMenu( SMESHOp::OpExportSTL, exportId, -1 );
4378 createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
4380 createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
4381 createMenu( SMESHOp::OpExportGMF, exportId, -1 );
4382 createMenu( separator(), fileId, 10 );
4384 createMenu( SMESHOp::OpDelete, editId, -1 );
4386 createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
4388 createMenu( SMESHOp::OpCreateMesh, meshId, -1 ); // "Mesh" menu
4389 createMenu( SMESHOp::OpCreateSubMesh, meshId, -1 );
4390 createMenu( SMESHOp::OpEditMeshOrSubMesh, meshId, -1 );
4391 createMenu( SMESHOp::OpBuildCompoundMesh, meshId, -1 );
4392 createMenu( SMESHOp::OpCopyMesh, meshId, -1 );
4393 createMenu( separator(), meshId, -1 );
4394 createMenu( SMESHOp::OpCompute, meshId, -1 );
4395 createMenu( SMESHOp::OpPreCompute, meshId, -1 );
4396 createMenu( SMESHOp::OpEvaluate, meshId, -1 );
4397 createMenu( SMESHOp::OpMeshOrder, meshId, -1 );
4398 createMenu( separator(), meshId, -1 );
4399 createMenu( SMESHOp::OpCreateGroup, meshId, -1 );
4400 createMenu( SMESHOp::OpCreateGeometryGroup, meshId, -1 );
4401 createMenu( SMESHOp::OpConstructGroup, meshId, -1 );
4402 createMenu( SMESHOp::OpEditGroup, meshId, -1 );
4403 createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4404 createMenu( separator(), meshId, -1 );
4405 createMenu( SMESHOp::OpUnionGroups, meshId, -1 );
4406 createMenu( SMESHOp::OpIntersectGroups, meshId, -1 );
4407 createMenu( SMESHOp::OpCutGroups, meshId, -1 );
4408 createMenu( separator(), meshId, -1 );
4409 createMenu( SMESHOp::OpGroupUnderlyingElem, meshId, -1 );
4410 createMenu( SMESHOp::OpFaceGroupsByEdges, meshId, -1 );
4411 createMenu( separator(), meshId, -1 );
4412 createMenu( SMESHOp::OpMeshInformation, meshId, -1 );
4413 //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4414 //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4415 createMenu( SMESHOp::OpFindElementByPoint, meshId, -1 );
4416 createMenu( separator(), meshId, -1 );
4418 createMenu( SMESHOp::OpFreeNode, nodeId, -1 );
4419 createMenu( SMESHOp::OpEqualNode, nodeId, -1 );
4420 //createMenu( SMESHOp::OpNodeConnectivityNb, nodeId, -1 );
4421 createMenu( SMESHOp::OpFreeBorder, edgeId, -1 );
4422 createMenu( SMESHOp::OpLength, edgeId, -1 );
4423 createMenu( SMESHOp::OpConnection, edgeId, -1 );
4424 createMenu( SMESHOp::OpEqualEdge, edgeId, -1 );
4425 createMenu( SMESHOp::OpFreeEdge, faceId, -1 );
4426 createMenu( SMESHOp::OpFreeFace, faceId, -1 );
4427 createMenu( SMESHOp::OpBareBorderFace, faceId, -1 );
4428 createMenu( SMESHOp::OpOverConstrainedFace, faceId, -1 );
4429 createMenu( SMESHOp::OpLength2D, faceId, -1 );
4430 createMenu( SMESHOp::OpConnection2D, faceId, -1 );
4431 createMenu( SMESHOp::OpArea, faceId, -1 );
4432 createMenu( SMESHOp::OpTaper, faceId, -1 );
4433 createMenu( SMESHOp::OpAspectRatio, faceId, -1 );
4434 createMenu( SMESHOp::OpMinimumAngle, faceId, -1 );
4435 createMenu( SMESHOp::OpWarpingAngle, faceId, -1 );
4436 createMenu( SMESHOp::OpSkew, faceId, -1 );
4437 createMenu( SMESHOp::OpMaxElementLength2D, faceId, -1 );
4438 createMenu( SMESHOp::OpEqualFace, faceId, -1 );
4439 createMenu( SMESHOp::OpDeflection2D, faceId, -1 );
4440 createMenu( SMESHOp::OpAspectRatio3D, volumeId, -1 );
4441 createMenu( SMESHOp::OpVolume, volumeId, -1 );
4442 createMenu( SMESHOp::OpMaxElementLength3D, volumeId, -1 );
4443 createMenu( SMESHOp::OpBareBorderVolume, volumeId, -1 );
4444 createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4445 createMenu( SMESHOp::OpEqualVolume, volumeId, -1 );
4446 createMenu( separator(), ctrlId, -1 );
4447 createMenu( SMESHOp::OpReset, ctrlId, -1 );
4448 createMenu( separator(), ctrlId, -1 );
4449 createMenu( SMESHOp::OpOverallMeshQuality, ctrlId, -1 );
4451 createMenu( SMESHOp::OpNode, addId, -1 );
4452 createMenu( SMESHOp::OpElem0D, addId, -1 );
4453 createMenu( SMESHOp::OpElem0DOnElemNodes, addId, -1 );
4454 createMenu( SMESHOp::OpBall, addId, -1 );
4455 createMenu( SMESHOp::OpEdge, addId, -1 );
4456 createMenu( SMESHOp::OpTriangle, addId, -1 );
4457 createMenu( SMESHOp::OpQuadrangle, addId, -1 );
4458 createMenu( SMESHOp::OpPolygon, addId, -1 );
4459 createMenu( SMESHOp::OpTetrahedron, addId, -1 );
4460 createMenu( SMESHOp::OpHexahedron, addId, -1 );
4461 createMenu( SMESHOp::OpPentahedron, addId, -1 );
4462 createMenu( SMESHOp::OpPyramid, addId, -1 );
4463 createMenu( SMESHOp::OpHexagonalPrism, addId, -1 );
4464 createMenu( SMESHOp::OpPolyhedron, addId, -1 );
4465 createMenu( separator(), addId, -1 );
4466 createMenu( SMESHOp::OpQuadraticEdge, addId, -1 );
4467 createMenu( SMESHOp::OpQuadraticTriangle, addId, -1 );
4468 createMenu( SMESHOp::OpBiQuadraticTriangle , addId, -1 );
4469 createMenu( SMESHOp::OpQuadraticQuadrangle, addId, -1 );
4470 createMenu( SMESHOp::OpBiQuadraticQuadrangle, addId, -1 );
4471 createMenu( SMESHOp::OpQuadraticPolygon, addId, -1 );
4472 createMenu( SMESHOp::OpQuadraticTetrahedron, addId, -1 );
4473 createMenu( SMESHOp::OpQuadraticPyramid, addId, -1 );
4474 createMenu( SMESHOp::OpQuadraticPentahedron, addId, -1 );
4475 createMenu( SMESHOp::OpBiQuadraticPentahedron, addId, -1 );
4476 createMenu( SMESHOp::OpQuadraticHexahedron, addId, -1 );
4477 createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4479 createMenu( SMESHOp::OpRemoveNodes, removeId, -1 );
4480 createMenu( SMESHOp::OpRemoveElements, removeId, -1 );
4481 createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4482 createMenu( separator(), removeId, -1 );
4483 createMenu( SMESHOp::OpDeleteGroup, removeId, -1 );
4484 createMenu( separator(), removeId, -1 );
4485 createMenu( SMESHOp::OpClearMesh, removeId, -1 );
4487 //createMenu( SMESHOp::OpRenumberingNodes, renumId, -1 );
4488 //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4490 createMenu( SMESHOp::OpMergeNodes, transfId, -1 );
4491 createMenu( SMESHOp::OpMergeElements, transfId, -1 );
4492 createMenu( SMESHOp::OpTranslation, transfId, -1 );
4493 createMenu( SMESHOp::OpRotation, transfId, -1 );
4494 createMenu( SMESHOp::OpSymmetry, transfId, -1 );
4495 createMenu( SMESHOp::OpScale, transfId, -1 );
4496 createMenu( SMESHOp::OpOffset, transfId, -1 );
4497 createMenu( SMESHOp::OpSewing, transfId, -1 );
4498 createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4500 createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4501 createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4502 createMenu( SMESHOp::OpExtrusion, modifyId, -1 );
4503 createMenu( SMESHOp::OpExtrusionAlongAPath, modifyId, -1 );
4504 createMenu( SMESHOp::OpRevolution, modifyId, -1 );
4505 createMenu( SMESHOp::OpOrientation, modifyId, -1 );
4506 createMenu( SMESHOp::OpReorientFaces, modifyId, -1 );
4507 createMenu( SMESHOp::OpMoveNode, modifyId, -1 );
4508 createMenu( SMESHOp::OpDiagonalInversion, modifyId, -1 );
4509 createMenu( SMESHOp::OpUnionOfTwoTriangle, modifyId, -1 );
4510 createMenu( SMESHOp::OpUnionOfTriangles, modifyId, -1 );
4511 createMenu( SMESHOp::OpCuttingOfQuadrangles, modifyId, -1 );
4512 createMenu( SMESHOp::OpSplitVolumes, modifyId, -1 );
4513 createMenu( SMESHOp::OpSplitBiQuadratic, modifyId, -1 );
4514 createMenu( SMESHOp::OpSmoothing, modifyId, -1 );
4515 createMenu( SMESHOp::OpPatternMapping, modifyId, -1 );
4517 // Adaptation - begin
4518 createMenu( SMESHOp::OpUniformRefinement, adaptId, -1 );
4519 createMenu( SMESHOp::OpHONewCase, refHomardId, -1 );
4520 createMenu( SMESHOp::OpHOCaseFollow, refHomardId, -1 );
4521 createMenu( separator(), refHomardId, -1 );
4522 createMenu( SMESHOp::OpHONewIter, refHomardId, -1 );
4523 createMenu( SMESHOp::OpHOIterCompute, refHomardId, -1 );
4524 createMenu( SMESHOp::OpHOIterComputePublish, refHomardId, -1 );
4525 createMenu( separator(), refHomardId, -1 );
4526 createMenu( SMESHOp::OpHOEdit, refHomardId, -1 );
4527 createMenu( SMESHOp::OpHODelete, refHomardId, -1 );
4528 createMenu( SMESHOp::OpMGAdapt, adaptId, -1 );
4531 createMenu( SMESHOp::OpMinimumDistance, measureId, -1 );
4532 createMenu( SMESHOp::OpBoundingBox, measureId, -1 );
4533 createMenu( SMESHOp::OpAngle, measureId, -1 );
4534 createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4535 createMenu( SMESHOp::OpPropertiesArea, basicPropId, -1 );
4536 createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4537 createMenu( SMESHOp::OpUpdate, viewId, -1 );
4539 connect( nodeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4540 connect( edgeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4541 connect( faceMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4542 connect( volumeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4544 // ----- create toolbars --------------
4545 int meshTb = createTool( tr( "TB_MESH" ), QString( "SMESHMeshToolbar" ) ) ;
4546 createTool( SMESHOp::OpCreateMesh, meshTb );
4547 createTool( SMESHOp::OpCreateSubMesh, meshTb );
4548 createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4549 createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4550 createTool( SMESHOp::OpCopyMesh, meshTb );
4551 createTool( separator(), meshTb );
4552 createTool( SMESHOp::OpCompute, meshTb );
4553 createTool( SMESHOp::OpPreCompute, meshTb );
4554 createTool( SMESHOp::OpEvaluate, meshTb );
4555 createTool( SMESHOp::OpMeshOrder, meshTb );
4557 int infoTb = createTool( tr( "TB_INFO" ), QString( "SMESHInformationToolbar" ) ) ;
4558 createTool( SMESHOp::OpMeshInformation, infoTb );
4559 //createTool( SMESHOp::OpStdInfo, meshTb );
4560 //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4561 createTool( SMESHOp::OpFindElementByPoint, infoTb );
4563 int groupTb = createTool( tr( "TB_GROUP" ), QString( "SMESHGroupToolbar" ) ) ;
4564 createTool( SMESHOp::OpCreateGroup, groupTb );
4565 createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4566 createTool( SMESHOp::OpConstructGroup, groupTb );
4567 createTool( SMESHOp::OpEditGroup, groupTb );
4569 int ctrl0dTb = createTool( tr( "TB_CTRL0D" ), QString( "SMESHNodeControlsToolbar" ) ) ;
4570 createTool( SMESHOp::OpFreeNode, ctrl0dTb );
4571 createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4572 //createTool( SMESHOp::OpNodeConnectivityNb, ctrl0dTb );
4574 int ctrl1dTb = createTool( tr( "TB_CTRL1D" ), QString( "SMESHEdgeControlsToolbar" ) ) ;
4575 createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4576 createTool( SMESHOp::OpLength, ctrl1dTb );
4577 createTool( SMESHOp::OpConnection, ctrl1dTb );
4578 createTool( SMESHOp::OpEqualEdge, ctrl1dTb );
4580 int ctrl2dTb = createTool( tr( "TB_CTRL2D" ), QString( "SMESHFaceControlsToolbar" ) ) ;
4581 createTool( SMESHOp::OpFreeEdge, ctrl2dTb );
4582 createTool( SMESHOp::OpFreeFace, ctrl2dTb );
4583 createTool( SMESHOp::OpBareBorderFace, ctrl2dTb );
4584 createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4585 createTool( SMESHOp::OpLength2D, ctrl2dTb );
4586 createTool( SMESHOp::OpConnection2D, ctrl2dTb );
4587 createTool( SMESHOp::OpArea, ctrl2dTb );
4588 createTool( SMESHOp::OpTaper, ctrl2dTb );
4589 createTool( SMESHOp::OpAspectRatio, ctrl2dTb );
4590 createTool( SMESHOp::OpMinimumAngle, ctrl2dTb );
4591 createTool( SMESHOp::OpWarpingAngle, ctrl2dTb );
4592 createTool( SMESHOp::OpSkew, ctrl2dTb );
4593 createTool( SMESHOp::OpMaxElementLength2D, ctrl2dTb );
4594 createTool( SMESHOp::OpEqualFace, ctrl2dTb );
4595 createTool( SMESHOp::OpDeflection2D, ctrl2dTb );
4597 int ctrl3dTb = createTool( tr( "TB_CTRL3D" ), QString( "SMESHVolumeControlsToolbar" ) ) ;
4598 createTool( SMESHOp::OpAspectRatio3D, ctrl3dTb );
4599 createTool( SMESHOp::OpVolume, ctrl3dTb );
4600 createTool( SMESHOp::OpMaxElementLength3D, ctrl3dTb );
4601 createTool( SMESHOp::OpBareBorderVolume, ctrl3dTb );
4602 createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
4603 createTool( SMESHOp::OpEqualVolume, ctrl3dTb );
4605 int addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ) ;
4606 createTool( SMESHOp::OpNode, addElemTb );
4607 createTool( SMESHOp::OpElem0D, addElemTb );
4608 createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4609 createTool( SMESHOp::OpBall, addElemTb );
4610 createTool( SMESHOp::OpEdge, addElemTb );
4611 createTool( SMESHOp::OpTriangle, addElemTb );
4612 createTool( SMESHOp::OpQuadrangle, addElemTb );
4613 createTool( SMESHOp::OpPolygon, addElemTb );
4614 createTool( SMESHOp::OpTetrahedron, addElemTb );
4615 createTool( SMESHOp::OpHexahedron, addElemTb );
4616 createTool( SMESHOp::OpPentahedron, addElemTb );
4617 createTool( SMESHOp::OpPyramid, addElemTb );
4618 createTool( SMESHOp::OpHexagonalPrism, addElemTb );
4619 createTool( SMESHOp::OpPolyhedron, addElemTb );
4621 int addNonElemTb = createTool( tr( "TB_ADDNON" ), QString( "SMESHAddElementToolbar" ) ) ;
4622 createTool( SMESHOp::OpQuadraticEdge, addNonElemTb );
4623 createTool( SMESHOp::OpQuadraticTriangle, addNonElemTb );
4624 createTool( SMESHOp::OpBiQuadraticTriangle, addNonElemTb );
4625 createTool( SMESHOp::OpQuadraticQuadrangle, addNonElemTb );
4626 createTool( SMESHOp::OpBiQuadraticQuadrangle, addNonElemTb );
4627 createTool( SMESHOp::OpQuadraticPolygon, addNonElemTb );
4628 createTool( SMESHOp::OpQuadraticTetrahedron, addNonElemTb );
4629 createTool( SMESHOp::OpQuadraticPyramid, addNonElemTb );
4630 createTool( SMESHOp::OpQuadraticPentahedron, addNonElemTb );
4631 createTool( SMESHOp::OpBiQuadraticPentahedron, addNonElemTb );
4632 createTool( SMESHOp::OpQuadraticHexahedron, addNonElemTb );
4633 createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4635 int remTb = createTool( tr( "TB_REM" ), QString( "SMESHRemoveToolbar" ) ) ;
4636 createTool( SMESHOp::OpRemoveNodes, remTb );
4637 createTool( SMESHOp::OpRemoveElements, remTb );
4638 createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4639 createTool( SMESHOp::OpClearMesh, remTb );
4641 // int renumbTb = createTool( tr( "TB_RENUMBER" ), QString( "SMESHRenumberingToolbar" ) ) ;
4642 //createTool( SMESHOp::OpRenumberingNodes, renumbTb );
4643 //createTool( SMESHOp::OpRenumberingElements, renumbTb );
4645 int transformTb = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ) ;
4646 createTool( SMESHOp::OpMergeNodes, transformTb );
4647 createTool( SMESHOp::OpMergeElements, transformTb );
4648 createTool( SMESHOp::OpTranslation, transformTb );
4649 createTool( SMESHOp::OpRotation, transformTb );
4650 createTool( SMESHOp::OpSymmetry, transformTb );
4651 createTool( SMESHOp::OpScale, transformTb );
4652 createTool( SMESHOp::OpOffset, transformTb );
4653 createTool( SMESHOp::OpSewing, transformTb );
4654 createTool( SMESHOp::OpDuplicateNodes, transformTb );
4656 int modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ) ;
4657 createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4658 createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4659 createTool( SMESHOp::OpExtrusion, modifyTb );
4660 createTool( SMESHOp::OpExtrusionAlongAPath, modifyTb );
4661 createTool( SMESHOp::OpRevolution, modifyTb );
4662 createTool( SMESHOp::OpOrientation, modifyTb );
4663 createTool( SMESHOp::OpReorientFaces, modifyTb );
4664 createTool( SMESHOp::OpMoveNode, modifyTb );
4665 createTool( SMESHOp::OpDiagonalInversion, modifyTb );
4666 createTool( SMESHOp::OpUnionOfTwoTriangle, modifyTb );
4667 createTool( SMESHOp::OpUnionOfTriangles, modifyTb );
4668 createTool( SMESHOp::OpCuttingOfQuadrangles, modifyTb );
4669 createTool( SMESHOp::OpSplitVolumes, modifyTb );
4670 createTool( SMESHOp::OpSplitBiQuadratic, modifyTb );
4671 createTool( SMESHOp::OpSmoothing, modifyTb );
4672 createTool( SMESHOp::OpPatternMapping, modifyTb );
4674 // Adaptation - begin
4675 int adaptTb = createTool( tr( "TB_ADAPTATION" ),QString( "SMESHAdaptationToolbar" ) ) ;
4676 createTool( SMESHOp::OpUniformRefinement, adaptTb );
4677 createTool( SMESHOp::OpHONewCase, adaptTb );
4678 createTool( SMESHOp::OpHOCaseFollow, adaptTb );
4679 createTool( SMESHOp::OpHONewIter, adaptTb );
4680 createTool( SMESHOp::OpHOIterCompute, adaptTb );
4681 createTool( SMESHOp::OpHOIterComputePublish, adaptTb );
4682 createTool( SMESHOp::OpMGAdapt, adaptTb );
4685 int measuremTb = createTool( tr( "TB_MEASUREM" ), QString( "SMESHMeasurementsToolbar" ) ) ;
4686 createTool( SMESHOp::OpMinimumDistance, measuremTb );
4688 int dispModeTb = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4689 createTool( SMESHOp::OpUpdate, dispModeTb );
4691 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4692 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4696 OB = "'ObjectBrowser'",
4697 View = "'" + SVTK_Viewer::Type() + "'",
4699 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4700 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4701 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4702 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4703 smesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::COMPONENT ) ),
4704 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4705 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4706 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4707 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4708 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4709 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4710 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4712 mesh_part = mesh + " " + subMesh + " " + group,
4713 mesh_group = mesh + " " + group,
4714 mesh_submesh = mesh + " " + subMesh,
4715 hyp_alg = hypo + " " + algo;
4717 // popup for object browser
4719 isInvisible("not( isVisible )"),
4720 isEmpty("numberOfNodes = 0"),
4721 isNotEmpty("numberOfNodes <> 0"),
4723 // has nodes, edges, etc in VISIBLE! actor
4724 hasNodes("(numberOfNodes > 0 ) && hasActor"),
4725 hasElems("(count( elemTypes ) > 0)"),
4726 hasDifferentElems("(count( elemTypes ) > 1)"),
4727 hasDifferentObjElems("(count( objElemTypes ) > 1)"),
4728 hasBalls("({'BallElem'} in elemTypes)"),
4729 hasElems0d("({'Elem0d'} in elemTypes)"),
4730 hasEdges("({'Edge'} in elemTypes)"),
4731 hasFaces("({'Face'} in elemTypes)"),
4732 hasVolumes("({'Volume'} in elemTypes)"),
4733 hasFacesOrVolumes("(({'Face'} in elemTypes) || ({'Volume'} in elemTypes)) ");
4735 createPopupItem( SMESHOp::OpEditMesh, OB, mesh, "&& selcount=1" );
4736 createPopupItem( SMESHOp::OpCreateSubMesh, OB, mesh, "&& hasGeomReference");
4737 createPopupItem( SMESHOp::OpMeshOrder, OB, mesh, "&& selcount=1 && hasAlgo && hasGeomReference" );
4738 createPopupItem( SMESHOp::OpEditSubMesh, OB, subMesh, "&& selcount=1 && hasGeomReference" );
4739 createPopupItem( SMESHOp::OpEditGroup, OB, group );
4740 createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4742 popupMgr()->insert( separator(), -1, 0 );
4743 createPopupItem( SMESHOp::OpCompute, OB, mesh, "&& selcount=1 && hasAlgo && isComputable" );
4744 createPopupItem( SMESHOp::OpRecompute, OB, mesh, "&& selcount=1 && hasAlgo && (" + isNotEmpty + " || hasErrors )");
4745 createPopupItem( SMESHOp::OpShowErrors, OB, mesh, "&& selcount=1 && hasErrors" );
4746 createPopupItem( SMESHOp::OpComputeSubMesh, OB, subMesh, "&& selcount=1 && hasAlgo && isComputable" );
4747 createPopupItem( SMESHOp::OpPreCompute, OB, mesh, "&& selcount=1 && hasAlgo && isPreComputable" );
4748 createPopupItem( SMESHOp::OpEvaluate, OB, mesh, "&& selcount=1 && hasAlgo && isComputable" );
4749 popupMgr()->insert( separator(), -1, 0 );
4750 createPopupItem( SMESHOp::OpFileInformation, OB, mesh, "&& selcount=1 && isImported" );
4751 createPopupItem( SMESHOp::OpMeshInformation, OB, mesh_part );
4752 createPopupItem( SMESHOp::OpFindElementByPoint,OB, mesh_group, "&& selcount=1 && " + hasElems );
4753 createPopupItem( SMESHOp::OpOverallMeshQuality,OB, mesh_part );
4754 popupMgr()->insert( separator(), -1, 0 );
4755 createPopupItem( SMESHOp::OpCreateGroup, OB, mesh, "&& selcount=1" );
4756 createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh, "&& selcount=1 && hasGeomReference" );
4757 createPopupItem( SMESHOp::OpConstructGroup, OB, subMesh );
4758 popupMgr()->insert( separator(), -1, 0 );
4759 createPopupItem( SMESHOp::OpEditHypothesis, OB, hypo, "&& isEditableHyp");
4760 createPopupItem( SMESHOp::OpUnassign, OB, hyp_alg );
4761 popupMgr()->insert( separator(), -1, 0 );
4762 createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh_submesh, "&& " + hasElems );
4763 createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh_group, "&& selcount=1 && dim>=2");
4764 popupMgr()->insert( separator(), -1, 0 );
4766 // Adaptation - begin
4767 createPopupItem( SMESHOp::OpUniformRefinement, OB, mesh );
4768 createPopupItem( SMESHOp::OpHONewCase, OB, mesh );
4769 // createPopupItem( SMESHOp::OpHOCaseFollow, OB, mesh );
4770 // createPopupItem( SMESHOp::OpHONewIter, OB, mesh );
4771 // createPopupItem( SMESHOp::OpHOIterCompute, OB, mesh );
4772 // createPopupItem( SMESHOp::OpHOIterComputePublish, OB, mesh );
4773 createPopupItem( SMESHOp::OpMGAdapt, OB, mesh );
4776 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4777 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4778 QString only_one_2D = only_one_non_empty + " && dim>1";
4780 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4781 popupMgr()->findMenu( anId )->menuAction()->setIcon( resourceMgr()->loadPixmap( "SMESH", tr( "ICON_EXPORT" )));
4782 createPopupItem( SMESHOp::OpPopupExportMED, OB, mesh_group, multiple_non_empty, anId );
4783 createPopupItem( SMESHOp::OpPopupExportUNV, OB, mesh_group, only_one_non_empty, anId );
4784 createPopupItem( SMESHOp::OpPopupExportSTL, OB, mesh_group, only_one_2D, anId );
4786 createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4788 createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, only_one_non_empty, anId );
4789 createPopupItem( SMESHOp::OpPopupExportGMF, OB, mesh_group, only_one_non_empty, anId );
4790 createPopupItem( SMESHOp::OpPopupExportDAT, OB, mesh_group, only_one_non_empty, anId );
4792 anId = popupMgr()->insert( tr( "MEN_IMPORT" ), -1, -1 ); // IMPORT submenu
4793 createPopupItem( SMESHOp::OpPopupImportMED, OB, smesh, "", anId );
4794 createPopupItem( SMESHOp::OpPopupImportUNV, OB, smesh, "", anId );
4795 createPopupItem( SMESHOp::OpPopupImportSTL, OB, smesh, "", anId );
4797 createPopupItem( SMESHOp::OpPopupImportCGNS, OB, smesh, "", anId );
4799 createPopupItem( SMESHOp::OpPopupImportSAUV, OB, smesh, "", anId );
4800 createPopupItem( SMESHOp::OpPopupImportGMF, OB, smesh, "", anId );
4801 createPopupItem( SMESHOp::OpPopupImportDAT, OB, smesh, "", anId );
4802 popupMgr()->insert( separator(), -1, 0 );
4804 createPopupItem( SMESHOp::OpClearMesh, OB, mesh );
4805 createPopupItem( SMESHOp::OpDelete, OB, mesh_part + " " + hyp_alg );
4806 createPopupItem( SMESHOp::OpDeleteGroup, OB, group );
4809 createPopupItem( SMESHOp::OpEditGroup, View, group );
4810 createPopupItem( SMESHOp::OpAddElemGroupPopup, View, elems, "&& guiState = 800" );
4811 createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems, "&& guiState = 800" );
4813 popupMgr()->insert( separator(), -1, 0 );
4814 createPopupItem( SMESHOp::OpMeshInformation, View, mesh_part );
4815 createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4816 createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh, "&& " + hasElems);
4817 popupMgr()->insert( separator(), -1, 0 );
4819 createPopupItem( SMESHOp::OpUpdate, OB + " " + View, mesh_part );
4820 createPopupItem( SMESHOp::OpAutoColor, OB + " " + View, mesh, "&& (not isAutoColor)" );
4821 createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4822 popupMgr()->insert( separator(), -1, 0 );
4824 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4825 QString aType = QString( "%1type in {%2}" ).arg( lc );
4826 aType = aType.arg( mesh_part );
4827 QString aMeshInVTK = aClient + "&&" + aType;
4829 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4830 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4831 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4833 //-------------------------------------------------
4835 //-------------------------------------------------
4836 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4838 popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4839 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4840 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4842 popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4843 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4844 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4846 popupMgr()->insert( separator(), -1, -1 );
4848 //-------------------------------------------------
4850 //-------------------------------------------------
4851 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4853 popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4854 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4855 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4857 popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4858 popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4859 popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4861 popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4862 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4863 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4865 popupMgr()->insert( separator(), anId, -1 );
4867 popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4868 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4869 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4871 //-------------------------------------------------
4873 //-------------------------------------------------
4874 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4876 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4878 popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4879 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4880 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4882 popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4883 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4884 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4886 popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4887 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4888 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4890 popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4891 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4892 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4894 popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4895 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4896 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4898 popupMgr()->insert( separator(), anId, -1 );
4900 popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4901 popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&& $type in {" + mesh + "} &&" + hasDifferentObjElems, QtxPopupMgr::VisibleRule );
4903 popupMgr()->insert( separator(), anId, -1 );
4905 popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4906 popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4909 //-------------------------------------------------
4910 // Representation of the 2D Quadratic elements
4911 //-------------------------------------------------
4912 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4913 popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4914 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "&& isVisible && isQuadratic",QtxPopupMgr::VisibleRule );
4915 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4917 popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4918 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "&& isVisible && isQuadratic", QtxPopupMgr::VisibleRule );
4919 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4921 //-------------------------------------------------
4922 // Orientation of faces
4923 //-------------------------------------------------
4924 popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4925 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4926 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4928 //-------------------------------------------------
4930 //-------------------------------------------------
4931 popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4932 popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4934 //-------------------------------------------------
4936 //-------------------------------------------------
4937 popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4938 popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4940 //-------------------------------------------------
4942 //-------------------------------------------------
4944 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4945 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4946 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4947 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4949 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4951 popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4952 popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4954 popupMgr()->insert( separator(), anId, -1 );
4956 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4958 popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4959 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4960 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4962 popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4963 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4964 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4966 // popupMgr()->insert( action( SMESHOp::OpNodeConnectivityNb ), aSubId, -1 );
4967 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4968 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), "controlMode = 'eNodeConnectivityNb'", QtxPopupMgr::ToggleRule );
4970 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4972 popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4973 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVTK + "&&" + hasEdges + "&&" + hasFacesOrVolumes, QtxPopupMgr::VisibleRule );
4974 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4976 popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4977 popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4978 popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4980 popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4981 popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4982 popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4983 popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4984 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4985 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4987 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4989 popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4990 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4991 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4993 popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4994 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4995 QtxPopupMgr::VisibleRule );
4996 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4998 popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4999 popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5000 popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
5002 popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
5003 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5004 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
5006 popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
5007 popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5008 popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
5010 popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
5011 popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5012 popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
5014 popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
5015 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5016 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
5018 popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
5019 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5020 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
5022 popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
5023 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5024 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
5026 popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
5027 popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5028 popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
5030 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
5031 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5032 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
5034 popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
5035 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5036 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
5038 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
5039 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5040 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
5042 popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
5043 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5044 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
5046 popupMgr()->insert ( action( SMESHOp::OpDeflection2D ), aSubId, -1 );
5047 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), aMeshInVtkHasFaces + " && hasGeomReference", QtxPopupMgr::VisibleRule );
5048 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), "controlMode = 'eDeflection2D'", QtxPopupMgr::ToggleRule );
5050 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
5052 popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D ), aSubId, -1 );
5053 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5054 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
5056 popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
5057 popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5058 popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
5060 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
5061 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5062 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
5064 popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
5065 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5066 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
5068 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
5069 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5070 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
5072 popupMgr()->insert ( action( SMESHOp::OpEqualVolume ), aSubId, -1 );
5073 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5074 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
5076 popupMgr()->insert( separator(), anId, -1 );
5078 popupMgr()->insert( action( SMESHOp::OpShowScalarBar ), anId, -1 );
5079 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
5080 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone' && isScalarBarVisible", QtxPopupMgr::ToggleRule );
5081 popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
5082 popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
5084 popupMgr()->insert( separator(), anId, -1 );
5086 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
5088 popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
5089 popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
5091 popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
5092 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
5093 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isScalarBarVisible && isDistributionVisible", QtxPopupMgr::ToggleRule);
5095 #ifndef DISABLE_PLOT2DVIEWER
5096 popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
5097 popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
5100 //-------------------------------------------------
5102 //-------------------------------------------------
5103 popupMgr()->insert( separator(), -1, -1 );
5104 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
5105 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
5106 popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
5107 popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
5109 popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
5110 popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
5112 popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
5113 popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
5115 popupMgr()->insert( separator(), -1, -1 );
5117 //-------------------------------------------------
5119 //-------------------------------------------------
5120 popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
5121 popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
5123 popupMgr()->insert( separator(), -1, -1 );
5125 popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
5126 popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
5127 popupMgr()->insert( separator(), -1, -1 );
5129 popupMgr()->insert( action( SMESHOp::OpBreakLink), -1, -1 );
5130 popupMgr()->setRule( action( SMESHOp::OpBreakLink), "$component={'SHAPERSTUDY'} and client='ObjectBrowser' and canBreakLink", QtxPopupMgr::VisibleRule );
5132 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
5133 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
5135 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
5136 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
5139 //================================================================================
5141 * \brief Return true if SMESH or GEOM objects are selected.
5142 * Is called form LightApp_Module::activateModule() which clear selection if
5143 * not isSelectionCompatible()
5145 //================================================================================
5147 bool SMESHGUI::isSelectionCompatible()
5149 bool isCompatible = true;
5150 SALOME_ListIO selected;
5151 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
5152 Sel->selectedObjects( selected );
5154 SALOME_ListIteratorOfListIO It( selected );
5155 for ( ; isCompatible && It.More(); It.Next())
5157 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
5158 ( strcmp("SHAPERSTUDY", It.Value()->getComponentDataType()) == 0 ) ||
5159 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
5161 return isCompatible;
5165 bool SMESHGUI::reusableOperation( const int id )
5167 // compute, evaluate and precompute are not reusable operations
5168 return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate || id == SMESHOp::OpRecompute ) ? false : SalomeApp_Module::reusableOperation( id );
5173 QString wrap(const QString& text, const QString& tag)
5174 { return QString("<%1>%2</%3>").arg(tag).arg(text).arg(tag);}
5177 bool SMESHGUI::activateModule( SUIT_Study* study )
5179 bool res = SalomeApp_Module::activateModule( study );
5181 setMenuShown( true );
5182 setToolShown( true );
5184 // Fill in Help Panel
5185 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( application() );
5186 app->infoPanel()->setTitle(tr("INFO_WELCOME_TO_SMESH"));
5188 int gb = app->infoPanel()->addGroup(tr("INFO_GRP_CREATE_MESH"));
5191 lab = tr("INFO_DEFINE_ALGOS") + "<br/>";
5192 lab = lab + tr("INFO_DEFINE_HYPOS") + "<br/>";
5193 lab = lab + tr("INFO_COMPUTE") + "<br/>";
5194 lab = lab + tr("INFO_REFINE") + ":";
5195 items << wrap(tr("INFO_REFINE_LOCAL_SIZE"), "li")
5196 << wrap(tr("INFO_REFINE_SUBMESH"), "li");
5197 lab = lab + wrap(items.join(""), "ul");
5200 app->infoPanel()->addLabel(lab, gb);
5202 gb = app->infoPanel()->addGroup(tr("INFO_GRP_IMPORT_MESH"));
5203 items << wrap("UNV", "li")
5204 << wrap("MED", "li")
5205 << wrap("STL", "li")
5206 << wrap("CGNS", "li")
5207 << wrap("SAUV", "li")
5208 << wrap("GMF", "li");
5209 lab = tr("INFO_AVAILABLE_FORMATS") + ":" + wrap(items.join(""), "ul");
5212 app->infoPanel()->addLabel(lab, gb);
5214 gb = app->infoPanel()->addGroup(tr("INFO_GRP_CHECK_MESH"));
5215 lab = tr("INFO_DISPLAY") + "<br/>";
5216 items << wrap(tr("INFO_QUALITY_AREA"), "li")
5217 << wrap(tr("INFO_QUALITY_VOLUME"), "li")
5218 << wrap(tr("INFO_QUALITY_ASPECT_RATION"), "li")
5219 << wrap("...", "li");
5220 lab = lab + tr("INFO_QUALITY_INFO") + ":" + wrap(items.join(""), "ul");
5222 lab = lab + tr("INFO_CLIPPING");
5224 app->infoPanel()->addLabel(lab, gb);
5227 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
5228 PyGILState_STATE gstate = PyGILState_Ensure();
5229 PyObject* pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
5230 if ( !pluginsmanager ) {
5234 PyObject* result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toUtf8().data(),tr("SMESH_PLUGINS_OTHER").toUtf8().data());
5239 PyGILState_Release(gstate);
5240 // end of SMESH plugins loading
5242 // Reset actions accelerator keys
5243 action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
5245 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
5246 GetSMESHGen()->UpdateStudy();
5248 // get all view currently opened in the study and connect their signals to
5249 // the corresponding slots of the class.
5250 SUIT_Desktop* aDesk = study->application()->desktop();
5252 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
5253 SUIT_ViewWindow* wnd;
5254 foreach ( wnd, wndList )
5258 // remove actors whose objects are removed in GetSMESHGen()->UpdateStudy()
5259 SMESH::UpdateActorsAfterUpdateStudy(wnd);
5265 Py_XDECREF(pluginsmanager);
5269 bool SMESHGUI::deactivateModule( SUIT_Study* study )
5271 setMenuShown( false );
5272 setToolShown( false );
5274 EmitSignalCloseAllDialogs();
5276 // Unset actions accelerator keys
5277 action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
5279 return SalomeApp_Module::deactivateModule( study );
5282 void SMESHGUI::studyClosed( SUIT_Study* s )
5286 SMESH::RemoveVisuData();
5287 SalomeApp_Module::studyClosed( s );
5290 void SMESHGUI::OnGUIEvent()
5292 const QObject* obj = sender();
5293 if ( !obj || !obj->inherits( "QAction" ) )
5295 int id = actionId((QAction*)obj);
5300 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
5302 if ( CORBA::is_nil( myComponentSMESH ) )
5304 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
5305 return aGUI.myComponentSMESH;
5307 return myComponentSMESH;
5310 QString SMESHGUI::engineIOR() const
5312 CORBA::ORB_var anORB = getApp()->orb();
5313 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
5314 return QString( anIOR.in() );
5317 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
5319 SalomeApp_Module::contextMenuPopup( client, menu, title );
5321 selectionMgr()->selectedObjects( lst );
5322 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
5323 Handle(SALOME_InteractiveObject) io = lst.First();
5324 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
5325 _PTR(Study) study = appStudy->studyDS();
5326 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
5328 QString aName = SMESH::fromUtf8( obj->GetName());
5329 while ( !aName.isEmpty() && aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
5330 aName.remove(( aName.length() - 1 ), 1 );
5336 LightApp_Selection* SMESHGUI::createSelection() const
5338 return new SMESHGUI_Selection();
5341 void SMESHGUI::windows( QMap<int, int>& aMap ) const
5343 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
5344 aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
5345 aMap.insert( SalomeApp_Application::WT_InfoPanel, Qt::RightDockWidgetArea);
5346 #ifndef DISABLE_PYCONSOLE
5347 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
5351 void SMESHGUI::viewManagers( QStringList& list ) const
5353 list.append( SVTK_Viewer::Type() );
5356 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
5358 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
5359 SMESH::UpdateSelectionProp( this );
5361 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
5362 for(int i = 0; i < aViews.count() ; i++){
5363 SUIT_ViewWindow *sf = aViews[i];
5366 EmitSignalActivatedViewManager();
5370 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
5372 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
5373 myClippingPlaneInfoMap.erase( theViewManager );
5376 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
5378 theActor->AddObserver( SMESH::DeleteActorEvent,
5379 myEventCallbackCommand.GetPointer(),
5383 void SMESHGUI::ProcessEvents( vtkObject* theObject,
5384 unsigned long theEvent,
5385 void* theClientData,
5386 void* /*theCallData*/ )
5388 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
5389 if( theObject && (int) theEvent == SMESH::DeleteActorEvent ) {
5390 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
5391 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
5392 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
5393 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
5394 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
5395 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
5396 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
5397 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
5398 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
5399 SMESH::TActorList::iterator anIter3 = anActorList.begin();
5400 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
5401 if( anActor == *anIter3 ) {
5402 anActorList.erase( anIter3 );
5413 void SMESHGUI::createPreferences()
5415 // General tab ------------------------------------------------------------------------
5416 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
5418 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
5419 setPreferenceProperty( autoUpdate, "columns", 2 );
5420 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
5421 setPreferenceProperty( lim, "min", 0 );
5422 setPreferenceProperty( lim, "max", 100000000 );
5423 setPreferenceProperty( lim, "step", 1000 );
5424 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5425 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
5427 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
5428 setPreferenceProperty( dispgroup, "columns", 2 );
5430 addPreference( tr( "PREF_FITALL_ON_DISPLAYONLY" ), dispgroup, LightApp_Preferences::Bool, "SMESH", "fitall_on_displayonly" );
5432 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
5434 modes.append( tr("MEN_WIRE") );
5435 modes.append( tr("MEN_SHADE") );
5436 modes.append( tr("MEN_NODES") );
5437 modes.append( tr("MEN_SHRINK") );
5438 QList<QVariant> indices;
5439 indices.append( 0 );
5440 indices.append( 1 );
5441 indices.append( 2 );
5442 indices.append( 3 );
5443 setPreferenceProperty( dispmode, "strings", modes );
5444 setPreferenceProperty( dispmode, "indexes", indices );
5446 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
5447 setPreferenceProperty( arcgroup, "columns", 2 );
5448 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
5449 QStringList quadraticModes;
5450 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
5451 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
5453 indices.append( 0 );
5454 indices.append( 1 );
5455 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
5456 setPreferenceProperty( quadraticmode, "indexes", indices );
5458 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
5459 "SMESH", "max_angle" );
5460 setPreferenceProperty( maxAngle, "min", 1 );
5461 setPreferenceProperty( maxAngle, "max", 90 );
5463 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
5464 setPreferenceProperty( qaGroup, "columns", 2 );
5465 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
5466 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
5467 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
5468 setPreferenceProperty( prec, "min", 0 );
5469 setPreferenceProperty( prec, "max", 100 );
5470 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
5471 setPreferenceProperty( doubleNodesTol, "precision", 10 );
5472 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
5473 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
5474 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
5477 int cinc = addPreference(tr("PREF_CONTROLS_INCREMENT"), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_increment");
5478 setPreferenceProperty( cinc, "min", 0 );
5479 setPreferenceProperty( cinc, "max", 5 );
5482 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
5483 setPreferenceProperty( exportgroup, "columns", 2 );
5484 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
5485 addPreference( tr( "PREF_SHOW_WARN" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "show_warning" );
5486 int zTol = addPreference( tr( "PREF_ZTOLERANCE" ), exportgroup, LightApp_Preferences::DblSpin, "SMESH", "med_ztolerance" );
5487 setPreferenceProperty( zTol, "precision", 10 );
5488 setPreferenceProperty( zTol, "min", 0.0000000001 );
5489 setPreferenceProperty( zTol, "max", 1000000.0 );
5490 setPreferenceProperty( zTol, "step", 1. );
5491 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
5493 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
5494 setPreferenceProperty( computeGroup, "columns", 2 );
5495 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
5497 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5498 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5499 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5501 indices.append( 0 );
5502 indices.append( 1 );
5503 indices.append( 2 );
5504 setPreferenceProperty( notifyMode, "strings", modes );
5505 setPreferenceProperty( notifyMode, "indexes", indices );
5507 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5508 setPreferenceProperty( infoGroup, "columns", 2 );
5509 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5511 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5512 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5514 indices.append( 0 );
5515 indices.append( 1 );
5516 setPreferenceProperty( elemInfo, "strings", modes );
5517 setPreferenceProperty( elemInfo, "indexes", indices );
5518 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5519 setPreferenceProperty( nodesLim, "min", 0 );
5520 setPreferenceProperty( nodesLim, "max", 10000000 );
5521 setPreferenceProperty( nodesLim, "step", 10000 );
5522 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5523 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5524 setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5525 setPreferenceProperty( ctrlLim, "min", 0 );
5526 setPreferenceProperty( ctrlLim, "max", 10000000 );
5527 setPreferenceProperty( ctrlLim, "step", 1000 );
5528 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5529 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5530 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5531 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5532 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5534 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5535 setPreferenceProperty( segGroup, "columns", 2 );
5536 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5537 "SMESH", "segmentation" );
5538 setPreferenceProperty( segLen, "min", 1 );
5539 setPreferenceProperty( segLen, "max", 10000000 );
5540 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5541 "SMESH", "nb_segments_per_edge" );
5542 setPreferenceProperty( nbSeg, "min", 1 );
5543 setPreferenceProperty( nbSeg, "max", 10000000 );
5544 addPreference( tr( "PREF_USE_MESHGEMS_HYPOSET" ), segGroup, LightApp_Preferences::Bool, "SMESH", "use-meshgems-hypo-sets" );
5546 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5547 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5548 "SMESH", "forget_mesh_on_hyp_modif" );
5551 // Quantities with individual precision settings
5552 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5553 setPreferenceProperty( precGroup, "columns", 2 );
5555 const int nbQuantities = 6;
5556 int precs[nbQuantities], ii = 0;
5557 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5558 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5559 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5560 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5561 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5562 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5563 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5564 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5565 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5566 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5567 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5568 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5570 // Set property for precision value for spinboxes
5571 for ( ii = 0; ii < nbQuantities; ii++ ){
5572 setPreferenceProperty( precs[ii], "min", -14 );
5573 setPreferenceProperty( precs[ii], "max", 14 );
5574 setPreferenceProperty( precs[ii], "precision", 2 );
5577 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5578 setPreferenceProperty( previewGroup, "columns", 2 );
5579 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5580 setPreferenceProperty( chunkSize, "min", 1 );
5581 setPreferenceProperty( chunkSize, "max", 1000 );
5582 setPreferenceProperty( chunkSize, "step", 50 );
5584 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5585 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5587 // Mesh tab ------------------------------------------------------------------------
5588 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5589 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5590 setPreferenceProperty( nodeGroup, "columns", 3 );
5592 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5594 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5596 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5597 QList<QVariant> aMarkerTypeIndicesList;
5598 QList<QVariant> aMarkerTypeIconsList;
5599 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5600 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5601 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5602 aMarkerTypeIndicesList << i;
5603 aMarkerTypeIconsList << pixmap;
5605 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5606 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
5608 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5610 QList<QVariant> aMarkerScaleIndicesList;
5611 QStringList aMarkerScaleValuesList;
5612 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5613 aMarkerScaleIndicesList << i;
5614 //aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5615 aMarkerScaleValuesList << QString::number( i );
5617 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5618 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5620 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5621 //setPreferenceProperty( elemGroup, "columns", 2 );
5623 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5624 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5625 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5626 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5627 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5628 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5629 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5630 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5631 addPreference( tr( "PREF_PREVIEW_COLOR" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5634 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5635 setPreferenceProperty( grpGroup, "columns", 2 );
5637 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5638 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5640 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5641 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5642 /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5643 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5644 double ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5645 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5646 double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5647 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5648 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
5649 LightApp_Preferences::IntSpin, "SMESH", "element_width");
5650 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5651 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5652 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5653 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5655 setPreferenceProperty( size0d, "min", 1 );
5656 setPreferenceProperty( size0d, "max", 10 );
5658 // setPreferenceProperty( ballSize, "min", 1 );
5659 // setPreferenceProperty( ballSize, "max", 10 );
5661 setPreferenceProperty( ballDiameter, "min", 1e-7 );
5662 setPreferenceProperty( ballDiameter, "max", 1e9 );
5663 setPreferenceProperty( ballDiameter, "step", 0.1 );
5665 setPreferenceProperty( ballScale, "min", 1e-2 );
5666 setPreferenceProperty( ballScale, "max", 1e7 );
5667 setPreferenceProperty( ballScale, "step", 0.5 );
5669 setPreferenceProperty( elemW, "min", 1 );
5670 setPreferenceProperty( elemW, "max", 5 );
5672 setPreferenceProperty( outW, "min", 1 );
5673 setPreferenceProperty( outW, "max", 5 );
5675 setPreferenceProperty( shrink, "min", 0 );
5676 setPreferenceProperty( shrink, "max", 100 );
5678 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5679 setPreferenceProperty( numGroup, "columns", 2 );
5681 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5682 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5684 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5685 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5687 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5688 setPreferenceProperty( orientGroup, "columns", 1 );
5690 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5691 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5693 setPreferenceProperty( orientScale, "min", 0.05 );
5694 setPreferenceProperty( orientScale, "max", 0.5 );
5695 setPreferenceProperty( orientScale, "step", 0.05 );
5697 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5699 // Selection tab ------------------------------------------------------------------------
5700 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5702 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5703 setPreferenceProperty( selGroup, "columns", 2 );
5705 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5706 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5708 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5709 setPreferenceProperty( preGroup, "columns", 2 );
5711 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5713 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5714 setPreferenceProperty( precSelGroup, "columns", 2 );
5716 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5717 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5718 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5720 int sinc = addPreference(tr("PREF_SELECTION_INCREMENT"), selTab, LightApp_Preferences::IntSpin, "SMESH", "selection_increment");
5721 setPreferenceProperty( sinc, "min", 0 );
5722 setPreferenceProperty( sinc, "max", 5 );
5724 // Scalar Bar tab ------------------------------------------------------------------------
5725 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5726 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5727 setPreferenceProperty( fontGr, "columns", 2 );
5729 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5730 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5732 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5733 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5735 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5736 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5738 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5739 setPreferenceProperty( numcol, "min", 2 );
5740 setPreferenceProperty( numcol, "max", 256 );
5742 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5743 setPreferenceProperty( numlab, "min", 2 );
5744 setPreferenceProperty( numlab, "max", 65 );
5746 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5747 setPreferenceProperty( orientGr, "columns", 2 );
5748 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5749 QStringList orients;
5750 orients.append( tr( "SMESH_VERTICAL" ) );
5751 orients.append( tr( "SMESH_HORIZONTAL" ) );
5752 indices.clear(); indices.append( 0 ); indices.append( 1 );
5753 setPreferenceProperty( orient, "strings", orients );
5754 setPreferenceProperty( orient, "indexes", indices );
5756 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5757 setPreferenceProperty( posVSizeGr, "columns", 2 );
5758 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5759 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5760 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5761 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5762 setPreferenceProperty( xv, "step", 0.1 );
5763 setPreferenceProperty( xv, "min", 0.0 );
5764 setPreferenceProperty( xv, "max", 1.0 );
5765 setPreferenceProperty( yv, "step", 0.1 );
5766 setPreferenceProperty( yv, "min", 0.0 );
5767 setPreferenceProperty( yv, "max", 1.0 );
5768 setPreferenceProperty( wv, "step", 0.1 );
5769 setPreferenceProperty( wv, "min", 0.0 );
5770 setPreferenceProperty( wv, "max", 1.0 );
5771 setPreferenceProperty( hv, "min", 0.0 );
5772 setPreferenceProperty( hv, "max", 1.0 );
5773 setPreferenceProperty( hv, "step", 0.1 );
5775 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5776 setPreferenceProperty( posHSizeGr, "columns", 2 );
5777 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5778 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5779 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5780 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5781 setPreferenceProperty( xv, "min", 0.0 );
5782 setPreferenceProperty( xv, "max", 1.0 );
5783 setPreferenceProperty( xv, "step", 0.1 );
5784 setPreferenceProperty( xh, "min", 0.0 );
5785 setPreferenceProperty( xh, "max", 1.0 );
5786 setPreferenceProperty( xh, "step", 0.1 );
5787 setPreferenceProperty( yh, "min", 0.0 );
5788 setPreferenceProperty( yh, "max", 1.0 );
5789 setPreferenceProperty( yh, "step", 0.1 );
5790 setPreferenceProperty( wh, "min", 0.0 );
5791 setPreferenceProperty( wh, "max", 1.0 );
5792 setPreferenceProperty( wh, "step", 0.1 );
5793 setPreferenceProperty( hh, "min", 0.0 );
5794 setPreferenceProperty( hh, "max", 1.0 );
5795 setPreferenceProperty( hh, "step", 0.1 );
5797 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5798 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5799 setPreferenceProperty( distributionGr, "columns", 3 );
5801 types.append( tr( "SMESH_MONOCOLOR" ) );
5802 types.append( tr( "SMESH_MULTICOLOR" ) );
5803 indices.clear(); indices.append( 0 ); indices.append( 1 );
5804 setPreferenceProperty( coloringType, "strings", types );
5805 setPreferenceProperty( coloringType, "indexes", indices );
5806 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5808 // Adaptation - begin
5809 // Adaptation tab ------------------------------------------------------------------------
5810 int adaptTab = addPreference( tr( "ADAPT_PREF_TAB_GENERAL" ) );
5812 // Refinement with HOMARD
5813 bloc = addPreference( tr( "ADAPT_PREF_HOMARD_PUBLICATION" ), adaptTab );
5814 setPreferenceProperty( bloc, "columns", 1 );
5815 pref = addPreference( tr( "ADAPT_PREF_HOMARD_PUBLICATION_MAILLAGE_IN" ), bloc, LightApp_Preferences::Bool, "HOMARD", "homard_publish_mesh_in" );
5816 pref = addPreference( tr( "ADAPT_PREF_HOMARD_PUBLICATION_MAILLAGE_OUT" ), bloc, LightApp_Preferences::Bool, "HOMARD", "homard_publish_mesh_out" );
5819 bloc = addPreference( tr( "ADAPT_PREF_HOMARD_YACS" ), adaptTab );
5820 setPreferenceProperty( bloc, "columns", 1 );
5821 pref = addPreference( tr( "ADAPT_PREF_HOMARD_YACS_MAX_ITER" ), bloc, LightApp_Preferences::IntSpin, "HOMARD", "homard_yacs_max_iter" );
5822 setPreferenceProperty( pref, "min", 0 );
5823 setPreferenceProperty( pref, "max", 100000000 );
5824 setPreferenceProperty( pref, "step", 1 );
5825 pref = addPreference( tr( "ADAPT_PREF_HOMARD_YACS_MAX_NODE" ), bloc, LightApp_Preferences::IntSpin, "HOMARD", "homard_yacs_max_node" );
5826 setPreferenceProperty( pref, "min", 0 );
5827 setPreferenceProperty( pref, "max", 100000000 );
5828 setPreferenceProperty( pref, "step", 1000 );
5829 pref = addPreference( tr( "ADAPT_PREF_HOMARD_YACS_MAX_ELEM" ), bloc, LightApp_Preferences::IntSpin, "HOMARD", "homard_yacs_max_elem" );
5830 setPreferenceProperty( pref, "min", 0 );
5831 setPreferenceProperty( pref, "max", 100000000 );
5832 setPreferenceProperty( pref, "step", 1000 );
5833 pref = addPreference( tr( "ADAPT_PREF_HOMARD_YACS_TYPE_CONVERGENCE" ), bloc, LightApp_Preferences::Selector, "HOMARD", "homard_yacs_type_test" );
5834 QStringList aListOfTypeTest;
5835 aListOfTypeTest << tr( "ADAPT_PREF_NONE" );
5836 aListOfTypeTest << "VTest > VRef";
5837 aListOfTypeTest << "VTest < VRef";
5838 setPreferenceProperty( pref, "strings", aListOfTypeTest );
5841 bloc = addPreference( tr( "ADAPT_PREF_MG_ADAPT" ), adaptTab );
5842 setPreferenceProperty( bloc, "columns", 1 );
5843 pref = addPreference( tr( "ADAPT_PREF_MG_ADAPT_FILE_MAILLAGE_OUT" ), bloc, LightApp_Preferences::Bool, "HOMARD", "mg_adapt_file_mesh_out" );
5844 pref = addPreference( tr( "ADAPT_PREF_MG_ADAPT_PUBLICATION_MAILLAGE_OUT" ), bloc, LightApp_Preferences::Bool, "HOMARD", "mg_adapt_publish_mesh_out" );
5845 pref = addPreference( tr( "ADAPT_PREF_MG_ADAPT_SIZE_MAP" ), bloc, LightApp_Preferences::Selector, "HOMARD", "mg_adapt_size_map" );
5846 QStringList aListOfSizeMap;
5847 aListOfSizeMap << tr( "ADAPT_PREF_MG_ADAPT_SIZE_MAP_LOCAL" );
5848 aListOfSizeMap << tr( "ADAPT_PREF_MG_ADAPT_SIZE_MAP_BACKGROUND" );
5849 aListOfSizeMap << tr( "ADAPT_PREF_NONE" );;
5850 setPreferenceProperty( pref, "strings", aListOfSizeMap );
5851 pref = addPreference( tr( "ADAPT_PREF_MG_ADAPT_TIME_STEP" ), bloc, LightApp_Preferences::Selector, "HOMARD", "mg_adapt_time_step" );
5852 QStringList aListOfTimeStep;
5853 aListOfTimeStep << tr( "ADAPT_PREF_NONE" );
5854 aListOfTimeStep << tr( "ADAPT_PREF_MG_ADAPT_TIME_STEP_LAST" );
5855 aListOfTimeStep << tr( "ADAPT_PREF_MG_ADAPT_TIME_STEP_C" );;
5856 setPreferenceProperty( pref, "strings", aListOfTimeStep );
5861 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5863 if ( sect=="SMESH" ) {
5864 float sbX1 = 0.01, sbY1 = 0.01, sbW = 0.08, sbH = 0.08;
5865 float aTol = 1.00000009999999;
5866 std::string aWarning;
5867 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5869 if ( name == "selection_object_color" ||
5870 name == "selection_element_color" ||
5871 name == "highlight_color" ||
5872 name == "selection_precision_node" ||
5873 name == "selection_precision_element" ||
5874 name == "selection_precision_object" ||
5875 name == "selection_increment")
5877 SMESH::UpdateSelectionProp( this );
5879 else if (name == "scalar_bar_vertical_x" || name == "scalar_bar_vertical_width")
5881 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5882 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5883 if ( sbX1+sbW > aTol ) {
5884 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5887 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5888 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5891 else if (name == "scalar_bar_vertical_y" || name == "scalar_bar_vertical_height" )
5893 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5894 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5895 if ( sbY1 + sbH > aTol ) {
5896 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5897 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5898 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5901 else if (name == "scalar_bar_horizontal_x" || name == "scalar_bar_horizontal_width")
5903 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5904 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5905 if ( sbX1 + sbW > aTol ) {
5906 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5909 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5910 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5913 else if (name == "scalar_bar_horizontal_y" || name == "scalar_bar_horizontal_height")
5915 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5916 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5917 if ( sbY1 + sbH > aTol ) {
5918 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5921 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5922 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5925 else if ( name == "segmentation" )
5927 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5928 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5930 else if ( name == "nb_segments_per_edge" )
5932 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5933 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5935 else if ( name == "historical_python_dump" || name == "forget_mesh_on_hyp_modif" || name == "default_grp_color" )
5937 QString val = aResourceMgr->stringValue( "SMESH", name );
5938 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5940 else if ( name == "numbering_node_color" || name == "numbering_node_font" )
5942 SMESH::UpdateFontProp( this );
5944 else if ( name == "numbering_elem_color" || name == "numbering_elem_font" )
5946 SMESH::UpdateFontProp( this );
5949 if ( aWarning.size() != 0 ) {
5950 aWarning += "The default values are applied instead.";
5951 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5952 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5953 QObject::tr(aWarning.c_str()));
5958 //================================================================================
5960 * \brief Update something in accordance with update flags
5961 * \param theFlags - update flags
5963 * Update viewer or/and object browser etc. in accordance with update flags ( see
5964 * LightApp_UpdateFlags enumeration ).
5966 //================================================================================
5967 void SMESHGUI::update( const int flags )
5969 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5970 SMESH::UpdateView();
5972 SalomeApp_Module::update( flags );
5975 //================================================================================
5977 * \brief Set default selection mode
5979 * SLOT called when operation committed. Sets default selection mode
5981 //================================================================================
5982 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5984 SVTK_ViewWindow* vtkWnd =
5985 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5987 vtkWnd->SetSelectionMode( ActorSelection );
5990 //================================================================================
5992 * \brief Set default selection mode
5994 * SLOT called when operation aborted. Sets default selection mode
5996 //================================================================================
5997 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5999 SVTK_ViewWindow* vtkWnd =
6000 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
6002 vtkWnd->SetSelectionMode( ActorSelection );
6005 //================================================================================
6007 * \brief Creates operation with given identifier
6008 * \param id - identifier of operation to be started
6009 * \return Pointer on created operation or NULL if operation is not created
6011 * Virtual method redefined from the base class creates operation with given id.
6012 * It is called called automatically from startOperation method of base class.
6014 //================================================================================
6015 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
6017 LightApp_Operation* op = 0;
6018 // to do : create operation here
6021 case SMESHOp::OpSplitBiQuadratic:
6022 op = new SMESHGUI_SplitBiQuadOp();
6024 case SMESHOp::OpConvertMeshToQuadratic:
6025 op = new SMESHGUI_ConvToQuadOp();
6027 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
6028 op = new SMESHGUI_Make2DFrom3DOp();
6030 case SMESHOp::OpReorientFaces:
6031 op = new SMESHGUI_ReorientFacesOp();
6033 case SMESHOp::OpCreateMesh:
6034 op = new SMESHGUI_MeshOp( true, true );
6036 case SMESHOp::OpCreateSubMesh:
6037 op = new SMESHGUI_MeshOp( true, false );
6039 case SMESHOp::OpEditMeshOrSubMesh:
6040 case SMESHOp::OpEditMesh:
6041 case SMESHOp::OpEditSubMesh:
6042 op = new SMESHGUI_MeshOp( false );
6044 case SMESHOp::OpCompute:
6045 case SMESHOp::OpComputeSubMesh:
6046 op = new SMESHGUI_ComputeOp();
6048 case SMESHOp::OpShowErrors:
6049 op = new SMESHGUI_ShowErrorsOp();
6051 case SMESHOp::OpPreCompute:
6052 op = new SMESHGUI_PrecomputeOp();
6054 case SMESHOp::OpEvaluate:
6055 op = new SMESHGUI_EvaluateOp();
6057 case SMESHOp::OpMeshOrder:
6058 op = new SMESHGUI_MeshOrderOp();
6060 case SMESHOp::OpCreateGeometryGroup:
6061 op = new SMESHGUI_GroupOnShapeOp();
6063 case SMESHOp::OpFindElementByPoint:
6064 op = new SMESHGUI_FindElemByPointOp();
6066 case SMESHOp::OpMoveNode: // Make mesh pass through point
6067 op = new SMESHGUI_MakeNodeAtPointOp();
6069 case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
6070 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
6072 // Adaptation - begin
6073 case SMESHOp::OpUniformRefinement:
6074 case SMESHOp::OpHONewCase:
6075 case SMESHOp::OpHOCaseFollow:
6076 case SMESHOp::OpHONewIter:
6077 case SMESHOp::OpHOIterCompute:
6078 case SMESHOp::OpHOIterComputePublish:
6079 case SMESHOp::OpHOEdit:
6080 case SMESHOp::OpHODelete:
6081 case SMESHOp::OpMGAdapt:
6089 op = SalomeApp_Module::createOperation( id );
6093 //================================================================================
6095 * \brief Stops current operations and starts a given one
6096 * \param id - The id of the operation to start
6098 //================================================================================
6100 void SMESHGUI::switchToOperation(int id)
6102 activeStudy()->abortAllOperations();
6103 startOperation( id );
6106 LightApp_Displayer* SMESHGUI::displayer()
6109 myDisplayer = new SMESHGUI_Displayer( getApp() );
6113 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
6116 int aTolerance = 64;
6117 int anIterations = 0;
6123 if( anIterations % aPeriod == 0 )
6126 if( aTolerance < 1 )
6130 aHue = (int)( 360.0 * rand() / RAND_MAX );
6133 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
6134 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
6135 for( ; it != itEnd; ++it )
6137 SALOMEDS::Color anAutoColor = *it;
6138 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
6141 aQColor.getHsv( &h, &s, &v );
6142 if( abs( h - aHue ) < aTolerance )
6154 aColor.setHsv( aHue, 255, 255 );
6156 SALOMEDS::Color aSColor;
6157 aSColor.R = aColor.redF();
6158 aSColor.G = aColor.greenF();
6159 aSColor.B = aColor.blueF();
6164 const char* gSeparator = "_"; // character used to separate parameter names
6165 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
6166 const char* gPathSep = "|"; // character used to separate paths
6169 * \brief Store visual parameters
6171 * This method is called just before the study document is saved.
6172 * Store visual parameters in AttributeParameter attribute(s)
6174 void SMESHGUI::storeVisualParameters (int savePoint)
6177 Kernel_Utils::Localizer loc;
6179 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6180 if (!appStudy || !appStudy->studyDS())
6182 _PTR(Study) studyDS = appStudy->studyDS();
6184 // componentName is used for encoding of entries when storing them in IParameters
6185 std::string componentName = myComponentSMESH->ComponentDataType();
6186 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
6187 //if (!aSComponent) return;
6190 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6191 componentName.c_str(),
6193 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6195 // store custom markers
6196 if( !myMarkerMap.empty() )
6198 VTK::MarkerMap::const_iterator anIter = myMarkerMap.begin();
6199 for( ; anIter != myMarkerMap.end(); anIter++ )
6201 int anId = anIter->first;
6202 VTK::MarkerData aMarkerData = anIter->second;
6203 std::string aMarkerFileName = aMarkerData.first;
6204 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
6205 if( aMarkerTexture.size() < 3 )
6206 continue; // should contain at least width, height and the first value
6208 QString aPropertyName( "texture" );
6209 aPropertyName += gSeparator;
6210 aPropertyName += QString::number( anId );
6212 QString aPropertyValue = aMarkerFileName.c_str();
6213 aPropertyValue += gPathSep;
6215 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
6216 ushort aWidth = *aTextureIter++;
6217 ushort aHeight = *aTextureIter++;
6218 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
6219 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
6220 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
6221 aPropertyValue += QString::number( *aTextureIter );
6223 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
6227 // viewers counters are used for storing view_numbers in IParameters
6230 // main cycle to store parameters of displayed objects
6231 QList<SUIT_ViewManager*> lst;
6232 QList<SUIT_ViewManager*>::Iterator it;
6233 getApp()->viewManagers(lst);
6234 for (it = lst.begin(); it != lst.end(); it++)
6236 SUIT_ViewManager* vman = *it;
6237 QString vType = vman->getType();
6239 // saving VTK actors properties
6240 if (vType == SVTK_Viewer::Type())
6242 // store the clipping planes attached to the view manager
6243 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
6244 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
6245 if( anIter != myClippingPlaneInfoMap.end() )
6246 aClippingPlaneInfoList = anIter->second;
6248 if( !aClippingPlaneInfoList.empty() ) {
6249 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
6250 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
6252 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
6253 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
6255 QString aPropertyName( "ClippingPlane" );
6256 aPropertyName += gSeparator;
6257 aPropertyName += QString::number( vtkViewers );
6258 aPropertyName += gSeparator;
6259 aPropertyName += QString::number( anId );
6261 QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
6262 aPropertyValue += gDigitsSep;
6263 aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
6264 aPropertyValue += gDigitsSep;
6265 if ( aPlane->PlaneMode == SMESH::Absolute ) {
6266 aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
6267 aPropertyValue += gDigitsSep;
6268 aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
6269 aPropertyValue += gDigitsSep;
6270 aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
6271 aPropertyValue += gDigitsSep;
6272 aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
6273 aPropertyValue += gDigitsSep;
6274 aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
6275 aPropertyValue += gDigitsSep;
6276 aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
6277 aPropertyValue += gDigitsSep;
6278 aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
6280 else if ( aPlane->PlaneMode == SMESH::Relative ) {
6281 aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
6282 aPropertyValue += gDigitsSep;
6283 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
6284 aPropertyValue += gDigitsSep;
6285 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
6286 aPropertyValue += gDigitsSep;
6287 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
6290 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
6294 QVector<SUIT_ViewWindow*> views = vman->getViews();
6295 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
6297 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
6299 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
6300 vtkActorCollection* allActors = aCopy.GetActors();
6301 allActors->InitTraversal();
6302 while (vtkActor* actor = allActors->GetNextActor())
6304 if (actor->GetVisibility()) // store only visible actors
6306 SMESH_Actor* aSmeshActor = 0;
6307 if (actor->IsA("SMESH_Actor"))
6308 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
6309 if (aSmeshActor && aSmeshActor->hasIO())
6311 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
6314 // entry is "encoded" = it does NOT contain component address,
6315 // since it is a subject to change on next component loading
6316 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
6318 std::string param, vtkParam = vType.toLatin1().data();
6319 vtkParam += gSeparator;
6320 vtkParam += QString::number(vtkViewers).toLatin1().data();
6321 vtkParam += gSeparator;
6324 param = vtkParam + "Visibility";
6325 ip->setParameter(entry, param, "On");
6328 param = vtkParam + "Representation";
6329 ip->setParameter(entry, param, QString::number
6330 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
6333 param = vtkParam + "IsShrunk";
6334 ip->setParameter(entry, param, QString::number
6335 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
6337 // Displayed entities
6338 unsigned int aMode = aSmeshActor->GetEntityMode();
6339 bool isE = aMode & SMESH_Actor::eEdges;
6340 bool isF = aMode & SMESH_Actor::eFaces;
6341 bool isV = aMode & SMESH_Actor::eVolumes;
6342 bool is0d = aMode & SMESH_Actor::e0DElements;
6343 bool isB = aMode & SMESH_Actor::eBallElem;
6345 QString modeStr ("e");
6346 modeStr += gDigitsSep; modeStr += QString::number(isE);
6347 modeStr += gDigitsSep; modeStr += "f";
6348 modeStr += gDigitsSep; modeStr += QString::number(isF);
6349 modeStr += gDigitsSep; modeStr += "v";
6350 modeStr += gDigitsSep; modeStr += QString::number(isV);
6351 modeStr += gDigitsSep; modeStr += "0d";
6352 modeStr += gDigitsSep; modeStr += QString::number(is0d);
6353 modeStr += gDigitsSep; modeStr += "b";
6354 modeStr += gDigitsSep; modeStr += QString::number(isB);
6356 param = vtkParam + "Entities";
6357 ip->setParameter(entry, param, modeStr.toLatin1().data());
6363 aSmeshActor->GetSufaceColor(r, g, b, delta);
6364 QStringList colorStr;
6365 colorStr << "surface";
6366 colorStr << QString::number(r);
6367 colorStr << QString::number(g);
6368 colorStr << QString::number(b);
6370 colorStr << "backsurface";
6371 colorStr << QString::number(delta);
6373 aSmeshActor->GetVolumeColor(r, g, b, delta);
6374 colorStr << "volume";
6375 colorStr << QString::number(r);
6376 colorStr << QString::number(g);
6377 colorStr << QString::number(b);
6378 colorStr << QString::number(delta);
6380 aSmeshActor->GetEdgeColor(r, g, b);
6382 colorStr << QString::number(r);
6383 colorStr << QString::number(g);
6384 colorStr << QString::number(b);
6386 aSmeshActor->GetNodeColor(r, g, b);
6388 colorStr << QString::number(r);
6389 colorStr << QString::number(g);
6390 colorStr << QString::number(b);
6392 aSmeshActor->GetOutlineColor(r, g, b);
6393 colorStr << "outline";
6394 colorStr << QString::number(r);
6395 colorStr << QString::number(g);
6396 colorStr << QString::number(b);
6398 aSmeshActor->Get0DColor(r, g, b);
6399 colorStr << "elem0d";
6400 colorStr << QString::number(r);
6401 colorStr << QString::number(g);
6402 colorStr << QString::number(b);
6404 aSmeshActor->GetBallColor(r, g, b);
6406 colorStr << QString::number(r);
6407 colorStr << QString::number(g);
6408 colorStr << QString::number(b);
6410 aSmeshActor->GetFacesOrientationColor(r, g, b);
6411 colorStr << "orientation";
6412 colorStr << QString::number(r);
6413 colorStr << QString::number(g);
6414 colorStr << QString::number(b);
6416 param = vtkParam + "Colors";
6417 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
6420 QStringList sizeStr;
6422 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
6423 sizeStr << "outline";
6424 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
6425 sizeStr << "elem0d";
6426 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
6428 //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
6429 sizeStr << QString::number((double)aSmeshActor->GetBallSize());
6430 sizeStr << QString::number((double)aSmeshActor->GetBallScale());
6431 sizeStr << "shrink";
6432 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
6433 sizeStr << "orientation";
6434 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
6435 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
6437 param = vtkParam + "Sizes";
6438 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
6443 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
6444 if( aMarkerType == VTK::MT_USER ) {
6445 markerStr += "custom";
6446 markerStr += gDigitsSep;
6447 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
6451 markerStr += gDigitsSep;
6452 markerStr += QString::number( (int)aMarkerType );
6453 markerStr += gDigitsSep;
6454 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
6457 param = vtkParam + "PointMarker";
6458 ip->setParameter(entry, param, markerStr.toLatin1().data());
6461 param = vtkParam + "Opacity";
6462 ip->setParameter(entry, param,
6463 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
6466 param = vtkParam + "ClippingPlane";
6468 if( !aClippingPlaneInfoList.empty() ) {
6469 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
6470 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
6472 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
6473 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
6474 SMESH::TActorList::iterator anIter2 = anActorList.begin();
6475 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
6476 if( aSmeshActor == *anIter2 ) {
6477 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
6478 QString::number( anId ).toLatin1().constData() );
6485 ip->setParameter( entry, param, "Off" );
6486 } // if (io->hasEntry())
6487 } // SMESH_Actor && hasIO
6489 } // while.. actors traversal
6493 } // if (SVTK view model)
6494 } // for (viewManagers)
6497 // data structures for clipping planes processing
6501 bool isOpenGLClipping;
6502 vtkIdType RelativeOrientation;
6505 int AbsoluteOrientation;
6506 double X, Y, Z, Dx, Dy, Dz;
6508 typedef std::list<TPlaneData> TPlaneDataList;
6509 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
6511 typedef std::list<vtkActor*> TActorList;
6514 TActorList ActorList;
6515 SUIT_ViewManager* ViewManager;
6517 typedef std::list<TPlaneInfo> TPlaneInfoList;
6518 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
6521 * \brief Restore visual parameters
6523 * This method is called after the study document is opened.
6524 * Restore visual parameters from AttributeParameter attribute(s)
6526 void SMESHGUI::restoreVisualParameters (int savePoint)
6529 Kernel_Utils::Localizer loc;
6531 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6532 if (!appStudy || !appStudy->studyDS())
6534 _PTR(Study) studyDS = appStudy->studyDS();
6536 // componentName is used for encoding of entries when storing them in IParameters
6537 std::string componentName = myComponentSMESH->ComponentDataType();
6540 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6541 componentName.c_str(),
6543 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6545 // restore custom markers and map of clipping planes
6546 TPlaneDataMap aPlaneDataMap;
6548 std::vector<std::string> properties = ip->getProperties();
6549 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
6551 std::string property = *propIt;
6552 QString aPropertyName( property.c_str() );
6553 QString aPropertyValue( ip->getProperty( property ).c_str() );
6555 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
6556 if( aPropertyNameList.isEmpty() )
6559 QString aPropertyType = aPropertyNameList[0];
6560 if( aPropertyType == "texture" )
6562 if( aPropertyNameList.size() != 2 )
6566 int anId = aPropertyNameList[1].toInt( &ok );
6567 if( !ok || anId < 1 )
6570 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
6571 if( aPropertyValueList.size() != 2 )
6574 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
6575 QString aMarkerTextureString = aPropertyValueList[1];
6576 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
6577 if( aMarkerTextureStringList.size() != 3 )
6581 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6586 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6590 VTK::MarkerTexture aMarkerTexture;
6591 aMarkerTexture.push_back( aWidth );
6592 aMarkerTexture.push_back( aHeight );
6594 QString aMarkerTextureData = aMarkerTextureStringList[2];
6595 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6597 QChar aChar = aMarkerTextureData.at( i );
6598 if( aChar.isDigit() )
6599 aMarkerTexture.push_back( aChar.digitValue() );
6602 myMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6604 else if( aPropertyType == "ClippingPlane" )
6606 if( aPropertyNameList.size() != 3 )
6610 int aViewId = aPropertyNameList[1].toInt( &ok );
6611 if( !ok || aViewId < 0 )
6615 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6616 if( !ok || aClippingPlaneId < 0 )
6619 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6620 if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6623 TPlaneData aPlaneData;
6624 aPlaneData.AbsoluteOrientation = false;
6625 aPlaneData.RelativeOrientation = 0;
6626 aPlaneData.Distance = aPlaneData.Angle[0] = aPlaneData.Angle[1] = 0;
6627 aPlaneData.X = aPlaneData.Y = aPlaneData.Z = 0;
6628 aPlaneData.Dx = aPlaneData.Dy = aPlaneData.Dz = 0;
6630 aPlaneData.Id = aClippingPlaneId;
6633 aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6638 aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6642 if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6645 aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6650 aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6655 aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6660 aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6665 aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6670 aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6675 aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6679 else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6681 aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6686 aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6691 aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6696 aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6701 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6702 aPlaneDataList.push_back( aPlaneData );
6706 TPlaneInfoMap aPlaneInfoMap;
6708 std::vector<std::string> entries = ip->getEntries();
6710 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6712 // entry is a normal entry - it should be "decoded" (setting base address of component)
6713 QString entry (ip->decodeEntry(*entIt).c_str());
6715 // Check that the entry corresponds to a real object in the Study
6716 // as the object may be deleted or modified after the visual state is saved.
6717 _PTR(SObject) so = studyDS->FindObjectID(entry.toUtf8().data());
6718 if (!so) continue; //Skip the not existent entry
6720 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6721 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6723 std::vector<std::string>::iterator namesIt = paramNames.begin();
6724 std::vector<std::string>::iterator valuesIt = paramValues.begin();
6726 // actors are stored in a map after displaying of them for
6727 // quicker access in the future: map < viewID to actor >
6728 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6730 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6732 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6733 // '_' is used as separator and should not be used in viewer type or parameter names.
6734 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6735 if (lst.size() != 3)
6738 QString viewerTypStr = lst[0];
6739 QString viewIndexStr = lst[1];
6740 QString paramNameStr = lst[2];
6743 int viewIndex = viewIndexStr.toUInt(&ok);
6744 if (!ok) // bad conversion of view index to integer
6748 if (viewerTypStr == SVTK_Viewer::Type())
6750 SMESH_Actor* aSmeshActor = 0;
6751 if (vtkActors.IsBound(viewIndex))
6752 aSmeshActor = vtkActors.Find(viewIndex);
6754 QList<SUIT_ViewManager*> lst;
6755 getApp()->viewManagers(viewerTypStr, lst);
6757 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6758 SUIT_ViewManager* vman = NULL;
6759 if (viewIndex >= 0 && viewIndex < lst.count())
6760 vman = lst.at(viewIndex);
6762 if (paramNameStr == "Visibility")
6764 if (!aSmeshActor && displayer() && vman)
6766 SUIT_ViewModel* vmodel = vman->getViewModel();
6767 // SVTK view model can be casted to SALOME_View
6768 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6770 // store displayed actor in a temporary map for quicker
6771 // access later when restoring other parameters
6772 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6773 vtkRenderer* Renderer = vtkView->getRenderer();
6774 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6775 vtkActorCollection* theActors = aCopy.GetActors();
6776 theActors->InitTraversal();
6777 bool isFound = false;
6778 vtkActor *ac = theActors->GetNextActor();
6779 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6780 if (ac->IsA("SMESH_Actor")) {
6781 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6782 if (aGeomAc->hasIO()) {
6783 Handle(SALOME_InteractiveObject) io = aGeomAc->getIO();
6784 if (io->hasEntry() && strcmp(io->getEntry(), entry.toUtf8().data()) == 0) {
6786 vtkActors.Bind(viewIndex, aGeomAc);
6792 } // if (paramNameStr == "Visibility")
6795 // the rest properties "work" with SMESH_Actor
6798 QString val ((*valuesIt).c_str());
6801 if (paramNameStr == "Representation") {
6802 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6805 else if (paramNameStr == "IsShrunk") {
6807 if (!aSmeshActor->IsShrunk())
6808 aSmeshActor->SetShrink();
6811 if (aSmeshActor->IsShrunk())
6812 aSmeshActor->UnShrink();
6815 // Displayed entities
6816 else if (paramNameStr == "Entities") {
6817 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6818 int aEntityMode = SMESH_Actor::eAllEntity;
6819 for ( int i = 0; i < mode.count(); i+=2 ) {
6820 if ( i < mode.count()-1 ) {
6821 QString type = mode[i];
6822 bool val = mode[i+1].toInt();
6823 if ( type == "e" && !val )
6824 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6825 else if ( type == "f" && !val )
6826 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6827 else if ( type == "v" && !val )
6828 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6829 else if ( type == "0d" && !val )
6830 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6831 else if ( type == "b" && !val )
6832 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6835 aSmeshActor->SetEntityMode( aEntityMode );
6838 else if (paramNameStr == "Colors") {
6839 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6846 QColor outlineColor;
6847 QColor orientationColor;
6853 // below lines are required to get default values for delta coefficients
6854 // of backface color for faces and color of reversed volumes
6855 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
6856 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6857 for ( int i = 0; i < colors.count(); i++ ) {
6858 QString type = colors[i];
6859 if ( type == "surface" ) {
6860 // face color is set by 3 values r:g:b, where
6861 // - r,g,b - is rgb color components
6862 if ( i+1 >= colors.count() ) break; // format error
6863 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6864 if ( i+2 >= colors.count() ) break; // format error
6865 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6866 if ( i+3 >= colors.count() ) break; // format error
6867 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6868 faceColor.setRgbF( r, g, b );
6871 else if ( type == "backsurface" ) {
6872 // backface color can be defined in several ways
6873 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6874 // - in latest versions, it is set as delta coefficient
6875 bool rgbOk = false, deltaOk;
6876 if ( i+1 >= colors.count() ) break; // format error
6877 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6878 int delta = colors[i+1].toInt( &deltaOk );
6880 if ( i+1 < colors.count() ) // index is shifted to 1
6881 g = colors[i+1].toDouble( &rgbOk );
6882 if ( rgbOk ) i++; // shift index
6883 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6884 b = colors[i+1].toDouble( &rgbOk );
6886 // - as currently there's no way to set directly backsurface color as it was before,
6887 // we ignore old dump where r,g,b triple was set
6888 // - also we check that delta parameter is set properly
6889 if ( !rgbOk && deltaOk )
6892 else if ( type == "volume" ) {
6893 // volume color is set by 4 values r:g:b:delta, where
6894 // - r,g,b - is a normal volume rgb color components
6895 // - delta - is a reversed volume color delta coefficient
6896 if ( i+1 >= colors.count() ) break; // format error
6897 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6898 if ( i+2 >= colors.count() ) break; // format error
6899 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6900 if ( i+3 >= colors.count() ) break; // format error
6901 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6902 if ( i+4 >= colors.count() ) break; // format error
6903 int delta = colors[i+4].toInt( &bOk );
6904 if ( !bOk ) break; // format error
6905 volumeColor.setRgbF( r, g, b );
6909 else if ( type == "edge" ) {
6910 // edge color is set by 3 values r:g:b, where
6911 // - r,g,b - is rgb color components
6912 if ( i+1 >= colors.count() ) break; // format error
6913 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6914 if ( i+2 >= colors.count() ) break; // format error
6915 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6916 if ( i+3 >= colors.count() ) break; // format error
6917 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6918 edgeColor.setRgbF( r, g, b );
6921 else if ( type == "node" ) {
6922 // node color is set by 3 values r:g:b, where
6923 // - r,g,b - is rgb color components
6924 if ( i+1 >= colors.count() ) break; // format error
6925 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6926 if ( i+2 >= colors.count() ) break; // format error
6927 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6928 if ( i+3 >= colors.count() ) break; // format error
6929 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6930 nodeColor.setRgbF( r, g, b );
6933 else if ( type == "elem0d" ) {
6934 // 0d element color is set by 3 values r:g:b, where
6935 // - r,g,b - is rgb color components
6936 if ( i+1 >= colors.count() ) break; // format error
6937 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6938 if ( i+2 >= colors.count() ) break; // format error
6939 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6940 if ( i+3 >= colors.count() ) break; // format error
6941 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6942 elem0dColor.setRgbF( r, g, b );
6945 else if ( type == "ball" ) {
6946 // ball color is set by 3 values r:g:b, where
6947 // - r,g,b - is rgb color components
6948 if ( i+1 >= colors.count() ) break; // format error
6949 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6950 if ( i+2 >= colors.count() ) break; // format error
6951 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6952 if ( i+3 >= colors.count() ) break; // format error
6953 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6954 ballColor.setRgbF( r, g, b );
6957 else if ( type == "outline" ) {
6958 // outline color is set by 3 values r:g:b, where
6959 // - r,g,b - is rgb color components
6960 if ( i+1 >= colors.count() ) break; // format error
6961 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6962 if ( i+2 >= colors.count() ) break; // format error
6963 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6964 if ( i+3 >= colors.count() ) break; // format error
6965 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6966 outlineColor.setRgbF( r, g, b );
6969 else if ( type == "orientation" ) {
6970 // orientation color is set by 3 values r:g:b, where
6971 // - r,g,b - is rgb color components
6972 if ( i+1 >= colors.count() ) break; // format error
6973 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6974 if ( i+2 >= colors.count() ) break; // format error
6975 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6976 if ( i+3 >= colors.count() ) break; // format error
6977 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6978 orientationColor.setRgbF( r, g, b );
6983 if ( nodeColor.isValid() )
6984 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6986 if ( edgeColor.isValid() )
6987 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6989 if ( faceColor.isValid() )
6990 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6992 if ( volumeColor.isValid() )
6993 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6994 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6995 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6997 if ( elem0dColor.isValid() )
6998 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
7000 if ( ballColor.isValid() )
7001 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
7003 if ( outlineColor.isValid() )
7004 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
7005 // orientation color
7006 if ( orientationColor.isValid() )
7007 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
7010 else if (paramNameStr == "Sizes") {
7011 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
7014 int outlineWidth = -1;
7015 int elem0dSize = -1;
7016 //int ballSize = -1;
7017 double ballDiameter = -1.0;
7018 double ballScale = -1.0;
7019 double shrinkSize = -1;
7020 double orientationSize = -1;
7021 bool orientation3d = false;
7022 for ( int i = 0; i < sizes.count(); i++ ) {
7023 QString type = sizes[i];
7024 if ( type == "line" ) {
7025 // line (wireframe) width is given as single integer value
7026 if ( i+1 >= sizes.count() ) break; // format error
7027 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
7031 if ( type == "outline" ) {
7032 // outline width is given as single integer value
7033 if ( i+1 >= sizes.count() ) break; // format error
7034 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
7038 else if ( type == "elem0d" ) {
7039 // 0d element size is given as single integer value
7040 if ( i+1 >= sizes.count() ) break; // format error
7041 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
7045 else if ( type == "ball" ) {
7046 // balls are specified by two values: size:scale, where
7047 // - size - is a integer value specifying size
7048 // - scale - is a double value specifying scale factor
7049 if ( i+1 >= sizes.count() ) break; // format error
7050 //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
7051 double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
7052 if ( i+2 >= sizes.count() ) break; // format error
7053 double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
7059 else if ( type == "shrink" ) {
7060 // shrink factor is given as single floating point value
7061 if ( i+1 >= sizes.count() ) break; // format error
7062 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
7066 else if ( type == "orientation" ) {
7067 // orientation vectors are specified by two values size:3d, where
7068 // - size - is a floating point value specifying scale factor
7069 // - 3d - is a boolean
7070 if ( i+1 >= sizes.count() ) break; // format error
7071 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
7072 if ( i+2 >= sizes.count() ) break; // format error
7073 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
7074 orientationSize = v1;
7075 orientation3d = (bool)v2;
7079 // line (wireframe) width
7080 if ( lineWidth > 0 )
7081 aSmeshActor->SetLineWidth( lineWidth );
7083 if ( outlineWidth > 0 )
7084 aSmeshActor->SetOutlineWidth( outlineWidth );
7085 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
7086 aSmeshActor->SetOutlineWidth( lineWidth );
7088 if ( elem0dSize > 0 )
7089 aSmeshActor->Set0DSize( elem0dSize );
7091 /*if ( ballSize > 0 )
7092 aSmeshActor->SetBallSize( ballSize );*/
7094 if ( ballDiameter > 0 )
7095 aSmeshActor->SetBallSize( ballDiameter );
7097 if ( ballScale > 0.0 )
7098 aSmeshActor->SetBallScale( ballScale );
7100 if ( shrinkSize > 0 )
7101 aSmeshActor->SetShrinkFactor( shrinkSize );
7102 // orientation vectors
7103 if ( orientationSize > 0 ) {
7104 aSmeshActor->SetFacesOrientationScale( orientationSize );
7105 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
7109 else if (paramNameStr == "PointMarker") {
7110 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
7111 if( data.count() >= 2 ) {
7113 int aParam1 = data[1].toInt( &ok );
7115 if( data[0] == "std" && data.count() == 3 ) {
7116 int aParam2 = data[2].toInt( &ok );
7117 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
7119 else if( data[0] == "custom" ) {
7120 VTK::MarkerMap::const_iterator markerIt = myMarkerMap.find( aParam1 );
7121 if( markerIt != myMarkerMap.end() ) {
7122 VTK::MarkerData aMarkerData = markerIt->second;
7123 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
7130 else if (paramNameStr == "Opacity") {
7131 aSmeshActor->SetOpacity(val.toFloat());
7134 else if (paramNameStr.startsWith("ClippingPlane")) {
7135 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
7136 // old format - val looks like "Off" or "1:0:0:0.5:0:0"
7137 // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
7138 // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
7139 // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
7140 // new format - val looks like "Off" or "0" (plane id)
7141 // (note: in new format "Off" value is used only for consistency,
7142 // so it is processed together with values in old format)
7143 bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
7144 if( anIsOldFormat ) {
7145 if (paramNameStr == "ClippingPlane1" || val == "Off")
7146 aSmeshActor->RemoveAllClippingPlanes();
7148 QList<SUIT_ViewManager*> lst;
7149 getApp()->viewManagers(viewerTypStr, lst);
7150 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
7151 if (viewIndex >= 0 && viewIndex < lst.count()) {
7152 SUIT_ViewManager* vman = lst.at(viewIndex);
7153 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
7155 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
7157 SMESH::TActorList anActorList;
7158 anActorList.push_back( aSmeshActor );
7159 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
7160 aPlane->myViewWindow = vtkView;
7161 SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
7162 aPlane->PlaneMode = aMode;
7163 bool isOpenGLClipping = ( bool )vals[1].toInt();
7164 aPlane->IsOpenGLClipping = isOpenGLClipping;
7165 if ( aMode == SMESH::Absolute ) {
7166 aPlane->myAbsoluteOrientation = vals[2].toInt();
7167 aPlane->X = vals[3].toFloat();
7168 aPlane->Y = vals[4].toFloat();
7169 aPlane->Z = vals[5].toFloat();
7170 aPlane->Dx = vals[6].toFloat();
7171 aPlane->Dy = vals[7].toFloat();
7172 aPlane->Dz = vals[8].toFloat();
7174 else if ( aMode == SMESH::Relative ) {
7175 aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
7176 aPlane->myDistance = vals[3].toFloat();
7177 aPlane->myAngle[0] = vals[4].toFloat();
7178 aPlane->myAngle[1] = vals[5].toFloat();
7182 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
7183 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
7184 aClippingPlaneInfo.Plane = aPlane;
7185 aClippingPlaneInfo.ActorList = anActorList;
7186 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
7194 int aPlaneId = val.toInt( &ok );
7195 if( ok && aPlaneId >= 0 ) {
7196 bool anIsDefinedPlane = false;
7197 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
7198 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
7199 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
7200 TPlaneInfo& aPlaneInfo = *anIter;
7201 if( aPlaneInfo.PlaneId == aPlaneId ) {
7202 aPlaneInfo.ActorList.push_back( aSmeshActor );
7203 anIsDefinedPlane = true;
7207 if( !anIsDefinedPlane ) {
7208 TPlaneInfo aPlaneInfo;
7209 aPlaneInfo.PlaneId = aPlaneId;
7210 aPlaneInfo.ActorList.push_back( aSmeshActor );
7211 aPlaneInfo.ViewManager = vman;
7213 // to make the list sorted by plane id
7214 anIter = aPlaneInfoList.begin();
7215 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
7216 const TPlaneInfo& aPlaneInfoRef = *anIter;
7217 if( aPlaneInfoRef.PlaneId > aPlaneId )
7220 aPlaneInfoList.insert( anIter, aPlaneInfo );
7225 } // if (aSmeshActor)
7226 } // other parameters than Visibility
7228 } // for names/parameters iterator
7229 } // for entries iterator
7231 // take into account planes with empty list of actors referred to them
7232 QList<SUIT_ViewManager*> aVMList;
7233 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
7235 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
7236 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
7237 int aViewId = aPlaneDataIter->first;
7238 if( aViewId >= 0 && aViewId < aVMList.count() ) {
7239 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
7241 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
7243 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
7244 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
7245 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
7246 const TPlaneData& aPlaneData = *anIter2;
7247 int aPlaneId = aPlaneData.Id;
7249 bool anIsFound = false;
7250 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
7251 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
7252 const TPlaneInfo& aPlaneInfo = *anIter3;
7253 if( aPlaneInfo.PlaneId == aPlaneId ) {
7260 TPlaneInfo aPlaneInfo; // ActorList field is empty
7261 aPlaneInfo.PlaneId = aPlaneId;
7262 aPlaneInfo.ViewManager = aViewManager;
7264 // to make the list sorted by plane id
7265 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
7266 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
7267 const TPlaneInfo& aPlaneInfoRef = *anIter4;
7268 if( aPlaneInfoRef.PlaneId > aPlaneId )
7271 aPlaneInfoList.insert( anIter4, aPlaneInfo );
7277 // add clipping planes to actors according to the restored parameters
7278 // and update the clipping plane map
7279 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
7280 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
7281 int aViewId = anIter1->first;
7282 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
7284 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
7285 if( anIter2 == aPlaneDataMap.end() )
7287 const TPlaneDataList& aPlaneDataList = anIter2->second;
7289 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
7290 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
7291 const TPlaneInfo& aPlaneInfo = *anIter3;
7292 int aPlaneId = aPlaneInfo.PlaneId;
7293 const TActorList& anActorList = aPlaneInfo.ActorList;
7294 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
7298 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
7302 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
7304 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
7305 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
7306 const TPlaneData& aPlaneData = *anIter4;
7307 if( aPlaneData.Id == aPlaneId ) {
7308 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
7309 aPlane->myViewWindow = aViewWindow;
7310 aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
7311 aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
7312 if ( aPlane->PlaneMode == SMESH::Absolute ) {
7313 aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
7314 aPlane->X = aPlaneData.X;
7315 aPlane->Y = aPlaneData.Y;
7316 aPlane->Z = aPlaneData.Z;
7317 aPlane->Dx = aPlaneData.Dx;
7318 aPlane->Dy = aPlaneData.Dy;
7319 aPlane->Dz = aPlaneData.Dz;
7321 else if ( aPlane->PlaneMode == SMESH::Relative ) {
7322 aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
7323 aPlane->myDistance = aPlaneData.Distance;
7324 aPlane->myAngle[0] = aPlaneData.Angle[0];
7325 aPlane->myAngle[1] = aPlaneData.Angle[1];
7328 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
7329 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
7330 aClippingPlaneInfo.Plane = aPlane;
7331 aClippingPlaneInfo.ActorList = anActorList;
7332 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
7343 // update all VTK views
7344 QList<SUIT_ViewManager*> lst;
7345 getApp()->viewManagers(lst);
7346 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
7347 SUIT_ViewModel* vmodel = (*it)->getViewModel();
7348 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
7349 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
7350 // set OpenGL clipping planes
7351 VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
7352 vtkActorCollection* anAllActors = aCopy.GetActors();
7353 anAllActors->InitTraversal();
7354 while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
7355 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
7356 anActor->SetOpenGLClippingPlane();
7358 vtkView->getRenderer()->ResetCameraClippingRange();
7365 \brief Adds preferences for dfont of VTK viewer
7367 \param pIf group identifier
7368 \param param parameter
7369 \return identifier of preferences
7371 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
7373 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
7375 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
7378 fam.append( tr( "SMESH_FONT_ARIAL" ) );
7379 fam.append( tr( "SMESH_FONT_COURIER" ) );
7380 fam.append( tr( "SMESH_FONT_TIMES" ) );
7382 setPreferenceProperty( tfont, "fonts", fam );
7384 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
7385 if ( needSize ) f = f | QtxFontEdit::Size;
7386 setPreferenceProperty( tfont, "features", f );
7392 \brief Actions after hypothesis edition
7393 Updates object browser after hypothesis edition
7395 void SMESHGUI::onHypothesisEdit( int result )
7398 SMESHGUI::Modified();
7399 updateObjBrowser( true );
7403 \brief Actions after choosing menu of control modes
7404 Updates control mode actions according to current selection
7406 void SMESHGUI::onUpdateControlActions()
7408 SALOME_ListIO selected;
7409 if ( LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr() )
7410 aSel->selectedObjects( selected );
7412 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
7413 if ( selected.Extent() ) {
7414 if ( selected.First()->hasEntry() ) {
7415 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( selected.First()->getEntry() )) {
7416 aControl = anActor->GetControlMode();
7417 SALOME_ListIteratorOfListIO it(selected);
7418 for ( it.Next(); it.More(); it.Next() ) {
7419 Handle(SALOME_InteractiveObject) anIO = it.Value();
7420 if ( anIO->hasEntry() ) {
7421 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
7422 if ( aControl != anActor->GetControlMode() ) {
7423 aControl = SMESH_Actor::eNone;
7433 int anAction = ActionToControl( aControl, true );
7435 action( anAction )->setChecked( true );
7437 QMenu* send = (QMenu*)sender();
7438 QList<QAction*> actions = send->actions();
7439 for ( int i = 0; i < actions.size(); i++ )
7440 actions[i]->setChecked( false );
7446 \brief Signal handler closing(SUIT_ViewWindow*) of a view
7447 \param pview view being closed
7449 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
7450 #ifndef DISABLE_PLOT2DVIEWER
7451 //Crear all Plot2d Viewers if need.
7452 SMESH::ClearPlot2Viewers(pview);
7454 EmitSignalCloseView();
7457 void SMESHGUI::message( const QString& msg )
7460 QStringList data = msg.split("/");
7461 if ( data.count() > 0 ) {
7462 if ( data.first() == "mesh_loading" ) {
7464 QString entry = data.count() > 1 ? data[1] : QString();
7465 if ( entry.isEmpty() )
7468 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
7470 _PTR(SObject) obj = study->FindObjectID( entry.toUtf8().constData() );
7473 name = SMESH::fromUtf8(obj->GetName());
7474 if ( name.isEmpty() )
7477 if ( data.last() == "stop" )
7478 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
7480 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
7481 QApplication::processEvents();
7487 \brief Connects or disconnects signals about activating and cloning view on the module slots
7488 \param pview view which is connected/disconnected
7490 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
7494 SUIT_ViewManager* viewMgr = pview->getViewManager();
7496 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7497 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7499 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7500 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7505 \brief Return \c true if object can be renamed
7507 bool SMESHGUI::renameAllowed( const QString& entry) const {
7508 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7512 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7516 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
7521 if(appStudy->isComponent(entry) || obj->isReference())
7524 // check type to prevent renaming of inappropriate objects
7525 int aType = SMESHGUI_Selection::type(qPrintable(entry));
7526 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7527 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7528 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7529 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7530 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
7537 Rename object by entry.
7538 \param entry entry of the object
7539 \param name new name of the object
7540 \brief Return \c true if rename operation finished successfully, \c false otherwise.
7542 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
7544 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7548 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7553 _PTR(Study) aStudy = appStudy->studyDS();
7558 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
7560 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
7565 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
7566 _PTR(GenericAttribute) anAttr;
7567 _PTR(AttributeName) aName;
7569 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
7571 // check type to prevent renaming of inappropriate objects
7572 int aType = SMESHGUI_Selection::type( qPrintable(entry));
7573 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7574 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7575 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7576 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7577 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
7578 if ( !name.isEmpty() ) {
7579 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qUtf8Printable(name) );
7581 // update name of group object and its actor
7582 Handle(SALOME_InteractiveObject) IObject =
7583 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
7585 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
7586 if( !aGroupObject->_is_nil() ) {
7587 aGroupObject->SetName( qUtf8Printable(name) );
7588 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
7589 anActor->setName( qUtf8Printable(name) );
7599 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
7601 static QList<QColor> colors;
7603 if ( colors.isEmpty() ) {
7605 for (int s = 0; s < 2 ; s++)
7607 for (int v = 100; v >= 40; v = v - 20)
7609 for (int h = 0; h < 359 ; h = h + 60)
7611 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
7616 static int currentColor = randomize( colors.size() );
7618 SALOMEDS::Color color;
7619 color.R = (double)colors[currentColor].red() / 255.0;
7620 color.G = (double)colors[currentColor].green() / 255.0;
7621 color.B = (double)colors[currentColor].blue() / 255.0;
7623 currentColor = (currentColor+1) % colors.count();