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_Add0DElemsOnAllNodesDlg.h"
34 #include "SMESHGUI_AddMeshElementDlg.h"
35 #include "SMESHGUI_AddQuadraticElementDlg.h"
36 #include "SMESHGUI_BuildCompoundDlg.h"
37 #include "SMESHGUI_ClippingDlg.h"
38 #include "SMESHGUI_ComputeDlg.h"
39 #include "SMESHGUI_ConvToQuadOp.h"
40 #include "SMESHGUI_CopyMeshDlg.h"
41 #include "SMESHGUI_CreatePolyhedralVolumeDlg.h"
42 #include "SMESHGUI_DeleteGroupDlg.h"
43 #include "SMESHGUI_DisplayEntitiesDlg.h"
44 #include "SMESHGUI_Displayer.h"
45 #include "SMESHGUI_DuplicateNodesDlg.h"
46 #include "SMESHGUI_ExtrusionAlongPathDlg.h"
47 #include "SMESHGUI_ExtrusionDlg.h"
48 #include "SMESHGUI_FaceGroupsSeparatedByEdgesDlg.h"
49 #include "SMESHGUI_FieldSelectorWdg.h"
50 #include "SMESHGUI_FileInfoDlg.h"
51 #include "SMESHGUI_FileValidator.h"
52 #include "SMESHGUI_FilterDlg.h"
53 #include "SMESHGUI_FilterLibraryDlg.h"
54 #include "SMESHGUI_FilterUtils.h"
55 #include "SMESHGUI_FindElemByPointDlg.h"
56 #include "SMESHGUI_GEOMGenUtils.h"
57 #include "SMESHGUI_GroupDlg.h"
58 #include "SMESHGUI_GroupOnShapeDlg.h"
59 #include "SMESHGUI_GroupOpDlg.h"
60 #include "SMESHGUI_GroupUtils.h"
61 #include "SMESHGUI_Hypotheses.h"
62 #include "SMESHGUI_HypothesesUtils.h"
63 #include "SMESHGUI_Make2DFrom3DOp.h"
64 #include "SMESHGUI_MakeNodeAtPointDlg.h"
65 #include "SMESHGUI_Measurements.h"
66 #include "SMESHGUI_MergeDlg.h"
67 #include "SMESHGUI_MeshInfo.h"
68 #include "SMESHGUI_MeshOp.h"
69 #include "SMESHGUI_MeshOrderOp.h"
70 #include "SMESHGUI_MeshPatternDlg.h"
71 #include "SMESHGUI_MeshUtils.h"
72 #include "SMESHGUI_MultiEditDlg.h"
73 #include "SMESHGUI_NodesDlg.h"
74 #include "SMESHGUI_OffsetDlg.h"
75 #include "SMESHGUI_Operations.h"
76 #include "SMESHGUI_PatternUtils.h"
77 #include "SMESHGUI_Preferences_ScalarBarDlg.h"
78 #include "SMESHGUI_PropertiesDlg.h"
79 #include "SMESHGUI_RemoveElementsDlg.h"
80 #include "SMESHGUI_RemoveNodesDlg.h"
81 #include "SMESHGUI_RenumberingDlg.h"
82 #include "SMESHGUI_ReorientFacesDlg.h"
83 #include "SMESHGUI_RevolutionDlg.h"
84 #include "SMESHGUI_RotationDlg.h"
85 #include "SMESHGUI_ScaleDlg.h"
86 #include "SMESHGUI_Selection.h"
87 #include "SMESHGUI_SewingDlg.h"
88 #include "SMESHGUI_SingleEditDlg.h"
89 #include "SMESHGUI_SmoothingDlg.h"
90 #include "SMESHGUI_SpinBox.h"
91 #include "SMESHGUI_SplitBiQuad.h"
92 #include "SMESHGUI_SymmetryDlg.h"
93 #include "SMESHGUI_TranslationDlg.h"
94 #include "SMESHGUI_TransparencyDlg.h"
95 #include "SMESHGUI_Utils.h"
96 #include "SMESHGUI_VTKUtils.h"
98 #include "SMESH_version.h"
100 #include "SMESH_Actor.h"
101 #include "SMESH_ActorUtils.h"
102 #include "SMESH_Client.hxx"
103 #include "SMESH_Comment.hxx"
104 #include "SMESH_ControlsDef.hxx"
105 #include "SMESH_ScalarBarActor.h"
106 #include "SMESH_TypeFilter.hxx"
108 // SALOME GUI includes
109 #include <LightApp_DataOwner.h>
110 #include <LightApp_NameDlg.h>
111 #include <LightApp_Preferences.h>
112 #include <LightApp_SelectionMgr.h>
113 #include <LightApp_UpdateFlags.h>
114 #include <QtxFontEdit.h>
115 #include <QtxPopupMgr.h>
116 #include <QtxInfoPanel.h>
117 #include <SALOME_ListIO.hxx>
118 #include <SUIT_Desktop.h>
119 #include <SUIT_FileDlg.h>
120 #include <SUIT_MessageBox.h>
121 #include <SUIT_OverrideCursor.h>
122 #include <SUIT_ResourceMgr.h>
123 #include <SUIT_Session.h>
124 #include <SVTK_Renderer.h>
125 #include <SVTK_ViewManager.h>
126 #include <SVTK_ViewModel.h>
127 #include <SVTK_ViewWindow.h>
128 #include <SalomeApp_Application.h>
129 #include <SalomeApp_CheckFileDlg.h>
130 #include <SalomeApp_DataObject.h>
131 #include <SalomeApp_Study.h>
132 #include <SalomeApp_Tools.h>
133 #include <VTKViewer_Algorithm.h>
135 #ifndef DISABLE_PLOT2DVIEWER
136 #include <SPlot2d_ViewModel.h>
137 #include <SPlot2d_Histogram.h>
141 #include <SALOMEconfig.h>
142 #include CORBA_CLIENT_HEADER(SALOMEDS_Attributes)
143 #include CORBA_CLIENT_HEADER(SMESH_MeshEditor)
144 #include CORBA_CLIENT_HEADER(SMESH_Measurements)
145 #include CORBA_CLIENT_HEADER(SMESH_Mesh)
148 // #define INCLUDE_MENUITEM_DEF // VSR commented ????????
149 #include <QApplication>
151 #include <QDialogButtonBox>
155 #include <QTextStream>
159 #include <boost/shared_ptr.hpp>
162 #include <vtkCallbackCommand.h>
163 #include <vtkCamera.h>
164 #include <vtkLookupTable.h>
165 #include <vtkPlane.h>
166 #include <vtkRenderer.h>
168 // SALOME KERNEL includes
169 #include <SALOMEDSClient_ClientFactory.hxx>
170 #include <SALOMEDSClient_IParameters.hxx>
171 #include <SALOMEDSClient_SComponent.hxx>
172 #include <SALOMEDSClient_StudyBuilder.hxx>
173 #include <SALOMEDS_Study.hxx>
174 #include <SALOMEDS_SObject.hxx>
175 #include "utilities.h"
176 #include <SALOME_LifeCycleCORBA.hxx>
179 #include <Standard_ErrorHandler.hxx>
180 #include <NCollection_DataMap.hxx>
181 #include <NCollection_DoubleMap.hxx>
183 #include <Basics_Utils.hxx>
185 // Below macro, when uncommented, switches on simplified (more performant) algorithm
186 // of auto-color picking up
187 #define SIMPLE_AUTOCOLOR
192 //=============================================================
193 void ImportMeshesFromFile(SMESH::SMESH_Gen_ptr theComponentMesh,
196 void ExportMeshToFile(int theCommandID);
198 void SetDisplayMode(int theCommandID, VTK::MarkerMap& theMarkerMap);
200 void SetDisplayEntity(int theCommandID);
202 int ActionToControl( int theID, bool theReversed = false );
204 void Control( int theCommandID );
207 //================================================================================
209 * \brief Reads meshes from file
211 //================================================================================
213 void ImportMeshesFromFile( SMESH::SMESH_Gen_ptr theComponentMesh,
217 std::string myExtension;
219 if ( theCommandID == SMESHOp::OpImportMED ||
220 theCommandID == SMESHOp::OpPopupImportMED ) {
221 filter.append( QObject::tr( "MED_FILES_FILTER" ) + " (*.*med)" );
222 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
224 else if ( theCommandID == SMESHOp::OpImportUNV ||
225 theCommandID == SMESHOp::OpPopupImportUNV ) {
226 filter.append( QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)" );
228 else if ( theCommandID == SMESHOp::OpImportDAT ||
229 theCommandID == SMESHOp::OpPopupImportDAT ) {
230 filter.append( QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)" );
232 else if ( theCommandID == SMESHOp::OpImportSTL ||
233 theCommandID == SMESHOp::OpPopupImportSTL ) {
234 filter.append( QObject::tr( "STL_FILES_FILTER" ) + " (*.stl)" );
236 else if ( theCommandID == SMESHOp::OpImportCGNS ||
237 theCommandID == SMESHOp::OpPopupImportCGNS ) {
238 filter.append( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
240 else if ( theCommandID == SMESHOp::OpImportSAUV ||
241 theCommandID == SMESHOp::OpPopupImportSAUV ) {
242 filter.append( QObject::tr( "SAUV_FILES_FILTER" ) + " (*.sauv *.sauve)" );
243 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
245 else if ( theCommandID == SMESHOp::OpImportGMF ||
246 theCommandID == SMESHOp::OpPopupImportGMF ) {
247 filter.append( QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" );
248 filter.append( QObject::tr( "GMF_BINARY_FILES_FILTER") + " (*.meshb)" );
251 QString anInitialPath = "";
252 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
253 anInitialPath = QDir::currentPath();
255 QStringList filenames;
256 bool toCreateGroups = true;
258 // if ( theCommandID == SMESHOp::OpImportGMF ) { // GMF
259 // SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg
260 // ( SMESHGUI::desktop(), true, QObject::tr("SMESH_REQUIRED_GROUPS"), true, true );
261 // fd->setWindowTitle( QObject::tr( "SMESH_IMPORT_MESH" ) );
262 // fd->setNameFilters( filter );
263 // fd->SetChecked( true );
265 // filenames << fd->selectedFile();
266 // toCreateGroups = fd->IsChecked();
272 filenames = SUIT_FileDlg::getOpenFileNames( SMESHGUI::desktop(),
275 QObject::tr( "SMESH_IMPORT_MESH" ) );
277 if ( filenames.count() > 0 )
279 SUIT_OverrideCursor wc;
280 _PTR(Study) aStudy = SMESH::getStudy();
283 QStringList anEntryList;
284 bool isEmpty = false;
285 for ( QStringList::ConstIterator it = filenames.begin(); it != filenames.end(); ++it )
287 QString filename = *it;
288 SMESH::mesh_array_var aMeshes = new SMESH::mesh_array;
290 switch ( theCommandID ) {
291 case SMESHOp::OpImportDAT:
292 case SMESHOp::OpPopupImportDAT:
294 // DAT format (currently unsupported)
295 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
296 arg( QObject::tr( "SMESH_ERR_NOT_SUPPORTED_FORMAT" ) ) );
299 case SMESHOp::OpImportUNV:
300 case SMESHOp::OpPopupImportUNV:
303 aMeshes->length( 1 );
304 aMeshes[0] = theComponentMesh->CreateMeshesFromUNV( filename.toUtf8().constData() );
305 if ( aMeshes[0]->_is_nil() )
306 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
307 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
310 case SMESHOp::OpImportMED:
311 case SMESHOp::OpPopupImportMED:
314 SMESH::DriverMED_ReadStatus res;
315 aMeshes = theComponentMesh->CreateMeshesFromMED( filename.toUtf8().constData(), res );
316 if ( res != SMESH::DRS_OK ) {
317 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
318 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
322 case SMESHOp::OpImportSTL:
323 case SMESHOp::OpPopupImportSTL:
326 aMeshes->length( 1 );
327 aMeshes[0] = theComponentMesh->CreateMeshesFromSTL( filename.toUtf8().constData() );
328 if ( aMeshes[0]->_is_nil() ) {
329 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
330 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
334 case SMESHOp::OpImportCGNS:
335 case SMESHOp::OpPopupImportCGNS:
338 SMESH::DriverMED_ReadStatus res;
339 aMeshes = theComponentMesh->CreateMeshesFromCGNS( filename.toUtf8().constData(), res );
340 if ( res != SMESH::DRS_OK ) {
341 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
342 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
346 case SMESHOp::OpImportSAUV:
347 case SMESHOp::OpPopupImportSAUV:
350 SMESH::DriverMED_ReadStatus res;
351 aMeshes = theComponentMesh->CreateMeshesFromSAUV( filename.toUtf8().constData(), res );
352 if ( res != SMESH::DRS_OK ) {
353 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
354 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
358 case SMESHOp::OpImportGMF:
359 case SMESHOp::OpPopupImportGMF:
362 SMESH::ComputeError_var res;
363 aMeshes->length( 1 );
364 aMeshes[0] = theComponentMesh->CreateMeshesFromGMF( filename.toUtf8().constData(),
367 if ( res->code != SMESH::DRS_OK ) {
368 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
369 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res->code ).toLatin1().data() ) ) );
370 if ( strlen( res->comment.in() ) > 0 ) {
371 errors.back() += ": ";
372 errors.back() += res->comment.in();
379 catch ( const SALOME::SALOME_Exception& S_ex ) {
380 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
381 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
384 for ( int i = 0, iEnd = aMeshes->length(); i < iEnd; i++ )
386 _PTR(SObject) aMeshSO = SMESH::FindSObject( aMeshes[i] );
388 _PTR(StudyBuilder) aBuilder = aStudy->NewBuilder();
389 _PTR(AttributePixMap) aPixmap = aBuilder->FindOrCreateAttribute( aMeshSO, "AttributePixMap" );
390 aPixmap->SetPixMap( "ICON_SMESH_TREE_MESH_IMPORTED" );
391 if ( theCommandID == SMESHOp::OpImportUNV ) // mesh names aren't taken from the file for UNV import
392 SMESH::SetName( aMeshSO, QFileInfo(filename).fileName() );
394 anEntryList.append( aMeshSO->GetID().c_str() );
402 // update Object browser
403 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
405 // browse to the published meshes
406 if( LightApp_Application* anApp =
407 dynamic_cast<LightApp_Application*>( SUIT_Session::session()->activeApplication() ) )
408 anApp->browseObjects( anEntryList );
410 // show Error message box if there were errors
411 if ( errors.count() > 0 ) {
412 SUIT_MessageBox::critical( SMESHGUI::desktop(),
413 QObject::tr( "SMESH_ERROR" ),
414 QObject::tr( "SMESH_IMPORT_ERRORS" ) + "\n" + errors.join( "\n" ) );
417 // show warning message box, if some imported mesh is empty
419 SUIT_MessageBox::warning( SMESHGUI::desktop(),
420 QObject::tr( "SMESH_WRN_WARNING" ),
421 QObject::tr( "SMESH_DRS_SOME_EMPTY" ) );
426 //================================================================================
428 * \brief Export selected meshes or groups into a file
430 //================================================================================
432 void ExportMeshToFile( int theCommandID )
434 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
435 SALOME_ListIO selected;
437 aSel->selectedObjects( selected );
439 const bool isDAT = ( theCommandID == SMESHOp::OpExportDAT ||
440 theCommandID == SMESHOp::OpPopupExportDAT );
441 const bool isMED = ( theCommandID == SMESHOp::OpExportMED ||
442 theCommandID == SMESHOp::OpPopupExportMED );
443 const bool isUNV = ( theCommandID == SMESHOp::OpExportUNV ||
444 theCommandID == SMESHOp::OpPopupExportUNV );
445 const bool isSTL = ( theCommandID == SMESHOp::OpExportSTL ||
446 theCommandID == SMESHOp::OpPopupExportSTL );
447 const bool isCGNS= ( theCommandID == SMESHOp::OpExportCGNS ||
448 theCommandID == SMESHOp::OpPopupExportCGNS );
449 const bool isSAUV= ( theCommandID == SMESHOp::OpExportSAUV ||
450 theCommandID == SMESHOp::OpPopupExportSAUV );
451 const bool isGMF = ( theCommandID == SMESHOp::OpExportGMF ||
452 theCommandID == SMESHOp::OpPopupExportGMF );
454 const bool multiMeshSupported = ( isMED || isCGNS ); // file can hold several meshes
455 if ( selected.Extent() == 0 || ( selected.Extent() > 1 && !multiMeshSupported ))
457 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
458 bool aCheckWarn = true;
460 aCheckWarn = resMgr->booleanValue( "SMESH", "show_warning", false );
461 // get mesh object from selection and check duplication of their names
462 bool hasDuplicatedMeshNames = false;
463 QList< QPair< SMESH::SMESH_IDSource_var, QString > > aMeshList;
464 QList< QPair< SMESH::SMESH_IDSource_var, QString > >::iterator aMeshIter;
465 SALOME_ListIteratorOfListIO It( selected );
466 for( ; It.More(); It.Next() )
468 Handle(SALOME_InteractiveObject) anIObject = It.Value();
469 SMESH::SMESH_IDSource_var aMeshItem =
470 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIObject);
471 if ( aMeshItem->_is_nil() ) {
472 SUIT_MessageBox::warning( SMESHGUI::desktop(),
473 QObject::tr( "SMESH_WRN_WARNING" ),
474 QObject::tr( "SMESH_BAD_MESH_SELECTION" ));
477 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( aMeshItem );
478 if ( aCheckWarn && !aGroup->_is_nil() )
480 QMessageBox msgBox(SUIT_MessageBox::Warning,
481 QObject::tr("SMESH_WRN_WARNING"),
482 QObject::tr("SMESH_EXPORT_ONLY_GPOUP"),
483 QMessageBox::StandardButton::NoButton,
484 SMESHGUI::desktop());
485 QCheckBox dontShowCheckBox(QObject::tr("SMESH_WRN_SHOW_DLG_CHECKBOX"));
486 msgBox.addButton(QMessageBox::Ok);
487 msgBox.addButton(QMessageBox::Cancel);
488 msgBox.setDefaultButton(QMessageBox::Cancel);
489 QGridLayout* lt = qobject_cast<QGridLayout*>(msgBox.layout());
490 QDialogButtonBox* btnbox = msgBox.findChild<QDialogButtonBox*>();
491 lt->addWidget(&dontShowCheckBox, lt->rowCount(), lt->columnCount()-1, lt->rowCount(), lt->columnCount());
492 lt->addWidget(btnbox, lt->rowCount(), 0, lt->rowCount(), lt->columnCount());
493 if ( msgBox.exec() != QMessageBox::Ok )
496 if ( dontShowCheckBox.checkState() == Qt::Checked && resMgr )
497 resMgr->setValue( "SMESH", "show_warning", false);
500 QString aMeshName = anIObject->getName();
502 // check for name duplications
503 if ( !hasDuplicatedMeshNames )
504 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
505 if( aMeshName == (*aMeshIter).second ) {
506 hasDuplicatedMeshNames = true;
511 aMeshList.append( QPair< SMESH::SMESH_IDSource_var, QString >( aMeshItem, aMeshName ) );
514 if( hasDuplicatedMeshNames && isMED ) {
515 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
516 QObject::tr("SMESH_WRN_WARNING"),
517 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_MESH_NAMES"),
518 QObject::tr("SMESH_BUT_YES"),
519 QObject::tr("SMESH_BUT_NO"), 0, 1);
524 aMeshIter = aMeshList.begin();
525 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
526 SMESH::SMESH_Mesh_var aMesh = aMeshOrGroup->GetMesh();
527 QString aMeshName = (*aMeshIter).second;
529 if ( isMED || isCGNS || isSAUV ) // formats where group names must be unique
531 // check for equal group names within each mesh
532 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
533 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
534 if ( !aMeshItem->_is_nil() && aMeshItem->HasDuplicatedGroupNamesMED()) {
535 int aRet = SUIT_MessageBox::warning
536 (SMESHGUI::desktop(),
537 QObject::tr("SMESH_WRN_WARNING"),
538 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_GRP").arg((*aMeshIter).second),
539 QObject::tr("SMESH_BUT_YES"),
540 QObject::tr("SMESH_BUT_NO"), 0, 1);
547 // Warn the user about presence of not supported elements
549 std::vector< SMESH::EntityType > notSupportedElemTypes, presentNotSupported;
553 notSupportedElemTypes.push_back( SMESH::Entity_0D );
554 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
559 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
560 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
561 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
562 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
563 notSupportedElemTypes.push_back( SMESH::Entity_Pyramid );
564 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
565 notSupportedElemTypes.push_back( SMESH::Entity_0D );
566 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
571 notSupportedElemTypes.push_back( SMESH::Entity_Edge );
572 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Edge );
573 notSupportedElemTypes.push_back( SMESH::Entity_0D );
574 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
579 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
584 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
585 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Triangle );
586 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Quadrangle );
587 notSupportedElemTypes.push_back( SMESH::Entity_TriQuad_Hexa );
588 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
589 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
590 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
591 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
596 notSupportedElemTypes.push_back( SMESH::Entity_0D );
597 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
598 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
599 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Pyramid );
600 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Penta );
601 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Penta );
602 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
603 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
604 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
605 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
607 if ( ! notSupportedElemTypes.empty() )
609 SMESH::smIdType_array_var nbElems = aMeshOrGroup->GetMeshInfo();
610 for ( size_t iType = 0; iType < notSupportedElemTypes.size(); ++iType )
611 if ( nbElems[ notSupportedElemTypes[ iType ]] > 0 )
612 presentNotSupported.push_back( notSupportedElemTypes[ iType ]);
614 if ( !presentNotSupported.empty() )
617 const char* typeMsg[] = {
618 "SMESH_NODES", "SMESH_ELEMS0D","SMESH_EDGES","SMESH_QUADRATIC_EDGES",
619 "SMESH_TRIANGLES", "SMESH_QUADRATIC_TRIANGLES", "SMESH_BIQUADRATIC_TRIANGLES",
620 "SMESH_QUADRANGLES","SMESH_QUADRATIC_QUADRANGLES", "SMESH_BIQUADRATIC_QUADRANGLES",
621 "SMESH_POLYGONS","SMESH_QUADRATIC_POLYGONS",
622 "SMESH_TETRAHEDRA","SMESH_QUADRATIC_TETRAHEDRONS","SMESH_PYRAMIDS",
623 "SMESH_QUADRATIC_PYRAMIDS","SMESH_HEXAHEDRA","SMESH_QUADRATIC_HEXAHEDRONS",
624 "SMESH_TRIQUADRATIC_HEXAHEDRONS","SMESH_PENTAHEDRA","SMESH_QUADRATIC_PENTAHEDRONS",
625 "SMESH_BIQUADRATIC_PENTAHEDRONS",
626 "SMESH_OCTAHEDRA","SMESH_POLYEDRONS","SMESH_QUADRATIC_POLYEDRONS","SMESH_BALLS"
628 // is typeMsg complete? (compilation failure mains that enum SMDSAbs_EntityType changed)
629 const int nbTypes = sizeof( typeMsg ) / sizeof( const char* );
630 int _assert[( nbTypes == SMESH::Entity_Last ) ? 2 : -1 ]; _assert[0]=_assert[1]=0;
632 QString andStr = " " + QObject::tr("SMESH_AND") + " ", comma(", ");
633 for ( size_t iType = 0; iType < presentNotSupported.size(); ++iType ) {
634 typeNames += QObject::tr( typeMsg[ presentNotSupported[ iType ]]);
635 if ( iType != presentNotSupported.size() - 1 )
636 typeNames += ( iType == presentNotSupported.size() - 2 ) ? andStr : comma;
638 int aRet = SUIT_MessageBox::warning
639 (SMESHGUI::desktop(),
640 QObject::tr("SMESH_WRN_WARNING"),
641 QObject::tr("EXPORT_NOT_SUPPORTED").arg(aMeshName).arg(format).arg(typeNames),
642 QObject::tr("SMESH_BUT_YES"),
643 QObject::tr("SMESH_BUT_NO"), 0, 1);
648 // Get parameters of export operation
651 int aFormat =-1; // for MED version used for write
652 bool isOkToWrite = true; // to check MED file version compatibility before adding a mesh in an existing file
654 // Init the parameters with the default values
655 bool aIsASCII_STL = true;
656 bool toCreateGroups = false;
658 toCreateGroups = resMgr->booleanValue( "SMESH", "auto_groups", false );
659 bool toOverwrite = true;
660 bool toFindOutDim = true;
661 double zTol = resMgr ? resMgr->doubleValue( "SMESH", "med_ztolerance", 0. ) : 0.;
663 QString aFilter, aTitle = QObject::tr("SMESH_EXPORT_MESH");
664 QString anInitialPath = "";
665 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
666 anInitialPath = QDir::currentPath();
668 QList< QPair< GEOM::ListOfFields_var, QString > > aFieldList;
670 // Get a file name to write in and additional options
671 if ( isUNV || isDAT || isGMF ) // Export w/o options
674 aFilter = QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)";
676 aFilter = QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)";
678 aFilter = QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" +
679 ";;" + QObject::tr( "GMF_BINARY_FILES_FILTER" ) + " (*.meshb)";
680 if ( anInitialPath.isEmpty() ) anInitialPath = SUIT_FileDlg::getLastVisitedPath();
681 aFilename = SUIT_FileDlg::getFileName(SMESHGUI::desktop(),
682 anInitialPath + QString("/") + aMeshName,
683 aFilter, aTitle, false);
685 else if ( isCGNS )// Export to CGNS
687 const char* theByTypeResource = "cgns_group_elems_by_type";
688 toCreateGroups = SMESHGUI::resourceMgr()->booleanValue( "SMESH", theByTypeResource, false );
690 QStringList checkBoxes;
691 checkBoxes << QObject::tr("CGNS_EXPORT_ELEMS_BY_TYPE");
693 SalomeApp_CheckFileDlg* fd =
694 new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true );
695 fd->setWindowTitle( aTitle );
696 fd->setNameFilter( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
697 if ( !anInitialPath.isEmpty() )
698 fd->setDirectory( anInitialPath );
699 fd->selectFile(aMeshName);
700 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
701 fd->setValidator( fv );
702 fd->SetChecked( toCreateGroups, 0 );
705 aFilename = fd->selectedFile();
706 toOverwrite = fv->isOverwrite(aFilename);
707 toCreateGroups = fd->IsChecked(0);
708 SMESHGUI::resourceMgr()->setValue("SMESH", theByTypeResource, toCreateGroups );
712 else if ( isSTL ) // Export to STL
714 QMap<QString, int> aFilterMap;
715 aFilterMap.insert( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)", 1 );
716 aFilterMap.insert( QObject::tr( "STL_BIN_FILES_FILTER" ) + " (*.stl)", 0 );
719 QMap<QString, int>::const_iterator it = aFilterMap.begin();
720 for ( ; it != aFilterMap.end(); ++it )
721 filters.push_back( it.key() );
723 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
724 fd->setWindowTitle( aTitle );
725 fd->setNameFilters( filters );
726 fd->selectNameFilter( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
727 if ( !anInitialPath.isEmpty() )
728 fd->setDirectory( anInitialPath );
729 fd->selectFile(aMeshName);
733 aFilename = fd->selectedFile();
734 aIsASCII_STL = (aFilterMap[fd->selectedNameFilter()]) == 1 ? true: false;
739 else if ( isMED || isSAUV ) // Export to MED or SAUV
741 int defaultVersion = 0;
742 QMap<QString, int> aFilterMap;
744 //filters << QObject::tr( "MED_FILES_FILTER" ) + " (*.med)";
745 //QString vmed (aMesh->GetVersionString(-1, 2));
746 SMESH::long_array_var mvok = aMesh->GetMEDVersionsCompatibleForAppend();
747 if ( mvok->length() > 0)
748 defaultVersion = mvok[0]; // the current version to set the default filter on it
749 for ( CORBA::ULong i = 0; i < mvok->length(); ++i )
751 QString vs = (char*)( SMESH_Comment( mvok[i]/10 ) << "." << mvok[i]%10 );
752 MESSAGE("MED version: " << vs.toStdString());
753 aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( vs ) + " (*.med)", mvok[i]);
757 aFilterMap.insert("All files (*)", -1 );
758 aFilterMap.insert("SAUV files (*.sauv)", defaultVersion ); // 0 = default filter (defaultVersion)
759 aFilterMap.insert("SAUV files (*.sauve)", -1 );
762 QMap<QString, int>::const_iterator it = aFilterMap.begin();
763 QString aDefaultFilter = it.key();
764 for ( ; it != aFilterMap.end(); ++it ) {
765 filters.push_back( it.key() );
766 if (it.value() == defaultVersion) // explicit default for MED = current MED version
767 aDefaultFilter = it.key();
769 QStringList checkBoxes;
770 checkBoxes << QObject::tr("SMESH_AUTO_GROUPS") << QObject::tr("SMESH_AUTO_DIM");
772 SMESHGUI_FieldSelectorWdg* fieldSelWdg = new SMESHGUI_FieldSelectorWdg();
773 QList< QWidget* > wdgList;
774 if ( fieldSelWdg->GetAllFields( aMeshList, aFieldList ))
775 wdgList.append( fieldSelWdg );
777 QWidget* zTolWdg = new QWidget();
778 QCheckBox* zTolCheck = new QCheckBox( QObject::tr( "SMESH_ZTOLERANCE" ), zTolWdg );
779 SMESHGUI_SpinBox* zTolSpin = new SMESHGUI_SpinBox( zTolWdg );
780 QHBoxLayout* zTolLayout = new QHBoxLayout( zTolWdg );
781 zTolLayout->addWidget( zTolCheck );
782 zTolLayout->addWidget( zTolSpin );
783 zTolLayout->setMargin( 0 );
784 zTolSpin->RangeStepAndValidator( 0, 1e+100, 1., "length_precision" );
785 zTolSpin->setValue( zTol );
786 QObject::connect( zTolCheck, SIGNAL( toggled(bool)), zTolSpin, SLOT( setEnabled(bool)));
787 zTolCheck->setChecked( resMgr->booleanValue( "SMESH", "enable_ztolerance", false ));
788 zTolSpin ->setEnabled( zTolCheck->isChecked() );
789 wdgList.append( zTolWdg );
791 SalomeApp_CheckFileDlg* fd =
792 new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true, wdgList );
793 fd->setWindowTitle( aTitle );
794 fd->setNameFilters( filters );
795 fd->selectNameFilter( aDefaultFilter );
796 fd->SetChecked( toCreateGroups, 0 );
797 fd->SetChecked( toFindOutDim, 1 );
798 if ( !anInitialPath.isEmpty() )
799 fd->setDirectory( anInitialPath );
800 fd->selectFile(aMeshName);
803 QListView *lview = fd->findChild<QListView*>("listView");
805 lview->setMinimumHeight(200);
807 QTreeView *tview = fd->findChild<QTreeView*>("treeView");
809 tview->setMinimumHeight(200);
812 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
813 fd->setValidator( fv );
818 //MESSAGE("******* Loop on file dialog ***********");
821 aFilename = fd->selectedFile();
823 aFilename = QString::null;
826 aFormat = aFilterMap[fd->selectedNameFilter()];
827 //MESSAGE("selected version: " << aFormat << " file: " << aFilename.toUtf8().constData());
828 toOverwrite = fv->isOverwrite(aFilename);
829 //MESSAGE("toOverwrite:" << toOverwrite);
831 if ( !aFilename.isEmpty() ) {
833 // append is only possible if the existing file format is compatible
834 bool isVersionOk = SMESHGUI::GetSMESHGen()->CheckWriteCompatibility( aFilename.toUtf8().constData() );
835 MESSAGE("Append check, isVersionOk:" << isVersionOk);
836 if ( !isVersionOk ) {
837 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
838 QObject::tr("SMESH_WRN_WARNING"),
839 QObject::tr("SMESH_EXPORT_MED_VERSION_COLLISION").arg(aFilename),
840 QObject::tr("SMESH_BUT_YES"),
841 QObject::tr("SMESH_BUT_NO"), 0, 1);
845 //MESSAGE("incompatible MED file version for add, overwrite accepted");
851 //MESSAGE("incompatible MED file version for add, overwrite refused");
854 QStringList aMeshNamesCollisionList;
855 SMESH::string_array_var aMeshNames = SMESHGUI::GetSMESHGen()->GetMeshNames( aFilename.toUtf8().constData() );
856 for( int i = 0, n = aMeshNames->length(); i < n; i++ ) {
857 QString anExistingMeshName( aMeshNames[ i ] );
858 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
859 QString anExportMeshName = (*aMeshIter).second;
860 if( anExportMeshName == anExistingMeshName ) {
861 aMeshNamesCollisionList.append( anExportMeshName );
866 if( !aMeshNamesCollisionList.isEmpty() ) {
868 QString aMeshNamesCollisionString = aMeshNamesCollisionList.join( ", " );
869 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
870 QObject::tr("SMESH_WRN_WARNING"),
871 QObject::tr("SMESH_EXPORT_MED_MESH_NAMES_COLLISION").arg(aMeshNamesCollisionString),
872 QObject::tr("SMESH_BUT_YES"),
873 QObject::tr("SMESH_BUT_NO"),
874 QObject::tr("SMESH_BUT_CANCEL"), 0, 2);
875 MESSAGE("answer collision name " << aRet);
886 toCreateGroups = fd->IsChecked(0);
887 toFindOutDim = fd->IsChecked(1);
888 zTol = zTolCheck->isChecked() ? zTolSpin->value() : -1;
889 fieldSelWdg->GetSelectedFields();
890 if ( resMgr ) resMgr->setValue( "SMESH", "enable_ztolerance", zTolCheck->isChecked() );
892 if ( !fieldSelWdg->parent() )
894 if ( !zTolWdg->parent() )
905 if ( !aFilename.isEmpty() ) {
906 // Check whether the file already exists and delete it if yes
907 QFile aFile( aFilename );
908 if ( aFile.exists() && toOverwrite )
910 SUIT_OverrideCursor wc;
913 // Renumbering is not needed since SMDS redesign in V6.2.0 (Nov 2010)
914 // bool Renumber = false;
915 // // PAL 14172 : Check of we have to renumber or not from the preferences before export
917 // Renumber= resMgr->booleanValue("renumbering");
919 // SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
920 // aMeshEditor->RenumberNodes();
921 // aMeshEditor->RenumberElements();
922 // if ( SMESHGUI::automaticUpdate() )
923 // SMESH::UpdateView();
925 if ( isMED && isOkToWrite)
927 MESSAGE("OK to write MED file "<< aFilename.toUtf8().constData());
928 aMeshIter = aMeshList.begin();
929 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
931 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
932 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
933 const GEOM::ListOfFields& fields = aFieldList[ aMeshIndex ].first.in();
934 const QString& geoAssFields = aFieldList[ aMeshIndex ].second;
935 const bool hasFields = ( fields.length() || !geoAssFields.isEmpty() );
936 if ( !hasFields && aMeshOrGroup->_is_equivalent( aMeshItem ) && zTol < 0 )
937 aMeshItem->ExportMED( aFilename.toUtf8().data(), toCreateGroups, aFormat,
938 toOverwrite && aMeshIndex == 0, toFindOutDim );
940 aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toUtf8().data(),
941 toCreateGroups, aFormat,
942 toOverwrite && aMeshIndex == 0, toFindOutDim,
943 fields, geoAssFields.toLatin1().data(), zTol );
948 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ )
950 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
951 if( !aMeshItem->_is_nil() )
952 aMeshItem->ExportSAUV( aFilename.toUtf8().data(), toCreateGroups );
957 if ( aMeshOrGroup->_is_equivalent( aMesh ))
958 aMesh->ExportDAT( aFilename.toUtf8().data() );
960 aMesh->ExportPartToDAT( aMeshOrGroup, aFilename.toUtf8().data() );
964 if ( aMeshOrGroup->_is_equivalent( aMesh ))
965 aMesh->ExportUNV( aFilename.toUtf8().data() );
967 aMesh->ExportPartToUNV( aMeshOrGroup, aFilename.toUtf8().data() );
971 if ( aMeshOrGroup->_is_equivalent( aMesh ))
972 aMesh->ExportSTL( aFilename.toUtf8().data(), aIsASCII_STL );
974 aMesh->ExportPartToSTL( aMeshOrGroup, aFilename.toUtf8().data(), aIsASCII_STL );
978 aMeshIter = aMeshList.begin();
979 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
981 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
982 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
983 aMeshItem->ExportCGNS( aMeshOrGroup,
984 aFilename.toUtf8().data(),
985 toOverwrite && aMeshIndex == 0,
991 toCreateGroups = true;
992 aMesh->ExportGMF( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups );
995 catch (const SALOME::SALOME_Exception& S_ex){
997 SUIT_MessageBox::warning(SMESHGUI::desktop(),
998 QObject::tr("SMESH_WRN_WARNING"),
999 QObject::tr("SMESH_EXPORT_FAILED") + SalomeApp_Tools::ExceptionToString(S_ex));
1005 inline void InverseEntityMode(unsigned int& theOutputMode,
1006 unsigned int theMode)
1008 bool anIsNotPresent = ~theOutputMode & theMode;
1010 theOutputMode |= theMode;
1012 theOutputMode &= ~theMode;
1015 void SetDisplayEntity(int theCommandID)
1017 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1018 SALOME_ListIO selected;
1020 aSel->selectedObjects( selected );
1022 if ( selected.Extent() >= 1 ) {
1023 SUIT_OverrideCursor wc;
1024 SALOME_ListIteratorOfListIO It( selected );
1025 for( ; It.More(); It.Next()){
1026 Handle(SALOME_InteractiveObject) IObject = It.Value();
1027 if(IObject->hasEntry()){
1028 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1029 unsigned int aMode = anActor->GetEntityMode();
1030 switch(theCommandID){
1031 case SMESHOp::OpDE0DElements: InverseEntityMode(aMode,SMESH_Actor::e0DElements); break;
1032 case SMESHOp::OpDEEdges: InverseEntityMode(aMode,SMESH_Actor::eEdges); break;
1033 case SMESHOp::OpDEFaces: InverseEntityMode(aMode,SMESH_Actor::eFaces); break;
1034 case SMESHOp::OpDEVolumes: InverseEntityMode(aMode,SMESH_Actor::eVolumes); break;
1035 case SMESHOp::OpDEBalls: InverseEntityMode(aMode,SMESH_Actor::eBallElem); break;
1036 case SMESHOp::OpDEAllEntity: aMode = SMESH_Actor::eAllEntity; break;
1039 anActor->SetEntityMode(aMode);
1048 SalomeApp_Application* app =
1049 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1053 LightApp_SelectionMgr* aSel = app->selectionMgr();
1054 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1055 if ( !aSel || !appStudy )
1058 SALOME_ListIO selected;
1059 aSel->selectedObjects( selected );
1060 if ( selected.IsEmpty() )
1063 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1065 _PTR(Study) aStudy = appStudy->studyDS();
1066 _PTR(SObject) aMainSObject = aStudy->FindObjectID( anIObject->getEntry() );
1067 SMESH::SMESH_Mesh_var aMainObject = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1068 if ( aMainObject->_is_nil() )
1071 SUIT_OverrideCursor wc;
1073 aMainObject->SetAutoColor( true ); // mesh groups are re-colored here
1075 QList<SALOMEDS::Color> aReservedColors;
1077 SMESH::ListOfGroups aListOfGroups = *aMainObject->GetGroups();
1078 for ( int i = 0, n = aListOfGroups.length(); i < n; i++ )
1080 SMESH::SMESH_GroupBase_var aGroupObject = aListOfGroups[i];
1082 #ifdef SIMPLE_AUTOCOLOR // simplified algorithm for auto-colors
1083 SALOMEDS::Color aColor = SMESHGUI::getPredefinedUniqueColor();
1084 #else // old algorithm for auto-colors
1085 SALOMEDS::Color aColor = SMESHGUI::getUniqueColor( aReservedColors );
1086 aReservedColors.append( aColor );
1087 #endif // SIMPLE_AUTOCOLOR
1088 aGroupObject->SetColor( aColor );
1090 _PTR(SObject) aGroupSObject = SMESH::FindSObject(aGroupObject);
1091 if ( aGroupSObject ) {
1094 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry(aGroupSObject->GetID().c_str())) {
1095 switch ( aGroupObject->GetType ()) {
1097 anActor->SetNodeColor( aColor.R, aColor.G, aColor.B ); break;
1099 anActor->SetEdgeColor( aColor.R, aColor.G, aColor.B ); break;
1101 anActor->Set0DColor( aColor.R, aColor.G, aColor.B ); break;
1103 anActor->SetBallColor( aColor.R, aColor.G, aColor.B ); break;
1105 SMESH::GetColor("SMESH", "volume_color", c, delta, "255,0,170|-100");
1106 anActor->SetVolumeColor( aColor.R, aColor.G, aColor.B, delta ); break;
1109 SMESH::GetColor("SMESH", "fill_color", c, delta, "0,170,255|-100");
1110 anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B, delta );
1116 SMESH::RepaintCurrentView();
1119 void OverallMeshQuality()
1121 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1122 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1123 SALOME_ListIO selected;
1125 aSel->selectedObjects( selected );
1127 if ( selected.IsEmpty() ) return;
1128 SALOME_ListIteratorOfListIO It( selected );
1129 for ( ; It.More(); It.Next() ) {
1130 SMESHGUI_CtrlInfoDlg* ctrlDlg = new SMESHGUI_CtrlInfoDlg( SMESHGUI::desktop() );
1131 ctrlDlg->showInfo( It.Value() );
1136 QString functorToString( SMESH::Controls::FunctorPtr f )
1138 QString type = QObject::tr( "UNKNOWN_CONTROL" );
1139 if ( dynamic_cast< SMESH::Controls::Volume* >( f.get() ) )
1140 type = QObject::tr( "VOLUME_3D_ELEMENTS" );
1141 else if ( dynamic_cast< SMESH::Controls::MaxElementLength2D* >( f.get() ) )
1142 type = QObject::tr( "MAX_ELEMENT_LENGTH_2D" );
1143 else if ( dynamic_cast< SMESH::Controls::MaxElementLength3D* >( f.get() ) )
1144 type = QObject::tr( "MAX_ELEMENT_LENGTH_3D" );
1145 else if ( dynamic_cast< SMESH::Controls::MinimumAngle* >( f.get() ) )
1146 type = QObject::tr( "MINIMUMANGLE_ELEMENTS" );
1147 else if ( dynamic_cast< SMESH::Controls::AspectRatio* >( f.get() ) )
1148 type = QObject::tr( "ASPECTRATIO_ELEMENTS" );
1149 else if ( dynamic_cast< SMESH::Controls::AspectRatio3D* >( f.get() ) )
1150 type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" );
1151 else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) )
1152 type = QObject::tr( "WARP_ELEMENTS" );
1153 else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) )
1154 type = QObject::tr( "TAPER_ELEMENTS" );
1155 else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) )
1156 type = QObject::tr( "SKEW_ELEMENTS" );
1157 else if ( dynamic_cast< SMESH::Controls::Area* >( f.get() ) )
1158 type = QObject::tr( "AREA_ELEMENTS" );
1159 else if ( dynamic_cast< SMESH::Controls::Length* >( f.get() ) )
1160 type = QObject::tr( "LENGTH_EDGES" );
1161 else if ( dynamic_cast< SMESH::Controls::Length2D* >( f.get() ) )
1162 type = QObject::tr( "LENGTH2D_EDGES" );
1163 else if ( dynamic_cast< SMESH::Controls::Deflection2D* >( f.get() ) )
1164 type = QObject::tr( "DEFLECTION2D_FACES" );
1165 else if ( dynamic_cast< SMESH::Controls::MultiConnection* >( f.get() ) )
1166 type = QObject::tr( "MULTI_BORDERS" );
1167 else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) )
1168 type = QObject::tr( "MULTI2D_BORDERS" );
1169 else if ( dynamic_cast< SMESH::Controls::FreeNodes* >( f.get() ) )
1170 type = QObject::tr( "FREE_NODES" );
1171 else if ( dynamic_cast< SMESH::Controls::FreeEdges* >( f.get() ) )
1172 type = QObject::tr( "FREE_EDGES" );
1173 else if ( dynamic_cast< SMESH::Controls::FreeBorders* >( f.get() ) )
1174 type = QObject::tr( "FREE_BORDERS" );
1175 else if ( dynamic_cast< SMESH::Controls::FreeFaces* >( f.get() ) )
1176 type = QObject::tr( "FREE_FACES" );
1177 else if ( dynamic_cast< SMESH::Controls::BareBorderVolume* >( f.get() ) )
1178 type = QObject::tr( "BARE_BORDER_VOLUME" );
1179 else if ( dynamic_cast< SMESH::Controls::BareBorderFace* >( f.get() ) )
1180 type = QObject::tr( "BARE_BORDER_FACE" );
1181 else if ( dynamic_cast< SMESH::Controls::OverConstrainedVolume* >( f.get() ) )
1182 type = QObject::tr( "OVER_CONSTRAINED_VOLUME" );
1183 else if ( dynamic_cast< SMESH::Controls::OverConstrainedFace* >( f.get() ) )
1184 type = QObject::tr( "OVER_CONSTRAINED_FACE" );
1185 else if ( dynamic_cast< SMESH::Controls::CoincidentNodes* >( f.get() ) )
1186 type = QObject::tr( "EQUAL_NODE" );
1187 else if ( dynamic_cast< SMESH::Controls::CoincidentElements1D* >( f.get() ) )
1188 type = QObject::tr( "EQUAL_EDGE" );
1189 else if ( dynamic_cast< SMESH::Controls::CoincidentElements2D* >( f.get() ) )
1190 type = QObject::tr( "EQUAL_FACE" );
1191 else if ( dynamic_cast< SMESH::Controls::CoincidentElements3D* >( f.get() ) )
1192 type = QObject::tr( "EQUAL_VOLUME" );
1193 else if ( dynamic_cast< SMESH::Controls::NodeConnectivityNumber* >( f.get() ) )
1194 type = QObject::tr( "NODE_CONNECTIVITY_NB" );
1198 void SaveDistribution()
1200 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1201 SALOME_ListIO selected;
1203 aSel->selectedObjects( selected );
1205 if ( selected.Extent() == 1 ) {
1206 Handle(SALOME_InteractiveObject) anIO = selected.First();
1207 if ( anIO->hasEntry() ) {
1208 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1210 anActor->GetScalarBarActor() &&
1211 anActor->GetControlMode() != SMESH_Actor::eNone )
1213 SMESH_ScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor();
1214 SMESH::Controls::FunctorPtr aFunctor = anActor->GetFunctor();
1215 if ( aScalarBarActor && aFunctor ) {
1216 SMESH::Controls::NumericalFunctor* aNumFun =
1217 dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
1219 std::vector<int> elements;
1220 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
1221 if ( mesh->_is_nil() ) {
1222 SMESH::SMESH_IDSource_var idSource =
1223 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
1224 if ( !idSource->_is_nil() )
1226 SMESH::smIdType_array_var ids = idSource->GetIDs();
1227 elements.resize( ids->length() );
1228 for ( unsigned i = 0; i < elements.size(); ++i )
1229 elements[i] = ids[i];
1232 int nbIntervals = aScalarBarActor->GetMaximumNumberOfColors();
1233 vtkLookupTable* lookupTable =
1234 static_cast<vtkLookupTable*>(aScalarBarActor->GetLookupTable());
1235 double * minmax = lookupTable->GetRange();
1236 bool isLogarithmic = lookupTable->GetScale() == VTK_SCALE_LOG10;
1237 std::vector<int> nbEvents;
1238 std::vector<double> funValues;
1239 aNumFun->GetHistogram( nbIntervals, nbEvents, funValues,
1240 elements, minmax, isLogarithmic );
1241 QString anInitialPath = "";
1242 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
1243 anInitialPath = QDir::currentPath();
1244 QString aMeshName = anIO->getName();
1246 filter.append( QObject::tr( "TEXT_FILES_FILTER" ) + " (*.txt)" );
1247 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
1248 QString aFilename = anInitialPath + "/" + aMeshName + "_" +
1249 functorToString( aFunctor ).toLower().simplified().replace( QRegExp( " |-" ), "_" ) + ".txt";
1250 aFilename = SUIT_FileDlg::getFileName( SMESHGUI::desktop(),
1253 QObject::tr( "SMESH_SAVE_DISTRIBUTION" ),
1255 if ( !aFilename.isEmpty() ) {
1256 QFile f( aFilename );
1257 if ( f.open( QFile::WriteOnly | QFile::Truncate ) ) {
1258 QTextStream out( &f );
1259 out << "# Mesh: " << aMeshName << endl;
1260 out << "# Control: " << functorToString( aFunctor ) << endl;
1262 out.setFieldWidth( 10 );
1263 for ( int i = 0; i < (int)qMin( nbEvents.size(), funValues.size()-1 ); i++ )
1264 out << funValues[i] << "\t" << funValues[i+1] << "\t" << nbEvents[i] << endl;
1275 void ShowElement( int theCommandID )
1277 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1278 SALOME_ListIO selected;
1280 aSel->selectedObjects( selected );
1282 if ( selected.Extent() == 1 ) {
1283 Handle(SALOME_InteractiveObject) anIO = selected.First();
1284 if ( anIO->hasEntry() ) {
1285 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1287 anActor->GetScalarBarActor() &&
1288 anActor->GetControlMode() != SMESH_Actor::eNone )
1290 SMESH_ScalarBarActor *aScalarBarActor = anActor->GetScalarBarActor();
1291 if ( theCommandID == SMESHOp::OpShowDistribution ) {
1292 aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility());
1294 else if ( theCommandID == SMESHOp::OpShowScalarBar ) {
1295 aScalarBarActor->SetVisibility( !aScalarBarActor->GetVisibility());
1302 #ifndef DISABLE_PLOT2DVIEWER
1303 void PlotDistribution()
1305 SalomeApp_Application* app =
1306 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1310 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1311 SALOME_ListIO selected;
1313 aSel->selectedObjects( selected );
1315 if ( selected.Extent() == 1 ) {
1316 Handle(SALOME_InteractiveObject) anIO = selected.First();
1317 if ( anIO->hasEntry() ) {
1318 //Find Actor by entry before getting Plot2d viewer,
1319 //because after call getViewManager( Plot2d_Viewer::Type(), true ) active window is Plot2d Viewer
1320 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1322 SUIT_ViewManager* aViewManager =
1323 app->getViewManager( Plot2d_Viewer::Type(), true ); // create if necessary
1327 SPlot2d_Viewer* aView = dynamic_cast<SPlot2d_Viewer*>(aViewManager->getViewModel());
1331 Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
1335 if ( anActor && anActor->GetControlMode() != SMESH_Actor::eNone )
1337 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1338 QString functorName = functorToString( anActor->GetFunctor());
1339 QString aHistogramName("%1 : %2");
1340 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1341 aHistogram->setName(aHistogramName);
1342 aHistogram->setHorTitle(functorName);
1343 aHistogram->setVerTitle(QObject::tr("DISTRIBUTION_NB_ENT"));
1344 aPlot->displayObject(aHistogram, true);
1349 #endif //DISABLE_PLOT2DVIEWER
1351 void DisableAutoColor()
1353 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1354 SALOME_ListIO selected;
1356 aSel->selectedObjects( selected );
1358 if ( selected.Extent() ) {
1359 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1360 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1361 if ( !aMesh->_is_nil() ) {
1362 aMesh->SetAutoColor( false );
1369 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1370 SALOME_ListIO selected;
1372 aSel->selectedObjects( selected );
1373 if ( selected.Extent() )
1375 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1376 _PTR(Study) aStudy = SMESH::getStudy();
1377 _PTR(SObject) aSObj = aStudy->FindObjectID(anIObject->getEntry());
1379 if ( aStudy->GetUseCaseBuilder()->SortChildren( aSObj, true/*AscendingOrder*/ ) ) {
1380 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1387 // Break link with Shaper model
1388 void breakShaperLink()
1390 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1391 SALOME_ListIO selected;
1393 aSel->selectedObjects(selected);
1394 if (selected.Extent()) {
1395 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1396 _PTR(Study) aStudy = SMESH::getStudy();
1397 std::string aEntry = anIObject->getEntry();
1398 _PTR(SObject) aSObj = aStudy->FindObjectID(aEntry);
1400 std::string aName = aSObj->GetName();
1401 QMessageBox::StandardButton aRes = SUIT_MessageBox::warning(SMESHGUI::desktop(),
1402 QObject::tr("SMESH_WRN_WARNING"),
1403 QObject::tr("MSG_BREAK_SHAPER_LINK").arg(aName.c_str()),
1404 SUIT_MessageBox::Yes | SUIT_MessageBox::No, SUIT_MessageBox::No);
1405 if (aRes == SUIT_MessageBox::Yes) {
1406 SUIT_DataOwnerPtrList aList;
1407 aSel->selected(aList, "ObjectBrowser", true);
1408 SUIT_DataOwner* aOwn = aList.first();
1409 LightApp_DataOwner* sowner = dynamic_cast<LightApp_DataOwner*>(aOwn);
1410 QString aREntry = sowner->entry();
1412 static GEOM::GEOM_Gen_var geomGen;
1413 if (CORBA::is_nil(geomGen)) {
1414 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>
1415 (SUIT_Session::session()->activeApplication());
1417 SALOME_LifeCycleCORBA* ls = new SALOME_LifeCycleCORBA(app->namingService());
1418 Engines::EngineComponent_var comp =
1419 ls->FindOrLoad_Component("FactoryServer", "SHAPERSTUDY");
1420 geomGen = GEOM::GEOM_Gen::_narrow(comp);
1423 if (!CORBA::is_nil(geomGen))
1425 geomGen->BreakLink(aREntry.toStdString().c_str());
1426 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1428 // remove actors whose objects are removed by BreakLink()
1429 QList<SUIT_ViewWindow*> wndList = SMESHGUI::desktop()->windows();
1430 SUIT_ViewWindow* wnd;
1431 foreach(wnd, wndList)
1432 SMESH::UpdateActorsAfterUpdateStudy(wnd);
1440 //================================================================================
1442 * \brief Return true if a mesh icon == ICON_SMESH_TREE_GEOM_MODIF
1443 * which means that the mesh can't be modified. It should be either re-computed
1444 * or breakShaperLink()'ed. Warn the user about it.
1446 //================================================================================
1448 bool warnOnGeomModif()
1450 SALOME_ListIO selected;
1451 if ( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
1452 aSel->selectedObjects(selected,"",/*convertReferences=*/false);
1454 SALOME_ListIteratorOfListIO It( selected );
1455 for ( ; It.More(); It.Next() )
1457 Handle(SALOME_InteractiveObject) io = It.Value();
1458 if ( !io->hasEntry() ) continue;
1459 _PTR(SObject) so = SMESH::getStudy()->FindObjectID( io->getEntry() );
1460 SMESH::SMESH_Mesh_var mesh;
1461 while ( mesh->_is_nil() && so && so->GetID() != "0:" )
1463 CORBA::Object_var obj = SMESH::SObjectToObject( so );
1464 SMESH::SMESH_IDSource_var isrc = SMESH::SMESH_IDSource::_narrow( obj );
1465 if ( isrc->_is_nil() )
1466 so = so->GetFather();
1468 mesh = isrc->GetMesh();
1470 if ( mesh->_is_nil() ) continue;
1471 so = SMESH::FindSObject( mesh );
1472 if ( !so ) continue;
1473 _PTR(GenericAttribute) attr;
1474 so->FindAttribute( attr, "AttributePixMap" );
1475 _PTR(AttributePixMap) pixmap = attr;
1476 if ( !pixmap ) continue;
1478 if ( pixmap->GetPixMap() == "ICON_SMESH_TREE_GEOM_MODIF" )
1480 SUIT_MessageBox::warning(SMESHGUI::desktop(),
1481 QObject::tr("SMESH_WRN_WARNING"),
1482 QObject::tr("MSG_WARN_ON_GEOM_MODIF"));
1489 void SetDisplayMode(int theCommandID, VTK::MarkerMap& theMarkerMap)
1491 SALOME_ListIO selected;
1492 SalomeApp_Application* app =
1493 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1497 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1498 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1499 if ( !aSel || !appStudy )
1502 if ( theCommandID == SMESHOp::OpClipping ) { // Clipping dialog can be activated without selection
1503 if ( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
1504 aModule->EmitSignalDeactivateDialog();
1505 if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
1506 (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
1511 aSel->selectedObjects( selected );
1513 if ( selected.Extent() >= 1 )
1515 switch ( theCommandID ) {
1516 case SMESHOp::OpTransparency:
1518 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1519 (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
1522 case SMESHOp::OpProperties:
1525 QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
1526 QColor orientationColor, outlineColor, volumeColor;
1527 int deltaF = 0, deltaV = 0;
1530 double ballScale = 1.0;
1532 int outlineWidth = 1;
1533 double shrinkCoef = 0.0;
1534 double orientationScale = 0.0;
1535 bool orientation3d = false;
1536 VTK::MarkerType markerType = VTK::MT_NONE;
1537 VTK::MarkerScale markerScale = VTK::MS_NONE;
1539 bool hasNodes = false;
1540 int presentEntities = 0;
1541 bool firstTime = true;
1543 SALOME_ListIteratorOfListIO It( selected );
1544 for ( ; It.More(); It.Next() ) {
1545 Handle(SALOME_InteractiveObject) IObject = It.Value();
1546 if ( !IObject->hasEntry() ) continue;
1547 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1548 if ( !anActor || !anActor->GetObject() ) continue;
1551 // nodes: color, marker
1552 anActor->GetNodeColor( color[0], color[1], color[2] );
1553 nodeColor.setRgbF( color[0], color[1], color[2] );
1554 markerType = anActor->GetMarkerType();
1555 markerScale = anActor->GetMarkerScale();
1556 markerId = anActor->GetMarkerTexture();
1557 // edges: color, width
1558 anActor->GetEdgeColor( color[0], color[1], color[2] );
1559 edgeColor.setRgbF( color[0], color[1], color[2] );
1560 edgeWidth = qMax( (int)anActor->GetLineWidth(), 1 ); // minimum allowed width is 1
1561 // faces: front color, back color (delta)
1562 anActor->GetSufaceColor( color[0], color[1], color[2], deltaF );
1563 faceColor.setRgbF( color[0], color[1], color[2] );
1564 // faces: front color, back color (delta)
1565 anActor->GetVolumeColor( color[0], color[1], color[2], deltaV );
1566 volumeColor.setRgbF( color[0], color[1], color[2] );
1567 // 0d elements: color, size
1568 anActor->Get0DColor( color[0], color[1], color[2] );
1569 elem0dColor.setRgbF( color[0], color[1], color[2] );
1570 elem0dSize = qMax( (int)anActor->Get0DSize(), 1 ); // minimum allowed size is 1
1571 // balls: color, size
1572 anActor->GetBallColor( color[0], color[1], color[2] );
1573 ballColor.setRgbF( color[0], color[1], color[2] );
1574 //ballSize = qMax( (int)anActor->GetBallSize(), 1 ); // minimum allowed size is 1
1575 ballScale = qMax( (double)anActor->GetBallScale(), 1e-2 ); // minimum allowed scale is 1e-2
1577 anActor->GetOutlineColor( color[0], color[1], color[2] );
1578 outlineColor.setRgbF( color[0], color[1], color[2] );
1579 outlineWidth = qMax( (int)anActor->GetOutlineWidth(), 1 ); // minimum allowed width is 1
1580 // orientation vectors: color, scale, 3d flag
1581 anActor->GetFacesOrientationColor( color[0], color[1], color[2] );
1582 orientationColor.setRgbF( color[0], color[1], color[2] );
1583 orientationScale = anActor->GetFacesOrientationScale();
1584 orientation3d = anActor->GetFacesOrientation3DVectors();
1586 shrinkCoef = anActor->GetShrinkFactor();
1589 firstTime = false; // we only take properties from first object (for performance reasons)
1592 hasNodes = anActor->GetObject()->GetNbEntities( SMDSAbs_Node );
1593 if ( !(presentEntities & SMESH_Actor::eEdges) && anActor->GetObject()->GetNbEntities( SMDSAbs_Edge ) )
1594 presentEntities = presentEntities | SMESH_Actor::eEdges;
1595 if ( !(presentEntities & SMESH_Actor::eFaces) && anActor->GetObject()->GetNbEntities( SMDSAbs_Face ) )
1596 presentEntities = presentEntities | SMESH_Actor::eFaces;
1597 if ( !(presentEntities & SMESH_Actor::eVolumes) && anActor->GetObject()->GetNbEntities( SMDSAbs_Volume ) )
1598 presentEntities = presentEntities | SMESH_Actor::eVolumes;
1599 if ( !(presentEntities & SMESH_Actor::e0DElements) && anActor->GetObject()->GetNbEntities( SMDSAbs_0DElement ) )
1600 presentEntities = presentEntities | SMESH_Actor::e0DElements;
1601 if ( !(presentEntities & SMESH_Actor::eBallElem) && anActor->GetObject()->GetNbEntities( SMDSAbs_Ball ) )
1602 presentEntities = presentEntities | SMESH_Actor::eBallElem;
1604 // as we know that all types of elements are present, we can exit the loop
1605 if ( presentEntities == SMESH_Actor::eAllEntity )
1609 SMESHGUI_PropertiesDlg dlg( theMarkerMap, SMESHGUI::desktop() );
1610 // nodes: color, marker
1611 dlg.setNodeColor( nodeColor );
1612 if( markerType != VTK::MT_USER )
1613 dlg.setNodeMarker( markerType, markerScale );
1615 dlg.setNodeCustomMarker( markerId );
1616 // edges: color, line width
1617 dlg.setEdgeColor( edgeColor );
1618 dlg.setEdgeWidth( edgeWidth );
1619 // faces: front color, back color
1620 dlg.setFaceColor( faceColor, deltaF );
1621 // volumes: normal color, reversed color
1622 dlg.setVolumeColor( volumeColor, deltaV );
1623 // outlines: color, line width
1624 dlg.setOutlineColor( outlineColor );
1625 dlg.setOutlineWidth( outlineWidth );
1626 // 0d elements: color, size
1627 dlg.setElem0dColor( elem0dColor );
1628 dlg.setElem0dSize( elem0dSize );
1629 // balls: color, size
1630 dlg.setBallColor( ballColor );
1631 //dlg.setBallSize( ballSize );
1632 dlg.setBallScale( ballScale );
1633 // orientation: color, scale, 3d flag
1634 dlg.setOrientationColor( orientationColor );
1635 dlg.setOrientationSize( int( orientationScale * 100. ) );
1636 dlg.setOrientation3d( orientation3d );
1637 // shrink: scale factor
1638 dlg.setShrinkCoef( int( shrinkCoef * 100. ) );
1639 // hide unused controls
1640 dlg.showControls( presentEntities, hasNodes );
1643 nodeColor = dlg.nodeColor();
1644 markerType = dlg.nodeMarkerType();
1645 markerScale = dlg.nodeMarkerScale();
1646 markerId = dlg.nodeMarkerId();
1647 edgeColor = dlg.edgeColor();
1648 edgeWidth = dlg.edgeWidth();
1649 faceColor = dlg.faceColor();
1650 deltaF = dlg.faceColorDelta();
1651 volumeColor = dlg.volumeColor();
1652 deltaV = dlg.volumeColorDelta();
1653 outlineColor = dlg.outlineColor();
1654 outlineWidth = dlg.outlineWidth();
1655 elem0dColor = dlg.elem0dColor();
1656 elem0dSize = dlg.elem0dSize();
1657 ballColor = dlg.ballColor();
1658 // ballSize = dlg.ballSize();
1659 ballScale = dlg.ballScale();
1660 orientationColor = dlg.orientationColor();
1661 orientationScale = dlg.orientationSize() / 100.;
1662 orientation3d = dlg.orientation3d();
1663 shrinkCoef = dlg.shrinkCoef() / 100.;
1665 // store point markers that might be changed by the user
1666 theMarkerMap = dlg.customMarkers();
1668 // set properties from dialog box to the presentations
1669 SALOME_ListIteratorOfListIO It( selected );
1670 for ( ; It.More(); It.Next() ) {
1671 Handle(SALOME_InteractiveObject) IObject = It.Value();
1672 if ( !IObject->hasEntry() ) continue;
1673 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1674 if ( !anActor ) continue;
1676 // nodes: color, marker
1677 anActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
1678 if ( markerType != VTK::MT_USER ) {
1679 anActor->SetMarkerStd( markerType, markerScale );
1682 VTK::MarkerMap::const_iterator iter = theMarkerMap.find( markerId );
1683 if ( iter != theMarkerMap.end() )
1684 anActor->SetMarkerTexture( markerId, iter->second.second );
1686 // volumes: normal color, reversed color (delta)
1687 anActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
1688 // faces: front color, back color (delta)
1689 anActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
1690 // edges: color, width
1691 anActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
1692 anActor->SetLineWidth( edgeWidth );
1694 anActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
1695 anActor->SetOutlineWidth( outlineWidth );
1696 // 0D elements: color, size
1697 anActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
1698 anActor->Set0DSize( elem0dSize );
1699 // balls: color, size
1700 anActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
1701 // anActor->SetBallSize( ballSize );
1702 anActor->SetBallScale( ballScale );
1703 // orientation: color, scale, 3d flag
1704 anActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
1705 anActor->SetFacesOrientationScale( orientationScale );
1706 anActor->SetFacesOrientation3DVectors( orientation3d );
1708 anActor->SetShrinkFactor( shrinkCoef );
1710 // for groups, set also proper color
1711 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1712 if ( !aGroupObject->_is_nil() ) {
1713 SMESH::ElementType anElementType = aGroupObject->GetType();
1715 switch( anElementType ) {
1717 aColor = nodeColor; break;
1719 aColor = edgeColor; break;
1721 aColor = faceColor; break;
1723 aColor = volumeColor; break;
1725 aColor = elem0dColor; break;
1727 aColor = ballColor; break;
1731 if ( aColor.isValid() ) {
1732 SALOMEDS::Color aGroupColor;
1733 aGroupColor.R = aColor.redF();
1734 aGroupColor.G = aColor.greenF();
1735 aGroupColor.B = aColor.blueF();
1736 aGroupObject->SetColor( aGroupColor );
1738 } // if ( !aGroupObject->_is_nil() )
1739 } // for ( ; It.More(); It.Next() )
1740 SMESH::RepaintCurrentView();
1741 } // if ( dlg.exec() )
1743 } // case SMESHOp::OpProperties:
1744 } // switch(theCommandID)
1745 SUIT_OverrideCursor wc;
1746 SALOME_ListIteratorOfListIO It( selected );
1747 for( ; It.More(); It.Next()){
1748 Handle(SALOME_InteractiveObject) IObject = It.Value();
1749 if(IObject->hasEntry()){
1750 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1751 switch(theCommandID){
1752 case SMESHOp::OpDMWireframe:
1753 anActor->SetRepresentation(SMESH_Actor::eEdge);
1755 case SMESHOp::OpDMShading:
1756 anActor->SetRepresentation(SMESH_Actor::eSurface);
1758 case SMESHOp::OpDMShrink:
1759 if(anActor->IsShrunk())
1760 anActor->UnShrink();
1762 anActor->SetShrink();
1764 case SMESHOp::OpDMNodes:
1765 anActor->SetRepresentation(SMESH_Actor::ePoint);
1767 case SMESHOp::OpRepresentationLines:
1768 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1769 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1771 case SMESHOp::OpRepresentationArcs:
1772 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1773 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1779 SMESH::RepaintCurrentView();
1783 int ActionToControl( int theID, bool theReversed )
1785 NCollection_DoubleMap<int,int> ActionControl;
1786 ActionControl.Bind( 0, SMESH_Actor::eNone );
1787 ActionControl.Bind( SMESHOp::OpFreeNode, SMESH_Actor::eFreeNodes );
1788 ActionControl.Bind( SMESHOp::OpEqualNode, SMESH_Actor::eCoincidentNodes );
1789 ActionControl.Bind( SMESHOp::OpNodeConnectivityNb, SMESH_Actor::eNodeConnectivityNb );
1790 ActionControl.Bind( SMESHOp::OpFreeEdge, SMESH_Actor::eFreeEdges );
1791 ActionControl.Bind( SMESHOp::OpFreeBorder, SMESH_Actor::eFreeBorders );
1792 ActionControl.Bind( SMESHOp::OpLength, SMESH_Actor::eLength );
1793 ActionControl.Bind( SMESHOp::OpConnection, SMESH_Actor::eMultiConnection );
1794 ActionControl.Bind( SMESHOp::OpEqualEdge, SMESH_Actor::eCoincidentElems1D );
1795 ActionControl.Bind( SMESHOp::OpFreeFace, SMESH_Actor::eFreeFaces );
1796 ActionControl.Bind( SMESHOp::OpBareBorderFace, SMESH_Actor::eBareBorderFace );
1797 ActionControl.Bind( SMESHOp::OpOverConstrainedFace, SMESH_Actor::eOverConstrainedFace );
1798 ActionControl.Bind( SMESHOp::OpLength2D, SMESH_Actor::eLength2D );
1799 ActionControl.Bind( SMESHOp::OpDeflection2D, SMESH_Actor::eDeflection2D );
1800 ActionControl.Bind( SMESHOp::OpConnection2D, SMESH_Actor::eMultiConnection2D );
1801 ActionControl.Bind( SMESHOp::OpArea, SMESH_Actor::eArea );
1802 ActionControl.Bind( SMESHOp::OpTaper, SMESH_Actor::eTaper );
1803 ActionControl.Bind( SMESHOp::OpAspectRatio, SMESH_Actor::eAspectRatio );
1804 ActionControl.Bind( SMESHOp::OpMinimumAngle, SMESH_Actor::eMinimumAngle );
1805 ActionControl.Bind( SMESHOp::OpWarpingAngle, SMESH_Actor::eWarping );
1806 ActionControl.Bind( SMESHOp::OpSkew, SMESH_Actor::eSkew );
1807 ActionControl.Bind( SMESHOp::OpMaxElementLength2D, SMESH_Actor::eMaxElementLength2D );
1808 ActionControl.Bind( SMESHOp::OpEqualFace, SMESH_Actor::eCoincidentElems2D );
1809 ActionControl.Bind( SMESHOp::OpAspectRatio3D, SMESH_Actor::eAspectRatio3D );
1810 ActionControl.Bind( SMESHOp::OpVolume, SMESH_Actor::eVolume3D );
1811 ActionControl.Bind( SMESHOp::OpMaxElementLength3D, SMESH_Actor::eMaxElementLength3D );
1812 ActionControl.Bind( SMESHOp::OpBareBorderVolume, SMESH_Actor::eBareBorderVolume );
1813 ActionControl.Bind( SMESHOp::OpOverConstrainedVolume, SMESH_Actor::eOverConstrainedVolume );
1814 ActionControl.Bind( SMESHOp::OpEqualVolume, SMESH_Actor::eCoincidentElems3D );
1817 return ActionControl.IsBound2( theID ) ? ActionControl.Find2( theID ) : 0;
1818 return ActionControl.IsBound1( theID ) ? ActionControl.Find1( theID ) : 0;
1821 void Control( int theCommandID )
1823 SMESH_Actor::eControl aControl = SMESH_Actor::eControl( ActionToControl( theCommandID ));
1824 _PTR(Study) aStudy = SMESH::getStudy();
1826 SALOME_ListIO selected;
1827 if ( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
1828 aSel->selectedObjects( selected );
1830 if ( !selected.IsEmpty() ) {
1831 SALOME_ListIteratorOfListIO It(selected);
1832 for ( ; It.More(); It.Next())
1834 Handle(SALOME_InteractiveObject) anIO = It.Value();
1835 if ( !anIO.IsNull() ) {
1836 _PTR(SObject) SO = aStudy->FindObjectID( It.Value()->getEntry() );
1838 CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
1839 SMESH::SMESH_IDSource_var anIDSrc = SMESH::SMESH_IDSource::_narrow( aObject );
1840 if ( !anIDSrc->_is_nil() ) {
1841 SMESH_Actor *anActor = SMESH::FindActorByEntry( anIO->getEntry());
1842 if (( !anActor && selected.Extent() == 1 ) &&
1843 ( anActor = SMESH::CreateActor( anIO->getEntry() )))
1845 anActor->SetControlMode( aControl );
1846 SMESH::DisplayActor( SMESH::GetCurrentVtkView(), anActor );
1847 SMESH::UpdateView ( SMESH::eDisplay, anIO->getEntry() );
1851 if ( anActor->GetControlMode() != aControl )
1852 anActor->SetControlMode( aControl );
1853 QString functorName = functorToString( anActor->GetFunctor() );
1854 int anEntitiesCount = anActor->GetNumberControlEntities();
1855 if (anEntitiesCount >= 0)
1856 functorName = functorName + ": " + QString::number(anEntitiesCount);
1857 anActor->GetScalarBarActor()->SetTitle( functorName.toUtf8().constData() );
1858 SMESH::RepaintCurrentView();
1859 #ifndef DISABLE_PLOT2DVIEWER
1860 if ( anActor->GetPlot2Histogram() ) {
1861 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1862 QString aHistogramName("%1 : %2");
1863 aHistogramName = aHistogramName.arg( anIO->getName() ).arg( functorName );
1864 aHistogram->setName( aHistogramName );
1865 aHistogram->setHorTitle( functorName );
1866 SMESH::ProcessIn2DViewers( anActor );
1878 bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1879 SMESH::MeshObjectType theType,
1880 const QString theInTypeName,
1881 QString & theOutTypeName)
1883 SMESH_TypeFilter aTypeFilter( theType );
1885 if ( !theIO.IsNull() )
1887 entry = theIO->getEntry();
1888 LightApp_DataOwner owner( entry );
1889 if ( aTypeFilter.isOk( &owner )) {
1890 theOutTypeName = theInTypeName;
1898 QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1900 _PTR(Study) aStudy = SMESH::getStudy();
1901 _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1903 _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1904 CORBA::String_var anID = aSComp->GetID().c_str();
1905 if ( !strcmp(anID.in(),theIO->getEntry()) )
1911 CheckOIType ( theIO, SMESH::HYPOTHESIS, "Hypothesis", aTypeName ) ||
1912 CheckOIType ( theIO, SMESH::ALGORITHM, "Algorithm", aTypeName ) ||
1913 CheckOIType ( theIO, SMESH::MESH, "Mesh", aTypeName ) ||
1914 CheckOIType ( theIO, SMESH::SUBMESH, "SubMesh", aTypeName ) ||
1915 CheckOIType ( theIO, SMESH::GROUP, "Group", aTypeName )
1923 // QString CheckHomogeneousSelection()
1925 // LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1926 // SALOME_ListIO selected;
1928 // aSel->selectedObjects( selected );
1930 // QString RefType = CheckTypeObject(selected.First());
1931 // SALOME_ListIteratorOfListIO It(selected);
1932 // for ( ; It.More(); It.Next())
1934 // Handle(SALOME_InteractiveObject) IObject = It.Value();
1935 // QString Type = CheckTypeObject(IObject);
1936 // if ( Type.compare(RefType) != 0 )
1937 // return "Heterogeneous Selection";
1943 uint randomize( uint size )
1945 static bool initialized = false;
1946 if ( !initialized ) {
1947 qsrand( QDateTime::currentDateTime().toTime_t() );
1951 v = uint( (double)( v ) / RAND_MAX * size );
1952 v = qMax( uint(0), qMin ( v, size-1 ) );
1958 void SMESHGUI::OnEditDelete()
1960 // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1961 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1962 SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1964 _PTR(Study) aStudy = SMESH::getStudy();
1965 _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1966 _PTR(GenericAttribute) anAttr;
1967 _PTR(AttributeIOR) anIOR;
1969 const int objectCountLimit = 30; // PAL23599
1970 int objectCount = 0;
1972 QString aParentComponent = QString::null;
1974 for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1976 Handle(SALOME_InteractiveObject) anIO = anIt.Value();
1977 if ( anIO.IsNull() ) continue;
1979 QString father = "unknown", name;
1981 _PTR(SObject) aSO = aStudy->FindObjectID( anIO->getEntry() );
1983 father = QString::fromStdString( aSO->GetFatherComponent()->ComponentDataType() );
1984 // check if object is reference
1985 _PTR(SObject) aRefSObj;
1986 if ( aSO->ReferencedObject( aRefSObj ) ) {
1987 name = QString::fromStdString ( aRefSObj->GetName() );
1988 father = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1991 name = anIO->getName();
1994 if ( objectCount < objectCountLimit ) { // avoid occupying the whole screen
1995 aNameList.append("\n - ");
1996 aNameList.append( name );
1999 if( aParentComponent.isNull() )
2000 aParentComponent = father;
2001 else if( !aParentComponent.isEmpty() && aParentComponent!=father )
2002 aParentComponent = "";
2004 if ( objectCount >= objectCountLimit )
2005 aNameList.append("\n - ...");
2007 if ( objectCount == 0 )
2008 return; // No Valid Objects Selected
2010 if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
2011 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2012 QObject::tr("ERR_ERROR"),
2013 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
2016 // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
2017 if (SUIT_MessageBox::warning
2018 (SMESHGUI::desktop(),
2019 QObject::tr("SMESH_WRN_WARNING"),
2020 QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
2021 SUIT_MessageBox::Yes | SUIT_MessageBox::No,
2022 SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
2025 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2027 // Put one level of sub-objects of the selected SO's into a list
2028 // in order to get objects inside folders like "Assigned Algorithms"
2029 std::list< _PTR(SObject) > listSO;
2030 SALOME_ListIteratorOfListIO It(selected);
2031 for( ; It.More(); It.Next()) // loop on selected IO's
2033 Handle(SALOME_InteractiveObject) IObject = It.Value();
2034 if(IObject->hasEntry()) {
2035 _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
2037 // disable removal of "SMESH" component object
2038 if(aSO->FindAttribute(anAttr, "AttributeIOR")){
2040 if ( engineIOR() == anIOR->Value().c_str() )
2043 //Check the referenced object
2044 _PTR(SObject) aRefSObject;
2045 if ( aSO && aSO->ReferencedObject( aRefSObject ) )
2046 aSO = aRefSObject; // Delete main Object instead of reference
2048 listSO.push_back( aSO );
2050 _PTR(ChildIterator) it = aStudy->NewChildIterator( aSO );
2051 for (it->InitEx(false); it->More(); it->Next())
2052 listSO.push_back( it->Value() );
2055 // Check if none of objects to delete is referred from outside
2056 std::list< _PTR(SObject) >::reverse_iterator ritSO;
2057 std::vector< _PTR(SObject) > subSO;
2058 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
2060 _PTR(SObject) SO = *ritSO;
2061 if ( !SO ) continue;
2063 int nbChildren = SO->GetLastChildTag();
2065 subSO.reserve( 1 + nbChildren );
2066 subSO.push_back( SO );
2067 if ( nbChildren > 0 )
2069 _PTR(ChildIterator) it = aStudy->NewChildIterator( SO );
2070 for ( it->InitEx( true ); it->More(); it->Next() )
2071 subSO.push_back( it->Value() );
2073 for ( size_t i = 0; i < subSO.size(); ++i )
2075 std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( subSO[i] );
2076 for ( size_t j = 0; j < aReferences.size(); j++ ) {
2077 _PTR(SComponent) aComponent = aReferences[j]->GetFatherComponent();
2078 std::string type = aComponent->ComponentDataType();
2079 if ( type != "SMESH" )
2081 SUIT_MessageBox::warning( anApp->desktop(),
2082 QObject::tr("WRN_WARNING"),
2083 QObject::tr("DEP_OBJECT") );
2084 return; // outside SMESH, there is an object depending on a SMESH object
2090 // Treat SO's in the list starting from the back
2091 aStudyBuilder->NewCommand(); // There is a transaction
2092 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
2094 _PTR(SObject) SO = *ritSO;
2095 if ( !SO ) continue;
2096 std::string anEntry = SO->GetID();
2098 /** Erase graphical object and remove all its data **/
2099 if ( SO->FindAttribute( anAttr, "AttributeIOR" )) {
2100 SMESH::RemoveVisualObjectWithActors( anEntry.c_str(), true);
2102 /** Remove an object from data structures **/
2103 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
2104 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
2105 if ( !aGroup->_is_nil() ) { // DELETE GROUP
2106 SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
2107 aMesh->RemoveGroup( aGroup );
2109 else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
2110 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2111 aMesh->RemoveSubMesh( aSubMesh );
2114 Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
2115 ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
2116 QString objType = CheckTypeObject(IObject);
2117 if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
2118 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
2119 aStudyBuilder->RemoveObjectWithChildren( SO );
2121 else {// default action: remove SObject from the study
2122 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
2123 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
2125 aStudyBuilder->RemoveObjectWithChildren( SO );
2129 } /* listSO back loop */
2131 aStudyBuilder->CommitCommand();
2133 /* Clear any previous selection */
2135 aSel->setSelectedObjects( l1 );
2137 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
2141 SMESHGUI_EXPORT CAM_Module* createModule()
2143 return new SMESHGUI();
2146 SMESHGUI_EXPORT char* getModuleVersion() {
2147 return (char*)SMESH_VERSION_STR;
2151 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
2153 //=============================================================================
2157 //=============================================================================
2158 SMESHGUI::SMESHGUI() :
2159 SalomeApp_Module( "SMESH" )
2161 if ( CORBA::is_nil( myComponentSMESH ) )
2163 CORBA::Boolean anIsEmbeddedMode;
2164 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
2165 //MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
2167 // 0019923: EDF 765 SMESH : default values of hypothesis
2168 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
2169 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
2170 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
2171 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
2172 myComponentSMESH->SetDefaultNbSegments( nbSeg );
2174 const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif", "default_grp_color" };
2175 for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
2176 if ( aResourceMgr->hasValue( "SMESH", options[i] ))
2178 QString val = aResourceMgr->stringValue( "SMESH", options[i] );
2179 myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
2183 myActiveDialogBox = 0;
2184 myFilterLibraryDlg = 0;
2188 myEventCallbackCommand = vtkCallbackCommand::New();
2189 myEventCallbackCommand->Delete();
2190 myEventCallbackCommand->SetClientData( this );
2191 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
2194 /* load resources for all available meshers */
2195 SMESH::InitAvailableHypotheses();
2198 //=============================================================================
2202 //=============================================================================
2203 SMESHGUI::~SMESHGUI()
2207 //=============================================================================
2211 //=============================================================================
2212 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
2214 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2216 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
2221 //=============================================================================
2225 //=============================================================================
2226 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
2228 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2232 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2233 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2234 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2235 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2236 return autoUpdate && !exceeded;
2239 //=============================================================================
2243 //=============================================================================
2244 bool SMESHGUI::automaticUpdate( SMESH::SMESH_IDSource_ptr theMesh,
2245 int* entities, bool* limitExceeded, int* hidden, long* nbElements )
2247 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2251 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2252 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2253 bool incrementalLimit = resMgr->booleanValue( "SMESH", "incremental_limit", false );
2255 SMESH::smIdType_array_var info = theMesh->GetMeshInfo();
2256 long nbOdElems = info[SMDSEntity_0D];
2257 long nbEdges = info[SMDSEntity_Edge] + info[SMDSEntity_Quad_Edge];
2258 long nbFaces = info[SMDSEntity_Triangle] + info[SMDSEntity_Quad_Triangle] + info[SMDSEntity_BiQuad_Triangle] +
2259 info[SMDSEntity_Quadrangle] + info[SMDSEntity_Quad_Quadrangle] + info[SMDSEntity_BiQuad_Quadrangle] +
2260 info[SMDSEntity_Polygon] + info[SMDSEntity_Quad_Polygon];
2261 long nbVolumes = info[SMDSEntity_Tetra] + info[SMDSEntity_Quad_Tetra] +
2262 info[SMDSEntity_Hexa] + info[SMDSEntity_Quad_Hexa] + info[SMDSEntity_TriQuad_Hexa] +
2263 info[SMDSEntity_Pyramid] + info[SMDSEntity_Quad_Pyramid] +
2264 info[SMDSEntity_Penta] + info[SMDSEntity_Quad_Penta] + info[SMDSEntity_BiQuad_Penta] +
2265 info[SMDSEntity_Polyhedra] +
2266 info[SMDSEntity_Hexagonal_Prism];
2267 long nbBalls = info[SMDSEntity_Ball];
2269 long requestedSize = nbOdElems + nbBalls + nbEdges + nbFaces + nbVolumes;
2270 *nbElements = requestedSize;
2272 *entities = SMESH_Actor::eAllEntity;
2275 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2277 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2279 if ( incrementalLimit ) {
2282 if ( nbOdElems > 0 ) {
2283 if ( total + nbOdElems > updateLimit ) {
2284 *entities = *entities & ~SMESH_Actor::e0DElements;
2285 *hidden = *hidden | SMESH_Actor::e0DElements;
2292 if ( nbEdges > 0 ) {
2293 if ( total + nbEdges > updateLimit ) {
2294 *entities = *entities & ~SMESH_Actor::eEdges;
2295 *hidden = *hidden | SMESH_Actor::eEdges;
2302 if ( nbFaces > 0 ) {
2303 if ( total + nbFaces > updateLimit ) {
2304 *entities = *entities & ~SMESH_Actor::eFaces;
2305 *hidden = *hidden | SMESH_Actor::eFaces;
2312 if ( nbVolumes > 0 ) {
2313 if ( total + nbVolumes > updateLimit ) {
2314 *entities = *entities & ~SMESH_Actor::eVolumes;
2315 *hidden = *hidden | SMESH_Actor::eVolumes;
2322 if ( nbBalls > 0 ) {
2323 if ( total + nbBalls > updateLimit ) {
2324 *entities = *entities & ~SMESH_Actor::eBallElem;
2325 *hidden = *hidden | SMESH_Actor::eBallElem;
2333 return autoUpdate && !exceeded;
2336 //=============================================================================
2340 //=============================================================================
2341 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
2343 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
2346 //=============================================================================
2350 //=============================================================================
2351 SMESHGUI* SMESHGUI::GetSMESHGUI()
2353 SMESHGUI* smeshMod = 0;
2354 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
2357 CAM_Module* module = app->module( "Mesh" );
2358 smeshMod = dynamic_cast<SMESHGUI*>( module );
2366 Standard_EXPORT SMESHGUI* GetComponentGUI()
2368 return SMESHGUI::GetSMESHGUI();
2372 //=============================================================================
2376 //=============================================================================
2377 void SMESHGUI::SetState(int aState)
2382 //=============================================================================
2386 //=============================================================================
2387 void SMESHGUI::ResetState()
2392 //=============================================================================
2396 //=============================================================================
2397 void SMESHGUI::EmitSignalDeactivateDialog()
2399 emit SignalDeactivateActiveDialog();
2402 //=============================================================================
2406 //=============================================================================
2407 void SMESHGUI::EmitSignalStudyFrameChanged()
2409 emit SignalStudyFrameChanged();
2412 //=============================================================================
2416 //=============================================================================
2417 void SMESHGUI::EmitSignalCloseAllDialogs()
2419 emit SignalCloseAllDialogs();
2422 //=============================================================================
2426 //=============================================================================
2427 void SMESHGUI::EmitSignalVisibilityChanged()
2429 emit SignalVisibilityChanged();
2432 //=============================================================================
2436 //=============================================================================
2437 void SMESHGUI::EmitSignalCloseView()
2439 emit SignalCloseView();
2442 //=============================================================================
2446 //=============================================================================
2447 void SMESHGUI::EmitSignalActivatedViewManager()
2449 emit SignalActivatedViewManager();
2452 //=============================================================================
2456 //=============================================================================
2457 QDialog *SMESHGUI::GetActiveDialogBox()
2459 return myActiveDialogBox;
2462 //=============================================================================
2466 //=============================================================================
2467 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2469 myActiveDialogBox = (QDialog *) aDlg;
2473 //=============================================================================
2477 //=============================================================================
2478 SUIT_Desktop* SMESHGUI::desktop()
2480 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2482 return app->desktop();
2487 //=============================================================================
2491 //=============================================================================
2492 SalomeApp_Study* SMESHGUI::activeStudy()
2494 SUIT_Application* app = SUIT_Session::session()->activeApplication();
2496 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2501 //=============================================================================
2505 //=============================================================================
2506 void SMESHGUI::Modified( bool theIsUpdateActions )
2508 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2509 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2510 appStudy->Modified();
2511 if( theIsUpdateActions )
2512 app->updateActions();
2517 //=============================================================================
2521 //=============================================================================
2522 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2524 /* Here the position is on the bottom right corner - 10 */
2525 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2527 SUIT_Desktop *PP = desktop();
2528 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2529 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2534 * \brief Verifies whether study of operation is locked
2535 * \param theMess - specifies whether message box must be shown if study is locked
2536 * \return State of study.
2538 * Verifies whether study of operation is locked. If second parameter is TRUE and study
2539 * is locked when corresponding message box appears
2541 bool SMESHGUI::isStudyLocked( bool theMessage )
2543 if ( SMESH::getStudy()->GetProperties()->IsLocked() )
2546 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2547 QObject::tr( "WRN_WARNING" ),
2548 QObject::tr( "WRN_STUDY_LOCKED" ) );
2554 //=============================================================================
2558 //=============================================================================
2559 bool SMESHGUI::OnGUIEvent( int theCommandID )
2561 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2565 SUIT_ResourceMgr* mgr = resourceMgr();
2569 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2570 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2572 //QAction* act = action( theCommandID );
2574 switch (theCommandID) {
2575 case SMESHOp::OpDelete:
2576 if(isStudyLocked()) break;
2579 case SMESHOp::OpImportDAT:
2580 case SMESHOp::OpImportUNV:
2581 case SMESHOp::OpImportMED:
2582 case SMESHOp::OpImportSTL:
2583 case SMESHOp::OpImportCGNS:
2584 case SMESHOp::OpImportSAUV:
2585 case SMESHOp::OpImportGMF:
2586 case SMESHOp::OpPopupImportDAT:
2587 case SMESHOp::OpPopupImportUNV:
2588 case SMESHOp::OpPopupImportMED:
2589 case SMESHOp::OpPopupImportSTL:
2590 case SMESHOp::OpPopupImportCGNS:
2591 case SMESHOp::OpPopupImportSAUV:
2592 case SMESHOp::OpPopupImportGMF:
2594 if(isStudyLocked()) break;
2595 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2599 case SMESHOp::OpFileInformation:
2601 SALOME_ListIO selected;
2602 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2604 aSel->selectedObjects( selected );
2605 if( selected.Extent() )
2607 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2608 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2609 if ( !aMesh->_is_nil() )
2611 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2617 case SMESHOp::OpExportDAT:
2618 case SMESHOp::OpExportMED:
2619 case SMESHOp::OpExportUNV:
2620 case SMESHOp::OpExportSTL:
2621 case SMESHOp::OpExportCGNS:
2622 case SMESHOp::OpExportSAUV:
2623 case SMESHOp::OpExportGMF:
2624 case SMESHOp::OpPopupExportDAT:
2625 case SMESHOp::OpPopupExportMED:
2626 case SMESHOp::OpPopupExportUNV:
2627 case SMESHOp::OpPopupExportSTL:
2628 case SMESHOp::OpPopupExportCGNS:
2629 case SMESHOp::OpPopupExportSAUV:
2630 case SMESHOp::OpPopupExportGMF:
2632 ::ExportMeshToFile(theCommandID);
2636 case SMESHOp::OpReset: // SCALAR BAR
2638 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2639 SALOME_ListIO selected;
2641 aSel->selectedObjects( selected );
2643 SALOME_ListIteratorOfListIO it(selected);
2644 for( ; it.More(); it.Next()) {
2645 Handle(SALOME_InteractiveObject) anIO = it.Value();
2646 if( anIO->hasEntry() ) {
2647 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2648 anActor->SetControlMode( SMESH_Actor::eNone );
2649 #ifndef DISABLE_PLOT2DVIEWER
2650 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2652 anActor->UpdateFilter();
2656 SMESH::UpdateView();
2659 case SMESHOp::OpScalarBarProperties:
2661 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2664 case SMESHOp::OpShowScalarBar:
2666 // show/hide scalar bar
2667 ::ShowElement(theCommandID);
2670 case SMESHOp::OpSaveDistribution:
2672 // dump control distribution data to the text file
2673 ::SaveDistribution();
2677 case SMESHOp::OpShowDistribution:
2679 // show/hide distribution
2680 ::ShowElement(theCommandID);
2684 #ifndef DISABLE_PLOT2DVIEWER
2685 case SMESHOp::OpPlotDistribution:
2687 // plot distribution
2688 ::PlotDistribution();
2694 case SMESHOp::OpAutoColor:
2698 case SMESHOp::OpDisableAutoColor:
2699 ::DisableAutoColor();
2702 case SMESHOp::OpClipping:
2703 case SMESHOp::OpTransparency:
2704 case SMESHOp::OpProperties: // Display preferences (colors, shrink size, line width, ...)
2707 case SMESHOp::OpDMWireframe:
2708 case SMESHOp::OpDMShading:
2709 case SMESHOp::OpDMNodes:
2710 case SMESHOp::OpDMShrink:
2711 ::SetDisplayMode(theCommandID, myMarkerMap);
2714 //2D quadratic representation
2715 case SMESHOp::OpRepresentationLines:
2716 case SMESHOp::OpRepresentationArcs:
2717 ::SetDisplayMode(theCommandID, myMarkerMap);
2721 case SMESHOp::OpDE0DElements:
2722 case SMESHOp::OpDEEdges:
2723 case SMESHOp::OpDEFaces:
2724 case SMESHOp::OpDEVolumes:
2725 case SMESHOp::OpDEBalls:
2726 case SMESHOp::OpDEAllEntity:
2727 ::SetDisplayEntity(theCommandID);
2730 // Choose entities to be displayed
2731 case SMESHOp::OpDEChoose:
2733 ( new SMESHGUI_DisplayEntitiesDlg( SMESHGUI::desktop() ) )->exec();
2737 case SMESHOp::OpOrientationOnFaces:
2739 SUIT_OverrideCursor wc;
2740 LightApp_SelectionMgr* mgr = selectionMgr();
2741 SALOME_ListIO selected; mgr->selectedObjects( selected );
2743 SALOME_ListIteratorOfListIO it(selected);
2744 for( ; it.More(); it.Next()) {
2745 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2746 if(anIObject->hasEntry()) {
2747 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2748 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2755 case SMESHOp::OpUpdate:
2757 if(isStudyLocked()) break;
2758 SUIT_OverrideCursor wc;
2761 SMESH::UpdateView();
2763 catch (std::bad_alloc&) { // PAL16774 (Crash after display of many groups)
2764 SMESH::OnVisuException();
2766 catch (...) { // PAL16774 (Crash after display of many groups)
2767 SMESH::OnVisuException();
2771 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2772 aSel->selectedObjects( l );
2773 aSel->setSelectedObjects( l );
2777 case SMESHOp::OpHide:
2778 case SMESHOp::OpShow:
2779 case SMESHOp::OpShowOnly:
2781 SUIT_OverrideCursor wc;
2782 SMESH::EDisplaing anAction;
2783 switch (theCommandID) {
2784 case SMESHOp::OpHide: anAction = SMESH::eErase; break;
2785 case SMESHOp::OpShow: anAction = SMESH::eDisplay; break;
2786 case SMESHOp::OpShowOnly: anAction = SMESH::eDisplayOnly; break;
2789 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2790 SALOME_ListIO sel_objects, to_process;
2792 aSel->selectedObjects( sel_objects );
2794 if ( theCommandID==SMESHOp::OpShowOnly )
2796 //MESSAGE("anAction = SMESH::eDisplayOnly");
2797 startOperation( myEraseAll );
2800 extractContainers( sel_objects, to_process );
2805 SALOME_ListIteratorOfListIO It( to_process );
2806 for ( ; It.More(); It.Next())
2808 Handle(SALOME_InteractiveObject) IOS = It.Value();
2809 if ( IOS->hasEntry() )
2811 if ( !SMESH::UpdateView( anAction, IOS->getEntry() )) {
2812 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2813 break; // PAL16774 (Crash after display of many groups)
2815 if (anAction == SMESH::eDisplayOnly)
2816 anAction = SMESH::eDisplay;
2821 // PAL13338 + PAL15161 -->
2822 if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !isStudyLocked()) {
2823 SMESH::UpdateView();
2824 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2826 // PAL13338 + PAL15161 <--
2828 catch (...) { // PAL16774 (Crash after display of many groups)
2829 SMESH::OnVisuException();
2832 if (anAction == SMESH::eErase) {
2834 aSel->setSelectedObjects( l1 );
2837 aSel->setSelectedObjects( to_process );
2839 if ( vtkwnd && vtkwnd->GetRenderer() && !isStudyLocked() &&
2840 ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) )
2841 vtkwnd->GetRenderer()->AdjustActors();
2846 case SMESHOp::OpNode:
2848 if(isStudyLocked()) break;
2851 EmitSignalDeactivateDialog();
2853 ( new SMESHGUI_NodesDlg( this ) )->show();
2856 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"),tr("SMESH_WRN_VIEWER_VTK"));
2861 case SMESHOp::OpEditMeshOrSubMesh:
2862 case SMESHOp::OpEditMesh:
2863 case SMESHOp::OpEditSubMesh:
2864 case SMESHOp::OpMeshOrder:
2865 case SMESHOp::OpCreateSubMesh:
2866 if ( warnOnGeomModif() )
2867 break; // action forbidden as geometry modified
2869 case SMESHOp::OpCreateMesh:
2870 case SMESHOp::OpCompute:
2871 case SMESHOp::OpComputeSubMesh:
2872 case SMESHOp::OpPreCompute:
2873 case SMESHOp::OpEvaluate:
2874 case SMESHOp::OpShowErrors:
2875 startOperation( theCommandID );
2877 case SMESHOp::OpRecompute:
2879 if ( isStudyLocked() )
2881 SALOME_ListIO selected;
2882 if ( LightApp_SelectionMgr *sel = selectionMgr() )
2883 sel->selectedObjects( selected );
2884 if ( selected.Extent() == 1 ) {
2885 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO( selected.First() );
2886 if ( !aMesh->_is_nil() )
2888 startOperation( SMESHOp::OpCompute );
2892 case SMESHOp::OpCopyMesh:
2894 if (isStudyLocked()) break;
2895 EmitSignalDeactivateDialog();
2896 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2899 case SMESHOp::OpBuildCompoundMesh:
2901 if (isStudyLocked()) break;
2902 EmitSignalDeactivateDialog();
2903 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2907 case SMESHOp::OpDiagonalInversion:
2908 case SMESHOp::OpUnionOfTwoTriangle:
2912 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2916 if ( isStudyLocked() )
2918 if ( warnOnGeomModif() )
2919 break; // action forbidden as geometry modified
2921 /*Standard_Boolean aRes;
2922 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2923 if ( aMesh->_is_nil() )
2925 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2926 tr( "SMESH_BAD_SELECTION" ) );
2930 EmitSignalDeactivateDialog();
2931 if ( theCommandID == SMESHOp::OpDiagonalInversion )
2932 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2934 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2937 case SMESHOp::OpOrientation:
2938 case SMESHOp::OpUnionOfTriangles:
2939 case SMESHOp::OpCuttingOfQuadrangles:
2940 case SMESHOp::OpSplitVolumes:
2944 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2948 if ( isStudyLocked() )
2950 if ( warnOnGeomModif() )
2951 break; // action forbidden as geometry modified
2953 EmitSignalDeactivateDialog();
2954 SMESHGUI_MultiEditDlg* aDlg = NULL;
2955 if ( theCommandID == SMESHOp::OpOrientation )
2956 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2957 else if ( theCommandID == SMESHOp::OpUnionOfTriangles )
2958 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2959 else if ( theCommandID == SMESHOp::OpSplitVolumes )
2960 aDlg = new SMESHGUI_SplitVolumesDlg(this);
2962 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2967 case SMESHOp::OpSmoothing:
2969 if(isStudyLocked()) break;
2970 if ( warnOnGeomModif() )
2971 break; // action forbidden as geometry modified
2973 EmitSignalDeactivateDialog();
2974 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2977 SUIT_MessageBox::warning(desktop(), tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2981 case SMESHOp::OpExtrusion:
2983 if (isStudyLocked()) break;
2984 if ( warnOnGeomModif() )
2985 break; // action forbidden as geometry modified
2987 EmitSignalDeactivateDialog();
2988 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2990 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2994 case SMESHOp::OpExtrusionAlongAPath:
2996 if (isStudyLocked()) break;
2997 if ( warnOnGeomModif() )
2998 break; // action forbidden as geometry modified
3000 EmitSignalDeactivateDialog();
3001 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
3003 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3007 case SMESHOp::OpRevolution:
3009 if(isStudyLocked()) break;
3010 if ( warnOnGeomModif() )
3011 break; // action forbidden as geometry modified
3013 EmitSignalDeactivateDialog();
3014 ( new SMESHGUI_RevolutionDlg( this ) )->show();
3017 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3021 case SMESHOp::OpPatternMapping:
3023 if ( isStudyLocked() )
3025 if ( warnOnGeomModif() )
3026 break; // action forbidden as geometry modified
3029 EmitSignalDeactivateDialog();
3030 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
3033 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3037 case SMESHOp::OpSplitBiQuadratic:
3038 case SMESHOp::OpConvertMeshToQuadratic:
3039 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
3040 case SMESHOp::OpReorientFaces:
3041 case SMESHOp::OpCreateGeometryGroup:
3043 if ( warnOnGeomModif() )
3044 break; // action forbidden as geometry modified
3045 startOperation( theCommandID );
3048 case SMESHOp::OpCreateGroup:
3052 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3056 if(isStudyLocked()) break;
3057 if ( warnOnGeomModif() )
3058 break; // action forbidden as geometry modified
3059 EmitSignalDeactivateDialog();
3060 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
3062 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3063 SALOME_ListIO selected;
3065 aSel->selectedObjects( selected );
3067 int nbSel = selected.Extent();
3069 // check if mesh is selected
3070 aMesh = SMESH::GetMeshByIO( selected.First() );
3072 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
3077 case SMESHOp::OpConstructGroup:
3081 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3085 if(isStudyLocked()) break;
3086 if ( warnOnGeomModif() )
3087 break; // action forbidden as geometry modified
3088 EmitSignalDeactivateDialog();
3090 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3091 SALOME_ListIO selected;
3093 aSel->selectedObjects( selected );
3095 int nbSel = selected.Extent();
3097 // check if submesh is selected
3098 Handle(SALOME_InteractiveObject) IObject = selected.First();
3099 if (IObject->hasEntry()) {
3100 _PTR(SObject) aSObj = SMESH::getStudy()->FindObjectID(IObject->getEntry());
3102 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
3103 if (!aSubMesh->_is_nil()) {
3105 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
3106 // get submesh elements list by types
3107 SMESH::smIdType_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
3108 SMESH::smIdType_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
3109 SMESH::smIdType_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
3110 SMESH::smIdType_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
3111 // create group for each type o elements
3112 QString aName = IObject->getName();
3113 QStringList anEntryList;
3114 if (aNodes->length() > 0) {
3115 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
3116 aGroup->Add(aNodes.inout());
3117 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3118 anEntryList.append( aSObject->GetID().c_str() );
3120 if (aEdges->length() > 0) {
3121 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
3122 aGroup->Add(aEdges.inout());
3123 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3124 anEntryList.append( aSObject->GetID().c_str() );
3126 if (aFaces->length() > 0) {
3127 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
3128 aGroup->Add(aFaces.inout());
3129 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3130 anEntryList.append( aSObject->GetID().c_str() );
3132 if (aVolumes->length() > 0) {
3133 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
3134 aGroup->Add(aVolumes.inout());
3135 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3136 anEntryList.append( aSObject->GetID().c_str() );
3139 anApp->browseObjects( anEntryList );
3141 catch(const SALOME::SALOME_Exception & S_ex){
3142 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3149 SUIT_MessageBox::warning(desktop(),
3150 tr("SMESH_WRN_WARNING"),
3151 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
3156 case SMESHOp::OpEditGroup:
3160 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3164 if(isStudyLocked()) break;
3165 if ( warnOnGeomModif() )
3166 break; // action forbidden as geometry modified
3167 EmitSignalDeactivateDialog();
3169 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3170 SALOME_ListIO selected;
3172 aSel->selectedObjects( selected );
3174 SALOME_ListIteratorOfListIO It (selected);
3175 int nbSelectedGroups = 0;
3176 for ( ; It.More(); It.Next() )
3178 SMESH::SMESH_GroupBase_var aGroup =
3179 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
3180 if (!aGroup->_is_nil()) {
3182 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
3186 if (nbSelectedGroups == 0)
3188 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
3194 case SMESHOp::OpAddElemGroupPopup: // Add elements to group
3196 if(isStudyLocked()) break;
3197 if (myState == 800) {
3198 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3199 if (aDlg) aDlg->onAdd();
3204 case SMESHOp::OpRemoveElemGroupPopup: // Remove elements from group
3206 if(isStudyLocked()) break;
3207 if (myState == 800) {
3208 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3209 if (aDlg) aDlg->onRemove();
3214 case SMESHOp::OpEditGeomGroupAsGroup:
3218 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3222 if(isStudyLocked()) break;
3223 EmitSignalDeactivateDialog();
3225 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3226 SALOME_ListIO selected;
3228 aSel->selectedObjects( selected );
3230 SALOME_ListIteratorOfListIO It (selected);
3231 for ( ; It.More(); It.Next() )
3233 SMESH::SMESH_GroupOnGeom_var aGroup =
3234 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
3235 if (!aGroup->_is_nil()) {
3236 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3241 SMESH::SMESH_GroupOnFilter_var aGroup =
3242 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
3243 if (!aGroup->_is_nil()) {
3244 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3252 case SMESHOp::OpUnionGroups:
3253 case SMESHOp::OpIntersectGroups:
3254 case SMESHOp::OpCutGroups:
3258 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3262 if ( isStudyLocked() )
3264 if ( warnOnGeomModif() )
3265 break; // action forbidden as geometry modified
3267 EmitSignalDeactivateDialog();
3269 SMESHGUI_GroupOpDlg* aDlg = 0;
3270 if ( theCommandID == SMESHOp::OpUnionGroups )
3271 aDlg = new SMESHGUI_UnionGroupsDlg( this );
3272 else if ( theCommandID == SMESHOp::OpIntersectGroups )
3273 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3275 aDlg = new SMESHGUI_CutGroupsDlg( this );
3282 case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
3284 if ( isStudyLocked() )
3286 if ( warnOnGeomModif() )
3287 break; // action forbidden as geometry modified
3289 EmitSignalDeactivateDialog();
3290 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3296 case SMESHOp::OpFaceGroupsByEdges: // Create face groups separated by sharp edges
3298 if ( isStudyLocked() )
3300 if ( warnOnGeomModif() )
3301 break; // action forbidden as geometry modified
3303 EmitSignalDeactivateDialog();
3304 SMESHGUI_FaceGroupsSeparatedByEdgesDlg* aDlg = new SMESHGUI_FaceGroupsSeparatedByEdgesDlg( this );
3310 case SMESHOp::OpDeleteGroup: // Delete groups with their contents
3314 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3318 if ( isStudyLocked() )
3321 EmitSignalDeactivateDialog();
3323 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3327 case SMESHOp::OpMeshInformation:
3328 case SMESHOp::OpWhatIs:
3330 int page = theCommandID == SMESHOp::OpMeshInformation ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3331 EmitSignalDeactivateDialog();
3332 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3333 SALOME_ListIO selected;
3335 aSel->selectedObjects( selected );
3337 if ( selected.Extent() > 1 ) { // a dlg for each IO
3338 SALOME_ListIteratorOfListIO It( selected );
3339 for ( ; It.More(); It.Next() ) {
3340 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3341 dlg->showInfo( It.Value() );
3346 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3352 case SMESHOp::OpFindElementByPoint:
3354 startOperation( theCommandID );
3358 case SMESHOp::OpEditHypothesis:
3360 if(isStudyLocked()) break;
3361 if ( warnOnGeomModif() )
3362 break; // action forbidden as geometry modified
3364 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3365 SALOME_ListIO selected;
3367 aSel->selectedObjects( selected );
3369 int nbSel = selected.Extent();
3372 Handle(SALOME_InteractiveObject) anIObject = selected.First();
3373 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3375 if ( !aHypothesis->_is_nil() )
3377 SMESHGUI_GenericHypothesisCreator* aCreator =
3378 SMESH::GetHypothesisCreator( SMESH::toQStr( aHypothesis->GetName() ));
3381 // set geometry of mesh and sub-mesh to aCreator
3382 aSel->selectedObjects( selected, "", /*convertReferences=*/false);
3383 if ( selected.Extent() == 1 )
3385 QString subGeomID, meshGeomID;
3386 Handle(SALOME_InteractiveObject) hypIO = selected.First();
3387 if ( SMESH::GetGeomEntries( hypIO, subGeomID, meshGeomID ))
3389 if ( subGeomID.isEmpty() ) subGeomID = meshGeomID;
3390 aCreator->setShapeEntry( subGeomID );
3391 aCreator->setMainShapeEntry( meshGeomID );
3395 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3405 case SMESHOp::OpUnassign: // REMOVE HYPOTHESIS / ALGORITHMS
3407 if(isStudyLocked()) break;
3408 if ( warnOnGeomModif() )
3409 break; // action forbidden as geometry modified
3410 SUIT_OverrideCursor wc;
3412 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3413 SALOME_ListIO selected;
3415 aSel->selectedObjects( selected, QString::null, false );
3417 SALOME_ListIteratorOfListIO It(selected);
3418 for (int i = 0; It.More(); It.Next(), i++) {
3419 Handle(SALOME_InteractiveObject) IObject = It.Value();
3420 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3423 aSel->setSelectedObjects( l1 );
3428 case SMESHOp::OpElem0D:
3429 case SMESHOp::OpBall:
3430 case SMESHOp::OpEdge:
3431 case SMESHOp::OpTriangle:
3432 case SMESHOp::OpQuadrangle:
3433 case SMESHOp::OpPolygon:
3434 case SMESHOp::OpTetrahedron:
3435 case SMESHOp::OpHexahedron:
3436 case SMESHOp::OpPentahedron:
3437 case SMESHOp::OpPyramid:
3438 case SMESHOp::OpHexagonalPrism:
3440 if(isStudyLocked()) break;
3441 if ( warnOnGeomModif() )
3442 break; // action forbidden as geometry modified
3444 EmitSignalDeactivateDialog();
3445 SMDSAbs_EntityType type = SMDSEntity_Edge;
3446 switch (theCommandID) {
3447 case SMESHOp::OpElem0D: type = SMDSEntity_0D; break;
3448 case SMESHOp::OpBall: type = SMDSEntity_Ball; break;
3449 case SMESHOp::OpTriangle: type = SMDSEntity_Triangle; break;
3450 case SMESHOp::OpQuadrangle: type = SMDSEntity_Quadrangle; break;
3451 case SMESHOp::OpTetrahedron: type = SMDSEntity_Tetra; break;
3452 case SMESHOp::OpPolygon: type = SMDSEntity_Polygon; break;
3453 case SMESHOp::OpHexahedron: type = SMDSEntity_Hexa; break;
3454 case SMESHOp::OpPentahedron: type = SMDSEntity_Penta; break;
3455 case SMESHOp::OpPyramid: type = SMDSEntity_Pyramid; break;
3456 case SMESHOp::OpHexagonalPrism: type = SMDSEntity_Hexagonal_Prism; break;
3459 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3462 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3466 case SMESHOp::OpPolyhedron:
3468 if(isStudyLocked()) break;
3469 if ( warnOnGeomModif() )
3470 break; // action forbidden as geometry modified
3472 EmitSignalDeactivateDialog();
3473 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3476 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3480 case SMESHOp::OpQuadraticEdge:
3481 case SMESHOp::OpQuadraticTriangle:
3482 case SMESHOp::OpBiQuadraticTriangle:
3483 case SMESHOp::OpQuadraticQuadrangle:
3484 case SMESHOp::OpBiQuadraticQuadrangle:
3485 case SMESHOp::OpQuadraticPolygon:
3486 case SMESHOp::OpQuadraticTetrahedron:
3487 case SMESHOp::OpQuadraticPyramid:
3488 case SMESHOp::OpQuadraticPentahedron:
3489 case SMESHOp::OpBiQuadraticPentahedron:
3490 case SMESHOp::OpQuadraticHexahedron:
3491 case SMESHOp::OpTriQuadraticHexahedron:
3493 if(isStudyLocked()) break;
3494 if ( warnOnGeomModif() )
3495 break; // action forbidden as geometry modified
3497 EmitSignalDeactivateDialog();
3498 SMDSAbs_EntityType type = SMDSEntity_Last;
3500 switch (theCommandID) {
3501 case SMESHOp::OpQuadraticEdge: type = SMDSEntity_Quad_Edge; break;
3502 case SMESHOp::OpQuadraticTriangle: type = SMDSEntity_Quad_Triangle; break;
3503 case SMESHOp::OpBiQuadraticTriangle: type = SMDSEntity_BiQuad_Triangle; break;
3504 case SMESHOp::OpQuadraticQuadrangle: type = SMDSEntity_Quad_Quadrangle; break;
3505 case SMESHOp::OpBiQuadraticQuadrangle: type = SMDSEntity_BiQuad_Quadrangle; break;
3506 case SMESHOp::OpQuadraticPolygon: type = SMDSEntity_Quad_Polygon; break;
3507 case SMESHOp::OpQuadraticTetrahedron: type = SMDSEntity_Quad_Tetra; break;
3508 case SMESHOp::OpQuadraticPyramid: type = SMDSEntity_Quad_Pyramid; break;
3509 case SMESHOp::OpQuadraticPentahedron: type = SMDSEntity_Quad_Penta; break;
3510 case SMESHOp::OpBiQuadraticPentahedron: type = SMDSEntity_BiQuad_Penta; break;
3511 case SMESHOp::OpQuadraticHexahedron: type = SMDSEntity_Quad_Hexa; break;
3512 case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
3515 if ( type != SMDSEntity_Last )
3516 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3519 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3520 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3524 case SMESHOp::OpRemoveNodes:
3526 if(isStudyLocked()) break;
3527 if ( warnOnGeomModif() )
3528 break; // action forbidden as geometry modified
3530 EmitSignalDeactivateDialog();
3531 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3534 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3535 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3539 case SMESHOp::OpRemoveElements: // REMOVES ELEMENTS
3541 if(isStudyLocked()) break;
3542 if ( warnOnGeomModif() )
3543 break; // action forbidden as geometry modified
3545 EmitSignalDeactivateDialog();
3546 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3550 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3551 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3555 case SMESHOp::OpClearMesh: {
3557 if(isStudyLocked()) break;
3558 if ( warnOnGeomModif() )
3559 break; // action forbidden as geometry modified
3561 SALOME_ListIO selected;
3562 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3563 aSel->selectedObjects( selected );
3565 SUIT_OverrideCursor wc;
3566 SALOME_ListIteratorOfListIO It (selected);
3567 for ( ; It.More(); It.Next() )
3569 Handle(SALOME_InteractiveObject) IOS = It.Value();
3570 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3571 if ( aMesh->_is_nil()) continue;
3574 if ( aMesh->NbNodes() == 0 ) // imported mesh is not empty
3575 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3576 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3577 // hide groups and submeshes
3578 _PTR(ChildIterator) anIter =
3579 SMESH::getStudy()->NewChildIterator( aMeshSObj );
3580 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3582 _PTR(SObject) so = anIter->Value();
3583 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3586 catch (const SALOME::SALOME_Exception& S_ex){
3588 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3592 SMESH::UpdateView();
3596 case SMESHOp::OpRemoveOrphanNodes:
3598 if(isStudyLocked()) break;
3599 if ( warnOnGeomModif() )
3600 break; // action forbidden as geometry modified
3601 SALOME_ListIO selected;
3602 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3603 aSel->selectedObjects( selected );
3604 if ( selected.Extent() == 1 ) {
3605 Handle(SALOME_InteractiveObject) anIO = selected.First();
3606 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3607 if ( !aMesh->_is_nil() ) {
3608 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3609 tr( "SMESH_WARNING" ),
3610 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3611 SUIT_MessageBox::Yes |
3612 SUIT_MessageBox::No,
3613 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3616 SUIT_OverrideCursor wc;
3617 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3618 int removed = aMeshEditor->RemoveOrphanNodes();
3619 SUIT_MessageBox::information(SMESHGUI::desktop(),
3620 tr("SMESH_INFORMATION"),
3621 tr("NB_NODES_REMOVED").arg(removed));
3622 if ( removed > 0 ) {
3623 SMESH::UpdateView();
3624 SMESHGUI::Modified();
3627 catch (const SALOME::SALOME_Exception& S_ex) {
3628 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3637 case SMESHOp::OpRenumberingNodes:
3639 if(isStudyLocked()) break;
3640 if ( warnOnGeomModif() )
3641 break; // action forbidden as geometry modified
3643 EmitSignalDeactivateDialog();
3644 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3648 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3649 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3653 case SMESHOp::OpRenumberingElements:
3655 if(isStudyLocked()) break;
3656 if ( warnOnGeomModif() )
3657 break; // action forbidden as geometry modified
3659 EmitSignalDeactivateDialog();
3660 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3664 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3665 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3669 case SMESHOp::OpTranslation:
3671 if(isStudyLocked()) break;
3672 if ( warnOnGeomModif() )
3673 break; // action forbidden as geometry modified
3675 EmitSignalDeactivateDialog();
3676 ( new SMESHGUI_TranslationDlg( this ) )->show();
3679 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3680 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3684 case SMESHOp::OpRotation:
3686 if(isStudyLocked()) break;
3687 if ( warnOnGeomModif() )
3688 break; // action forbidden as geometry modified
3690 EmitSignalDeactivateDialog();
3691 ( new SMESHGUI_RotationDlg( this ) )->show();
3694 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3695 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3699 case SMESHOp::OpSymmetry:
3701 if(isStudyLocked()) break;
3702 if ( warnOnGeomModif() )
3703 break; // action forbidden as geometry modified
3705 EmitSignalDeactivateDialog();
3706 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3709 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3710 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3714 case SMESHOp::OpScale:
3716 if(isStudyLocked()) break;
3717 if ( warnOnGeomModif() )
3718 break; // action forbidden as geometry modified
3720 EmitSignalDeactivateDialog();
3721 ( new SMESHGUI_ScaleDlg( this ) )->show();
3724 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3725 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3730 case SMESHOp::OpOffset:
3732 if(isStudyLocked()) break;
3733 if ( warnOnGeomModif() )
3734 break; // action forbidden as geometry modified
3736 EmitSignalDeactivateDialog();
3737 ( new SMESHGUI_OffsetDlg( this ) )->show();
3740 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3741 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3746 case SMESHOp::OpSewing:
3748 if(isStudyLocked()) break;
3749 if ( warnOnGeomModif() )
3750 break; // action forbidden as geometry modified
3752 EmitSignalDeactivateDialog();
3753 ( new SMESHGUI_SewingDlg( this ) )->show();
3756 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3757 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3761 case SMESHOp::OpMergeNodes:
3763 if(isStudyLocked()) break;
3764 if ( warnOnGeomModif() )
3765 break; // action forbidden as geometry modified
3767 EmitSignalDeactivateDialog();
3768 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3771 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3772 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3776 case SMESHOp::OpMergeElements:
3778 if (isStudyLocked()) break;
3779 if ( warnOnGeomModif() )
3780 break; // action forbidden as geometry modified
3782 EmitSignalDeactivateDialog();
3783 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3785 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3786 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3791 case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
3792 if ( warnOnGeomModif() )
3793 break; // action forbidden as geometry modified
3794 startOperation( SMESHOp::OpMoveNode );
3797 case SMESHOp::OpDuplicateNodes:
3799 if(isStudyLocked()) break;
3800 if ( warnOnGeomModif() )
3801 break; // action forbidden as geometry modified
3803 EmitSignalDeactivateDialog();
3804 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3807 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3808 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3813 case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
3814 if ( warnOnGeomModif() )
3815 break; // action forbidden as geometry modified
3816 startOperation( SMESHOp::OpElem0DOnElemNodes );
3819 case SMESHOp::OpSelectFiltersLibrary: // Library of selection filters
3821 static QList<int> aTypes;
3822 if ( aTypes.isEmpty() )
3824 aTypes.append( SMESH::NODE );
3825 aTypes.append( SMESH::EDGE );
3826 aTypes.append( SMESH::FACE );
3827 aTypes.append( SMESH::VOLUME );
3829 if (!myFilterLibraryDlg)
3830 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3831 else if (myFilterLibraryDlg->isHidden())
3832 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3833 myFilterLibraryDlg->raise();
3837 case SMESHOp::OpFreeNode:
3838 case SMESHOp::OpEqualNode:
3839 case SMESHOp::OpNodeConnectivityNb:
3840 case SMESHOp::OpFreeEdge:
3841 case SMESHOp::OpFreeBorder:
3842 case SMESHOp::OpLength:
3843 case SMESHOp::OpConnection:
3844 case SMESHOp::OpEqualEdge:
3845 case SMESHOp::OpFreeFace:
3846 case SMESHOp::OpBareBorderFace:
3847 case SMESHOp::OpOverConstrainedFace:
3848 case SMESHOp::OpLength2D:
3849 case SMESHOp::OpDeflection2D:
3850 case SMESHOp::OpConnection2D:
3851 case SMESHOp::OpArea:
3852 case SMESHOp::OpTaper:
3853 case SMESHOp::OpAspectRatio:
3854 case SMESHOp::OpMinimumAngle:
3855 case SMESHOp::OpWarpingAngle:
3856 case SMESHOp::OpSkew:
3857 case SMESHOp::OpMaxElementLength2D:
3858 case SMESHOp::OpEqualFace:
3859 case SMESHOp::OpAspectRatio3D:
3860 case SMESHOp::OpVolume:
3861 case SMESHOp::OpMaxElementLength3D:
3862 case SMESHOp::OpBareBorderVolume:
3863 case SMESHOp::OpOverConstrainedVolume:
3864 case SMESHOp::OpEqualVolume:
3867 LightApp_SelectionMgr* mgr = selectionMgr();
3868 SALOME_ListIO selected; mgr->selectedObjects( selected );
3870 if( !selected.IsEmpty() ) {
3871 SUIT_OverrideCursor wc;
3872 ::Control( theCommandID );
3875 SUIT_MessageBox::warning(desktop(),
3876 tr( "SMESH_WRN_WARNING" ),
3877 tr( "SMESH_BAD_SELECTION" ) );
3881 SUIT_MessageBox::warning(desktop(),
3882 tr( "SMESH_WRN_WARNING" ),
3883 tr( "NOT_A_VTK_VIEWER" ) );
3886 case SMESHOp::OpOverallMeshQuality:
3887 OverallMeshQuality();
3889 case SMESHOp::OpNumberingNodes:
3891 SUIT_OverrideCursor wc;
3892 LightApp_SelectionMgr* mgr = selectionMgr();
3893 SALOME_ListIO selected; mgr->selectedObjects( selected );
3895 SALOME_ListIteratorOfListIO it(selected);
3896 for( ; it.More(); it.Next()) {
3897 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3898 if(anIObject->hasEntry()) {
3899 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3900 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3906 case SMESHOp::OpNumberingElements:
3908 SUIT_OverrideCursor wc;
3909 LightApp_SelectionMgr* mgr = selectionMgr();
3910 SALOME_ListIO selected; mgr->selectedObjects( selected );
3912 SALOME_ListIteratorOfListIO it(selected);
3913 for( ; it.More(); it.Next()) {
3914 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3915 if(anIObject->hasEntry())
3916 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3917 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3922 case SMESHOp::OpPropertiesLength:
3923 case SMESHOp::OpPropertiesArea:
3924 case SMESHOp::OpPropertiesVolume:
3925 case SMESHOp::OpMinimumDistance:
3926 case SMESHOp::OpBoundingBox:
3927 case SMESHOp::OpAngle:
3929 int page = SMESHGUI_MeasureDlg::MinDistance;
3930 if ( theCommandID == SMESHOp::OpBoundingBox )
3931 page = SMESHGUI_MeasureDlg::BoundingBox;
3932 else if ( theCommandID == SMESHOp::OpPropertiesLength )
3933 page = SMESHGUI_MeasureDlg::Length;
3934 else if ( theCommandID == SMESHOp::OpPropertiesArea )
3935 page = SMESHGUI_MeasureDlg::Area;
3936 else if ( theCommandID == SMESHOp::OpPropertiesVolume )
3937 page = SMESHGUI_MeasureDlg::Volume;
3938 else if ( theCommandID == SMESHOp::OpAngle )
3939 page = SMESHGUI_MeasureDlg::Angle;
3941 EmitSignalDeactivateDialog();
3942 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3946 case SMESHOp::OpSortChild:
3949 case SMESHOp::OpBreakLink:
3950 ::breakShaperLink();
3955 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3956 //updateObjBrowser();
3960 //=============================================================================
3964 //=============================================================================
3965 bool SMESHGUI::OnMousePress( QMouseEvent * /*pe*/, SUIT_ViewWindow * /*wnd*/ )
3970 //=============================================================================
3974 //=============================================================================
3975 bool SMESHGUI::OnMouseMove( QMouseEvent * /*pe*/, SUIT_ViewWindow * /*wnd*/ )
3980 //=============================================================================
3984 //=============================================================================
3985 bool SMESHGUI::OnKeyPress( QKeyEvent * /*pe*/, SUIT_ViewWindow * /*wnd*/ )
3990 //=============================================================================
3991 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3992 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3994 //=============================================================================
3995 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3996 SUIT_ViewWindow* wnd )
3998 if(theIO->hasEntry()){
3999 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
4000 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
4004 //=======================================================================
4005 // function : createSMESHAction
4007 //=======================================================================
4008 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
4009 const int key, const bool toggle, const QString& shortcutAction )
4012 QWidget* parent = application()->desktop();
4013 SUIT_ResourceMgr* resMgr = resourceMgr();
4015 if ( !icon_id.isEmpty() )
4016 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
4018 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICON_%1" ).arg( po_id ).toLatin1().data() ), false );
4019 if ( !pix.isNull() )
4020 icon = QIcon( pix );
4022 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
4023 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
4024 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
4026 createAction( id, tooltip, icon, menu, status_bar, key, parent,
4027 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
4030 //=======================================================================
4031 // function : createPopupItem
4033 //=======================================================================
4034 void SMESHGUI::createPopupItem( const int id,
4035 const QString& clients,
4036 const QString& types,
4037 const QString& theRule,
4040 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
4041 popupMgr()->insert( action( id ), pId, 0 );
4043 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4044 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4045 QString rule = "(%1) and (%2) and (%3)";
4046 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
4047 if( clients.isEmpty() )
4048 rule = rule.arg( QString( "true" ) );
4050 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
4051 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
4054 bool cont = myRules.contains( id );
4056 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
4058 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
4059 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
4062 //=======================================================================
4063 // function : initialize
4065 //=======================================================================
4066 void SMESHGUI::initialize( CAM_Application* app )
4068 SalomeApp_Module::initialize( app );
4070 // SUIT_ResourceMgr* mgr = app->resourceMgr();
4072 /* Automatic Update flag */
4073 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
4075 // ----- create actions --------------
4077 //createSMESHAction( SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
4078 createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_I) );
4079 createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
4080 createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL" );
4082 createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
4084 createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
4085 createSMESHAction( SMESHOp::OpImportGMF, "IMPORT_GMF" );
4086 createSMESHAction( SMESHOp::OpPopupImportUNV, "IMPORT_UNV");
4087 createSMESHAction( SMESHOp::OpPopupImportMED, "IMPORT_MED");
4088 createSMESHAction( SMESHOp::OpPopupImportSTL, "IMPORT_STL" );
4090 createSMESHAction( SMESHOp::OpPopupImportCGNS, "IMPORT_CGNS" );
4092 createSMESHAction( SMESHOp::OpPopupImportSAUV, "IMPORT_SAUV" );
4093 createSMESHAction( SMESHOp::OpPopupImportGMF, "IMPORT_GMF" );
4095 createSMESHAction( SMESHOp::OpExportDAT, "DAT" );
4096 createSMESHAction( SMESHOp::OpExportMED, "MED" );
4097 createSMESHAction( SMESHOp::OpExportUNV, "UNV" );
4098 createSMESHAction( SMESHOp::OpExportSTL, "STL" );
4100 createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
4102 createSMESHAction( SMESHOp::OpExportSAUV, "SAUV");
4103 createSMESHAction( SMESHOp::OpExportGMF, "GMF" );
4104 createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
4105 createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
4106 createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
4107 createSMESHAction( SMESHOp::OpPopupExportSTL, "STL" );
4109 createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
4111 createSMESHAction( SMESHOp::OpPopupExportSAUV, "SAUV");
4112 createSMESHAction( SMESHOp::OpPopupExportGMF, "GMF" );
4113 createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
4114 createSMESHAction( SMESHOp::OpDelete, "DELETE", "ICON_DELETE", Qt::Key_Delete );
4115 createSMESHAction( SMESHOp::OpSelectFiltersLibrary, "SEL_FILTER_LIB" );
4116 createSMESHAction( SMESHOp::OpCreateMesh, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
4117 createSMESHAction( SMESHOp::OpCreateSubMesh, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
4118 createSMESHAction( SMESHOp::OpEditMeshOrSubMesh, "EDIT_MESHSUBMESH", "ICON_DLG_EDIT_MESH" );
4119 createSMESHAction( SMESHOp::OpEditMesh, "EDIT_MESH", "ICON_DLG_EDIT_MESH" );
4120 createSMESHAction( SMESHOp::OpEditSubMesh, "EDIT_SUBMESH", "ICON_DLG_EDIT_MESH" );
4121 createSMESHAction( SMESHOp::OpBuildCompoundMesh, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
4122 createSMESHAction( SMESHOp::OpCopyMesh, "COPY_MESH", "ICON_COPY_MESH" );
4123 createSMESHAction( SMESHOp::OpCompute, "COMPUTE", "ICON_COMPUTE" );
4124 createSMESHAction( SMESHOp::OpComputeSubMesh, "COMPUTE_SUBMESH", "ICON_COMPUTE" );
4125 createSMESHAction( SMESHOp::OpRecompute, "RE_COMPUTE", "ICON_COMPUTE" );
4126 createSMESHAction( SMESHOp::OpPreCompute, "PRECOMPUTE", "ICON_PRECOMPUTE" );
4127 createSMESHAction( SMESHOp::OpShowErrors, "SHOW_ERRORS", "ICON_SHOW_ERRORS" );
4128 createSMESHAction( SMESHOp::OpEvaluate, "EVALUATE", "ICON_EVALUATE" );
4129 createSMESHAction( SMESHOp::OpMeshOrder, "MESH_ORDER", "ICON_MESH_ORDER");
4130 createSMESHAction( SMESHOp::OpCreateGroup, "CREATE_GROUP", "ICON_CREATE_GROUP" );
4131 createSMESHAction( SMESHOp::OpCreateGeometryGroup, "CREATE_GEO_GROUP", "ICON_CREATE_GEO_GROUP" );
4132 createSMESHAction( SMESHOp::OpConstructGroup, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
4133 createSMESHAction( SMESHOp::OpEditGroup, "EDIT_GROUP", "ICON_EDIT_GROUP" );
4134 createSMESHAction( SMESHOp::OpEditGeomGroupAsGroup, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
4135 createSMESHAction( SMESHOp::OpUnionGroups, "UN_GROUP", "ICON_UNION" );
4136 createSMESHAction( SMESHOp::OpIntersectGroups, "INT_GROUP", "ICON_INTERSECT" );
4137 createSMESHAction( SMESHOp::OpCutGroups, "CUT_GROUP", "ICON_CUT" );
4138 createSMESHAction( SMESHOp::OpGroupUnderlyingElem, "UNDERLYING_ELEMS", "ICON_UNDERLYING_ELEMS" );
4139 createSMESHAction( SMESHOp::OpFaceGroupsByEdges, "FACE_GROUPS_BY_EDGES", "ICON_FACE_GROUPS_BY_EDGES" );
4140 createSMESHAction( SMESHOp::OpAddElemGroupPopup, "ADD_TO_GROUP" );
4141 createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE_FROM_GROUP" );
4142 createSMESHAction( SMESHOp::OpDeleteGroup, "DEL_GROUP", "ICON_DEL_GROUP" );
4143 createSMESHAction( SMESHOp::OpMeshInformation , "ADV_INFO", "ICON_ADV_INFO" );
4144 //createSMESHAction( SMESHOp::OpStdInfo, "STD_INFO", "ICON_STD_INFO" );
4145 //createSMESHAction( SMESHOp::OpWhatIs, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4146 createSMESHAction( SMESHOp::OpFindElementByPoint, "FIND_ELEM", "ICON_FIND_ELEM" );
4148 createSMESHAction( SMESHOp::OpFreeNode, "FREE_NODE", "ICON_FREE_NODE", 0, true );
4149 createSMESHAction( SMESHOp::OpEqualNode, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
4150 createSMESHAction( SMESHOp::OpNodeConnectivityNb, "NODE_CONNECTIVITY_NB", "ICON_NODE_CONN_NB", 0, true );
4151 createSMESHAction( SMESHOp::OpFreeEdge, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
4152 createSMESHAction( SMESHOp::OpFreeBorder, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
4153 createSMESHAction( SMESHOp::OpLength, "LENGTH", "ICON_LENGTH", 0, true );
4154 createSMESHAction( SMESHOp::OpConnection, "CONNECTION", "ICON_CONNECTION", 0, true );
4155 createSMESHAction( SMESHOp::OpEqualEdge, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
4156 createSMESHAction( SMESHOp::OpFreeFace, "FREE_FACES", "ICON_FREE_FACES", 0, true );
4157 createSMESHAction( SMESHOp::OpBareBorderFace, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
4158 createSMESHAction( SMESHOp::OpOverConstrainedFace, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
4159 createSMESHAction( SMESHOp::OpLength2D, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
4160 createSMESHAction( SMESHOp::OpDeflection2D, "DEFLECTION_2D", "ICON_DEFLECTION_2D", 0, true );
4161 createSMESHAction( SMESHOp::OpConnection2D, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
4162 createSMESHAction( SMESHOp::OpArea, "AREA", "ICON_AREA", 0, true );
4163 createSMESHAction( SMESHOp::OpTaper, "TAPER", "ICON_TAPER", 0, true );
4164 createSMESHAction( SMESHOp::OpAspectRatio, "ASPECT", "ICON_ASPECT", 0, true );
4165 createSMESHAction( SMESHOp::OpMinimumAngle, "MIN_ANG", "ICON_ANGLE", 0, true );
4166 createSMESHAction( SMESHOp::OpWarpingAngle, "WARP", "ICON_WARP", 0, true );
4167 createSMESHAction( SMESHOp::OpSkew, "SKEW", "ICON_SKEW", 0, true );
4168 createSMESHAction( SMESHOp::OpMaxElementLength2D, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
4169 createSMESHAction( SMESHOp::OpEqualFace, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
4170 createSMESHAction( SMESHOp::OpAspectRatio3D, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
4171 createSMESHAction( SMESHOp::OpVolume, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
4172 createSMESHAction( SMESHOp::OpMaxElementLength3D, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
4173 createSMESHAction( SMESHOp::OpBareBorderVolume, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
4174 createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
4175 createSMESHAction( SMESHOp::OpEqualVolume, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
4176 createSMESHAction( SMESHOp::OpOverallMeshQuality, "OVERALL_MESH_QUALITY", "ICON_OVL_MESH_QUALITY" );
4178 createSMESHAction( SMESHOp::OpNode, "NODE", "ICON_DLG_NODE" );
4179 createSMESHAction( SMESHOp::OpElem0D, "ELEM0D", "ICON_DLG_ELEM0D" );
4180 createSMESHAction( SMESHOp::OpElem0DOnElemNodes, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
4181 createSMESHAction( SMESHOp::OpBall, "BALL", "ICON_DLG_BALL" );
4182 createSMESHAction( SMESHOp::OpEdge, "EDGE", "ICON_DLG_EDGE" );
4183 createSMESHAction( SMESHOp::OpTriangle, "TRIANGLE", "ICON_DLG_TRIANGLE" );
4184 createSMESHAction( SMESHOp::OpQuadrangle, "QUAD", "ICON_DLG_QUADRANGLE" );
4185 createSMESHAction( SMESHOp::OpPolygon, "POLYGON", "ICON_DLG_POLYGON" );
4186 createSMESHAction( SMESHOp::OpTetrahedron, "TETRA", "ICON_DLG_TETRAS" );
4187 createSMESHAction( SMESHOp::OpHexahedron, "HEXA", "ICON_DLG_HEXAS" );
4188 createSMESHAction( SMESHOp::OpPentahedron, "PENTA", "ICON_DLG_PENTA" );
4189 createSMESHAction( SMESHOp::OpPyramid , "PYRAMID", "ICON_DLG_PYRAMID" );
4190 createSMESHAction( SMESHOp::OpHexagonalPrism, "OCTA", "ICON_DLG_OCTA" );
4191 createSMESHAction( SMESHOp::OpPolyhedron, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
4192 createSMESHAction( SMESHOp::OpQuadraticEdge, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
4193 createSMESHAction( SMESHOp::OpQuadraticTriangle, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
4194 createSMESHAction( SMESHOp::OpBiQuadraticTriangle, "BIQUADRATIC_TRIANGLE", "ICON_DLG_BIQUADRATIC_TRIANGLE" );
4195 createSMESHAction( SMESHOp::OpQuadraticQuadrangle, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
4196 createSMESHAction( SMESHOp::OpBiQuadraticQuadrangle, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
4197 createSMESHAction( SMESHOp::OpQuadraticPolygon, "QUADRATIC_POLYGON", "ICON_DLG_QUADRATIC_POLYGON" );
4198 createSMESHAction( SMESHOp::OpQuadraticTetrahedron, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
4199 createSMESHAction( SMESHOp::OpQuadraticPyramid, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
4200 createSMESHAction( SMESHOp::OpQuadraticPentahedron, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
4201 createSMESHAction( SMESHOp::OpBiQuadraticPentahedron, "BIQUADRATIC_PENTAHEDRON", "ICON_DLG_BIQUADRATIC_PENTAHEDRON" );
4202 createSMESHAction( SMESHOp::OpQuadraticHexahedron, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
4203 createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
4205 createSMESHAction( SMESHOp::OpRemoveNodes, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
4206 createSMESHAction( SMESHOp::OpRemoveElements, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
4207 createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
4208 createSMESHAction( SMESHOp::OpClearMesh, "CLEAR_MESH", "ICON_CLEAR_MESH" );
4210 //createSMESHAction( SMESHOp::OpRenumberingNodes, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
4211 //createSMESHAction( SMESHOp::OpRenumberingElements, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
4213 createSMESHAction( SMESHOp::OpTranslation, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
4214 createSMESHAction( SMESHOp::OpRotation, "ROT", "ICON_DLG_MESH_ROTATION" );
4215 createSMESHAction( SMESHOp::OpSymmetry, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
4216 createSMESHAction( SMESHOp::OpScale, "SCALE", "ICON_DLG_MESH_SCALE" );
4217 createSMESHAction( SMESHOp::OpOffset, "OFFSET", "ICON_DLG_MESH_OFFSET" );
4218 createSMESHAction( SMESHOp::OpSewing, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
4219 createSMESHAction( SMESHOp::OpMergeNodes, "MERGE", "ICON_SMESH_MERGE_NODES" );
4220 createSMESHAction( SMESHOp::OpMergeElements, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
4221 createSMESHAction( SMESHOp::OpMoveNode, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
4222 createSMESHAction( SMESHOp::OpDuplicateNodes, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
4223 createSMESHAction( SMESHOp::OpDiagonalInversion, "INV", "ICON_DLG_MESH_DIAGONAL" );
4224 createSMESHAction( SMESHOp::OpUnionOfTwoTriangle, "UNION2", "ICON_UNION2TRI" );
4225 createSMESHAction( SMESHOp::OpOrientation, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
4226 createSMESHAction( SMESHOp::OpReorientFaces, "REORIENT_2D", "ICON_REORIENT_2D" );
4227 createSMESHAction( SMESHOp::OpUnionOfTriangles, "UNION", "ICON_UNIONTRI" );
4228 createSMESHAction( SMESHOp::OpCuttingOfQuadrangles, "CUT", "ICON_CUTQUAD" );
4229 createSMESHAction( SMESHOp::OpSplitVolumes, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
4230 createSMESHAction( SMESHOp::OpSplitBiQuadratic, "SPLIT_BIQUAD", "ICON_SPLIT_BIQUAD" );
4231 createSMESHAction( SMESHOp::OpSmoothing, "SMOOTH", "ICON_DLG_SMOOTHING" );
4232 createSMESHAction( SMESHOp::OpExtrusion, "EXTRUSION", "ICON_EXTRUSION" );
4233 createSMESHAction( SMESHOp::OpExtrusionAlongAPath, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
4234 createSMESHAction( SMESHOp::OpRevolution, "REVOLUTION", "ICON_REVOLUTION" );
4235 createSMESHAction( SMESHOp::OpPatternMapping, "MAP", "ICON_MAP" );
4236 createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
4237 createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D", "ICON_2D_FROM_3D" );
4239 createSMESHAction( SMESHOp::OpReset, "RESET" );
4240 createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
4241 createSMESHAction( SMESHOp::OpShowScalarBar, "SHOW_SCALAR_BAR","",0, true );
4242 createSMESHAction( SMESHOp::OpSaveDistribution, "SAVE_DISTRIBUTION" );
4243 createSMESHAction( SMESHOp::OpShowDistribution, "SHOW_DISTRIBUTION","",0, true );
4244 #ifndef DISABLE_PLOT2DVIEWER
4245 createSMESHAction( SMESHOp::OpPlotDistribution, "PLOT_DISTRIBUTION" );
4247 createSMESHAction( SMESHOp::OpDMWireframe, "WIRE", "ICON_WIRE", 0, true );
4248 createSMESHAction( SMESHOp::OpDMShading, "SHADE", "ICON_SHADE", 0, true );
4249 createSMESHAction( SMESHOp::OpDMNodes, "NODES", "ICON_POINTS", 0, true );
4250 createSMESHAction( SMESHOp::OpDMShrink, "SHRINK", "ICON_SHRINK", 0, true );
4251 createSMESHAction( SMESHOp::OpUpdate, "UPDATE", "ICON_UPDATE" );
4252 createSMESHAction( SMESHOp::OpDE0DElements, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
4253 createSMESHAction( SMESHOp::OpDEEdges, "EDGES", "ICON_DLG_EDGE", 0, true );
4254 createSMESHAction( SMESHOp::OpDEFaces, "FACES", "ICON_DLG_TRIANGLE", 0, true );
4255 createSMESHAction( SMESHOp::OpDEVolumes, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
4256 createSMESHAction( SMESHOp::OpDEBalls, "BALLS", "ICON_DLG_BALL", 0, true );
4257 createSMESHAction( SMESHOp::OpDEChoose, "CHOOSE", "ICON_DLG_CHOOSE", 0, false );
4258 createSMESHAction( SMESHOp::OpDEAllEntity, "ALL", "ICON_DLG_CHOOSE_ALL", 0, false );
4259 createSMESHAction( SMESHOp::OpOrientationOnFaces, "FACE_ORIENTATION", "", 0, true );
4261 createSMESHAction( SMESHOp::OpRepresentationLines, "LINE_REPRESENTATION", "", 0, true );
4262 createSMESHAction( SMESHOp::OpRepresentationArcs, "ARC_REPRESENTATION", "", 0, true );
4264 createSMESHAction( SMESHOp::OpEditHypothesis, "EDIT_HYPO" );
4265 createSMESHAction( SMESHOp::OpUnassign, "UNASSIGN" );
4266 createSMESHAction( SMESHOp::OpNumberingNodes, "NUM_NODES", "", 0, true );
4267 createSMESHAction( SMESHOp::OpNumberingElements, "NUM_ELEMENTS", "", 0, true );
4268 createSMESHAction( SMESHOp::OpProperties, "COLORS" );
4269 createSMESHAction( SMESHOp::OpTransparency, "TRANSP" );
4270 createSMESHAction( SMESHOp::OpClipping, "CLIP" );
4271 createSMESHAction( SMESHOp::OpAutoColor, "AUTO_COLOR" );
4272 createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
4274 createSMESHAction( SMESHOp::OpMinimumDistance, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
4275 createSMESHAction( SMESHOp::OpBoundingBox, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
4276 createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH", "ICON_MEASURE_LENGTH" );
4277 createSMESHAction( SMESHOp::OpPropertiesArea, "MEASURE_AREA", "ICON_MEASURE_AREA" );
4278 createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME", "ICON_MEASURE_VOLUME" );
4279 createSMESHAction( SMESHOp::OpAngle, "MEASURE_ANGLE", "ICON_MEASURE_ANGLE" );
4281 createSMESHAction( SMESHOp::OpHide, "HIDE", "ICON_HIDE" );
4282 createSMESHAction( SMESHOp::OpShow, "SHOW", "ICON_SHOW" );
4283 createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
4285 createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
4287 createSMESHAction( SMESHOp::OpBreakLink, "BREAK_SHAPER_LINK" );
4289 QList<int> aCtrlActions;
4290 aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode
4291 << SMESHOp::OpNodeConnectivityNb // node controls
4292 << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
4293 << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge // edge controls
4294 << SMESHOp::OpDeflection2D
4295 << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
4296 << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
4297 << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
4298 << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
4299 << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace // face controls
4300 << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
4301 << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
4302 << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume; // volume controls
4303 QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
4304 aCtrlGroup->setExclusive( true );
4305 for( int i = 0; i < aCtrlActions.size(); i++ )
4306 aCtrlGroup->addAction( action( aCtrlActions[i] ) );
4308 // ----- create menu --------------
4309 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
4310 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
4311 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
4312 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
4313 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
4314 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
4315 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
4316 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
4318 createMenu( separator(), fileId );
4320 QMenu* nodeMenu = new QMenu(); QMenu* edgeMenu = new QMenu();
4321 QMenu* faceMenu = new QMenu(); QMenu* volumeMenu = new QMenu();
4322 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
4323 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
4324 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10, -1, nodeMenu ),
4325 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10, -1, edgeMenu ),
4326 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10, -1, faceMenu ),
4327 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10, -1, volumeMenu ),
4328 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
4329 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
4330 //renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
4331 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
4332 basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
4334 //createMenu( SMESHOp::OpImportDAT, importId, -1 );
4335 createMenu( SMESHOp::OpImportUNV, importId, -1 );
4336 createMenu( SMESHOp::OpImportMED, importId, -1 );
4337 createMenu( SMESHOp::OpImportSTL, importId, -1 );
4339 createMenu( SMESHOp::OpImportCGNS, importId, -1 );
4341 createMenu( SMESHOp::OpImportSAUV, importId, -1 );
4342 createMenu( SMESHOp::OpImportGMF, importId, -1 );
4343 createMenu( SMESHOp::OpExportDAT, exportId, -1 );
4344 createMenu( SMESHOp::OpExportMED, exportId, -1 );
4345 createMenu( SMESHOp::OpExportUNV, exportId, -1 );
4346 createMenu( SMESHOp::OpExportSTL, exportId, -1 );
4348 createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
4350 createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
4351 createMenu( SMESHOp::OpExportGMF, exportId, -1 );
4352 createMenu( separator(), fileId, 10 );
4354 createMenu( SMESHOp::OpDelete, editId, -1 );
4356 createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
4358 createMenu( SMESHOp::OpCreateMesh, meshId, -1 ); // "Mesh" menu
4359 createMenu( SMESHOp::OpCreateSubMesh, meshId, -1 );
4360 createMenu( SMESHOp::OpEditMeshOrSubMesh, meshId, -1 );
4361 createMenu( SMESHOp::OpBuildCompoundMesh, meshId, -1 );
4362 createMenu( SMESHOp::OpCopyMesh, meshId, -1 );
4363 createMenu( separator(), meshId, -1 );
4364 createMenu( SMESHOp::OpCompute, meshId, -1 );
4365 createMenu( SMESHOp::OpPreCompute, meshId, -1 );
4366 createMenu( SMESHOp::OpEvaluate, meshId, -1 );
4367 createMenu( SMESHOp::OpMeshOrder, meshId, -1 );
4368 createMenu( separator(), meshId, -1 );
4369 createMenu( SMESHOp::OpCreateGroup, meshId, -1 );
4370 createMenu( SMESHOp::OpCreateGeometryGroup, meshId, -1 );
4371 createMenu( SMESHOp::OpConstructGroup, meshId, -1 );
4372 createMenu( SMESHOp::OpEditGroup, meshId, -1 );
4373 createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4374 createMenu( separator(), meshId, -1 );
4375 createMenu( SMESHOp::OpUnionGroups, meshId, -1 );
4376 createMenu( SMESHOp::OpIntersectGroups, meshId, -1 );
4377 createMenu( SMESHOp::OpCutGroups, meshId, -1 );
4378 createMenu( separator(), meshId, -1 );
4379 createMenu( SMESHOp::OpGroupUnderlyingElem, meshId, -1 );
4380 createMenu( SMESHOp::OpFaceGroupsByEdges, meshId, -1 );
4381 createMenu( separator(), meshId, -1 );
4382 createMenu( SMESHOp::OpMeshInformation, meshId, -1 );
4383 //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4384 //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4385 createMenu( SMESHOp::OpFindElementByPoint, meshId, -1 );
4386 createMenu( separator(), meshId, -1 );
4388 createMenu( SMESHOp::OpFreeNode, nodeId, -1 );
4389 createMenu( SMESHOp::OpEqualNode, nodeId, -1 );
4390 //createMenu( SMESHOp::OpNodeConnectivityNb, nodeId, -1 );
4391 createMenu( SMESHOp::OpFreeBorder, edgeId, -1 );
4392 createMenu( SMESHOp::OpLength, edgeId, -1 );
4393 createMenu( SMESHOp::OpConnection, edgeId, -1 );
4394 createMenu( SMESHOp::OpEqualEdge, edgeId, -1 );
4395 createMenu( SMESHOp::OpFreeEdge, faceId, -1 );
4396 createMenu( SMESHOp::OpFreeFace, faceId, -1 );
4397 createMenu( SMESHOp::OpBareBorderFace, faceId, -1 );
4398 createMenu( SMESHOp::OpOverConstrainedFace, faceId, -1 );
4399 createMenu( SMESHOp::OpLength2D, faceId, -1 );
4400 createMenu( SMESHOp::OpConnection2D, faceId, -1 );
4401 createMenu( SMESHOp::OpArea, faceId, -1 );
4402 createMenu( SMESHOp::OpTaper, faceId, -1 );
4403 createMenu( SMESHOp::OpAspectRatio, faceId, -1 );
4404 createMenu( SMESHOp::OpMinimumAngle, faceId, -1 );
4405 createMenu( SMESHOp::OpWarpingAngle, faceId, -1 );
4406 createMenu( SMESHOp::OpSkew, faceId, -1 );
4407 createMenu( SMESHOp::OpMaxElementLength2D, faceId, -1 );
4408 createMenu( SMESHOp::OpEqualFace, faceId, -1 );
4409 createMenu( SMESHOp::OpDeflection2D, faceId, -1 );
4410 createMenu( SMESHOp::OpAspectRatio3D, volumeId, -1 );
4411 createMenu( SMESHOp::OpVolume, volumeId, -1 );
4412 createMenu( SMESHOp::OpMaxElementLength3D, volumeId, -1 );
4413 createMenu( SMESHOp::OpBareBorderVolume, volumeId, -1 );
4414 createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4415 createMenu( SMESHOp::OpEqualVolume, volumeId, -1 );
4416 createMenu( separator(), ctrlId, -1 );
4417 createMenu( SMESHOp::OpReset, ctrlId, -1 );
4418 createMenu( separator(), ctrlId, -1 );
4419 createMenu( SMESHOp::OpOverallMeshQuality, ctrlId, -1 );
4421 createMenu( SMESHOp::OpNode, addId, -1 );
4422 createMenu( SMESHOp::OpElem0D, addId, -1 );
4423 createMenu( SMESHOp::OpElem0DOnElemNodes, addId, -1 );
4424 createMenu( SMESHOp::OpBall, addId, -1 );
4425 createMenu( SMESHOp::OpEdge, addId, -1 );
4426 createMenu( SMESHOp::OpTriangle, addId, -1 );
4427 createMenu( SMESHOp::OpQuadrangle, addId, -1 );
4428 createMenu( SMESHOp::OpPolygon, addId, -1 );
4429 createMenu( SMESHOp::OpTetrahedron, addId, -1 );
4430 createMenu( SMESHOp::OpHexahedron, addId, -1 );
4431 createMenu( SMESHOp::OpPentahedron, addId, -1 );
4432 createMenu( SMESHOp::OpPyramid, addId, -1 );
4433 createMenu( SMESHOp::OpHexagonalPrism, addId, -1 );
4434 createMenu( SMESHOp::OpPolyhedron, addId, -1 );
4435 createMenu( separator(), addId, -1 );
4436 createMenu( SMESHOp::OpQuadraticEdge, addId, -1 );
4437 createMenu( SMESHOp::OpQuadraticTriangle, addId, -1 );
4438 createMenu( SMESHOp::OpBiQuadraticTriangle , addId, -1 );
4439 createMenu( SMESHOp::OpQuadraticQuadrangle, addId, -1 );
4440 createMenu( SMESHOp::OpBiQuadraticQuadrangle, addId, -1 );
4441 createMenu( SMESHOp::OpQuadraticPolygon, addId, -1 );
4442 createMenu( SMESHOp::OpQuadraticTetrahedron, addId, -1 );
4443 createMenu( SMESHOp::OpQuadraticPyramid, addId, -1 );
4444 createMenu( SMESHOp::OpQuadraticPentahedron, addId, -1 );
4445 createMenu( SMESHOp::OpBiQuadraticPentahedron, addId, -1 );
4446 createMenu( SMESHOp::OpQuadraticHexahedron, addId, -1 );
4447 createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4449 createMenu( SMESHOp::OpRemoveNodes, removeId, -1 );
4450 createMenu( SMESHOp::OpRemoveElements, removeId, -1 );
4451 createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4452 createMenu( separator(), removeId, -1 );
4453 createMenu( SMESHOp::OpDeleteGroup, removeId, -1 );
4454 createMenu( separator(), removeId, -1 );
4455 createMenu( SMESHOp::OpClearMesh, removeId, -1 );
4457 //createMenu( SMESHOp::OpRenumberingNodes, renumId, -1 );
4458 //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4460 createMenu( SMESHOp::OpMergeNodes, transfId, -1 );
4461 createMenu( SMESHOp::OpMergeElements, transfId, -1 );
4462 createMenu( SMESHOp::OpTranslation, transfId, -1 );
4463 createMenu( SMESHOp::OpRotation, transfId, -1 );
4464 createMenu( SMESHOp::OpSymmetry, transfId, -1 );
4465 createMenu( SMESHOp::OpScale, transfId, -1 );
4466 createMenu( SMESHOp::OpOffset, transfId, -1 );
4467 createMenu( SMESHOp::OpSewing, transfId, -1 );
4468 createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4470 createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4471 createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4472 createMenu( SMESHOp::OpExtrusion, modifyId, -1 );
4473 createMenu( SMESHOp::OpExtrusionAlongAPath, modifyId, -1 );
4474 createMenu( SMESHOp::OpRevolution, modifyId, -1 );
4475 createMenu( SMESHOp::OpOrientation, modifyId, -1 );
4476 createMenu( SMESHOp::OpReorientFaces, modifyId, -1 );
4477 createMenu( SMESHOp::OpMoveNode, modifyId, -1 );
4478 createMenu( SMESHOp::OpDiagonalInversion, modifyId, -1 );
4479 createMenu( SMESHOp::OpUnionOfTwoTriangle, modifyId, -1 );
4480 createMenu( SMESHOp::OpUnionOfTriangles, modifyId, -1 );
4481 createMenu( SMESHOp::OpCuttingOfQuadrangles, modifyId, -1 );
4482 createMenu( SMESHOp::OpSplitVolumes, modifyId, -1 );
4483 createMenu( SMESHOp::OpSplitBiQuadratic, modifyId, -1 );
4484 createMenu( SMESHOp::OpSmoothing, modifyId, -1 );
4485 createMenu( SMESHOp::OpPatternMapping, modifyId, -1 );
4487 createMenu( SMESHOp::OpMinimumDistance, measureId, -1 );
4488 createMenu( SMESHOp::OpBoundingBox, measureId, -1 );
4489 createMenu( SMESHOp::OpAngle, measureId, -1 );
4490 createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4491 createMenu( SMESHOp::OpPropertiesArea, basicPropId, -1 );
4492 createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4493 createMenu( SMESHOp::OpUpdate, viewId, -1 );
4495 connect( nodeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4496 connect( edgeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4497 connect( faceMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4498 connect( volumeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4500 // ----- create toolbars --------------
4501 int meshTb = createTool( tr( "TB_MESH" ), QString( "SMESHMeshToolbar" ) ),
4502 info = createTool( tr( "TB_INFO" ), QString( "SMESHInformationToolbar" ) ),
4503 groupTb = createTool( tr( "TB_GROUP" ), QString( "SMESHGroupToolbar" ) ),
4504 ctrl0dTb = createTool( tr( "TB_CTRL0D" ), QString( "SMESHNodeControlsToolbar" ) ),
4505 ctrl1dTb = createTool( tr( "TB_CTRL1D" ), QString( "SMESHEdgeControlsToolbar" ) ),
4506 ctrl2dTb = createTool( tr( "TB_CTRL2D" ), QString( "SMESHFaceControlsToolbar" ) ),
4507 ctrl3dTb = createTool( tr( "TB_CTRL3D" ), QString( "SMESHVolumeControlsToolbar" ) ),
4508 addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ),
4509 addNonElemTb = createTool( tr( "TB_ADDNON" ), QString( "SMESHAddElementToolbar" ) ),
4510 remTb = createTool( tr( "TB_REM" ), QString( "SMESHRemoveToolbar" ) ),
4511 //renumbTb = createTool( tr( "TB_RENUMBER" ), QString( "SMESHRenumberingToolbar" ) ),
4512 transformTb = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ),
4513 modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ),
4514 measuremTb = createTool( tr( "TB_MEASUREM" ), QString( "SMESHMeasurementsToolbar" ) ),
4515 dispModeTb = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4517 createTool( SMESHOp::OpCreateMesh, meshTb );
4518 createTool( SMESHOp::OpCreateSubMesh, meshTb );
4519 createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4520 createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4521 createTool( SMESHOp::OpCopyMesh, meshTb );
4522 createTool( separator(), meshTb );
4523 createTool( SMESHOp::OpCompute, meshTb );
4524 createTool( SMESHOp::OpPreCompute, meshTb );
4525 createTool( SMESHOp::OpEvaluate, meshTb );
4526 createTool( SMESHOp::OpMeshOrder, meshTb );
4528 createTool( SMESHOp::OpCreateGroup, groupTb );
4529 createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4530 createTool( SMESHOp::OpConstructGroup, groupTb );
4531 createTool( SMESHOp::OpEditGroup, groupTb );
4533 createTool( SMESHOp::OpMeshInformation, info );
4534 //createTool( SMESHOp::OpStdInfo, meshTb );
4535 //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4536 createTool( SMESHOp::OpFindElementByPoint, info );
4538 createTool( SMESHOp::OpFreeNode, ctrl0dTb );
4539 createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4540 //createTool( SMESHOp::OpNodeConnectivityNb, ctrl0dTb );
4542 createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4543 createTool( SMESHOp::OpLength, ctrl1dTb );
4544 createTool( SMESHOp::OpConnection, ctrl1dTb );
4545 createTool( SMESHOp::OpEqualEdge, ctrl1dTb );
4547 createTool( SMESHOp::OpFreeEdge, ctrl2dTb );
4548 createTool( SMESHOp::OpFreeFace, ctrl2dTb );
4549 createTool( SMESHOp::OpBareBorderFace, ctrl2dTb );
4550 createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4551 createTool( SMESHOp::OpLength2D, ctrl2dTb );
4552 createTool( SMESHOp::OpConnection2D, ctrl2dTb );
4553 createTool( SMESHOp::OpArea, ctrl2dTb );
4554 createTool( SMESHOp::OpTaper, ctrl2dTb );
4555 createTool( SMESHOp::OpAspectRatio, ctrl2dTb );
4556 createTool( SMESHOp::OpMinimumAngle, ctrl2dTb );
4557 createTool( SMESHOp::OpWarpingAngle, ctrl2dTb );
4558 createTool( SMESHOp::OpSkew, ctrl2dTb );
4559 createTool( SMESHOp::OpMaxElementLength2D, ctrl2dTb );
4560 createTool( SMESHOp::OpEqualFace, ctrl2dTb );
4561 createTool( SMESHOp::OpDeflection2D, ctrl2dTb );
4563 createTool( SMESHOp::OpAspectRatio3D, ctrl3dTb );
4564 createTool( SMESHOp::OpVolume, ctrl3dTb );
4565 createTool( SMESHOp::OpMaxElementLength3D, ctrl3dTb );
4566 createTool( SMESHOp::OpBareBorderVolume, ctrl3dTb );
4567 createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
4568 createTool( SMESHOp::OpEqualVolume, ctrl3dTb );
4570 createTool( SMESHOp::OpNode, addElemTb );
4571 createTool( SMESHOp::OpElem0D, addElemTb );
4572 createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4573 createTool( SMESHOp::OpBall, addElemTb );
4574 createTool( SMESHOp::OpEdge, addElemTb );
4575 createTool( SMESHOp::OpTriangle, addElemTb );
4576 createTool( SMESHOp::OpQuadrangle, addElemTb );
4577 createTool( SMESHOp::OpPolygon, addElemTb );
4578 createTool( SMESHOp::OpTetrahedron, addElemTb );
4579 createTool( SMESHOp::OpHexahedron, addElemTb );
4580 createTool( SMESHOp::OpPentahedron, addElemTb );
4581 createTool( SMESHOp::OpPyramid, addElemTb );
4582 createTool( SMESHOp::OpHexagonalPrism, addElemTb );
4583 createTool( SMESHOp::OpPolyhedron, addElemTb );
4585 createTool( SMESHOp::OpQuadraticEdge, addNonElemTb );
4586 createTool( SMESHOp::OpQuadraticTriangle, addNonElemTb );
4587 createTool( SMESHOp::OpBiQuadraticTriangle, addNonElemTb );
4588 createTool( SMESHOp::OpQuadraticQuadrangle, addNonElemTb );
4589 createTool( SMESHOp::OpBiQuadraticQuadrangle, addNonElemTb );
4590 createTool( SMESHOp::OpQuadraticPolygon, addNonElemTb );
4591 createTool( SMESHOp::OpQuadraticTetrahedron, addNonElemTb );
4592 createTool( SMESHOp::OpQuadraticPyramid, addNonElemTb );
4593 createTool( SMESHOp::OpQuadraticPentahedron, addNonElemTb );
4594 createTool( SMESHOp::OpBiQuadraticPentahedron, addNonElemTb );
4595 createTool( SMESHOp::OpQuadraticHexahedron, addNonElemTb );
4596 createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4598 createTool( SMESHOp::OpRemoveNodes, remTb );
4599 createTool( SMESHOp::OpRemoveElements, remTb );
4600 createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4601 createTool( SMESHOp::OpClearMesh, remTb );
4603 //createTool( SMESHOp::OpRenumberingNodes, renumbTb );
4604 //createTool( SMESHOp::OpRenumberingElements, renumbTb );
4606 createTool( SMESHOp::OpMergeNodes, transformTb );
4607 createTool( SMESHOp::OpMergeElements, transformTb );
4608 createTool( SMESHOp::OpTranslation, transformTb );
4609 createTool( SMESHOp::OpRotation, transformTb );
4610 createTool( SMESHOp::OpSymmetry, transformTb );
4611 createTool( SMESHOp::OpScale, transformTb );
4612 createTool( SMESHOp::OpOffset, transformTb );
4613 createTool( SMESHOp::OpSewing, transformTb );
4614 createTool( SMESHOp::OpDuplicateNodes, transformTb );
4616 createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4617 createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4618 createTool( SMESHOp::OpExtrusion, modifyTb );
4619 createTool( SMESHOp::OpExtrusionAlongAPath, modifyTb );
4620 createTool( SMESHOp::OpRevolution, modifyTb );
4621 createTool( SMESHOp::OpOrientation, modifyTb );
4622 createTool( SMESHOp::OpReorientFaces, modifyTb );
4623 createTool( SMESHOp::OpMoveNode, modifyTb );
4624 createTool( SMESHOp::OpDiagonalInversion, modifyTb );
4625 createTool( SMESHOp::OpUnionOfTwoTriangle, modifyTb );
4626 createTool( SMESHOp::OpUnionOfTriangles, modifyTb );
4627 createTool( SMESHOp::OpCuttingOfQuadrangles, modifyTb );
4628 createTool( SMESHOp::OpSplitVolumes, modifyTb );
4629 createTool( SMESHOp::OpSplitBiQuadratic, modifyTb );
4630 createTool( SMESHOp::OpSmoothing, modifyTb );
4631 createTool( SMESHOp::OpPatternMapping, modifyTb );
4633 createTool( SMESHOp::OpMinimumDistance, measuremTb );
4635 createTool( SMESHOp::OpUpdate, dispModeTb );
4637 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4638 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4642 OB = "'ObjectBrowser'",
4643 View = "'" + SVTK_Viewer::Type() + "'",
4645 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4646 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4647 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4648 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4649 smesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::COMPONENT ) ),
4650 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4651 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4652 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4653 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4654 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4655 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4656 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4658 mesh_part = mesh + " " + subMesh + " " + group,
4659 mesh_group = mesh + " " + group,
4660 mesh_submesh = mesh + " " + subMesh,
4661 hyp_alg = hypo + " " + algo;
4663 // popup for object browser
4665 isInvisible("not( isVisible )"),
4666 isEmpty("numberOfNodes = 0"),
4667 isNotEmpty("numberOfNodes <> 0"),
4669 // has nodes, edges, etc in VISIBLE! actor
4670 hasNodes("(numberOfNodes > 0 ) && hasActor"),
4671 hasElems("(count( elemTypes ) > 0)"),
4672 hasDifferentElems("(count( elemTypes ) > 1)"),
4673 hasDifferentObjElems("(count( objElemTypes ) > 1)"),
4674 hasBalls("({'BallElem'} in elemTypes)"),
4675 hasElems0d("({'Elem0d'} in elemTypes)"),
4676 hasEdges("({'Edge'} in elemTypes)"),
4677 hasFaces("({'Face'} in elemTypes)"),
4678 hasVolumes("({'Volume'} in elemTypes)"),
4679 hasFacesOrVolumes("(({'Face'} in elemTypes) || ({'Volume'} in elemTypes)) ");
4681 createPopupItem( SMESHOp::OpEditMesh, OB, mesh, "&& selcount=1" );
4682 createPopupItem( SMESHOp::OpCreateSubMesh, OB, mesh, "&& hasGeomReference");
4683 createPopupItem( SMESHOp::OpMeshOrder, OB, mesh, "&& selcount=1 && hasAlgo && hasGeomReference" );
4684 createPopupItem( SMESHOp::OpEditSubMesh, OB, subMesh, "&& selcount=1 && hasGeomReference" );
4685 createPopupItem( SMESHOp::OpEditGroup, OB, group );
4686 createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4688 popupMgr()->insert( separator(), -1, 0 );
4689 createPopupItem( SMESHOp::OpCompute, OB, mesh, "&& selcount=1 && hasAlgo && isComputable" );
4690 createPopupItem( SMESHOp::OpRecompute, OB, mesh, "&& selcount=1 && hasAlgo && (" + isNotEmpty + " || hasErrors )");
4691 createPopupItem( SMESHOp::OpShowErrors, OB, mesh, "&& selcount=1 && hasErrors" );
4692 createPopupItem( SMESHOp::OpComputeSubMesh, OB, subMesh, "&& selcount=1 && hasAlgo && isComputable" );
4693 createPopupItem( SMESHOp::OpPreCompute, OB, mesh, "&& selcount=1 && hasAlgo && isPreComputable" );
4694 createPopupItem( SMESHOp::OpEvaluate, OB, mesh, "&& selcount=1 && hasAlgo && isComputable" );
4695 popupMgr()->insert( separator(), -1, 0 );
4696 createPopupItem( SMESHOp::OpFileInformation, OB, mesh, "&& selcount=1 && isImported" );
4697 createPopupItem( SMESHOp::OpMeshInformation, OB, mesh_part );
4698 createPopupItem( SMESHOp::OpFindElementByPoint,OB, mesh_group, "&& selcount=1 && " + hasElems );
4699 createPopupItem( SMESHOp::OpOverallMeshQuality,OB, mesh_part );
4700 popupMgr()->insert( separator(), -1, 0 );
4701 createPopupItem( SMESHOp::OpCreateGroup, OB, mesh, "&& selcount=1" );
4702 createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh, "&& selcount=1 && hasGeomReference" );
4703 createPopupItem( SMESHOp::OpConstructGroup, OB, subMesh );
4704 popupMgr()->insert( separator(), -1, 0 );
4705 createPopupItem( SMESHOp::OpEditHypothesis, OB, hypo, "&& isEditableHyp");
4706 createPopupItem( SMESHOp::OpUnassign, OB, hyp_alg );
4707 popupMgr()->insert( separator(), -1, 0 );
4708 createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh_submesh, "&& " + hasElems );
4709 createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh_group, "&& selcount=1 && dim>=2");
4710 //popupMgr()->insert( separator(), -1, 0 );
4712 //popupMgr()->insert( separator(), -1, 0 );
4714 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4715 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4716 QString only_one_2D = only_one_non_empty + " && dim>1";
4718 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4719 popupMgr()->findMenu( anId )->menuAction()->setIcon( resourceMgr()->loadPixmap( "SMESH", tr( "ICON_EXPORT" )));
4720 createPopupItem( SMESHOp::OpPopupExportMED, OB, mesh_group, multiple_non_empty, anId );
4721 createPopupItem( SMESHOp::OpPopupExportUNV, OB, mesh_group, only_one_non_empty, anId );
4722 createPopupItem( SMESHOp::OpPopupExportSTL, OB, mesh_group, only_one_2D, anId );
4724 createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4726 createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, only_one_non_empty, anId );
4727 createPopupItem( SMESHOp::OpPopupExportGMF, OB, mesh_group, only_one_non_empty, anId );
4728 createPopupItem( SMESHOp::OpPopupExportDAT, OB, mesh_group, only_one_non_empty, anId );
4730 anId = popupMgr()->insert( tr( "MEN_IMPORT" ), -1, -1 ); // IMPORT submenu
4731 createPopupItem( SMESHOp::OpPopupImportMED, OB, smesh, "", anId );
4732 createPopupItem( SMESHOp::OpPopupImportUNV, OB, smesh, "", anId );
4733 createPopupItem( SMESHOp::OpPopupImportSTL, OB, smesh, "", anId );
4735 createPopupItem( SMESHOp::OpPopupImportCGNS, OB, smesh, "", anId );
4737 createPopupItem( SMESHOp::OpPopupImportSAUV, OB, smesh, "", anId );
4738 createPopupItem( SMESHOp::OpPopupImportGMF, OB, smesh, "", anId );
4739 createPopupItem( SMESHOp::OpPopupImportDAT, OB, smesh, "", anId );
4740 popupMgr()->insert( separator(), -1, 0 );
4742 createPopupItem( SMESHOp::OpClearMesh, OB, mesh );
4743 createPopupItem( SMESHOp::OpDelete, OB, mesh_part + " " + hyp_alg );
4744 createPopupItem( SMESHOp::OpDeleteGroup, OB, group );
4747 createPopupItem( SMESHOp::OpEditGroup, View, group );
4748 createPopupItem( SMESHOp::OpAddElemGroupPopup, View, elems, "&& guiState = 800" );
4749 createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems, "&& guiState = 800" );
4751 popupMgr()->insert( separator(), -1, 0 );
4752 createPopupItem( SMESHOp::OpMeshInformation, View, mesh_part );
4753 createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4754 createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh, "&& " + hasElems);
4755 popupMgr()->insert( separator(), -1, 0 );
4757 createPopupItem( SMESHOp::OpUpdate, OB + " " + View, mesh_part );
4758 createPopupItem( SMESHOp::OpAutoColor, OB + " " + View, mesh, "&& (not isAutoColor)" );
4759 createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4760 popupMgr()->insert( separator(), -1, 0 );
4762 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4763 QString aType = QString( "%1type in {%2}" ).arg( lc );
4764 aType = aType.arg( mesh_part );
4765 QString aMeshInVTK = aClient + "&&" + aType;
4767 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4768 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4769 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4771 //-------------------------------------------------
4773 //-------------------------------------------------
4774 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4776 popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4777 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4778 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4780 popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4781 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4782 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4784 popupMgr()->insert( separator(), -1, -1 );
4786 //-------------------------------------------------
4788 //-------------------------------------------------
4789 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4791 popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4792 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4793 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4795 popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4796 popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4797 popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4799 popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4800 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4801 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4803 popupMgr()->insert( separator(), anId, -1 );
4805 popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4806 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4807 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4809 //-------------------------------------------------
4811 //-------------------------------------------------
4812 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4814 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4816 popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4817 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4818 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4820 popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4821 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4822 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4824 popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4825 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4826 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4828 popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4829 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4830 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4832 popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4833 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4834 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4836 popupMgr()->insert( separator(), anId, -1 );
4838 popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4839 popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&& $type in {" + mesh + "} &&" + hasDifferentObjElems, QtxPopupMgr::VisibleRule );
4841 popupMgr()->insert( separator(), anId, -1 );
4843 popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4844 popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4847 //-------------------------------------------------
4848 // Representation of the 2D Quadratic elements
4849 //-------------------------------------------------
4850 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4851 popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4852 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "&& isVisible && isQuadratic",QtxPopupMgr::VisibleRule );
4853 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4855 popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4856 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "&& isVisible && isQuadratic", QtxPopupMgr::VisibleRule );
4857 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4859 //-------------------------------------------------
4860 // Orientation of faces
4861 //-------------------------------------------------
4862 popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4863 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4864 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4866 //-------------------------------------------------
4868 //-------------------------------------------------
4869 popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4870 popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4872 //-------------------------------------------------
4874 //-------------------------------------------------
4875 popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4876 popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4878 //-------------------------------------------------
4880 //-------------------------------------------------
4882 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4883 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4884 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4885 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4887 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4889 popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4890 popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4892 popupMgr()->insert( separator(), anId, -1 );
4894 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4896 popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4897 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4898 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4900 popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4901 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4902 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4904 // popupMgr()->insert( action( SMESHOp::OpNodeConnectivityNb ), aSubId, -1 );
4905 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4906 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), "controlMode = 'eNodeConnectivityNb'", QtxPopupMgr::ToggleRule );
4908 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4910 popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4911 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVTK + "&&" + hasEdges + "&&" + hasFacesOrVolumes, QtxPopupMgr::VisibleRule );
4912 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4914 popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4915 popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4916 popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4918 popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4919 popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4920 popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4921 popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4922 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4923 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4925 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4927 popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4928 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4929 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4931 popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4932 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4933 QtxPopupMgr::VisibleRule );
4934 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4936 popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4937 popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4938 popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4940 popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4941 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4942 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4944 popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
4945 popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4946 popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4948 popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
4949 popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4950 popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4952 popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
4953 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4954 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4956 popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
4957 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4958 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4960 popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
4961 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4962 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4964 popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
4965 popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4966 popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4968 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
4969 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4970 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4972 popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
4973 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4974 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4976 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
4977 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4978 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4980 popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
4981 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4982 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4984 popupMgr()->insert ( action( SMESHOp::OpDeflection2D ), aSubId, -1 );
4985 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), aMeshInVtkHasFaces + " && hasGeomReference", QtxPopupMgr::VisibleRule );
4986 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), "controlMode = 'eDeflection2D'", QtxPopupMgr::ToggleRule );
4988 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4990 popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D ), aSubId, -1 );
4991 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4992 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4994 popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
4995 popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4996 popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4998 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
4999 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5000 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
5002 popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
5003 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5004 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
5006 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
5007 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5008 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
5010 popupMgr()->insert ( action( SMESHOp::OpEqualVolume ), aSubId, -1 );
5011 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5012 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
5014 popupMgr()->insert( separator(), anId, -1 );
5016 popupMgr()->insert( action( SMESHOp::OpShowScalarBar ), anId, -1 );
5017 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
5018 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone' && isScalarBarVisible", QtxPopupMgr::ToggleRule );
5019 popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
5020 popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
5022 popupMgr()->insert( separator(), anId, -1 );
5024 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
5026 popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
5027 popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
5029 popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
5030 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
5031 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isScalarBarVisible && isDistributionVisible", QtxPopupMgr::ToggleRule);
5033 #ifndef DISABLE_PLOT2DVIEWER
5034 popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
5035 popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
5038 //-------------------------------------------------
5040 //-------------------------------------------------
5041 popupMgr()->insert( separator(), -1, -1 );
5042 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
5043 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
5044 popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
5045 popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
5047 popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
5048 popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
5050 popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
5051 popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
5053 popupMgr()->insert( separator(), -1, -1 );
5055 //-------------------------------------------------
5057 //-------------------------------------------------
5058 popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
5059 popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
5061 popupMgr()->insert( separator(), -1, -1 );
5063 popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
5064 popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
5065 popupMgr()->insert( separator(), -1, -1 );
5067 popupMgr()->insert( action( SMESHOp::OpBreakLink), -1, -1 );
5068 popupMgr()->setRule( action( SMESHOp::OpBreakLink), "$component={'SHAPERSTUDY'} and client='ObjectBrowser' and canBreakLink", QtxPopupMgr::VisibleRule );
5070 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
5071 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
5073 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
5074 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
5077 //================================================================================
5079 * \brief Return true if SMESH or GEOM objects are selected.
5080 * Is called form LightApp_Module::activateModule() which clear selection if
5081 * not isSelectionCompatible()
5083 //================================================================================
5085 bool SMESHGUI::isSelectionCompatible()
5087 bool isCompatible = true;
5088 SALOME_ListIO selected;
5089 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
5090 Sel->selectedObjects( selected );
5092 SALOME_ListIteratorOfListIO It( selected );
5093 for ( ; isCompatible && It.More(); It.Next())
5095 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
5096 ( strcmp("SHAPERSTUDY", It.Value()->getComponentDataType()) == 0 ) ||
5097 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
5099 return isCompatible;
5103 bool SMESHGUI::reusableOperation( const int id )
5105 // compute, evaluate and precompute are not reusable operations
5106 return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate || id == SMESHOp::OpRecompute ) ? false : SalomeApp_Module::reusableOperation( id );
5111 QString wrap(const QString& text, const QString& tag)
5112 { return QString("<%1>%2</%3>").arg(tag).arg(text).arg(tag);}
5115 bool SMESHGUI::activateModule( SUIT_Study* study )
5117 bool res = SalomeApp_Module::activateModule( study );
5119 setMenuShown( true );
5120 setToolShown( true );
5122 // Fill in Help Panel
5123 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( application() );
5124 app->infoPanel()->setTitle(tr("INFO_WELCOME_TO_SMESH"));
5126 int gb = app->infoPanel()->addGroup(tr("INFO_GRP_CREATE_MESH"));
5129 lab = tr("INFO_DEFINE_ALGOS") + "<br/>";
5130 lab = lab + tr("INFO_DEFINE_HYPOS") + "<br/>";
5131 lab = lab + tr("INFO_COMPUTE") + "<br/>";
5132 lab = lab + tr("INFO_REFINE") + ":";
5133 items << wrap(tr("INFO_REFINE_LOCAL_SIZE"), "li")
5134 << wrap(tr("INFO_REFINE_SUBMESH"), "li");
5135 lab = lab + wrap(items.join(""), "ul");
5138 app->infoPanel()->addLabel(lab, gb);
5140 gb = app->infoPanel()->addGroup(tr("INFO_GRP_IMPORT_MESH"));
5141 items << wrap("UNV", "li")
5142 << wrap("MED", "li")
5143 << wrap("STL", "li")
5144 << wrap("CGNS", "li")
5145 << wrap("SAUV", "li")
5146 << wrap("GMF", "li");
5147 lab = tr("INFO_AVAILABLE_FORMATS") + ":" + wrap(items.join(""), "ul");
5150 app->infoPanel()->addLabel(lab, gb);
5152 gb = app->infoPanel()->addGroup(tr("INFO_GRP_CHECK_MESH"));
5153 lab = tr("INFO_DISPLAY") + "<br/>";
5154 items << wrap(tr("INFO_QUALITY_AREA"), "li")
5155 << wrap(tr("INFO_QUALITY_VOLUME"), "li")
5156 << wrap(tr("INFO_QUALITY_ASPECT_RATION"), "li")
5157 << wrap("...", "li");
5158 lab = lab + tr("INFO_QUALITY_INFO") + ":" + wrap(items.join(""), "ul");
5160 lab = lab + tr("INFO_CLIPPING");
5162 app->infoPanel()->addLabel(lab, gb);
5165 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
5166 PyGILState_STATE gstate = PyGILState_Ensure();
5167 PyObject* pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
5168 if ( !pluginsmanager ) {
5172 PyObject* result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toUtf8().data(),tr("SMESH_PLUGINS_OTHER").toUtf8().data());
5177 PyGILState_Release(gstate);
5178 // end of SMESH plugins loading
5180 // Reset actions accelerator keys
5181 action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
5183 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
5184 GetSMESHGen()->UpdateStudy();
5186 // get all view currently opened in the study and connect their signals to
5187 // the corresponding slots of the class.
5188 SUIT_Desktop* aDesk = study->application()->desktop();
5190 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
5191 SUIT_ViewWindow* wnd;
5192 foreach ( wnd, wndList )
5196 // remove actors whose objects are removed in GetSMESHGen()->UpdateStudy()
5197 SMESH::UpdateActorsAfterUpdateStudy(wnd);
5203 Py_XDECREF(pluginsmanager);
5207 bool SMESHGUI::deactivateModule( SUIT_Study* study )
5209 setMenuShown( false );
5210 setToolShown( false );
5212 EmitSignalCloseAllDialogs();
5214 // Unset actions accelerator keys
5215 action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
5217 return SalomeApp_Module::deactivateModule( study );
5220 void SMESHGUI::studyClosed( SUIT_Study* s )
5224 SMESH::RemoveVisuData();
5225 SalomeApp_Module::studyClosed( s );
5228 void SMESHGUI::OnGUIEvent()
5230 const QObject* obj = sender();
5231 if ( !obj || !obj->inherits( "QAction" ) )
5233 int id = actionId((QAction*)obj);
5238 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
5240 if ( CORBA::is_nil( myComponentSMESH ) )
5242 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
5243 return aGUI.myComponentSMESH;
5245 return myComponentSMESH;
5248 QString SMESHGUI::engineIOR() const
5250 CORBA::ORB_var anORB = getApp()->orb();
5251 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
5252 return QString( anIOR.in() );
5255 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
5257 SalomeApp_Module::contextMenuPopup( client, menu, title );
5259 selectionMgr()->selectedObjects( lst );
5260 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
5261 Handle(SALOME_InteractiveObject) io = lst.First();
5262 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
5263 _PTR(Study) study = appStudy->studyDS();
5264 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
5266 QString aName = SMESH::fromUtf8( obj->GetName());
5267 while ( !aName.isEmpty() && aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
5268 aName.remove(( aName.length() - 1 ), 1 );
5274 LightApp_Selection* SMESHGUI::createSelection() const
5276 return new SMESHGUI_Selection();
5279 void SMESHGUI::windows( QMap<int, int>& aMap ) const
5281 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
5282 aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
5283 aMap.insert( SalomeApp_Application::WT_InfoPanel, Qt::RightDockWidgetArea);
5284 #ifndef DISABLE_PYCONSOLE
5285 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
5289 void SMESHGUI::viewManagers( QStringList& list ) const
5291 list.append( SVTK_Viewer::Type() );
5294 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
5296 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
5297 SMESH::UpdateSelectionProp( this );
5299 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
5300 for(int i = 0; i < aViews.count() ; i++){
5301 SUIT_ViewWindow *sf = aViews[i];
5304 EmitSignalActivatedViewManager();
5308 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
5310 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
5311 myClippingPlaneInfoMap.erase( theViewManager );
5314 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
5316 theActor->AddObserver( SMESH::DeleteActorEvent,
5317 myEventCallbackCommand.GetPointer(),
5321 void SMESHGUI::ProcessEvents( vtkObject* theObject,
5322 unsigned long theEvent,
5323 void* theClientData,
5324 void* /*theCallData*/ )
5326 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
5327 if( theObject && (int) theEvent == SMESH::DeleteActorEvent ) {
5328 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
5329 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
5330 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
5331 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
5332 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
5333 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
5334 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
5335 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
5336 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
5337 SMESH::TActorList::iterator anIter3 = anActorList.begin();
5338 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
5339 if( anActor == *anIter3 ) {
5340 anActorList.erase( anIter3 );
5351 void SMESHGUI::createPreferences()
5353 // General tab ------------------------------------------------------------------------
5354 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
5356 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
5357 setPreferenceProperty( autoUpdate, "columns", 2 );
5358 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
5359 setPreferenceProperty( lim, "min", 0 );
5360 setPreferenceProperty( lim, "max", 100000000 );
5361 setPreferenceProperty( lim, "step", 1000 );
5362 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5363 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
5365 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
5366 setPreferenceProperty( dispgroup, "columns", 2 );
5368 addPreference( tr( "PREF_FITALL_ON_DISPLAYONLY" ), dispgroup, LightApp_Preferences::Bool, "SMESH", "fitall_on_displayonly" );
5370 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
5372 modes.append( tr("MEN_WIRE") );
5373 modes.append( tr("MEN_SHADE") );
5374 modes.append( tr("MEN_NODES") );
5375 modes.append( tr("MEN_SHRINK") );
5376 QList<QVariant> indices;
5377 indices.append( 0 );
5378 indices.append( 1 );
5379 indices.append( 2 );
5380 indices.append( 3 );
5381 setPreferenceProperty( dispmode, "strings", modes );
5382 setPreferenceProperty( dispmode, "indexes", indices );
5384 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
5385 setPreferenceProperty( arcgroup, "columns", 2 );
5386 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
5387 QStringList quadraticModes;
5388 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
5389 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
5391 indices.append( 0 );
5392 indices.append( 1 );
5393 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
5394 setPreferenceProperty( quadraticmode, "indexes", indices );
5396 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
5397 "SMESH", "max_angle" );
5398 setPreferenceProperty( maxAngle, "min", 1 );
5399 setPreferenceProperty( maxAngle, "max", 90 );
5401 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
5402 setPreferenceProperty( qaGroup, "columns", 2 );
5403 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
5404 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
5405 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
5406 setPreferenceProperty( prec, "min", 0 );
5407 setPreferenceProperty( prec, "max", 100 );
5408 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
5409 setPreferenceProperty( doubleNodesTol, "precision", 10 );
5410 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
5411 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
5412 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
5415 int cinc = addPreference(tr("PREF_CONTROLS_INCREMENT"), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_increment");
5416 setPreferenceProperty( cinc, "min", 0 );
5417 setPreferenceProperty( cinc, "max", 5 );
5420 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
5421 setPreferenceProperty( exportgroup, "columns", 2 );
5422 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
5423 addPreference( tr( "PREF_SHOW_WARN" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "show_warning" );
5424 int zTol = addPreference( tr( "PREF_ZTOLERANCE" ), exportgroup, LightApp_Preferences::DblSpin, "SMESH", "med_ztolerance" );
5425 setPreferenceProperty( zTol, "precision", 10 );
5426 setPreferenceProperty( zTol, "min", 0.0000000001 );
5427 setPreferenceProperty( zTol, "max", 1000000.0 );
5428 setPreferenceProperty( zTol, "step", 1. );
5429 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
5431 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
5432 setPreferenceProperty( computeGroup, "columns", 2 );
5433 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
5435 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5436 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5437 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5439 indices.append( 0 );
5440 indices.append( 1 );
5441 indices.append( 2 );
5442 setPreferenceProperty( notifyMode, "strings", modes );
5443 setPreferenceProperty( notifyMode, "indexes", indices );
5445 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5446 setPreferenceProperty( infoGroup, "columns", 2 );
5447 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5449 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5450 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5452 indices.append( 0 );
5453 indices.append( 1 );
5454 setPreferenceProperty( elemInfo, "strings", modes );
5455 setPreferenceProperty( elemInfo, "indexes", indices );
5456 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5457 setPreferenceProperty( nodesLim, "min", 0 );
5458 setPreferenceProperty( nodesLim, "max", 10000000 );
5459 setPreferenceProperty( nodesLim, "step", 10000 );
5460 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5461 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5462 setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5463 setPreferenceProperty( ctrlLim, "min", 0 );
5464 setPreferenceProperty( ctrlLim, "max", 10000000 );
5465 setPreferenceProperty( ctrlLim, "step", 1000 );
5466 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5467 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5468 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5469 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5470 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5472 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5473 setPreferenceProperty( segGroup, "columns", 2 );
5474 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5475 "SMESH", "segmentation" );
5476 setPreferenceProperty( segLen, "min", 1 );
5477 setPreferenceProperty( segLen, "max", 10000000 );
5478 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5479 "SMESH", "nb_segments_per_edge" );
5480 setPreferenceProperty( nbSeg, "min", 1 );
5481 setPreferenceProperty( nbSeg, "max", 10000000 );
5482 addPreference( tr( "PREF_USE_MESHGEMS_HYPOSET" ), segGroup, LightApp_Preferences::Bool, "SMESH", "use-meshgems-hypo-sets" );
5484 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5485 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5486 "SMESH", "forget_mesh_on_hyp_modif" );
5489 // Quantities with individual precision settings
5490 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5491 setPreferenceProperty( precGroup, "columns", 2 );
5493 const int nbQuantities = 6;
5494 int precs[nbQuantities], ii = 0;
5495 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5496 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5497 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5498 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5499 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5500 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5501 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5502 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5503 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5504 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5505 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5506 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5508 // Set property for precision value for spinboxes
5509 for ( ii = 0; ii < nbQuantities; ii++ ){
5510 setPreferenceProperty( precs[ii], "min", -14 );
5511 setPreferenceProperty( precs[ii], "max", 14 );
5512 setPreferenceProperty( precs[ii], "precision", 2 );
5515 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5516 setPreferenceProperty( previewGroup, "columns", 2 );
5517 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5518 setPreferenceProperty( chunkSize, "min", 1 );
5519 setPreferenceProperty( chunkSize, "max", 1000 );
5520 setPreferenceProperty( chunkSize, "step", 50 );
5522 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5523 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5525 // Mesh tab ------------------------------------------------------------------------
5526 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5527 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5528 setPreferenceProperty( nodeGroup, "columns", 3 );
5530 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5532 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5534 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5535 QList<QVariant> aMarkerTypeIndicesList;
5536 QList<QVariant> aMarkerTypeIconsList;
5537 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5538 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5539 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5540 aMarkerTypeIndicesList << i;
5541 aMarkerTypeIconsList << pixmap;
5543 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5544 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
5546 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5548 QList<QVariant> aMarkerScaleIndicesList;
5549 QStringList aMarkerScaleValuesList;
5550 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5551 aMarkerScaleIndicesList << i;
5552 //aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5553 aMarkerScaleValuesList << QString::number( i );
5555 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5556 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5558 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5559 //setPreferenceProperty( elemGroup, "columns", 2 );
5561 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5562 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5563 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5564 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5565 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5566 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5567 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5568 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5569 addPreference( tr( "PREF_PREVIEW_COLOR" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5572 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5573 setPreferenceProperty( grpGroup, "columns", 2 );
5575 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5576 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5578 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5579 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5580 /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5581 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5582 double ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5583 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5584 double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5585 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5586 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
5587 LightApp_Preferences::IntSpin, "SMESH", "element_width");
5588 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5589 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5590 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5591 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5593 setPreferenceProperty( size0d, "min", 1 );
5594 setPreferenceProperty( size0d, "max", 10 );
5596 // setPreferenceProperty( ballSize, "min", 1 );
5597 // setPreferenceProperty( ballSize, "max", 10 );
5599 setPreferenceProperty( ballDiameter, "min", 1e-7 );
5600 setPreferenceProperty( ballDiameter, "max", 1e9 );
5601 setPreferenceProperty( ballDiameter, "step", 0.1 );
5603 setPreferenceProperty( ballScale, "min", 1e-2 );
5604 setPreferenceProperty( ballScale, "max", 1e7 );
5605 setPreferenceProperty( ballScale, "step", 0.5 );
5607 setPreferenceProperty( elemW, "min", 1 );
5608 setPreferenceProperty( elemW, "max", 5 );
5610 setPreferenceProperty( outW, "min", 1 );
5611 setPreferenceProperty( outW, "max", 5 );
5613 setPreferenceProperty( shrink, "min", 0 );
5614 setPreferenceProperty( shrink, "max", 100 );
5616 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5617 setPreferenceProperty( numGroup, "columns", 2 );
5619 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5620 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5622 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5623 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5625 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5626 setPreferenceProperty( orientGroup, "columns", 1 );
5628 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5629 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5631 setPreferenceProperty( orientScale, "min", 0.05 );
5632 setPreferenceProperty( orientScale, "max", 0.5 );
5633 setPreferenceProperty( orientScale, "step", 0.05 );
5635 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5637 // Selection tab ------------------------------------------------------------------------
5638 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5640 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5641 setPreferenceProperty( selGroup, "columns", 2 );
5643 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5644 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5646 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5647 setPreferenceProperty( preGroup, "columns", 2 );
5649 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5651 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5652 setPreferenceProperty( precSelGroup, "columns", 2 );
5654 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5655 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5656 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5658 int sinc = addPreference(tr("PREF_SELECTION_INCREMENT"), selTab, LightApp_Preferences::IntSpin, "SMESH", "selection_increment");
5659 setPreferenceProperty( sinc, "min", 0 );
5660 setPreferenceProperty( sinc, "max", 5 );
5662 // Scalar Bar tab ------------------------------------------------------------------------
5663 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5664 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5665 setPreferenceProperty( fontGr, "columns", 2 );
5667 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5668 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5670 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5671 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5673 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5674 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5676 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5677 setPreferenceProperty( numcol, "min", 2 );
5678 setPreferenceProperty( numcol, "max", 256 );
5680 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5681 setPreferenceProperty( numlab, "min", 2 );
5682 setPreferenceProperty( numlab, "max", 65 );
5684 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5685 setPreferenceProperty( orientGr, "columns", 2 );
5686 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5687 QStringList orients;
5688 orients.append( tr( "SMESH_VERTICAL" ) );
5689 orients.append( tr( "SMESH_HORIZONTAL" ) );
5690 indices.clear(); indices.append( 0 ); indices.append( 1 );
5691 setPreferenceProperty( orient, "strings", orients );
5692 setPreferenceProperty( orient, "indexes", indices );
5694 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5695 setPreferenceProperty( posVSizeGr, "columns", 2 );
5696 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5697 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5698 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5699 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5700 setPreferenceProperty( xv, "step", 0.1 );
5701 setPreferenceProperty( xv, "min", 0.0 );
5702 setPreferenceProperty( xv, "max", 1.0 );
5703 setPreferenceProperty( yv, "step", 0.1 );
5704 setPreferenceProperty( yv, "min", 0.0 );
5705 setPreferenceProperty( yv, "max", 1.0 );
5706 setPreferenceProperty( wv, "step", 0.1 );
5707 setPreferenceProperty( wv, "min", 0.0 );
5708 setPreferenceProperty( wv, "max", 1.0 );
5709 setPreferenceProperty( hv, "min", 0.0 );
5710 setPreferenceProperty( hv, "max", 1.0 );
5711 setPreferenceProperty( hv, "step", 0.1 );
5713 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5714 setPreferenceProperty( posHSizeGr, "columns", 2 );
5715 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5716 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5717 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5718 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5719 setPreferenceProperty( xv, "min", 0.0 );
5720 setPreferenceProperty( xv, "max", 1.0 );
5721 setPreferenceProperty( xv, "step", 0.1 );
5722 setPreferenceProperty( xh, "min", 0.0 );
5723 setPreferenceProperty( xh, "max", 1.0 );
5724 setPreferenceProperty( xh, "step", 0.1 );
5725 setPreferenceProperty( yh, "min", 0.0 );
5726 setPreferenceProperty( yh, "max", 1.0 );
5727 setPreferenceProperty( yh, "step", 0.1 );
5728 setPreferenceProperty( wh, "min", 0.0 );
5729 setPreferenceProperty( wh, "max", 1.0 );
5730 setPreferenceProperty( wh, "step", 0.1 );
5731 setPreferenceProperty( hh, "min", 0.0 );
5732 setPreferenceProperty( hh, "max", 1.0 );
5733 setPreferenceProperty( hh, "step", 0.1 );
5735 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5736 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5737 setPreferenceProperty( distributionGr, "columns", 3 );
5739 types.append( tr( "SMESH_MONOCOLOR" ) );
5740 types.append( tr( "SMESH_MULTICOLOR" ) );
5741 indices.clear(); indices.append( 0 ); indices.append( 1 );
5742 setPreferenceProperty( coloringType, "strings", types );
5743 setPreferenceProperty( coloringType, "indexes", indices );
5744 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5748 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5750 if ( sect=="SMESH" ) {
5751 float sbX1 = 0.01, sbY1 = 0.01, sbW = 0.08, sbH = 0.08;
5752 float aTol = 1.00000009999999;
5753 std::string aWarning;
5754 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5756 if ( name == "selection_object_color" ||
5757 name == "selection_element_color" ||
5758 name == "highlight_color" ||
5759 name == "selection_precision_node" ||
5760 name == "selection_precision_element" ||
5761 name == "selection_precision_object" ||
5762 name == "selection_increment")
5764 SMESH::UpdateSelectionProp( this );
5766 else if (name == "scalar_bar_vertical_x" || name == "scalar_bar_vertical_width")
5768 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5769 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5770 if ( sbX1+sbW > aTol ) {
5771 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5774 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5775 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5778 else if (name == "scalar_bar_vertical_y" || name == "scalar_bar_vertical_height" )
5780 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5781 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5782 if ( sbY1 + sbH > aTol ) {
5783 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5784 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5785 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5788 else if (name == "scalar_bar_horizontal_x" || name == "scalar_bar_horizontal_width")
5790 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5791 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5792 if ( sbX1 + sbW > aTol ) {
5793 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5796 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5797 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5800 else if (name == "scalar_bar_horizontal_y" || name == "scalar_bar_horizontal_height")
5802 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5803 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5804 if ( sbY1 + sbH > aTol ) {
5805 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5808 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5809 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5812 else if ( name == "segmentation" )
5814 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5815 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5817 else if ( name == "nb_segments_per_edge" )
5819 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5820 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5822 else if ( name == "historical_python_dump" || name == "forget_mesh_on_hyp_modif" || name == "default_grp_color" )
5824 QString val = aResourceMgr->stringValue( "SMESH", name );
5825 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5827 else if ( name == "numbering_node_color" || name == "numbering_node_font" )
5829 SMESH::UpdateFontProp( this );
5831 else if ( name == "numbering_elem_color" || name == "numbering_elem_font" )
5833 SMESH::UpdateFontProp( this );
5836 if ( aWarning.size() != 0 ) {
5837 aWarning += "The default values are applied instead.";
5838 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5839 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5840 QObject::tr(aWarning.c_str()));
5845 //================================================================================
5847 * \brief Update something in accordance with update flags
5848 * \param theFlags - update flags
5850 * Update viewer or/and object browser etc. in accordance with update flags ( see
5851 * LightApp_UpdateFlags enumeration ).
5853 //================================================================================
5854 void SMESHGUI::update( const int flags )
5856 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5857 SMESH::UpdateView();
5859 SalomeApp_Module::update( flags );
5862 //================================================================================
5864 * \brief Set default selection mode
5866 * SLOT called when operation committed. Sets default selection mode
5868 //================================================================================
5869 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5871 SVTK_ViewWindow* vtkWnd =
5872 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5874 vtkWnd->SetSelectionMode( ActorSelection );
5877 //================================================================================
5879 * \brief Set default selection mode
5881 * SLOT called when operation aborted. Sets default selection mode
5883 //================================================================================
5884 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5886 SVTK_ViewWindow* vtkWnd =
5887 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5889 vtkWnd->SetSelectionMode( ActorSelection );
5892 //================================================================================
5894 * \brief Creates operation with given identifier
5895 * \param id - identifier of operation to be started
5896 * \return Pointer on created operation or NULL if operation is not created
5898 * Virtual method redefined from the base class creates operation with given id.
5899 * It is called called automatically from startOperation method of base class.
5901 //================================================================================
5902 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5904 LightApp_Operation* op = 0;
5905 // to do : create operation here
5908 case SMESHOp::OpSplitBiQuadratic:
5909 op = new SMESHGUI_SplitBiQuadOp();
5911 case SMESHOp::OpConvertMeshToQuadratic:
5912 op = new SMESHGUI_ConvToQuadOp();
5914 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5915 op = new SMESHGUI_Make2DFrom3DOp();
5917 case SMESHOp::OpReorientFaces:
5918 op = new SMESHGUI_ReorientFacesOp();
5920 case SMESHOp::OpCreateMesh:
5921 op = new SMESHGUI_MeshOp( true, true );
5923 case SMESHOp::OpCreateSubMesh:
5924 op = new SMESHGUI_MeshOp( true, false );
5926 case SMESHOp::OpEditMeshOrSubMesh:
5927 case SMESHOp::OpEditMesh:
5928 case SMESHOp::OpEditSubMesh:
5929 op = new SMESHGUI_MeshOp( false );
5931 case SMESHOp::OpCompute:
5932 case SMESHOp::OpComputeSubMesh:
5933 op = new SMESHGUI_ComputeOp();
5935 case SMESHOp::OpShowErrors:
5936 op = new SMESHGUI_ShowErrorsOp();
5938 case SMESHOp::OpPreCompute:
5939 op = new SMESHGUI_PrecomputeOp();
5941 case SMESHOp::OpEvaluate:
5942 op = new SMESHGUI_EvaluateOp();
5944 case SMESHOp::OpMeshOrder:
5945 op = new SMESHGUI_MeshOrderOp();
5947 case SMESHOp::OpCreateGeometryGroup:
5948 op = new SMESHGUI_GroupOnShapeOp();
5950 case SMESHOp::OpFindElementByPoint:
5951 op = new SMESHGUI_FindElemByPointOp();
5953 case SMESHOp::OpMoveNode: // Make mesh pass through point
5954 op = new SMESHGUI_MakeNodeAtPointOp();
5956 case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
5957 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5964 op = SalomeApp_Module::createOperation( id );
5968 //================================================================================
5970 * \brief Stops current operations and starts a given one
5971 * \param id - The id of the operation to start
5973 //================================================================================
5975 void SMESHGUI::switchToOperation(int id)
5977 activeStudy()->abortAllOperations();
5978 startOperation( id );
5981 LightApp_Displayer* SMESHGUI::displayer()
5984 myDisplayer = new SMESHGUI_Displayer( getApp() );
5988 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5991 int aTolerance = 64;
5992 int anIterations = 0;
5998 if( anIterations % aPeriod == 0 )
6001 if( aTolerance < 1 )
6005 aHue = (int)( 360.0 * rand() / RAND_MAX );
6008 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
6009 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
6010 for( ; it != itEnd; ++it )
6012 SALOMEDS::Color anAutoColor = *it;
6013 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
6016 aQColor.getHsv( &h, &s, &v );
6017 if( abs( h - aHue ) < aTolerance )
6029 aColor.setHsv( aHue, 255, 255 );
6031 SALOMEDS::Color aSColor;
6032 aSColor.R = aColor.redF();
6033 aSColor.G = aColor.greenF();
6034 aSColor.B = aColor.blueF();
6039 const char* gSeparator = "_"; // character used to separate parameter names
6040 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
6041 const char* gPathSep = "|"; // character used to separate paths
6044 * \brief Store visual parameters
6046 * This method is called just before the study document is saved.
6047 * Store visual parameters in AttributeParameter attribute(s)
6049 void SMESHGUI::storeVisualParameters (int savePoint)
6052 Kernel_Utils::Localizer loc;
6054 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6055 if (!appStudy || !appStudy->studyDS())
6057 _PTR(Study) studyDS = appStudy->studyDS();
6059 // componentName is used for encoding of entries when storing them in IParameters
6060 std::string componentName = myComponentSMESH->ComponentDataType();
6061 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
6062 //if (!aSComponent) return;
6065 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6066 componentName.c_str(),
6068 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6070 // store custom markers
6071 if( !myMarkerMap.empty() )
6073 VTK::MarkerMap::const_iterator anIter = myMarkerMap.begin();
6074 for( ; anIter != myMarkerMap.end(); anIter++ )
6076 int anId = anIter->first;
6077 VTK::MarkerData aMarkerData = anIter->second;
6078 std::string aMarkerFileName = aMarkerData.first;
6079 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
6080 if( aMarkerTexture.size() < 3 )
6081 continue; // should contain at least width, height and the first value
6083 QString aPropertyName( "texture" );
6084 aPropertyName += gSeparator;
6085 aPropertyName += QString::number( anId );
6087 QString aPropertyValue = aMarkerFileName.c_str();
6088 aPropertyValue += gPathSep;
6090 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
6091 ushort aWidth = *aTextureIter++;
6092 ushort aHeight = *aTextureIter++;
6093 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
6094 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
6095 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
6096 aPropertyValue += QString::number( *aTextureIter );
6098 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
6102 // viewers counters are used for storing view_numbers in IParameters
6105 // main cycle to store parameters of displayed objects
6106 QList<SUIT_ViewManager*> lst;
6107 QList<SUIT_ViewManager*>::Iterator it;
6108 getApp()->viewManagers(lst);
6109 for (it = lst.begin(); it != lst.end(); it++)
6111 SUIT_ViewManager* vman = *it;
6112 QString vType = vman->getType();
6114 // saving VTK actors properties
6115 if (vType == SVTK_Viewer::Type())
6117 // store the clipping planes attached to the view manager
6118 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
6119 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
6120 if( anIter != myClippingPlaneInfoMap.end() )
6121 aClippingPlaneInfoList = anIter->second;
6123 if( !aClippingPlaneInfoList.empty() ) {
6124 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
6125 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
6127 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
6128 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
6130 QString aPropertyName( "ClippingPlane" );
6131 aPropertyName += gSeparator;
6132 aPropertyName += QString::number( vtkViewers );
6133 aPropertyName += gSeparator;
6134 aPropertyName += QString::number( anId );
6136 QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
6137 aPropertyValue += gDigitsSep;
6138 aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
6139 aPropertyValue += gDigitsSep;
6140 if ( aPlane->PlaneMode == SMESH::Absolute ) {
6141 aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
6142 aPropertyValue += gDigitsSep;
6143 aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
6144 aPropertyValue += gDigitsSep;
6145 aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
6146 aPropertyValue += gDigitsSep;
6147 aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
6148 aPropertyValue += gDigitsSep;
6149 aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
6150 aPropertyValue += gDigitsSep;
6151 aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
6152 aPropertyValue += gDigitsSep;
6153 aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
6155 else if ( aPlane->PlaneMode == SMESH::Relative ) {
6156 aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
6157 aPropertyValue += gDigitsSep;
6158 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
6159 aPropertyValue += gDigitsSep;
6160 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
6161 aPropertyValue += gDigitsSep;
6162 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
6165 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
6169 QVector<SUIT_ViewWindow*> views = vman->getViews();
6170 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
6172 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
6174 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
6175 vtkActorCollection* allActors = aCopy.GetActors();
6176 allActors->InitTraversal();
6177 while (vtkActor* actor = allActors->GetNextActor())
6179 if (actor->GetVisibility()) // store only visible actors
6181 SMESH_Actor* aSmeshActor = 0;
6182 if (actor->IsA("SMESH_Actor"))
6183 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
6184 if (aSmeshActor && aSmeshActor->hasIO())
6186 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
6189 // entry is "encoded" = it does NOT contain component address,
6190 // since it is a subject to change on next component loading
6191 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
6193 std::string param, vtkParam = vType.toLatin1().data();
6194 vtkParam += gSeparator;
6195 vtkParam += QString::number(vtkViewers).toLatin1().data();
6196 vtkParam += gSeparator;
6199 param = vtkParam + "Visibility";
6200 ip->setParameter(entry, param, "On");
6203 param = vtkParam + "Representation";
6204 ip->setParameter(entry, param, QString::number
6205 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
6208 param = vtkParam + "IsShrunk";
6209 ip->setParameter(entry, param, QString::number
6210 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
6212 // Displayed entities
6213 unsigned int aMode = aSmeshActor->GetEntityMode();
6214 bool isE = aMode & SMESH_Actor::eEdges;
6215 bool isF = aMode & SMESH_Actor::eFaces;
6216 bool isV = aMode & SMESH_Actor::eVolumes;
6217 bool is0d = aMode & SMESH_Actor::e0DElements;
6218 bool isB = aMode & SMESH_Actor::eBallElem;
6220 QString modeStr ("e");
6221 modeStr += gDigitsSep; modeStr += QString::number(isE);
6222 modeStr += gDigitsSep; modeStr += "f";
6223 modeStr += gDigitsSep; modeStr += QString::number(isF);
6224 modeStr += gDigitsSep; modeStr += "v";
6225 modeStr += gDigitsSep; modeStr += QString::number(isV);
6226 modeStr += gDigitsSep; modeStr += "0d";
6227 modeStr += gDigitsSep; modeStr += QString::number(is0d);
6228 modeStr += gDigitsSep; modeStr += "b";
6229 modeStr += gDigitsSep; modeStr += QString::number(isB);
6231 param = vtkParam + "Entities";
6232 ip->setParameter(entry, param, modeStr.toLatin1().data());
6238 aSmeshActor->GetSufaceColor(r, g, b, delta);
6239 QStringList colorStr;
6240 colorStr << "surface";
6241 colorStr << QString::number(r);
6242 colorStr << QString::number(g);
6243 colorStr << QString::number(b);
6245 colorStr << "backsurface";
6246 colorStr << QString::number(delta);
6248 aSmeshActor->GetVolumeColor(r, g, b, delta);
6249 colorStr << "volume";
6250 colorStr << QString::number(r);
6251 colorStr << QString::number(g);
6252 colorStr << QString::number(b);
6253 colorStr << QString::number(delta);
6255 aSmeshActor->GetEdgeColor(r, g, b);
6257 colorStr << QString::number(r);
6258 colorStr << QString::number(g);
6259 colorStr << QString::number(b);
6261 aSmeshActor->GetNodeColor(r, g, b);
6263 colorStr << QString::number(r);
6264 colorStr << QString::number(g);
6265 colorStr << QString::number(b);
6267 aSmeshActor->GetOutlineColor(r, g, b);
6268 colorStr << "outline";
6269 colorStr << QString::number(r);
6270 colorStr << QString::number(g);
6271 colorStr << QString::number(b);
6273 aSmeshActor->Get0DColor(r, g, b);
6274 colorStr << "elem0d";
6275 colorStr << QString::number(r);
6276 colorStr << QString::number(g);
6277 colorStr << QString::number(b);
6279 aSmeshActor->GetBallColor(r, g, b);
6281 colorStr << QString::number(r);
6282 colorStr << QString::number(g);
6283 colorStr << QString::number(b);
6285 aSmeshActor->GetFacesOrientationColor(r, g, b);
6286 colorStr << "orientation";
6287 colorStr << QString::number(r);
6288 colorStr << QString::number(g);
6289 colorStr << QString::number(b);
6291 param = vtkParam + "Colors";
6292 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
6295 QStringList sizeStr;
6297 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
6298 sizeStr << "outline";
6299 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
6300 sizeStr << "elem0d";
6301 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
6303 //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
6304 sizeStr << QString::number((double)aSmeshActor->GetBallSize());
6305 sizeStr << QString::number((double)aSmeshActor->GetBallScale());
6306 sizeStr << "shrink";
6307 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
6308 sizeStr << "orientation";
6309 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
6310 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
6312 param = vtkParam + "Sizes";
6313 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
6318 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
6319 if( aMarkerType == VTK::MT_USER ) {
6320 markerStr += "custom";
6321 markerStr += gDigitsSep;
6322 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
6326 markerStr += gDigitsSep;
6327 markerStr += QString::number( (int)aMarkerType );
6328 markerStr += gDigitsSep;
6329 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
6332 param = vtkParam + "PointMarker";
6333 ip->setParameter(entry, param, markerStr.toLatin1().data());
6336 param = vtkParam + "Opacity";
6337 ip->setParameter(entry, param,
6338 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
6341 param = vtkParam + "ClippingPlane";
6343 if( !aClippingPlaneInfoList.empty() ) {
6344 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
6345 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
6347 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
6348 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
6349 SMESH::TActorList::iterator anIter2 = anActorList.begin();
6350 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
6351 if( aSmeshActor == *anIter2 ) {
6352 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
6353 QString::number( anId ).toLatin1().constData() );
6360 ip->setParameter( entry, param, "Off" );
6361 } // if (io->hasEntry())
6362 } // SMESH_Actor && hasIO
6364 } // while.. actors traversal
6368 } // if (SVTK view model)
6369 } // for (viewManagers)
6372 // data structures for clipping planes processing
6376 bool isOpenGLClipping;
6377 vtkIdType RelativeOrientation;
6380 int AbsoluteOrientation;
6381 double X, Y, Z, Dx, Dy, Dz;
6383 typedef std::list<TPlaneData> TPlaneDataList;
6384 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
6386 typedef std::list<vtkActor*> TActorList;
6389 TActorList ActorList;
6390 SUIT_ViewManager* ViewManager;
6392 typedef std::list<TPlaneInfo> TPlaneInfoList;
6393 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
6396 * \brief Restore visual parameters
6398 * This method is called after the study document is opened.
6399 * Restore visual parameters from AttributeParameter attribute(s)
6401 void SMESHGUI::restoreVisualParameters (int savePoint)
6404 Kernel_Utils::Localizer loc;
6406 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6407 if (!appStudy || !appStudy->studyDS())
6409 _PTR(Study) studyDS = appStudy->studyDS();
6411 // componentName is used for encoding of entries when storing them in IParameters
6412 std::string componentName = myComponentSMESH->ComponentDataType();
6415 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6416 componentName.c_str(),
6418 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6420 // restore custom markers and map of clipping planes
6421 TPlaneDataMap aPlaneDataMap;
6423 std::vector<std::string> properties = ip->getProperties();
6424 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
6426 std::string property = *propIt;
6427 QString aPropertyName( property.c_str() );
6428 QString aPropertyValue( ip->getProperty( property ).c_str() );
6430 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
6431 if( aPropertyNameList.isEmpty() )
6434 QString aPropertyType = aPropertyNameList[0];
6435 if( aPropertyType == "texture" )
6437 if( aPropertyNameList.size() != 2 )
6441 int anId = aPropertyNameList[1].toInt( &ok );
6442 if( !ok || anId < 1 )
6445 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
6446 if( aPropertyValueList.size() != 2 )
6449 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
6450 QString aMarkerTextureString = aPropertyValueList[1];
6451 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
6452 if( aMarkerTextureStringList.size() != 3 )
6456 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6461 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6465 VTK::MarkerTexture aMarkerTexture;
6466 aMarkerTexture.push_back( aWidth );
6467 aMarkerTexture.push_back( aHeight );
6469 QString aMarkerTextureData = aMarkerTextureStringList[2];
6470 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6472 QChar aChar = aMarkerTextureData.at( i );
6473 if( aChar.isDigit() )
6474 aMarkerTexture.push_back( aChar.digitValue() );
6477 myMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6479 else if( aPropertyType == "ClippingPlane" )
6481 if( aPropertyNameList.size() != 3 )
6485 int aViewId = aPropertyNameList[1].toInt( &ok );
6486 if( !ok || aViewId < 0 )
6490 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6491 if( !ok || aClippingPlaneId < 0 )
6494 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6495 if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6498 TPlaneData aPlaneData;
6499 aPlaneData.AbsoluteOrientation = false;
6500 aPlaneData.RelativeOrientation = 0;
6501 aPlaneData.Distance = aPlaneData.Angle[0] = aPlaneData.Angle[1] = 0;
6502 aPlaneData.X = aPlaneData.Y = aPlaneData.Z = 0;
6503 aPlaneData.Dx = aPlaneData.Dy = aPlaneData.Dz = 0;
6505 aPlaneData.Id = aClippingPlaneId;
6508 aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6513 aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6517 if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6520 aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6525 aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6530 aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6535 aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6540 aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6545 aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6550 aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6554 else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6556 aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6561 aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6566 aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6571 aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6576 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6577 aPlaneDataList.push_back( aPlaneData );
6581 TPlaneInfoMap aPlaneInfoMap;
6583 std::vector<std::string> entries = ip->getEntries();
6585 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6587 // entry is a normal entry - it should be "decoded" (setting base address of component)
6588 QString entry (ip->decodeEntry(*entIt).c_str());
6590 // Check that the entry corresponds to a real object in the Study
6591 // as the object may be deleted or modified after the visual state is saved.
6592 _PTR(SObject) so = studyDS->FindObjectID(entry.toUtf8().data());
6593 if (!so) continue; //Skip the not existent entry
6595 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6596 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6598 std::vector<std::string>::iterator namesIt = paramNames.begin();
6599 std::vector<std::string>::iterator valuesIt = paramValues.begin();
6601 // actors are stored in a map after displaying of them for
6602 // quicker access in the future: map < viewID to actor >
6603 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6605 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6607 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6608 // '_' is used as separator and should not be used in viewer type or parameter names.
6609 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6610 if (lst.size() != 3)
6613 QString viewerTypStr = lst[0];
6614 QString viewIndexStr = lst[1];
6615 QString paramNameStr = lst[2];
6618 int viewIndex = viewIndexStr.toUInt(&ok);
6619 if (!ok) // bad conversion of view index to integer
6623 if (viewerTypStr == SVTK_Viewer::Type())
6625 SMESH_Actor* aSmeshActor = 0;
6626 if (vtkActors.IsBound(viewIndex))
6627 aSmeshActor = vtkActors.Find(viewIndex);
6629 QList<SUIT_ViewManager*> lst;
6630 getApp()->viewManagers(viewerTypStr, lst);
6632 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6633 SUIT_ViewManager* vman = NULL;
6634 if (viewIndex >= 0 && viewIndex < lst.count())
6635 vman = lst.at(viewIndex);
6637 if (paramNameStr == "Visibility")
6639 if (!aSmeshActor && displayer() && vman)
6641 SUIT_ViewModel* vmodel = vman->getViewModel();
6642 // SVTK view model can be casted to SALOME_View
6643 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6645 // store displayed actor in a temporary map for quicker
6646 // access later when restoring other parameters
6647 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6648 vtkRenderer* Renderer = vtkView->getRenderer();
6649 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6650 vtkActorCollection* theActors = aCopy.GetActors();
6651 theActors->InitTraversal();
6652 bool isFound = false;
6653 vtkActor *ac = theActors->GetNextActor();
6654 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6655 if (ac->IsA("SMESH_Actor")) {
6656 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6657 if (aGeomAc->hasIO()) {
6658 Handle(SALOME_InteractiveObject) io = aGeomAc->getIO();
6659 if (io->hasEntry() && strcmp(io->getEntry(), entry.toUtf8().data()) == 0) {
6661 vtkActors.Bind(viewIndex, aGeomAc);
6667 } // if (paramNameStr == "Visibility")
6670 // the rest properties "work" with SMESH_Actor
6673 QString val ((*valuesIt).c_str());
6676 if (paramNameStr == "Representation") {
6677 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6680 else if (paramNameStr == "IsShrunk") {
6682 if (!aSmeshActor->IsShrunk())
6683 aSmeshActor->SetShrink();
6686 if (aSmeshActor->IsShrunk())
6687 aSmeshActor->UnShrink();
6690 // Displayed entities
6691 else if (paramNameStr == "Entities") {
6692 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6693 int aEntityMode = SMESH_Actor::eAllEntity;
6694 for ( int i = 0; i < mode.count(); i+=2 ) {
6695 if ( i < mode.count()-1 ) {
6696 QString type = mode[i];
6697 bool val = mode[i+1].toInt();
6698 if ( type == "e" && !val )
6699 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6700 else if ( type == "f" && !val )
6701 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6702 else if ( type == "v" && !val )
6703 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6704 else if ( type == "0d" && !val )
6705 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6706 else if ( type == "b" && !val )
6707 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6710 aSmeshActor->SetEntityMode( aEntityMode );
6713 else if (paramNameStr == "Colors") {
6714 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6721 QColor outlineColor;
6722 QColor orientationColor;
6728 // below lines are required to get default values for delta coefficients
6729 // of backface color for faces and color of reversed volumes
6730 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
6731 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6732 for ( int i = 0; i < colors.count(); i++ ) {
6733 QString type = colors[i];
6734 if ( type == "surface" ) {
6735 // face color is set by 3 values r:g:b, where
6736 // - r,g,b - is rgb color components
6737 if ( i+1 >= colors.count() ) break; // format error
6738 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6739 if ( i+2 >= colors.count() ) break; // format error
6740 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6741 if ( i+3 >= colors.count() ) break; // format error
6742 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6743 faceColor.setRgbF( r, g, b );
6746 else if ( type == "backsurface" ) {
6747 // backface color can be defined in several ways
6748 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6749 // - in latest versions, it is set as delta coefficient
6750 bool rgbOk = false, deltaOk;
6751 if ( i+1 >= colors.count() ) break; // format error
6752 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6753 int delta = colors[i+1].toInt( &deltaOk );
6755 if ( i+1 < colors.count() ) // index is shifted to 1
6756 g = colors[i+1].toDouble( &rgbOk );
6757 if ( rgbOk ) i++; // shift index
6758 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6759 b = colors[i+1].toDouble( &rgbOk );
6761 // - as currently there's no way to set directly backsurface color as it was before,
6762 // we ignore old dump where r,g,b triple was set
6763 // - also we check that delta parameter is set properly
6764 if ( !rgbOk && deltaOk )
6767 else if ( type == "volume" ) {
6768 // volume color is set by 4 values r:g:b:delta, where
6769 // - r,g,b - is a normal volume rgb color components
6770 // - delta - is a reversed volume color delta coefficient
6771 if ( i+1 >= colors.count() ) break; // format error
6772 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6773 if ( i+2 >= colors.count() ) break; // format error
6774 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6775 if ( i+3 >= colors.count() ) break; // format error
6776 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6777 if ( i+4 >= colors.count() ) break; // format error
6778 int delta = colors[i+4].toInt( &bOk );
6779 if ( !bOk ) break; // format error
6780 volumeColor.setRgbF( r, g, b );
6784 else if ( type == "edge" ) {
6785 // edge color is set by 3 values r:g:b, where
6786 // - r,g,b - is rgb color components
6787 if ( i+1 >= colors.count() ) break; // format error
6788 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6789 if ( i+2 >= colors.count() ) break; // format error
6790 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6791 if ( i+3 >= colors.count() ) break; // format error
6792 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6793 edgeColor.setRgbF( r, g, b );
6796 else if ( type == "node" ) {
6797 // node color is set by 3 values r:g:b, where
6798 // - r,g,b - is rgb color components
6799 if ( i+1 >= colors.count() ) break; // format error
6800 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6801 if ( i+2 >= colors.count() ) break; // format error
6802 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6803 if ( i+3 >= colors.count() ) break; // format error
6804 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6805 nodeColor.setRgbF( r, g, b );
6808 else if ( type == "elem0d" ) {
6809 // 0d element color is set by 3 values r:g:b, where
6810 // - r,g,b - is rgb color components
6811 if ( i+1 >= colors.count() ) break; // format error
6812 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6813 if ( i+2 >= colors.count() ) break; // format error
6814 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6815 if ( i+3 >= colors.count() ) break; // format error
6816 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6817 elem0dColor.setRgbF( r, g, b );
6820 else if ( type == "ball" ) {
6821 // ball color is set by 3 values r:g:b, where
6822 // - r,g,b - is rgb color components
6823 if ( i+1 >= colors.count() ) break; // format error
6824 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6825 if ( i+2 >= colors.count() ) break; // format error
6826 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6827 if ( i+3 >= colors.count() ) break; // format error
6828 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6829 ballColor.setRgbF( r, g, b );
6832 else if ( type == "outline" ) {
6833 // outline color is set by 3 values r:g:b, where
6834 // - r,g,b - is rgb color components
6835 if ( i+1 >= colors.count() ) break; // format error
6836 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6837 if ( i+2 >= colors.count() ) break; // format error
6838 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6839 if ( i+3 >= colors.count() ) break; // format error
6840 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6841 outlineColor.setRgbF( r, g, b );
6844 else if ( type == "orientation" ) {
6845 // orientation color is set by 3 values r:g:b, where
6846 // - r,g,b - is rgb color components
6847 if ( i+1 >= colors.count() ) break; // format error
6848 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6849 if ( i+2 >= colors.count() ) break; // format error
6850 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6851 if ( i+3 >= colors.count() ) break; // format error
6852 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6853 orientationColor.setRgbF( r, g, b );
6858 if ( nodeColor.isValid() )
6859 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6861 if ( edgeColor.isValid() )
6862 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6864 if ( faceColor.isValid() )
6865 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6867 if ( volumeColor.isValid() )
6868 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6869 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6870 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6872 if ( elem0dColor.isValid() )
6873 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6875 if ( ballColor.isValid() )
6876 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6878 if ( outlineColor.isValid() )
6879 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6880 // orientation color
6881 if ( orientationColor.isValid() )
6882 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6885 else if (paramNameStr == "Sizes") {
6886 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6889 int outlineWidth = -1;
6890 int elem0dSize = -1;
6891 //int ballSize = -1;
6892 double ballDiameter = -1.0;
6893 double ballScale = -1.0;
6894 double shrinkSize = -1;
6895 double orientationSize = -1;
6896 bool orientation3d = false;
6897 for ( int i = 0; i < sizes.count(); i++ ) {
6898 QString type = sizes[i];
6899 if ( type == "line" ) {
6900 // line (wireframe) width is given as single integer value
6901 if ( i+1 >= sizes.count() ) break; // format error
6902 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6906 if ( type == "outline" ) {
6907 // outline width is given as single integer value
6908 if ( i+1 >= sizes.count() ) break; // format error
6909 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6913 else if ( type == "elem0d" ) {
6914 // 0d element size is given as single integer value
6915 if ( i+1 >= sizes.count() ) break; // format error
6916 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6920 else if ( type == "ball" ) {
6921 // balls are specified by two values: size:scale, where
6922 // - size - is a integer value specifying size
6923 // - scale - is a double value specifying scale factor
6924 if ( i+1 >= sizes.count() ) break; // format error
6925 //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6926 double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6927 if ( i+2 >= sizes.count() ) break; // format error
6928 double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6934 else if ( type == "shrink" ) {
6935 // shrink factor is given as single floating point value
6936 if ( i+1 >= sizes.count() ) break; // format error
6937 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6941 else if ( type == "orientation" ) {
6942 // orientation vectors are specified by two values size:3d, where
6943 // - size - is a floating point value specifying scale factor
6944 // - 3d - is a boolean
6945 if ( i+1 >= sizes.count() ) break; // format error
6946 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6947 if ( i+2 >= sizes.count() ) break; // format error
6948 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6949 orientationSize = v1;
6950 orientation3d = (bool)v2;
6954 // line (wireframe) width
6955 if ( lineWidth > 0 )
6956 aSmeshActor->SetLineWidth( lineWidth );
6958 if ( outlineWidth > 0 )
6959 aSmeshActor->SetOutlineWidth( outlineWidth );
6960 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6961 aSmeshActor->SetOutlineWidth( lineWidth );
6963 if ( elem0dSize > 0 )
6964 aSmeshActor->Set0DSize( elem0dSize );
6966 /*if ( ballSize > 0 )
6967 aSmeshActor->SetBallSize( ballSize );*/
6969 if ( ballDiameter > 0 )
6970 aSmeshActor->SetBallSize( ballDiameter );
6972 if ( ballScale > 0.0 )
6973 aSmeshActor->SetBallScale( ballScale );
6975 if ( shrinkSize > 0 )
6976 aSmeshActor->SetShrinkFactor( shrinkSize );
6977 // orientation vectors
6978 if ( orientationSize > 0 ) {
6979 aSmeshActor->SetFacesOrientationScale( orientationSize );
6980 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6984 else if (paramNameStr == "PointMarker") {
6985 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6986 if( data.count() >= 2 ) {
6988 int aParam1 = data[1].toInt( &ok );
6990 if( data[0] == "std" && data.count() == 3 ) {
6991 int aParam2 = data[2].toInt( &ok );
6992 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6994 else if( data[0] == "custom" ) {
6995 VTK::MarkerMap::const_iterator markerIt = myMarkerMap.find( aParam1 );
6996 if( markerIt != myMarkerMap.end() ) {
6997 VTK::MarkerData aMarkerData = markerIt->second;
6998 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
7005 else if (paramNameStr == "Opacity") {
7006 aSmeshActor->SetOpacity(val.toFloat());
7009 else if (paramNameStr.startsWith("ClippingPlane")) {
7010 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
7011 // old format - val looks like "Off" or "1:0:0:0.5:0:0"
7012 // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
7013 // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
7014 // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
7015 // new format - val looks like "Off" or "0" (plane id)
7016 // (note: in new format "Off" value is used only for consistency,
7017 // so it is processed together with values in old format)
7018 bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
7019 if( anIsOldFormat ) {
7020 if (paramNameStr == "ClippingPlane1" || val == "Off")
7021 aSmeshActor->RemoveAllClippingPlanes();
7023 QList<SUIT_ViewManager*> lst;
7024 getApp()->viewManagers(viewerTypStr, lst);
7025 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
7026 if (viewIndex >= 0 && viewIndex < lst.count()) {
7027 SUIT_ViewManager* vman = lst.at(viewIndex);
7028 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
7030 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
7032 SMESH::TActorList anActorList;
7033 anActorList.push_back( aSmeshActor );
7034 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
7035 aPlane->myViewWindow = vtkView;
7036 SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
7037 aPlane->PlaneMode = aMode;
7038 bool isOpenGLClipping = ( bool )vals[1].toInt();
7039 aPlane->IsOpenGLClipping = isOpenGLClipping;
7040 if ( aMode == SMESH::Absolute ) {
7041 aPlane->myAbsoluteOrientation = vals[2].toInt();
7042 aPlane->X = vals[3].toFloat();
7043 aPlane->Y = vals[4].toFloat();
7044 aPlane->Z = vals[5].toFloat();
7045 aPlane->Dx = vals[6].toFloat();
7046 aPlane->Dy = vals[7].toFloat();
7047 aPlane->Dz = vals[8].toFloat();
7049 else if ( aMode == SMESH::Relative ) {
7050 aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
7051 aPlane->myDistance = vals[3].toFloat();
7052 aPlane->myAngle[0] = vals[4].toFloat();
7053 aPlane->myAngle[1] = vals[5].toFloat();
7057 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
7058 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
7059 aClippingPlaneInfo.Plane = aPlane;
7060 aClippingPlaneInfo.ActorList = anActorList;
7061 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
7069 int aPlaneId = val.toInt( &ok );
7070 if( ok && aPlaneId >= 0 ) {
7071 bool anIsDefinedPlane = false;
7072 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
7073 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
7074 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
7075 TPlaneInfo& aPlaneInfo = *anIter;
7076 if( aPlaneInfo.PlaneId == aPlaneId ) {
7077 aPlaneInfo.ActorList.push_back( aSmeshActor );
7078 anIsDefinedPlane = true;
7082 if( !anIsDefinedPlane ) {
7083 TPlaneInfo aPlaneInfo;
7084 aPlaneInfo.PlaneId = aPlaneId;
7085 aPlaneInfo.ActorList.push_back( aSmeshActor );
7086 aPlaneInfo.ViewManager = vman;
7088 // to make the list sorted by plane id
7089 anIter = aPlaneInfoList.begin();
7090 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
7091 const TPlaneInfo& aPlaneInfoRef = *anIter;
7092 if( aPlaneInfoRef.PlaneId > aPlaneId )
7095 aPlaneInfoList.insert( anIter, aPlaneInfo );
7100 } // if (aSmeshActor)
7101 } // other parameters than Visibility
7103 } // for names/parameters iterator
7104 } // for entries iterator
7106 // take into account planes with empty list of actors referred to them
7107 QList<SUIT_ViewManager*> aVMList;
7108 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
7110 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
7111 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
7112 int aViewId = aPlaneDataIter->first;
7113 if( aViewId >= 0 && aViewId < aVMList.count() ) {
7114 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
7116 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
7118 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
7119 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
7120 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
7121 const TPlaneData& aPlaneData = *anIter2;
7122 int aPlaneId = aPlaneData.Id;
7124 bool anIsFound = false;
7125 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
7126 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
7127 const TPlaneInfo& aPlaneInfo = *anIter3;
7128 if( aPlaneInfo.PlaneId == aPlaneId ) {
7135 TPlaneInfo aPlaneInfo; // ActorList field is empty
7136 aPlaneInfo.PlaneId = aPlaneId;
7137 aPlaneInfo.ViewManager = aViewManager;
7139 // to make the list sorted by plane id
7140 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
7141 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
7142 const TPlaneInfo& aPlaneInfoRef = *anIter4;
7143 if( aPlaneInfoRef.PlaneId > aPlaneId )
7146 aPlaneInfoList.insert( anIter4, aPlaneInfo );
7152 // add clipping planes to actors according to the restored parameters
7153 // and update the clipping plane map
7154 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
7155 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
7156 int aViewId = anIter1->first;
7157 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
7159 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
7160 if( anIter2 == aPlaneDataMap.end() )
7162 const TPlaneDataList& aPlaneDataList = anIter2->second;
7164 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
7165 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
7166 const TPlaneInfo& aPlaneInfo = *anIter3;
7167 int aPlaneId = aPlaneInfo.PlaneId;
7168 const TActorList& anActorList = aPlaneInfo.ActorList;
7169 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
7173 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
7177 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
7179 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
7180 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
7181 const TPlaneData& aPlaneData = *anIter4;
7182 if( aPlaneData.Id == aPlaneId ) {
7183 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
7184 aPlane->myViewWindow = aViewWindow;
7185 aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
7186 aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
7187 if ( aPlane->PlaneMode == SMESH::Absolute ) {
7188 aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
7189 aPlane->X = aPlaneData.X;
7190 aPlane->Y = aPlaneData.Y;
7191 aPlane->Z = aPlaneData.Z;
7192 aPlane->Dx = aPlaneData.Dx;
7193 aPlane->Dy = aPlaneData.Dy;
7194 aPlane->Dz = aPlaneData.Dz;
7196 else if ( aPlane->PlaneMode == SMESH::Relative ) {
7197 aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
7198 aPlane->myDistance = aPlaneData.Distance;
7199 aPlane->myAngle[0] = aPlaneData.Angle[0];
7200 aPlane->myAngle[1] = aPlaneData.Angle[1];
7203 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
7204 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
7205 aClippingPlaneInfo.Plane = aPlane;
7206 aClippingPlaneInfo.ActorList = anActorList;
7207 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
7218 // update all VTK views
7219 QList<SUIT_ViewManager*> lst;
7220 getApp()->viewManagers(lst);
7221 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
7222 SUIT_ViewModel* vmodel = (*it)->getViewModel();
7223 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
7224 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
7225 // set OpenGL clipping planes
7226 VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
7227 vtkActorCollection* anAllActors = aCopy.GetActors();
7228 anAllActors->InitTraversal();
7229 while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
7230 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
7231 anActor->SetOpenGLClippingPlane();
7233 vtkView->getRenderer()->ResetCameraClippingRange();
7240 \brief Adds preferences for dfont of VTK viewer
7242 \param pIf group identifier
7243 \param param parameter
7244 \return identifier of preferences
7246 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
7248 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
7250 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
7253 fam.append( tr( "SMESH_FONT_ARIAL" ) );
7254 fam.append( tr( "SMESH_FONT_COURIER" ) );
7255 fam.append( tr( "SMESH_FONT_TIMES" ) );
7257 setPreferenceProperty( tfont, "fonts", fam );
7259 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
7260 if ( needSize ) f = f | QtxFontEdit::Size;
7261 setPreferenceProperty( tfont, "features", f );
7267 \brief Actions after hypothesis edition
7268 Updates object browser after hypothesis edition
7270 void SMESHGUI::onHypothesisEdit( int result )
7273 SMESHGUI::Modified();
7274 updateObjBrowser( true );
7278 \brief Actions after choosing menu of control modes
7279 Updates control mode actions according to current selection
7281 void SMESHGUI::onUpdateControlActions()
7283 SALOME_ListIO selected;
7284 if ( LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr() )
7285 aSel->selectedObjects( selected );
7287 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
7288 if ( selected.Extent() ) {
7289 if ( selected.First()->hasEntry() ) {
7290 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( selected.First()->getEntry() )) {
7291 aControl = anActor->GetControlMode();
7292 SALOME_ListIteratorOfListIO it(selected);
7293 for ( it.Next(); it.More(); it.Next() ) {
7294 Handle(SALOME_InteractiveObject) anIO = it.Value();
7295 if ( anIO->hasEntry() ) {
7296 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
7297 if ( aControl != anActor->GetControlMode() ) {
7298 aControl = SMESH_Actor::eNone;
7308 int anAction = ActionToControl( aControl, true );
7310 action( anAction )->setChecked( true );
7312 QMenu* send = (QMenu*)sender();
7313 QList<QAction*> actions = send->actions();
7314 for ( int i = 0; i < actions.size(); i++ )
7315 actions[i]->setChecked( false );
7321 \brief Signal handler closing(SUIT_ViewWindow*) of a view
7322 \param pview view being closed
7324 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
7325 #ifndef DISABLE_PLOT2DVIEWER
7326 //Crear all Plot2d Viewers if need.
7327 SMESH::ClearPlot2Viewers(pview);
7329 EmitSignalCloseView();
7332 void SMESHGUI::message( const QString& msg )
7335 QStringList data = msg.split("/");
7336 if ( data.count() > 0 ) {
7337 if ( data.first() == "mesh_loading" ) {
7339 QString entry = data.count() > 1 ? data[1] : QString();
7340 if ( entry.isEmpty() )
7343 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
7345 _PTR(SObject) obj = study->FindObjectID( entry.toUtf8().constData() );
7348 name = SMESH::fromUtf8(obj->GetName());
7349 if ( name.isEmpty() )
7352 if ( data.last() == "stop" )
7353 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
7355 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
7356 QApplication::processEvents();
7362 \brief Connects or disconnects signals about activating and cloning view on the module slots
7363 \param pview view which is connected/disconnected
7365 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
7369 SUIT_ViewManager* viewMgr = pview->getViewManager();
7371 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7372 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7374 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7375 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7380 \brief Return \c true if object can be renamed
7382 bool SMESHGUI::renameAllowed( const QString& entry) const {
7383 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7387 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7391 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
7396 if(appStudy->isComponent(entry) || obj->isReference())
7399 // check type to prevent renaming of inappropriate objects
7400 int aType = SMESHGUI_Selection::type(qPrintable(entry));
7401 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7402 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7403 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7404 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7405 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
7412 Rename object by entry.
7413 \param entry entry of the object
7414 \param name new name of the object
7415 \brief Return \c true if rename operation finished successfully, \c false otherwise.
7417 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
7419 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7423 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7428 _PTR(Study) aStudy = appStudy->studyDS();
7433 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
7435 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
7440 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
7441 _PTR(GenericAttribute) anAttr;
7442 _PTR(AttributeName) aName;
7444 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
7446 // check type to prevent renaming of inappropriate objects
7447 int aType = SMESHGUI_Selection::type( qPrintable(entry));
7448 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7449 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7450 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7451 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7452 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
7453 if ( !name.isEmpty() ) {
7454 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qUtf8Printable(name) );
7456 // update name of group object and its actor
7457 Handle(SALOME_InteractiveObject) IObject =
7458 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
7460 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
7461 if( !aGroupObject->_is_nil() ) {
7462 aGroupObject->SetName( qUtf8Printable(name) );
7463 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
7464 anActor->setName( qUtf8Printable(name) );
7474 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
7476 static QList<QColor> colors;
7478 if ( colors.isEmpty() ) {
7480 for (int s = 0; s < 2 ; s++)
7482 for (int v = 100; v >= 40; v = v - 20)
7484 for (int h = 0; h < 359 ; h = h + 60)
7486 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
7491 static int currentColor = randomize( colors.size() );
7493 SALOMEDS::Color color;
7494 color.R = (double)colors[currentColor].red() / 255.0;
7495 color.G = (double)colors[currentColor].green() / 255.0;
7496 color.B = (double)colors[currentColor].blue() / 255.0;
7498 currentColor = (currentColor+1) % colors.count();