1 // Copyright (C) 2007-2020 CEA/DEN, EDF R&D, OPEN CASCADE
3 // Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
6 // This library is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU Lesser General Public
8 // License as published by the Free Software Foundation; either
9 // version 2.1 of the License, or (at your option) any later version.
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 // Lesser General Public License for more details.
16 // You should have received a copy of the GNU Lesser General Public
17 // License along with this library; if not, write to the Free Software
18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
22 // File : SMESHGUI.cxx
23 // Author : Nicolas REJNERI, Open CASCADE S.A.S.
25 #include <Standard_math.hxx> // E.A. must be included before Python.h to fix compilation on windows
27 #undef HAVE_FINITE // VSR: avoid compilation warning on Linux : "HAVE_FINITE" redefined
33 #include "SMESHGUI_AdaptDlg.h"
34 #include "SMESHGUI_Add0DElemsOnAllNodesDlg.h"
35 #include "SMESHGUI_AddMeshElementDlg.h"
36 #include "SMESHGUI_AddQuadraticElementDlg.h"
37 #include "SMESHGUI_BuildCompoundDlg.h"
38 #include "SMESHGUI_ClippingDlg.h"
39 #include "SMESHGUI_ComputeDlg.h"
40 #include "SMESHGUI_ConvToQuadOp.h"
41 #include "SMESHGUI_CopyMeshDlg.h"
42 #include "SMESHGUI_CreatePolyhedralVolumeDlg.h"
43 #include "SMESHGUI_DeleteGroupDlg.h"
44 #include "SMESHGUI_DisplayEntitiesDlg.h"
45 #include "SMESHGUI_Displayer.h"
46 #include "SMESHGUI_DuplicateNodesDlg.h"
47 #include "SMESHGUI_ExtrusionAlongPathDlg.h"
48 #include "SMESHGUI_ExtrusionDlg.h"
49 #include "SMESHGUI_FaceGroupsSeparatedByEdgesDlg.h"
50 #include "SMESHGUI_FieldSelectorWdg.h"
51 #include "SMESHGUI_FileInfoDlg.h"
52 #include "SMESHGUI_FileValidator.h"
53 #include "SMESHGUI_FilterDlg.h"
54 #include "SMESHGUI_FilterLibraryDlg.h"
55 #include "SMESHGUI_FilterUtils.h"
56 #include "SMESHGUI_FindElemByPointDlg.h"
57 #include "SMESHGUI_GEOMGenUtils.h"
58 #include "SMESHGUI_GroupDlg.h"
59 #include "SMESHGUI_GroupOnShapeDlg.h"
60 #include "SMESHGUI_GroupOpDlg.h"
61 #include "SMESHGUI_GroupUtils.h"
62 #include "SMESHGUI_Hypotheses.h"
63 #include "SMESHGUI_HypothesesUtils.h"
64 #include "SMESHGUI_Make2DFrom3DOp.h"
65 #include "SMESHGUI_MakeNodeAtPointDlg.h"
66 #include "SMESHGUI_Measurements.h"
67 #include "SMESHGUI_MergeDlg.h"
68 #include "SMESHGUI_MeshInfo.h"
69 #include "SMESHGUI_MeshOp.h"
70 #include "SMESHGUI_MeshOrderOp.h"
71 #include "SMESHGUI_MeshPatternDlg.h"
72 #include "SMESHGUI_MeshUtils.h"
73 #include "SMESHGUI_MultiEditDlg.h"
74 #include "SMESHGUI_NodesDlg.h"
75 #include "SMESHGUI_OffsetDlg.h"
76 #include "SMESHGUI_Operations.h"
77 #include "SMESHGUI_PatternUtils.h"
78 #include "SMESHGUI_Preferences_ScalarBarDlg.h"
79 #include "SMESHGUI_PropertiesDlg.h"
80 #include "SMESHGUI_RemoveElementsDlg.h"
81 #include "SMESHGUI_RemoveNodesDlg.h"
82 #include "SMESHGUI_RenumberingDlg.h"
83 #include "SMESHGUI_ReorientFacesDlg.h"
84 #include "SMESHGUI_RevolutionDlg.h"
85 #include "SMESHGUI_RotationDlg.h"
86 #include "SMESHGUI_ScaleDlg.h"
87 #include "SMESHGUI_Selection.h"
88 #include "SMESHGUI_SewingDlg.h"
89 #include "SMESHGUI_SingleEditDlg.h"
90 #include "SMESHGUI_SmoothingDlg.h"
91 #include "SMESHGUI_SpinBox.h"
92 #include "SMESHGUI_SplitBiQuad.h"
93 #include "SMESHGUI_SymmetryDlg.h"
94 #include "SMESHGUI_TranslationDlg.h"
95 #include "SMESHGUI_TransparencyDlg.h"
96 #include "SMESHGUI_Utils.h"
97 #include "SMESHGUI_VTKUtils.h"
99 #include "SMESH_version.h"
101 #include "SMESH_Actor.h"
102 #include "SMESH_ActorUtils.h"
103 #include "SMESH_Client.hxx"
104 #include "SMESH_Comment.hxx"
105 #include "SMESH_ControlsDef.hxx"
106 #include "SMESH_ScalarBarActor.h"
107 #include "SMESH_TypeFilter.hxx"
109 // SALOME GUI includes
110 #include <LightApp_DataOwner.h>
111 #include <LightApp_NameDlg.h>
112 #include <LightApp_Preferences.h>
113 #include <LightApp_SelectionMgr.h>
114 #include <LightApp_UpdateFlags.h>
115 #include <QtxFontEdit.h>
116 #include <QtxPopupMgr.h>
117 #include <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::long_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::long_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::long_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 forbiden 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 forbiden 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 forbiden 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 forbiden 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 forbiden 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 forbiden 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 forbiden 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 forbiden 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"));
3038 // Adaptation - begin
3039 case SMESHOp::OpUniformRefinement:
3040 case SMESHOp::OpHONewCase:
3041 case SMESHOp::OpHOCaseFollow:
3042 case SMESHOp::OpHONewIter:
3043 case SMESHOp::OpHOIterCompute:
3044 case SMESHOp::OpHOIterComputePublish:
3045 case SMESHOp::OpHOEdit:
3046 case SMESHOp::OpHODelete:
3047 case SMESHOp::OpMGAdapt:
3049 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
3050 SMESHGUI_AdaptDlg *aDlg = new SMESHGUI_AdaptDlg( this, theCommandID, aMesh);
3055 case SMESHOp::OpSplitBiQuadratic:
3056 case SMESHOp::OpConvertMeshToQuadratic:
3057 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
3058 case SMESHOp::OpReorientFaces:
3059 case SMESHOp::OpCreateGeometryGroup:
3061 if ( warnOnGeomModif() )
3062 break; // action forbiden as geometry modified
3063 startOperation( theCommandID );
3066 case SMESHOp::OpCreateGroup:
3070 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3074 if(isStudyLocked()) break;
3075 if ( warnOnGeomModif() )
3076 break; // action forbiden as geometry modified
3077 EmitSignalDeactivateDialog();
3078 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
3080 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3081 SALOME_ListIO selected;
3083 aSel->selectedObjects( selected );
3085 int nbSel = selected.Extent();
3087 // check if mesh is selected
3088 aMesh = SMESH::GetMeshByIO( selected.First() );
3090 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
3095 case SMESHOp::OpConstructGroup:
3099 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3103 if(isStudyLocked()) break;
3104 if ( warnOnGeomModif() )
3105 break; // action forbiden as geometry modified
3106 EmitSignalDeactivateDialog();
3108 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3109 SALOME_ListIO selected;
3111 aSel->selectedObjects( selected );
3113 int nbSel = selected.Extent();
3115 // check if submesh is selected
3116 Handle(SALOME_InteractiveObject) IObject = selected.First();
3117 if (IObject->hasEntry()) {
3118 _PTR(SObject) aSObj = SMESH::getStudy()->FindObjectID(IObject->getEntry());
3120 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
3121 if (!aSubMesh->_is_nil()) {
3123 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
3124 // get submesh elements list by types
3125 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
3126 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
3127 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
3128 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
3129 // create group for each type o elements
3130 QString aName = IObject->getName();
3131 QStringList anEntryList;
3132 if (aNodes->length() > 0) {
3133 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
3134 aGroup->Add(aNodes.inout());
3135 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3136 anEntryList.append( aSObject->GetID().c_str() );
3138 if (aEdges->length() > 0) {
3139 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
3140 aGroup->Add(aEdges.inout());
3141 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3142 anEntryList.append( aSObject->GetID().c_str() );
3144 if (aFaces->length() > 0) {
3145 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
3146 aGroup->Add(aFaces.inout());
3147 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3148 anEntryList.append( aSObject->GetID().c_str() );
3150 if (aVolumes->length() > 0) {
3151 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
3152 aGroup->Add(aVolumes.inout());
3153 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3154 anEntryList.append( aSObject->GetID().c_str() );
3157 anApp->browseObjects( anEntryList );
3159 catch(const SALOME::SALOME_Exception & S_ex){
3160 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3167 SUIT_MessageBox::warning(desktop(),
3168 tr("SMESH_WRN_WARNING"),
3169 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
3174 case SMESHOp::OpEditGroup:
3178 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3182 if(isStudyLocked()) break;
3183 if ( warnOnGeomModif() )
3184 break; // action forbiden as geometry modified
3185 EmitSignalDeactivateDialog();
3187 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3188 SALOME_ListIO selected;
3190 aSel->selectedObjects( selected );
3192 SALOME_ListIteratorOfListIO It (selected);
3193 int nbSelectedGroups = 0;
3194 for ( ; It.More(); It.Next() )
3196 SMESH::SMESH_GroupBase_var aGroup =
3197 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
3198 if (!aGroup->_is_nil()) {
3200 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
3204 if (nbSelectedGroups == 0)
3206 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
3212 case SMESHOp::OpAddElemGroupPopup: // Add elements to group
3214 if(isStudyLocked()) break;
3215 if (myState == 800) {
3216 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3217 if (aDlg) aDlg->onAdd();
3222 case SMESHOp::OpRemoveElemGroupPopup: // Remove elements from group
3224 if(isStudyLocked()) break;
3225 if (myState == 800) {
3226 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3227 if (aDlg) aDlg->onRemove();
3232 case SMESHOp::OpEditGeomGroupAsGroup:
3236 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3240 if(isStudyLocked()) break;
3241 EmitSignalDeactivateDialog();
3243 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3244 SALOME_ListIO selected;
3246 aSel->selectedObjects( selected );
3248 SALOME_ListIteratorOfListIO It (selected);
3249 for ( ; It.More(); It.Next() )
3251 SMESH::SMESH_GroupOnGeom_var aGroup =
3252 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
3253 if (!aGroup->_is_nil()) {
3254 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3259 SMESH::SMESH_GroupOnFilter_var aGroup =
3260 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
3261 if (!aGroup->_is_nil()) {
3262 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3270 case SMESHOp::OpUnionGroups:
3271 case SMESHOp::OpIntersectGroups:
3272 case SMESHOp::OpCutGroups:
3276 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3280 if ( isStudyLocked() )
3282 if ( warnOnGeomModif() )
3283 break; // action forbiden as geometry modified
3285 EmitSignalDeactivateDialog();
3287 SMESHGUI_GroupOpDlg* aDlg = 0;
3288 if ( theCommandID == SMESHOp::OpUnionGroups )
3289 aDlg = new SMESHGUI_UnionGroupsDlg( this );
3290 else if ( theCommandID == SMESHOp::OpIntersectGroups )
3291 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3293 aDlg = new SMESHGUI_CutGroupsDlg( this );
3300 case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
3302 if ( isStudyLocked() )
3304 if ( warnOnGeomModif() )
3305 break; // action forbiden as geometry modified
3307 EmitSignalDeactivateDialog();
3308 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3314 case SMESHOp::OpFaceGroupsByEdges: // Create face groups separated by sharp edges
3316 if ( isStudyLocked() )
3318 if ( warnOnGeomModif() )
3319 break; // action forbiden as geometry modified
3321 EmitSignalDeactivateDialog();
3322 SMESHGUI_FaceGroupsSeparatedByEdgesDlg* aDlg = new SMESHGUI_FaceGroupsSeparatedByEdgesDlg( this );
3328 case SMESHOp::OpDeleteGroup: // Delete groups with their contents
3332 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3336 if ( isStudyLocked() )
3339 EmitSignalDeactivateDialog();
3341 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3345 case SMESHOp::OpMeshInformation:
3346 case SMESHOp::OpWhatIs:
3348 int page = theCommandID == SMESHOp::OpMeshInformation ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3349 EmitSignalDeactivateDialog();
3350 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3351 SALOME_ListIO selected;
3353 aSel->selectedObjects( selected );
3355 if ( selected.Extent() > 1 ) { // a dlg for each IO
3356 SALOME_ListIteratorOfListIO It( selected );
3357 for ( ; It.More(); It.Next() ) {
3358 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3359 dlg->showInfo( It.Value() );
3364 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3370 case SMESHOp::OpFindElementByPoint:
3372 startOperation( theCommandID );
3376 case SMESHOp::OpEditHypothesis:
3378 if(isStudyLocked()) break;
3379 if ( warnOnGeomModif() )
3380 break; // action forbiden as geometry modified
3382 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3383 SALOME_ListIO selected;
3385 aSel->selectedObjects( selected );
3387 int nbSel = selected.Extent();
3390 Handle(SALOME_InteractiveObject) anIObject = selected.First();
3391 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3393 if ( !aHypothesis->_is_nil() )
3395 SMESHGUI_GenericHypothesisCreator* aCreator =
3396 SMESH::GetHypothesisCreator( SMESH::toQStr( aHypothesis->GetName() ));
3399 // set geometry of mesh and sub-mesh to aCreator
3400 aSel->selectedObjects( selected, "", /*convertReferences=*/false);
3401 if ( selected.Extent() == 1 )
3403 QString subGeomID, meshGeomID;
3404 Handle(SALOME_InteractiveObject) hypIO = selected.First();
3405 if ( SMESH::GetGeomEntries( hypIO, subGeomID, meshGeomID ))
3407 if ( subGeomID.isEmpty() ) subGeomID = meshGeomID;
3408 aCreator->setShapeEntry( subGeomID );
3409 aCreator->setMainShapeEntry( meshGeomID );
3413 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3423 case SMESHOp::OpUnassign: // REMOVE HYPOTHESIS / ALGORITHMS
3425 if(isStudyLocked()) break;
3426 if ( warnOnGeomModif() )
3427 break; // action forbiden as geometry modified
3428 SUIT_OverrideCursor wc;
3430 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3431 SALOME_ListIO selected;
3433 aSel->selectedObjects( selected, QString::null, false );
3435 SALOME_ListIteratorOfListIO It(selected);
3436 for (int i = 0; It.More(); It.Next(), i++) {
3437 Handle(SALOME_InteractiveObject) IObject = It.Value();
3438 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3441 aSel->setSelectedObjects( l1 );
3446 case SMESHOp::OpElem0D:
3447 case SMESHOp::OpBall:
3448 case SMESHOp::OpEdge:
3449 case SMESHOp::OpTriangle:
3450 case SMESHOp::OpQuadrangle:
3451 case SMESHOp::OpPolygon:
3452 case SMESHOp::OpTetrahedron:
3453 case SMESHOp::OpHexahedron:
3454 case SMESHOp::OpPentahedron:
3455 case SMESHOp::OpPyramid:
3456 case SMESHOp::OpHexagonalPrism:
3458 if(isStudyLocked()) break;
3459 if ( warnOnGeomModif() )
3460 break; // action forbiden as geometry modified
3462 EmitSignalDeactivateDialog();
3463 SMDSAbs_EntityType type = SMDSEntity_Edge;
3464 switch (theCommandID) {
3465 case SMESHOp::OpElem0D: type = SMDSEntity_0D; break;
3466 case SMESHOp::OpBall: type = SMDSEntity_Ball; break;
3467 case SMESHOp::OpTriangle: type = SMDSEntity_Triangle; break;
3468 case SMESHOp::OpQuadrangle: type = SMDSEntity_Quadrangle; break;
3469 case SMESHOp::OpTetrahedron: type = SMDSEntity_Tetra; break;
3470 case SMESHOp::OpPolygon: type = SMDSEntity_Polygon; break;
3471 case SMESHOp::OpHexahedron: type = SMDSEntity_Hexa; break;
3472 case SMESHOp::OpPentahedron: type = SMDSEntity_Penta; break;
3473 case SMESHOp::OpPyramid: type = SMDSEntity_Pyramid; break;
3474 case SMESHOp::OpHexagonalPrism: type = SMDSEntity_Hexagonal_Prism; break;
3477 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3480 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3484 case SMESHOp::OpPolyhedron:
3486 if(isStudyLocked()) break;
3487 if ( warnOnGeomModif() )
3488 break; // action forbiden as geometry modified
3490 EmitSignalDeactivateDialog();
3491 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3494 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3498 case SMESHOp::OpQuadraticEdge:
3499 case SMESHOp::OpQuadraticTriangle:
3500 case SMESHOp::OpBiQuadraticTriangle:
3501 case SMESHOp::OpQuadraticQuadrangle:
3502 case SMESHOp::OpBiQuadraticQuadrangle:
3503 case SMESHOp::OpQuadraticPolygon:
3504 case SMESHOp::OpQuadraticTetrahedron:
3505 case SMESHOp::OpQuadraticPyramid:
3506 case SMESHOp::OpQuadraticPentahedron:
3507 case SMESHOp::OpBiQuadraticPentahedron:
3508 case SMESHOp::OpQuadraticHexahedron:
3509 case SMESHOp::OpTriQuadraticHexahedron:
3511 if(isStudyLocked()) break;
3512 if ( warnOnGeomModif() )
3513 break; // action forbiden as geometry modified
3515 EmitSignalDeactivateDialog();
3516 SMDSAbs_EntityType type = SMDSEntity_Last;
3518 switch (theCommandID) {
3519 case SMESHOp::OpQuadraticEdge: type = SMDSEntity_Quad_Edge; break;
3520 case SMESHOp::OpQuadraticTriangle: type = SMDSEntity_Quad_Triangle; break;
3521 case SMESHOp::OpBiQuadraticTriangle: type = SMDSEntity_BiQuad_Triangle; break;
3522 case SMESHOp::OpQuadraticQuadrangle: type = SMDSEntity_Quad_Quadrangle; break;
3523 case SMESHOp::OpBiQuadraticQuadrangle: type = SMDSEntity_BiQuad_Quadrangle; break;
3524 case SMESHOp::OpQuadraticPolygon: type = SMDSEntity_Quad_Polygon; break;
3525 case SMESHOp::OpQuadraticTetrahedron: type = SMDSEntity_Quad_Tetra; break;
3526 case SMESHOp::OpQuadraticPyramid: type = SMDSEntity_Quad_Pyramid; break;
3527 case SMESHOp::OpQuadraticPentahedron: type = SMDSEntity_Quad_Penta; break;
3528 case SMESHOp::OpBiQuadraticPentahedron: type = SMDSEntity_BiQuad_Penta; break;
3529 case SMESHOp::OpQuadraticHexahedron: type = SMDSEntity_Quad_Hexa; break;
3530 case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
3533 if ( type != SMDSEntity_Last )
3534 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3537 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3538 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3542 case SMESHOp::OpRemoveNodes:
3544 if(isStudyLocked()) break;
3545 if ( warnOnGeomModif() )
3546 break; // action forbiden as geometry modified
3548 EmitSignalDeactivateDialog();
3549 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3552 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3553 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3557 case SMESHOp::OpRemoveElements: // REMOVES ELEMENTS
3559 if(isStudyLocked()) break;
3560 if ( warnOnGeomModif() )
3561 break; // action forbiden as geometry modified
3563 EmitSignalDeactivateDialog();
3564 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3568 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3569 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3573 case SMESHOp::OpClearMesh: {
3575 if(isStudyLocked()) break;
3576 if ( warnOnGeomModif() )
3577 break; // action forbiden as geometry modified
3579 SALOME_ListIO selected;
3580 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3581 aSel->selectedObjects( selected );
3583 SUIT_OverrideCursor wc;
3584 SALOME_ListIteratorOfListIO It (selected);
3585 for ( ; It.More(); It.Next() )
3587 Handle(SALOME_InteractiveObject) IOS = It.Value();
3588 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3589 if ( aMesh->_is_nil()) continue;
3592 if ( aMesh->NbNodes() == 0 ) // imported mesh is not empty
3593 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3594 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3595 // hide groups and submeshes
3596 _PTR(ChildIterator) anIter =
3597 SMESH::getStudy()->NewChildIterator( aMeshSObj );
3598 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3600 _PTR(SObject) so = anIter->Value();
3601 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3604 catch (const SALOME::SALOME_Exception& S_ex){
3606 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3610 SMESH::UpdateView();
3614 case SMESHOp::OpRemoveOrphanNodes:
3616 if(isStudyLocked()) break;
3617 if ( warnOnGeomModif() )
3618 break; // action forbiden as geometry modified
3619 SALOME_ListIO selected;
3620 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3621 aSel->selectedObjects( selected );
3622 if ( selected.Extent() == 1 ) {
3623 Handle(SALOME_InteractiveObject) anIO = selected.First();
3624 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3625 if ( !aMesh->_is_nil() ) {
3626 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3627 tr( "SMESH_WARNING" ),
3628 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3629 SUIT_MessageBox::Yes |
3630 SUIT_MessageBox::No,
3631 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3634 SUIT_OverrideCursor wc;
3635 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3636 int removed = aMeshEditor->RemoveOrphanNodes();
3637 SUIT_MessageBox::information(SMESHGUI::desktop(),
3638 tr("SMESH_INFORMATION"),
3639 tr("NB_NODES_REMOVED").arg(removed));
3640 if ( removed > 0 ) {
3641 SMESH::UpdateView();
3642 SMESHGUI::Modified();
3645 catch (const SALOME::SALOME_Exception& S_ex) {
3646 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3655 case SMESHOp::OpRenumberingNodes:
3657 if(isStudyLocked()) break;
3658 if ( warnOnGeomModif() )
3659 break; // action forbiden as geometry modified
3661 EmitSignalDeactivateDialog();
3662 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3666 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3667 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3671 case SMESHOp::OpRenumberingElements:
3673 if(isStudyLocked()) break;
3674 if ( warnOnGeomModif() )
3675 break; // action forbiden as geometry modified
3677 EmitSignalDeactivateDialog();
3678 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3682 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3683 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3687 case SMESHOp::OpTranslation:
3689 if(isStudyLocked()) break;
3690 if ( warnOnGeomModif() )
3691 break; // action forbiden as geometry modified
3693 EmitSignalDeactivateDialog();
3694 ( new SMESHGUI_TranslationDlg( this ) )->show();
3697 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3698 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3702 case SMESHOp::OpRotation:
3704 if(isStudyLocked()) break;
3705 if ( warnOnGeomModif() )
3706 break; // action forbiden as geometry modified
3708 EmitSignalDeactivateDialog();
3709 ( new SMESHGUI_RotationDlg( this ) )->show();
3712 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3713 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3717 case SMESHOp::OpSymmetry:
3719 if(isStudyLocked()) break;
3720 if ( warnOnGeomModif() )
3721 break; // action forbiden as geometry modified
3723 EmitSignalDeactivateDialog();
3724 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3727 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3728 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3732 case SMESHOp::OpScale:
3734 if(isStudyLocked()) break;
3735 if ( warnOnGeomModif() )
3736 break; // action forbiden as geometry modified
3738 EmitSignalDeactivateDialog();
3739 ( new SMESHGUI_ScaleDlg( this ) )->show();
3742 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3743 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3748 case SMESHOp::OpOffset:
3750 if(isStudyLocked()) break;
3751 if ( warnOnGeomModif() )
3752 break; // action forbiden as geometry modified
3754 EmitSignalDeactivateDialog();
3755 ( new SMESHGUI_OffsetDlg( this ) )->show();
3758 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3759 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3764 case SMESHOp::OpSewing:
3766 if(isStudyLocked()) break;
3767 if ( warnOnGeomModif() )
3768 break; // action forbiden as geometry modified
3770 EmitSignalDeactivateDialog();
3771 ( new SMESHGUI_SewingDlg( this ) )->show();
3774 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3775 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3779 case SMESHOp::OpMergeNodes:
3781 if(isStudyLocked()) break;
3782 if ( warnOnGeomModif() )
3783 break; // action forbiden as geometry modified
3785 EmitSignalDeactivateDialog();
3786 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3789 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3790 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3794 case SMESHOp::OpMergeElements:
3796 if (isStudyLocked()) break;
3797 if ( warnOnGeomModif() )
3798 break; // action forbiden as geometry modified
3800 EmitSignalDeactivateDialog();
3801 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3803 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3804 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3809 case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
3810 if ( warnOnGeomModif() )
3811 break; // action forbiden as geometry modified
3812 startOperation( SMESHOp::OpMoveNode );
3815 case SMESHOp::OpDuplicateNodes:
3817 if(isStudyLocked()) break;
3818 if ( warnOnGeomModif() )
3819 break; // action forbiden as geometry modified
3821 EmitSignalDeactivateDialog();
3822 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3825 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3826 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3831 case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
3832 if ( warnOnGeomModif() )
3833 break; // action forbiden as geometry modified
3834 startOperation( SMESHOp::OpElem0DOnElemNodes );
3837 case SMESHOp::OpSelectFiltersLibrary: // Library of selection filters
3839 static QList<int> aTypes;
3840 if ( aTypes.isEmpty() )
3842 aTypes.append( SMESH::NODE );
3843 aTypes.append( SMESH::EDGE );
3844 aTypes.append( SMESH::FACE );
3845 aTypes.append( SMESH::VOLUME );
3847 if (!myFilterLibraryDlg)
3848 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3849 else if (myFilterLibraryDlg->isHidden())
3850 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3851 myFilterLibraryDlg->raise();
3855 case SMESHOp::OpFreeNode:
3856 case SMESHOp::OpEqualNode:
3857 case SMESHOp::OpNodeConnectivityNb:
3858 case SMESHOp::OpFreeEdge:
3859 case SMESHOp::OpFreeBorder:
3860 case SMESHOp::OpLength:
3861 case SMESHOp::OpConnection:
3862 case SMESHOp::OpEqualEdge:
3863 case SMESHOp::OpFreeFace:
3864 case SMESHOp::OpBareBorderFace:
3865 case SMESHOp::OpOverConstrainedFace:
3866 case SMESHOp::OpLength2D:
3867 case SMESHOp::OpDeflection2D:
3868 case SMESHOp::OpConnection2D:
3869 case SMESHOp::OpArea:
3870 case SMESHOp::OpTaper:
3871 case SMESHOp::OpAspectRatio:
3872 case SMESHOp::OpMinimumAngle:
3873 case SMESHOp::OpWarpingAngle:
3874 case SMESHOp::OpSkew:
3875 case SMESHOp::OpMaxElementLength2D:
3876 case SMESHOp::OpEqualFace:
3877 case SMESHOp::OpAspectRatio3D:
3878 case SMESHOp::OpVolume:
3879 case SMESHOp::OpMaxElementLength3D:
3880 case SMESHOp::OpBareBorderVolume:
3881 case SMESHOp::OpOverConstrainedVolume:
3882 case SMESHOp::OpEqualVolume:
3885 LightApp_SelectionMgr* mgr = selectionMgr();
3886 SALOME_ListIO selected; mgr->selectedObjects( selected );
3888 if( !selected.IsEmpty() ) {
3889 SUIT_OverrideCursor wc;
3890 ::Control( theCommandID );
3893 SUIT_MessageBox::warning(desktop(),
3894 tr( "SMESH_WRN_WARNING" ),
3895 tr( "SMESH_BAD_SELECTION" ) );
3899 SUIT_MessageBox::warning(desktop(),
3900 tr( "SMESH_WRN_WARNING" ),
3901 tr( "NOT_A_VTK_VIEWER" ) );
3904 case SMESHOp::OpOverallMeshQuality:
3905 OverallMeshQuality();
3907 case SMESHOp::OpNumberingNodes:
3909 SUIT_OverrideCursor wc;
3910 LightApp_SelectionMgr* mgr = selectionMgr();
3911 SALOME_ListIO selected; mgr->selectedObjects( selected );
3913 SALOME_ListIteratorOfListIO it(selected);
3914 for( ; it.More(); it.Next()) {
3915 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3916 if(anIObject->hasEntry()) {
3917 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3918 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3924 case SMESHOp::OpNumberingElements:
3926 SUIT_OverrideCursor wc;
3927 LightApp_SelectionMgr* mgr = selectionMgr();
3928 SALOME_ListIO selected; mgr->selectedObjects( selected );
3930 SALOME_ListIteratorOfListIO it(selected);
3931 for( ; it.More(); it.Next()) {
3932 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3933 if(anIObject->hasEntry())
3934 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3935 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3940 case SMESHOp::OpPropertiesLength:
3941 case SMESHOp::OpPropertiesArea:
3942 case SMESHOp::OpPropertiesVolume:
3943 case SMESHOp::OpMinimumDistance:
3944 case SMESHOp::OpBoundingBox:
3945 case SMESHOp::OpAngle:
3947 int page = SMESHGUI_MeasureDlg::MinDistance;
3948 if ( theCommandID == SMESHOp::OpBoundingBox )
3949 page = SMESHGUI_MeasureDlg::BoundingBox;
3950 else if ( theCommandID == SMESHOp::OpPropertiesLength )
3951 page = SMESHGUI_MeasureDlg::Length;
3952 else if ( theCommandID == SMESHOp::OpPropertiesArea )
3953 page = SMESHGUI_MeasureDlg::Area;
3954 else if ( theCommandID == SMESHOp::OpPropertiesVolume )
3955 page = SMESHGUI_MeasureDlg::Volume;
3956 else if ( theCommandID == SMESHOp::OpAngle )
3957 page = SMESHGUI_MeasureDlg::Angle;
3959 EmitSignalDeactivateDialog();
3960 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3964 case SMESHOp::OpSortChild:
3967 case SMESHOp::OpBreakLink:
3968 ::breakShaperLink();
3973 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3974 //updateObjBrowser();
3978 //=============================================================================
3982 //=============================================================================
3983 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3988 //=============================================================================
3992 //=============================================================================
3993 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3998 //=============================================================================
4002 //=============================================================================
4003 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
4008 //=============================================================================
4009 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
4010 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
4012 //=============================================================================
4013 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
4014 SUIT_ViewWindow* wnd )
4016 if(theIO->hasEntry()){
4017 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
4018 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
4022 //=======================================================================
4023 // function : createSMESHAction
4025 //=======================================================================
4026 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
4027 const int key, const bool toggle, const QString& shortcutAction )
4030 QWidget* parent = application()->desktop();
4031 SUIT_ResourceMgr* resMgr = resourceMgr();
4033 if ( !icon_id.isEmpty() )
4034 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
4036 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICON_%1" ).arg( po_id ).toLatin1().data() ), false );
4037 if ( !pix.isNull() )
4038 icon = QIcon( pix );
4040 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
4041 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
4042 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
4044 createAction( id, tooltip, icon, menu, status_bar, key, parent,
4045 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
4048 //=======================================================================
4049 // function : createPopupItem
4051 //=======================================================================
4052 void SMESHGUI::createPopupItem( const int id,
4053 const QString& clients,
4054 const QString& types,
4055 const QString& theRule,
4058 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
4059 popupMgr()->insert( action( id ), pId, 0 );
4061 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4062 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4063 QString rule = "(%1) and (%2) and (%3)";
4064 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
4065 if( clients.isEmpty() )
4066 rule = rule.arg( QString( "true" ) );
4068 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
4069 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
4072 bool cont = myRules.contains( id );
4074 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
4076 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
4077 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
4080 //=======================================================================
4081 // function : initialize
4083 //=======================================================================
4084 void SMESHGUI::initialize( CAM_Application* app )
4086 SalomeApp_Module::initialize( app );
4088 // SUIT_ResourceMgr* mgr = app->resourceMgr();
4090 /* Automatic Update flag */
4091 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
4093 // ----- create actions --------------
4095 //createSMESHAction( SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
4096 createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_I) );
4097 createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
4098 createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL" );
4100 createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
4102 createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
4103 createSMESHAction( SMESHOp::OpImportGMF, "IMPORT_GMF" );
4104 createSMESHAction( SMESHOp::OpPopupImportUNV, "IMPORT_UNV");
4105 createSMESHAction( SMESHOp::OpPopupImportMED, "IMPORT_MED");
4106 createSMESHAction( SMESHOp::OpPopupImportSTL, "IMPORT_STL" );
4108 createSMESHAction( SMESHOp::OpPopupImportCGNS, "IMPORT_CGNS" );
4110 createSMESHAction( SMESHOp::OpPopupImportSAUV, "IMPORT_SAUV" );
4111 createSMESHAction( SMESHOp::OpPopupImportGMF, "IMPORT_GMF" );
4113 createSMESHAction( SMESHOp::OpExportDAT, "DAT" );
4114 createSMESHAction( SMESHOp::OpExportMED, "MED" );
4115 createSMESHAction( SMESHOp::OpExportUNV, "UNV" );
4116 createSMESHAction( SMESHOp::OpExportSTL, "STL" );
4118 createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
4120 createSMESHAction( SMESHOp::OpExportSAUV, "SAUV");
4121 createSMESHAction( SMESHOp::OpExportGMF, "GMF" );
4122 createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
4123 createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
4124 createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
4125 createSMESHAction( SMESHOp::OpPopupExportSTL, "STL" );
4127 createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
4129 createSMESHAction( SMESHOp::OpPopupExportSAUV, "SAUV");
4130 createSMESHAction( SMESHOp::OpPopupExportGMF, "GMF" );
4131 createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
4132 createSMESHAction( SMESHOp::OpDelete, "DELETE", "ICON_DELETE", Qt::Key_Delete );
4133 createSMESHAction( SMESHOp::OpSelectFiltersLibrary, "SEL_FILTER_LIB" );
4134 createSMESHAction( SMESHOp::OpCreateMesh, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
4135 createSMESHAction( SMESHOp::OpCreateSubMesh, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
4136 createSMESHAction( SMESHOp::OpEditMeshOrSubMesh, "EDIT_MESHSUBMESH", "ICON_DLG_EDIT_MESH" );
4137 createSMESHAction( SMESHOp::OpEditMesh, "EDIT_MESH", "ICON_DLG_EDIT_MESH" );
4138 createSMESHAction( SMESHOp::OpEditSubMesh, "EDIT_SUBMESH", "ICON_DLG_EDIT_MESH" );
4139 createSMESHAction( SMESHOp::OpBuildCompoundMesh, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
4140 createSMESHAction( SMESHOp::OpCopyMesh, "COPY_MESH", "ICON_COPY_MESH" );
4141 createSMESHAction( SMESHOp::OpCompute, "COMPUTE", "ICON_COMPUTE" );
4142 createSMESHAction( SMESHOp::OpComputeSubMesh, "COMPUTE_SUBMESH", "ICON_COMPUTE" );
4143 createSMESHAction( SMESHOp::OpRecompute, "RE_COMPUTE", "ICON_COMPUTE" );
4144 createSMESHAction( SMESHOp::OpPreCompute, "PRECOMPUTE", "ICON_PRECOMPUTE" );
4145 createSMESHAction( SMESHOp::OpShowErrors, "SHOW_ERRORS", "ICON_SHOW_ERRORS" );
4146 createSMESHAction( SMESHOp::OpEvaluate, "EVALUATE", "ICON_EVALUATE" );
4147 createSMESHAction( SMESHOp::OpMeshOrder, "MESH_ORDER", "ICON_MESH_ORDER");
4148 createSMESHAction( SMESHOp::OpCreateGroup, "CREATE_GROUP", "ICON_CREATE_GROUP" );
4149 createSMESHAction( SMESHOp::OpCreateGeometryGroup, "CREATE_GEO_GROUP", "ICON_CREATE_GEO_GROUP" );
4150 createSMESHAction( SMESHOp::OpConstructGroup, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
4151 createSMESHAction( SMESHOp::OpEditGroup, "EDIT_GROUP", "ICON_EDIT_GROUP" );
4152 createSMESHAction( SMESHOp::OpEditGeomGroupAsGroup, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
4153 createSMESHAction( SMESHOp::OpUnionGroups, "UN_GROUP", "ICON_UNION" );
4154 createSMESHAction( SMESHOp::OpIntersectGroups, "INT_GROUP", "ICON_INTERSECT" );
4155 createSMESHAction( SMESHOp::OpCutGroups, "CUT_GROUP", "ICON_CUT" );
4156 createSMESHAction( SMESHOp::OpGroupUnderlyingElem, "UNDERLYING_ELEMS", "ICON_UNDERLYING_ELEMS" );
4157 createSMESHAction( SMESHOp::OpFaceGroupsByEdges, "FACE_GROUPS_BY_EDGES", "ICON_FACE_GROUPS_BY_EDGES" );
4158 createSMESHAction( SMESHOp::OpAddElemGroupPopup, "ADD_TO_GROUP" );
4159 createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE_FROM_GROUP" );
4160 createSMESHAction( SMESHOp::OpDeleteGroup, "DEL_GROUP", "ICON_DEL_GROUP" );
4161 createSMESHAction( SMESHOp::OpMeshInformation , "ADV_INFO", "ICON_ADV_INFO" );
4162 //createSMESHAction( SMESHOp::OpStdInfo, "STD_INFO", "ICON_STD_INFO" );
4163 //createSMESHAction( SMESHOp::OpWhatIs, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4164 createSMESHAction( SMESHOp::OpFindElementByPoint, "FIND_ELEM", "ICON_FIND_ELEM" );
4166 createSMESHAction( SMESHOp::OpFreeNode, "FREE_NODE", "ICON_FREE_NODE", 0, true );
4167 createSMESHAction( SMESHOp::OpEqualNode, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
4168 createSMESHAction( SMESHOp::OpNodeConnectivityNb, "NODE_CONNECTIVITY_NB", "ICON_NODE_CONN_NB", 0, true );
4169 createSMESHAction( SMESHOp::OpFreeEdge, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
4170 createSMESHAction( SMESHOp::OpFreeBorder, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
4171 createSMESHAction( SMESHOp::OpLength, "LENGTH", "ICON_LENGTH", 0, true );
4172 createSMESHAction( SMESHOp::OpConnection, "CONNECTION", "ICON_CONNECTION", 0, true );
4173 createSMESHAction( SMESHOp::OpEqualEdge, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
4174 createSMESHAction( SMESHOp::OpFreeFace, "FREE_FACES", "ICON_FREE_FACES", 0, true );
4175 createSMESHAction( SMESHOp::OpBareBorderFace, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
4176 createSMESHAction( SMESHOp::OpOverConstrainedFace, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
4177 createSMESHAction( SMESHOp::OpLength2D, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
4178 createSMESHAction( SMESHOp::OpDeflection2D, "DEFLECTION_2D", "ICON_DEFLECTION_2D", 0, true );
4179 createSMESHAction( SMESHOp::OpConnection2D, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
4180 createSMESHAction( SMESHOp::OpArea, "AREA", "ICON_AREA", 0, true );
4181 createSMESHAction( SMESHOp::OpTaper, "TAPER", "ICON_TAPER", 0, true );
4182 createSMESHAction( SMESHOp::OpAspectRatio, "ASPECT", "ICON_ASPECT", 0, true );
4183 createSMESHAction( SMESHOp::OpMinimumAngle, "MIN_ANG", "ICON_ANGLE", 0, true );
4184 createSMESHAction( SMESHOp::OpWarpingAngle, "WARP", "ICON_WARP", 0, true );
4185 createSMESHAction( SMESHOp::OpSkew, "SKEW", "ICON_SKEW", 0, true );
4186 createSMESHAction( SMESHOp::OpMaxElementLength2D, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
4187 createSMESHAction( SMESHOp::OpEqualFace, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
4188 createSMESHAction( SMESHOp::OpAspectRatio3D, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
4189 createSMESHAction( SMESHOp::OpVolume, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
4190 createSMESHAction( SMESHOp::OpMaxElementLength3D, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
4191 createSMESHAction( SMESHOp::OpBareBorderVolume, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
4192 createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
4193 createSMESHAction( SMESHOp::OpEqualVolume, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
4194 createSMESHAction( SMESHOp::OpOverallMeshQuality, "OVERALL_MESH_QUALITY", "ICON_OVL_MESH_QUALITY" );
4196 createSMESHAction( SMESHOp::OpNode, "NODE", "ICON_DLG_NODE" );
4197 createSMESHAction( SMESHOp::OpElem0D, "ELEM0D", "ICON_DLG_ELEM0D" );
4198 createSMESHAction( SMESHOp::OpElem0DOnElemNodes, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
4199 createSMESHAction( SMESHOp::OpBall, "BALL", "ICON_DLG_BALL" );
4200 createSMESHAction( SMESHOp::OpEdge, "EDGE", "ICON_DLG_EDGE" );
4201 createSMESHAction( SMESHOp::OpTriangle, "TRIANGLE", "ICON_DLG_TRIANGLE" );
4202 createSMESHAction( SMESHOp::OpQuadrangle, "QUAD", "ICON_DLG_QUADRANGLE" );
4203 createSMESHAction( SMESHOp::OpPolygon, "POLYGON", "ICON_DLG_POLYGON" );
4204 createSMESHAction( SMESHOp::OpTetrahedron, "TETRA", "ICON_DLG_TETRAS" );
4205 createSMESHAction( SMESHOp::OpHexahedron, "HEXA", "ICON_DLG_HEXAS" );
4206 createSMESHAction( SMESHOp::OpPentahedron, "PENTA", "ICON_DLG_PENTA" );
4207 createSMESHAction( SMESHOp::OpPyramid , "PYRAMID", "ICON_DLG_PYRAMID" );
4208 createSMESHAction( SMESHOp::OpHexagonalPrism, "OCTA", "ICON_DLG_OCTA" );
4209 createSMESHAction( SMESHOp::OpPolyhedron, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
4210 createSMESHAction( SMESHOp::OpQuadraticEdge, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
4211 createSMESHAction( SMESHOp::OpQuadraticTriangle, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
4212 createSMESHAction( SMESHOp::OpBiQuadraticTriangle, "BIQUADRATIC_TRIANGLE", "ICON_DLG_BIQUADRATIC_TRIANGLE" );
4213 createSMESHAction( SMESHOp::OpQuadraticQuadrangle, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
4214 createSMESHAction( SMESHOp::OpBiQuadraticQuadrangle, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
4215 createSMESHAction( SMESHOp::OpQuadraticPolygon, "QUADRATIC_POLYGON", "ICON_DLG_QUADRATIC_POLYGON" );
4216 createSMESHAction( SMESHOp::OpQuadraticTetrahedron, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
4217 createSMESHAction( SMESHOp::OpQuadraticPyramid, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
4218 createSMESHAction( SMESHOp::OpQuadraticPentahedron, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
4219 createSMESHAction( SMESHOp::OpBiQuadraticPentahedron, "BIQUADRATIC_PENTAHEDRON", "ICON_DLG_BIQUADRATIC_PENTAHEDRON" );
4220 createSMESHAction( SMESHOp::OpQuadraticHexahedron, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
4221 createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
4223 createSMESHAction( SMESHOp::OpRemoveNodes, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
4224 createSMESHAction( SMESHOp::OpRemoveElements, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
4225 createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
4226 createSMESHAction( SMESHOp::OpClearMesh, "CLEAR_MESH", "ICON_CLEAR_MESH" );
4228 //createSMESHAction( SMESHOp::OpRenumberingNodes, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
4229 //createSMESHAction( SMESHOp::OpRenumberingElements, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
4231 createSMESHAction( SMESHOp::OpTranslation, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
4232 createSMESHAction( SMESHOp::OpRotation, "ROT", "ICON_DLG_MESH_ROTATION" );
4233 createSMESHAction( SMESHOp::OpSymmetry, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
4234 createSMESHAction( SMESHOp::OpScale, "SCALE", "ICON_DLG_MESH_SCALE" );
4235 createSMESHAction( SMESHOp::OpOffset, "OFFSET", "ICON_DLG_MESH_OFFSET" );
4236 createSMESHAction( SMESHOp::OpSewing, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
4237 createSMESHAction( SMESHOp::OpMergeNodes, "MERGE", "ICON_SMESH_MERGE_NODES" );
4238 createSMESHAction( SMESHOp::OpMergeElements, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
4239 createSMESHAction( SMESHOp::OpMoveNode, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
4240 createSMESHAction( SMESHOp::OpDuplicateNodes, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
4241 createSMESHAction( SMESHOp::OpDiagonalInversion, "INV", "ICON_DLG_MESH_DIAGONAL" );
4242 createSMESHAction( SMESHOp::OpUnionOfTwoTriangle, "UNION2", "ICON_UNION2TRI" );
4243 createSMESHAction( SMESHOp::OpOrientation, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
4244 createSMESHAction( SMESHOp::OpReorientFaces, "REORIENT_2D", "ICON_REORIENT_2D" );
4245 createSMESHAction( SMESHOp::OpUnionOfTriangles, "UNION", "ICON_UNIONTRI" );
4246 createSMESHAction( SMESHOp::OpCuttingOfQuadrangles, "CUT", "ICON_CUTQUAD" );
4247 createSMESHAction( SMESHOp::OpSplitVolumes, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
4248 createSMESHAction( SMESHOp::OpSplitBiQuadratic, "SPLIT_BIQUAD", "ICON_SPLIT_BIQUAD" );
4249 createSMESHAction( SMESHOp::OpSmoothing, "SMOOTH", "ICON_DLG_SMOOTHING" );
4250 createSMESHAction( SMESHOp::OpExtrusion, "EXTRUSION", "ICON_EXTRUSION" );
4251 createSMESHAction( SMESHOp::OpExtrusionAlongAPath, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
4252 createSMESHAction( SMESHOp::OpRevolution, "REVOLUTION", "ICON_REVOLUTION" );
4253 createSMESHAction( SMESHOp::OpPatternMapping, "MAP", "ICON_MAP" );
4254 createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
4255 createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D", "ICON_2D_FROM_3D" );
4257 createSMESHAction( SMESHOp::OpReset, "RESET" );
4258 createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
4259 createSMESHAction( SMESHOp::OpShowScalarBar, "SHOW_SCALAR_BAR","",0, true );
4260 createSMESHAction( SMESHOp::OpSaveDistribution, "SAVE_DISTRIBUTION" );
4261 createSMESHAction( SMESHOp::OpShowDistribution, "SHOW_DISTRIBUTION","",0, true );
4262 #ifndef DISABLE_PLOT2DVIEWER
4263 createSMESHAction( SMESHOp::OpPlotDistribution, "PLOT_DISTRIBUTION" );
4265 createSMESHAction( SMESHOp::OpDMWireframe, "WIRE", "ICON_WIRE", 0, true );
4266 createSMESHAction( SMESHOp::OpDMShading, "SHADE", "ICON_SHADE", 0, true );
4267 createSMESHAction( SMESHOp::OpDMNodes, "NODES", "ICON_POINTS", 0, true );
4268 createSMESHAction( SMESHOp::OpDMShrink, "SHRINK", "ICON_SHRINK", 0, true );
4269 createSMESHAction( SMESHOp::OpUpdate, "UPDATE", "ICON_UPDATE" );
4270 createSMESHAction( SMESHOp::OpDE0DElements, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
4271 createSMESHAction( SMESHOp::OpDEEdges, "EDGES", "ICON_DLG_EDGE", 0, true );
4272 createSMESHAction( SMESHOp::OpDEFaces, "FACES", "ICON_DLG_TRIANGLE", 0, true );
4273 createSMESHAction( SMESHOp::OpDEVolumes, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
4274 createSMESHAction( SMESHOp::OpDEBalls, "BALLS", "ICON_DLG_BALL", 0, true );
4275 createSMESHAction( SMESHOp::OpDEChoose, "CHOOSE", "ICON_DLG_CHOOSE", 0, false );
4276 createSMESHAction( SMESHOp::OpDEAllEntity, "ALL", "ICON_DLG_CHOOSE_ALL", 0, false );
4277 createSMESHAction( SMESHOp::OpOrientationOnFaces, "FACE_ORIENTATION", "", 0, true );
4279 createSMESHAction( SMESHOp::OpRepresentationLines, "LINE_REPRESENTATION", "", 0, true );
4280 createSMESHAction( SMESHOp::OpRepresentationArcs, "ARC_REPRESENTATION", "", 0, true );
4282 createSMESHAction( SMESHOp::OpEditHypothesis, "EDIT_HYPO" );
4283 createSMESHAction( SMESHOp::OpUnassign, "UNASSIGN" );
4284 createSMESHAction( SMESHOp::OpNumberingNodes, "NUM_NODES", "", 0, true );
4285 createSMESHAction( SMESHOp::OpNumberingElements, "NUM_ELEMENTS", "", 0, true );
4286 createSMESHAction( SMESHOp::OpProperties, "COLORS" );
4287 createSMESHAction( SMESHOp::OpTransparency, "TRANSP" );
4288 createSMESHAction( SMESHOp::OpClipping, "CLIP" );
4289 createSMESHAction( SMESHOp::OpAutoColor, "AUTO_COLOR" );
4290 createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
4293 createSMESHAction( SMESHOp::OpUniformRefinement, "REF_ALL", "ICON_REF_ALL" );
4294 createSMESHAction( SMESHOp::OpHONewCase, "HOMARD_CREATE_CASE", "ICON_HOMARD_CREATE_CASE" );
4295 createSMESHAction( SMESHOp::OpHOCaseFollow, "HOMARD_FOLLOW_ITERATION", "ICON_HOMARD_FOLLOW_ITERATION" );
4296 createSMESHAction( SMESHOp::OpHONewIter, "HOMARD_NEW_ITERATION", "ICON_HOMARD_NEW_ITERATION" );
4297 createSMESHAction( SMESHOp::OpHOIterCompute, "HOMARD_COMPUTE", "ICON_HOMARD_COMPUTE" );
4298 createSMESHAction( SMESHOp::OpHOIterComputePublish, "HOMARD_COMPUTE_PUBLISH", "ICON_HOMARD_COMPUTE_PUBLISH" );
4299 createSMESHAction( SMESHOp::OpHOEdit, "EDIT", "ICON_DLG_EDIT_MESH" );
4300 createSMESHAction( SMESHOp::OpHODelete, "DELETE", "ICON_DELETE" );
4301 createSMESHAction( SMESHOp::OpMGAdapt, "MG_ADAPT", "ICON_MG_ADAPT" );
4303 createSMESHAction( SMESHOp::OpMinimumDistance, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
4304 createSMESHAction( SMESHOp::OpBoundingBox, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
4305 createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH", "ICON_MEASURE_LENGTH" );
4306 createSMESHAction( SMESHOp::OpPropertiesArea, "MEASURE_AREA", "ICON_MEASURE_AREA" );
4307 createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME", "ICON_MEASURE_VOLUME" );
4308 createSMESHAction( SMESHOp::OpAngle, "MEASURE_ANGLE", "ICON_MEASURE_ANGLE" );
4310 createSMESHAction( SMESHOp::OpHide, "HIDE", "ICON_HIDE" );
4311 createSMESHAction( SMESHOp::OpShow, "SHOW", "ICON_SHOW" );
4312 createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
4314 createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
4316 createSMESHAction( SMESHOp::OpBreakLink, "BREAK_SHAPER_LINK" );
4318 QList<int> aCtrlActions;
4319 aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode
4320 << SMESHOp::OpNodeConnectivityNb // node controls
4321 << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
4322 << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge // edge controls
4323 << SMESHOp::OpDeflection2D
4324 << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
4325 << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
4326 << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
4327 << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
4328 << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace // face controls
4329 << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
4330 << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
4331 << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume; // volume controls
4332 QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
4333 aCtrlGroup->setExclusive( true );
4334 for( int i = 0; i < aCtrlActions.size(); i++ )
4335 aCtrlGroup->addAction( action( aCtrlActions[i] ) );
4337 // ----- create menu --------------
4338 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
4339 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
4340 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
4341 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
4342 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
4343 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
4344 adaptId = createMenu( tr( "MEN_ADAPT" ), -1, 80, 10 ),
4345 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
4346 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
4348 createMenu( separator(), fileId );
4350 QMenu* nodeMenu = new QMenu(); QMenu* edgeMenu = new QMenu();
4351 QMenu* faceMenu = new QMenu(); QMenu* volumeMenu = new QMenu();
4352 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
4353 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
4354 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10, -1, nodeMenu ),
4355 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10, -1, edgeMenu ),
4356 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10, -1, faceMenu ),
4357 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10, -1, volumeMenu ),
4358 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
4359 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
4360 //renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
4361 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
4362 refHomardId = createMenu( tr( "MEN_REF_HOMARD" ), adaptId, -1, 10 ),
4363 basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
4365 //createMenu( SMESHOp::OpImportDAT, importId, -1 );
4366 createMenu( SMESHOp::OpImportUNV, importId, -1 );
4367 createMenu( SMESHOp::OpImportMED, importId, -1 );
4368 createMenu( SMESHOp::OpImportSTL, importId, -1 );
4370 createMenu( SMESHOp::OpImportCGNS, importId, -1 );
4372 createMenu( SMESHOp::OpImportSAUV, importId, -1 );
4373 createMenu( SMESHOp::OpImportGMF, importId, -1 );
4374 createMenu( SMESHOp::OpExportDAT, exportId, -1 );
4375 createMenu( SMESHOp::OpExportMED, exportId, -1 );
4376 createMenu( SMESHOp::OpExportUNV, exportId, -1 );
4377 createMenu( SMESHOp::OpExportSTL, exportId, -1 );
4379 createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
4381 createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
4382 createMenu( SMESHOp::OpExportGMF, exportId, -1 );
4383 createMenu( separator(), fileId, 10 );
4385 createMenu( SMESHOp::OpDelete, editId, -1 );
4387 createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
4389 createMenu( SMESHOp::OpCreateMesh, meshId, -1 ); // "Mesh" menu
4390 createMenu( SMESHOp::OpCreateSubMesh, meshId, -1 );
4391 createMenu( SMESHOp::OpEditMeshOrSubMesh, meshId, -1 );
4392 createMenu( SMESHOp::OpBuildCompoundMesh, meshId, -1 );
4393 createMenu( SMESHOp::OpCopyMesh, meshId, -1 );
4394 createMenu( separator(), meshId, -1 );
4395 createMenu( SMESHOp::OpCompute, meshId, -1 );
4396 createMenu( SMESHOp::OpPreCompute, meshId, -1 );
4397 createMenu( SMESHOp::OpEvaluate, meshId, -1 );
4398 createMenu( SMESHOp::OpMeshOrder, meshId, -1 );
4399 createMenu( separator(), meshId, -1 );
4400 createMenu( SMESHOp::OpCreateGroup, meshId, -1 );
4401 createMenu( SMESHOp::OpCreateGeometryGroup, meshId, -1 );
4402 createMenu( SMESHOp::OpConstructGroup, meshId, -1 );
4403 createMenu( SMESHOp::OpEditGroup, meshId, -1 );
4404 createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4405 createMenu( separator(), meshId, -1 );
4406 createMenu( SMESHOp::OpUnionGroups, meshId, -1 );
4407 createMenu( SMESHOp::OpIntersectGroups, meshId, -1 );
4408 createMenu( SMESHOp::OpCutGroups, meshId, -1 );
4409 createMenu( separator(), meshId, -1 );
4410 createMenu( SMESHOp::OpGroupUnderlyingElem, meshId, -1 );
4411 createMenu( SMESHOp::OpFaceGroupsByEdges, meshId, -1 );
4412 createMenu( separator(), meshId, -1 );
4413 createMenu( SMESHOp::OpMeshInformation, meshId, -1 );
4414 //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4415 //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4416 createMenu( SMESHOp::OpFindElementByPoint, meshId, -1 );
4417 createMenu( separator(), meshId, -1 );
4419 createMenu( SMESHOp::OpFreeNode, nodeId, -1 );
4420 createMenu( SMESHOp::OpEqualNode, nodeId, -1 );
4421 //createMenu( SMESHOp::OpNodeConnectivityNb, nodeId, -1 );
4422 createMenu( SMESHOp::OpFreeBorder, edgeId, -1 );
4423 createMenu( SMESHOp::OpLength, edgeId, -1 );
4424 createMenu( SMESHOp::OpConnection, edgeId, -1 );
4425 createMenu( SMESHOp::OpEqualEdge, edgeId, -1 );
4426 createMenu( SMESHOp::OpFreeEdge, faceId, -1 );
4427 createMenu( SMESHOp::OpFreeFace, faceId, -1 );
4428 createMenu( SMESHOp::OpBareBorderFace, faceId, -1 );
4429 createMenu( SMESHOp::OpOverConstrainedFace, faceId, -1 );
4430 createMenu( SMESHOp::OpLength2D, faceId, -1 );
4431 createMenu( SMESHOp::OpConnection2D, faceId, -1 );
4432 createMenu( SMESHOp::OpArea, faceId, -1 );
4433 createMenu( SMESHOp::OpTaper, faceId, -1 );
4434 createMenu( SMESHOp::OpAspectRatio, faceId, -1 );
4435 createMenu( SMESHOp::OpMinimumAngle, faceId, -1 );
4436 createMenu( SMESHOp::OpWarpingAngle, faceId, -1 );
4437 createMenu( SMESHOp::OpSkew, faceId, -1 );
4438 createMenu( SMESHOp::OpMaxElementLength2D, faceId, -1 );
4439 createMenu( SMESHOp::OpEqualFace, faceId, -1 );
4440 createMenu( SMESHOp::OpDeflection2D, faceId, -1 );
4441 createMenu( SMESHOp::OpAspectRatio3D, volumeId, -1 );
4442 createMenu( SMESHOp::OpVolume, volumeId, -1 );
4443 createMenu( SMESHOp::OpMaxElementLength3D, volumeId, -1 );
4444 createMenu( SMESHOp::OpBareBorderVolume, volumeId, -1 );
4445 createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4446 createMenu( SMESHOp::OpEqualVolume, volumeId, -1 );
4447 createMenu( separator(), ctrlId, -1 );
4448 createMenu( SMESHOp::OpReset, ctrlId, -1 );
4449 createMenu( separator(), ctrlId, -1 );
4450 createMenu( SMESHOp::OpOverallMeshQuality, ctrlId, -1 );
4452 createMenu( SMESHOp::OpNode, addId, -1 );
4453 createMenu( SMESHOp::OpElem0D, addId, -1 );
4454 createMenu( SMESHOp::OpElem0DOnElemNodes, addId, -1 );
4455 createMenu( SMESHOp::OpBall, addId, -1 );
4456 createMenu( SMESHOp::OpEdge, addId, -1 );
4457 createMenu( SMESHOp::OpTriangle, addId, -1 );
4458 createMenu( SMESHOp::OpQuadrangle, addId, -1 );
4459 createMenu( SMESHOp::OpPolygon, addId, -1 );
4460 createMenu( SMESHOp::OpTetrahedron, addId, -1 );
4461 createMenu( SMESHOp::OpHexahedron, addId, -1 );
4462 createMenu( SMESHOp::OpPentahedron, addId, -1 );
4463 createMenu( SMESHOp::OpPyramid, addId, -1 );
4464 createMenu( SMESHOp::OpHexagonalPrism, addId, -1 );
4465 createMenu( SMESHOp::OpPolyhedron, addId, -1 );
4466 createMenu( separator(), addId, -1 );
4467 createMenu( SMESHOp::OpQuadraticEdge, addId, -1 );
4468 createMenu( SMESHOp::OpQuadraticTriangle, addId, -1 );
4469 createMenu( SMESHOp::OpBiQuadraticTriangle , addId, -1 );
4470 createMenu( SMESHOp::OpQuadraticQuadrangle, addId, -1 );
4471 createMenu( SMESHOp::OpBiQuadraticQuadrangle, addId, -1 );
4472 createMenu( SMESHOp::OpQuadraticPolygon, addId, -1 );
4473 createMenu( SMESHOp::OpQuadraticTetrahedron, addId, -1 );
4474 createMenu( SMESHOp::OpQuadraticPyramid, addId, -1 );
4475 createMenu( SMESHOp::OpQuadraticPentahedron, addId, -1 );
4476 createMenu( SMESHOp::OpBiQuadraticPentahedron, addId, -1 );
4477 createMenu( SMESHOp::OpQuadraticHexahedron, addId, -1 );
4478 createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4480 createMenu( SMESHOp::OpRemoveNodes, removeId, -1 );
4481 createMenu( SMESHOp::OpRemoveElements, removeId, -1 );
4482 createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4483 createMenu( separator(), removeId, -1 );
4484 createMenu( SMESHOp::OpDeleteGroup, removeId, -1 );
4485 createMenu( separator(), removeId, -1 );
4486 createMenu( SMESHOp::OpClearMesh, removeId, -1 );
4488 //createMenu( SMESHOp::OpRenumberingNodes, renumId, -1 );
4489 //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4491 createMenu( SMESHOp::OpMergeNodes, transfId, -1 );
4492 createMenu( SMESHOp::OpMergeElements, transfId, -1 );
4493 createMenu( SMESHOp::OpTranslation, transfId, -1 );
4494 createMenu( SMESHOp::OpRotation, transfId, -1 );
4495 createMenu( SMESHOp::OpSymmetry, transfId, -1 );
4496 createMenu( SMESHOp::OpScale, transfId, -1 );
4497 createMenu( SMESHOp::OpOffset, transfId, -1 );
4498 createMenu( SMESHOp::OpSewing, transfId, -1 );
4499 createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4501 createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4502 createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4503 createMenu( SMESHOp::OpExtrusion, modifyId, -1 );
4504 createMenu( SMESHOp::OpExtrusionAlongAPath, modifyId, -1 );
4505 createMenu( SMESHOp::OpRevolution, modifyId, -1 );
4506 createMenu( SMESHOp::OpOrientation, modifyId, -1 );
4507 createMenu( SMESHOp::OpReorientFaces, modifyId, -1 );
4508 createMenu( SMESHOp::OpMoveNode, modifyId, -1 );
4509 createMenu( SMESHOp::OpDiagonalInversion, modifyId, -1 );
4510 createMenu( SMESHOp::OpUnionOfTwoTriangle, modifyId, -1 );
4511 createMenu( SMESHOp::OpUnionOfTriangles, modifyId, -1 );
4512 createMenu( SMESHOp::OpCuttingOfQuadrangles, modifyId, -1 );
4513 createMenu( SMESHOp::OpSplitVolumes, modifyId, -1 );
4514 createMenu( SMESHOp::OpSplitBiQuadratic, modifyId, -1 );
4515 createMenu( SMESHOp::OpSmoothing, modifyId, -1 );
4516 createMenu( SMESHOp::OpPatternMapping, modifyId, -1 );
4518 createMenu( SMESHOp::OpUniformRefinement, adaptId, -1 );
4519 createMenu( SMESHOp::OpHONewCase, refHomardId, -1 );
4520 createMenu( SMESHOp::OpHOCaseFollow, refHomardId, -1 );
4521 createMenu( separator(), refHomardId, -1 );
4522 createMenu( SMESHOp::OpHONewIter, refHomardId, -1 );
4523 createMenu( SMESHOp::OpHOIterCompute, refHomardId, -1 );
4524 createMenu( SMESHOp::OpHOIterComputePublish, refHomardId, -1 );
4525 createMenu( separator(), refHomardId, -1 );
4526 createMenu( SMESHOp::OpHOEdit, refHomardId, -1 );
4527 createMenu( SMESHOp::OpHODelete, refHomardId, -1 );
4528 createMenu( SMESHOp::OpMGAdapt, adaptId, -1 );
4530 createMenu( SMESHOp::OpMinimumDistance, measureId, -1 );
4531 createMenu( SMESHOp::OpBoundingBox, measureId, -1 );
4532 createMenu( SMESHOp::OpAngle, measureId, -1 );
4533 createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4534 createMenu( SMESHOp::OpPropertiesArea, basicPropId, -1 );
4535 createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4536 createMenu( SMESHOp::OpUpdate, viewId, -1 );
4538 connect( nodeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4539 connect( edgeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4540 connect( faceMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4541 connect( volumeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4543 // ----- create toolbars --------------
4544 int meshTb = createTool( tr( "TB_MESH" ), QString( "SMESHMeshToolbar" ) ),
4545 info = createTool( tr( "TB_INFO" ), QString( "SMESHInformationToolbar" ) ),
4546 groupTb = createTool( tr( "TB_GROUP" ), QString( "SMESHGroupToolbar" ) ),
4547 ctrl0dTb = createTool( tr( "TB_CTRL0D" ), QString( "SMESHNodeControlsToolbar" ) ),
4548 ctrl1dTb = createTool( tr( "TB_CTRL1D" ), QString( "SMESHEdgeControlsToolbar" ) ),
4549 ctrl2dTb = createTool( tr( "TB_CTRL2D" ), QString( "SMESHFaceControlsToolbar" ) ),
4550 ctrl3dTb = createTool( tr( "TB_CTRL3D" ), QString( "SMESHVolumeControlsToolbar" ) ),
4551 addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ),
4552 addNonElemTb = createTool( tr( "TB_ADDNON" ), QString( "SMESHAddElementToolbar" ) ),
4553 remTb = createTool( tr( "TB_REM" ), QString( "SMESHRemoveToolbar" ) ),
4554 //renumbTb = createTool( tr( "TB_RENUMBER" ), QString( "SMESHRenumberingToolbar" ) ),
4555 transformTb = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ),
4556 modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ),
4557 // adaptTb = createTool( tr( "TB_ADAPTATION" ),QString( "SMESHAdaptationToolbar" ) ),
4558 measuremTb = createTool( tr( "TB_MEASUREM" ), QString( "SMESHMeasurementsToolbar" ) ),
4559 dispModeTb = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4561 createTool( SMESHOp::OpCreateMesh, meshTb );
4562 createTool( SMESHOp::OpCreateSubMesh, meshTb );
4563 createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4564 createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4565 createTool( SMESHOp::OpCopyMesh, meshTb );
4566 createTool( separator(), meshTb );
4567 createTool( SMESHOp::OpCompute, meshTb );
4568 createTool( SMESHOp::OpPreCompute, meshTb );
4569 createTool( SMESHOp::OpEvaluate, meshTb );
4570 createTool( SMESHOp::OpMeshOrder, meshTb );
4572 createTool( SMESHOp::OpCreateGroup, groupTb );
4573 createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4574 createTool( SMESHOp::OpConstructGroup, groupTb );
4575 createTool( SMESHOp::OpEditGroup, groupTb );
4577 createTool( SMESHOp::OpMeshInformation, info );
4578 //createTool( SMESHOp::OpStdInfo, meshTb );
4579 //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4580 createTool( SMESHOp::OpFindElementByPoint, info );
4582 createTool( SMESHOp::OpFreeNode, ctrl0dTb );
4583 createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4584 //createTool( SMESHOp::OpNodeConnectivityNb, ctrl0dTb );
4586 createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4587 createTool( SMESHOp::OpLength, ctrl1dTb );
4588 createTool( SMESHOp::OpConnection, ctrl1dTb );
4589 createTool( SMESHOp::OpEqualEdge, ctrl1dTb );
4591 createTool( SMESHOp::OpFreeEdge, ctrl2dTb );
4592 createTool( SMESHOp::OpFreeFace, ctrl2dTb );
4593 createTool( SMESHOp::OpBareBorderFace, ctrl2dTb );
4594 createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4595 createTool( SMESHOp::OpLength2D, ctrl2dTb );
4596 createTool( SMESHOp::OpConnection2D, ctrl2dTb );
4597 createTool( SMESHOp::OpArea, ctrl2dTb );
4598 createTool( SMESHOp::OpTaper, ctrl2dTb );
4599 createTool( SMESHOp::OpAspectRatio, ctrl2dTb );
4600 createTool( SMESHOp::OpMinimumAngle, ctrl2dTb );
4601 createTool( SMESHOp::OpWarpingAngle, ctrl2dTb );
4602 createTool( SMESHOp::OpSkew, ctrl2dTb );
4603 createTool( SMESHOp::OpMaxElementLength2D, ctrl2dTb );
4604 createTool( SMESHOp::OpEqualFace, ctrl2dTb );
4605 createTool( SMESHOp::OpDeflection2D, ctrl2dTb );
4607 createTool( SMESHOp::OpAspectRatio3D, ctrl3dTb );
4608 createTool( SMESHOp::OpVolume, ctrl3dTb );
4609 createTool( SMESHOp::OpMaxElementLength3D, ctrl3dTb );
4610 createTool( SMESHOp::OpBareBorderVolume, ctrl3dTb );
4611 createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
4612 createTool( SMESHOp::OpEqualVolume, ctrl3dTb );
4614 createTool( SMESHOp::OpNode, addElemTb );
4615 createTool( SMESHOp::OpElem0D, addElemTb );
4616 createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4617 createTool( SMESHOp::OpBall, addElemTb );
4618 createTool( SMESHOp::OpEdge, addElemTb );
4619 createTool( SMESHOp::OpTriangle, addElemTb );
4620 createTool( SMESHOp::OpQuadrangle, addElemTb );
4621 createTool( SMESHOp::OpPolygon, addElemTb );
4622 createTool( SMESHOp::OpTetrahedron, addElemTb );
4623 createTool( SMESHOp::OpHexahedron, addElemTb );
4624 createTool( SMESHOp::OpPentahedron, addElemTb );
4625 createTool( SMESHOp::OpPyramid, addElemTb );
4626 createTool( SMESHOp::OpHexagonalPrism, addElemTb );
4627 createTool( SMESHOp::OpPolyhedron, addElemTb );
4629 createTool( SMESHOp::OpQuadraticEdge, addNonElemTb );
4630 createTool( SMESHOp::OpQuadraticTriangle, addNonElemTb );
4631 createTool( SMESHOp::OpBiQuadraticTriangle, addNonElemTb );
4632 createTool( SMESHOp::OpQuadraticQuadrangle, addNonElemTb );
4633 createTool( SMESHOp::OpBiQuadraticQuadrangle, addNonElemTb );
4634 createTool( SMESHOp::OpQuadraticPolygon, addNonElemTb );
4635 createTool( SMESHOp::OpQuadraticTetrahedron, addNonElemTb );
4636 createTool( SMESHOp::OpQuadraticPyramid, addNonElemTb );
4637 createTool( SMESHOp::OpQuadraticPentahedron, addNonElemTb );
4638 createTool( SMESHOp::OpBiQuadraticPentahedron, addNonElemTb );
4639 createTool( SMESHOp::OpQuadraticHexahedron, addNonElemTb );
4640 createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4642 createTool( SMESHOp::OpRemoveNodes, remTb );
4643 createTool( SMESHOp::OpRemoveElements, remTb );
4644 createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4645 createTool( SMESHOp::OpClearMesh, remTb );
4647 //createTool( SMESHOp::OpRenumberingNodes, renumbTb );
4648 //createTool( SMESHOp::OpRenumberingElements, renumbTb );
4650 createTool( SMESHOp::OpMergeNodes, transformTb );
4651 createTool( SMESHOp::OpMergeElements, transformTb );
4652 createTool( SMESHOp::OpTranslation, transformTb );
4653 createTool( SMESHOp::OpRotation, transformTb );
4654 createTool( SMESHOp::OpSymmetry, transformTb );
4655 createTool( SMESHOp::OpScale, transformTb );
4656 createTool( SMESHOp::OpOffset, transformTb );
4657 createTool( SMESHOp::OpSewing, transformTb );
4658 createTool( SMESHOp::OpDuplicateNodes, transformTb );
4660 createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4661 createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4662 createTool( SMESHOp::OpExtrusion, modifyTb );
4663 createTool( SMESHOp::OpExtrusionAlongAPath, modifyTb );
4664 createTool( SMESHOp::OpRevolution, modifyTb );
4665 createTool( SMESHOp::OpOrientation, modifyTb );
4666 createTool( SMESHOp::OpReorientFaces, modifyTb );
4667 createTool( SMESHOp::OpMoveNode, modifyTb );
4668 createTool( SMESHOp::OpDiagonalInversion, modifyTb );
4669 createTool( SMESHOp::OpUnionOfTwoTriangle, modifyTb );
4670 createTool( SMESHOp::OpUnionOfTriangles, modifyTb );
4671 createTool( SMESHOp::OpCuttingOfQuadrangles, modifyTb );
4672 createTool( SMESHOp::OpSplitVolumes, modifyTb );
4673 createTool( SMESHOp::OpSplitBiQuadratic, modifyTb );
4674 createTool( SMESHOp::OpSmoothing, modifyTb );
4675 createTool( SMESHOp::OpPatternMapping, modifyTb );
4677 // createTool( SMESHOp::OpUniformRefinement, adaptTb );
4678 // createTool( SMESHOp::OpHOMARDRefinement, adaptTb );
4679 // createTool( SMESHOp::OpMGAdapt, adaptTb );
4681 createTool( SMESHOp::OpMinimumDistance, measuremTb );
4683 createTool( SMESHOp::OpUpdate, dispModeTb );
4685 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4686 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4690 OB = "'ObjectBrowser'",
4691 View = "'" + SVTK_Viewer::Type() + "'",
4693 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4694 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4695 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4696 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4697 smesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::COMPONENT ) ),
4698 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4699 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4700 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4701 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4702 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4703 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4704 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4706 mesh_part = mesh + " " + subMesh + " " + group,
4707 mesh_group = mesh + " " + group,
4708 mesh_submesh = mesh + " " + subMesh,
4709 hyp_alg = hypo + " " + algo;
4711 // popup for object browser
4713 isInvisible("not( isVisible )"),
4714 isEmpty("numberOfNodes = 0"),
4715 isNotEmpty("numberOfNodes <> 0"),
4717 // has nodes, edges, etc in VISIBLE! actor
4718 hasNodes("(numberOfNodes > 0 ) && hasActor"),
4719 hasElems("(count( elemTypes ) > 0)"),
4720 hasDifferentElems("(count( elemTypes ) > 1)"),
4721 hasDifferentObjElems("(count( objElemTypes ) > 1)"),
4722 hasBalls("({'BallElem'} in elemTypes)"),
4723 hasElems0d("({'Elem0d'} in elemTypes)"),
4724 hasEdges("({'Edge'} in elemTypes)"),
4725 hasFaces("({'Face'} in elemTypes)"),
4726 hasVolumes("({'Volume'} in elemTypes)"),
4727 hasFacesOrVolumes("(({'Face'} in elemTypes) || ({'Volume'} in elemTypes)) ");
4729 createPopupItem( SMESHOp::OpEditMesh, OB, mesh, "&& selcount=1" );
4730 createPopupItem( SMESHOp::OpCreateSubMesh, OB, mesh, "&& hasGeomReference");
4731 createPopupItem( SMESHOp::OpMeshOrder, OB, mesh, "&& selcount=1 && hasAlgo && hasGeomReference" );
4732 createPopupItem( SMESHOp::OpEditSubMesh, OB, subMesh, "&& selcount=1 && hasGeomReference" );
4733 createPopupItem( SMESHOp::OpEditGroup, OB, group );
4734 createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4736 popupMgr()->insert( separator(), -1, 0 );
4737 createPopupItem( SMESHOp::OpCompute, OB, mesh, "&& selcount=1 && hasAlgo && isComputable" );
4738 createPopupItem( SMESHOp::OpRecompute, OB, mesh, "&& selcount=1 && hasAlgo && " + isNotEmpty );
4739 createPopupItem( SMESHOp::OpShowErrors, OB, mesh, "&& selcount=1 && hasErrors" );
4740 createPopupItem( SMESHOp::OpComputeSubMesh, OB, subMesh, "&& selcount=1 && hasAlgo && isComputable" );
4741 createPopupItem( SMESHOp::OpPreCompute, OB, mesh, "&& selcount=1 && hasAlgo && isPreComputable" );
4742 createPopupItem( SMESHOp::OpEvaluate, OB, mesh, "&& selcount=1 && hasAlgo && isComputable" );
4743 popupMgr()->insert( separator(), -1, 0 );
4744 createPopupItem( SMESHOp::OpFileInformation, OB, mesh, "&& selcount=1 && isImported" );
4745 createPopupItem( SMESHOp::OpMeshInformation, OB, mesh_part );
4746 createPopupItem( SMESHOp::OpFindElementByPoint,OB, mesh_group, "&& selcount=1" );
4747 createPopupItem( SMESHOp::OpOverallMeshQuality,OB, mesh_part );
4748 popupMgr()->insert( separator(), -1, 0 );
4749 createPopupItem( SMESHOp::OpCreateGroup, OB, mesh, "&& selcount=1" );
4750 createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh, "&& selcount=1 && hasGeomReference" );
4751 createPopupItem( SMESHOp::OpConstructGroup, OB, subMesh );
4752 popupMgr()->insert( separator(), -1, 0 );
4753 createPopupItem( SMESHOp::OpEditHypothesis, OB, hypo, "&& isEditableHyp");
4754 createPopupItem( SMESHOp::OpUnassign, OB, hyp_alg );
4755 popupMgr()->insert( separator(), -1, 0 );
4756 createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh_submesh );
4757 createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh_group, "&& selcount=1 && dim>=2");
4758 //popupMgr()->insert( separator(), -1, 0 );
4760 //popupMgr()->insert( separator(), -1, 0 );
4762 // createPopupItem( SMESHOp::OpUniformRefinement, OB, mesh );
4763 // createPopupItem( SMESHOp::OpHOMARDRefinement, OB, mesh );
4764 // createPopupItem( SMESHOp::OpMGAdapt, OB, mesh );
4766 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4767 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4768 QString only_one_2D = only_one_non_empty + " && dim>1";
4770 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4771 popupMgr()->findMenu( anId )->menuAction()->setIcon( resourceMgr()->loadPixmap( "SMESH", tr( "ICON_EXPORT" )));
4772 createPopupItem( SMESHOp::OpPopupExportMED, OB, mesh_group, multiple_non_empty, anId );
4773 createPopupItem( SMESHOp::OpPopupExportUNV, OB, mesh_group, only_one_non_empty, anId );
4774 createPopupItem( SMESHOp::OpPopupExportSTL, OB, mesh_group, only_one_2D, anId );
4776 createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4778 createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, only_one_non_empty, anId );
4779 createPopupItem( SMESHOp::OpPopupExportGMF, OB, mesh_group, only_one_non_empty, anId );
4780 createPopupItem( SMESHOp::OpPopupExportDAT, OB, mesh_group, only_one_non_empty, anId );
4782 anId = popupMgr()->insert( tr( "MEN_IMPORT" ), -1, -1 ); // IMPORT submenu
4783 createPopupItem( SMESHOp::OpPopupImportMED, OB, smesh, "", anId );
4784 createPopupItem( SMESHOp::OpPopupImportUNV, OB, smesh, "", anId );
4785 createPopupItem( SMESHOp::OpPopupImportSTL, OB, smesh, "", anId );
4787 createPopupItem( SMESHOp::OpPopupImportCGNS, OB, smesh, "", anId );
4789 createPopupItem( SMESHOp::OpPopupImportSAUV, OB, smesh, "", anId );
4790 createPopupItem( SMESHOp::OpPopupImportGMF, OB, smesh, "", anId );
4791 createPopupItem( SMESHOp::OpPopupImportDAT, OB, smesh, "", anId );
4792 popupMgr()->insert( separator(), -1, 0 );
4794 createPopupItem( SMESHOp::OpClearMesh, OB, mesh );
4795 createPopupItem( SMESHOp::OpDelete, OB, mesh_part + " " + hyp_alg );
4796 createPopupItem( SMESHOp::OpDeleteGroup, OB, group );
4799 createPopupItem( SMESHOp::OpEditGroup, View, group );
4800 createPopupItem( SMESHOp::OpAddElemGroupPopup, View, elems, "&& guiState = 800" );
4801 createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems, "&& guiState = 800" );
4803 popupMgr()->insert( separator(), -1, 0 );
4804 createPopupItem( SMESHOp::OpMeshInformation, View, mesh_part );
4805 createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4806 createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh );
4807 popupMgr()->insert( separator(), -1, 0 );
4809 createPopupItem( SMESHOp::OpUpdate, OB + " " + View, mesh_part );
4810 createPopupItem( SMESHOp::OpAutoColor, OB + " " + View, mesh, "&& (not isAutoColor)" );
4811 createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4812 popupMgr()->insert( separator(), -1, 0 );
4814 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4815 QString aType = QString( "%1type in {%2}" ).arg( lc );
4816 aType = aType.arg( mesh_part );
4817 QString aMeshInVTK = aClient + "&&" + aType;
4819 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4820 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4821 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4823 //-------------------------------------------------
4825 //-------------------------------------------------
4826 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4828 popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4829 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4830 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4832 popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4833 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4834 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4836 popupMgr()->insert( separator(), -1, -1 );
4838 //-------------------------------------------------
4840 //-------------------------------------------------
4841 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4843 popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4844 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4845 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4847 popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4848 popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4849 popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4851 popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4852 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4853 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4855 popupMgr()->insert( separator(), anId, -1 );
4857 popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4858 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4859 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4861 //-------------------------------------------------
4863 //-------------------------------------------------
4864 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4866 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4868 popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4869 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4870 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4872 popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4873 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4874 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4876 popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4877 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4878 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4880 popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4881 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4882 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4884 popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4885 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4886 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4888 popupMgr()->insert( separator(), anId, -1 );
4890 popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4891 popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&& $type in {" + mesh + "} &&" + hasDifferentObjElems, QtxPopupMgr::VisibleRule );
4893 popupMgr()->insert( separator(), anId, -1 );
4895 popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4896 popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4899 //-------------------------------------------------
4900 // Representation of the 2D Quadratic elements
4901 //-------------------------------------------------
4902 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4903 popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4904 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "&& isVisible && isQuadratic",QtxPopupMgr::VisibleRule );
4905 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4907 popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4908 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "&& isVisible && isQuadratic", QtxPopupMgr::VisibleRule );
4909 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4911 //-------------------------------------------------
4912 // Orientation of faces
4913 //-------------------------------------------------
4914 popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4915 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4916 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4918 //-------------------------------------------------
4920 //-------------------------------------------------
4921 popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4922 popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4924 //-------------------------------------------------
4926 //-------------------------------------------------
4927 popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4928 popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4930 //-------------------------------------------------
4932 //-------------------------------------------------
4934 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4935 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4936 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4937 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4939 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4941 popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4942 popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4944 popupMgr()->insert( separator(), anId, -1 );
4946 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4948 popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4949 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4950 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4952 popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4953 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4954 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4956 // popupMgr()->insert( action( SMESHOp::OpNodeConnectivityNb ), aSubId, -1 );
4957 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4958 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), "controlMode = 'eNodeConnectivityNb'", QtxPopupMgr::ToggleRule );
4960 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4962 popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4963 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVTK + "&&" + hasEdges + "&&" + hasFacesOrVolumes, QtxPopupMgr::VisibleRule );
4964 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4966 popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4967 popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4968 popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4970 popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4971 popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4972 popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4973 popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4974 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4975 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4977 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4979 popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4980 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4981 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4983 popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4984 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4985 QtxPopupMgr::VisibleRule );
4986 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4988 popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4989 popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4990 popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4992 popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4993 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4994 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4996 popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
4997 popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4998 popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
5000 popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
5001 popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5002 popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
5004 popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
5005 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5006 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
5008 popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
5009 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5010 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
5012 popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
5013 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5014 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
5016 popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
5017 popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5018 popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
5020 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
5021 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5022 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
5024 popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
5025 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5026 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
5028 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
5029 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5030 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
5032 popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
5033 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5034 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
5036 popupMgr()->insert ( action( SMESHOp::OpDeflection2D ), aSubId, -1 );
5037 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), aMeshInVtkHasFaces + " && hasGeomReference", QtxPopupMgr::VisibleRule );
5038 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), "controlMode = 'eDeflection2D'", QtxPopupMgr::ToggleRule );
5040 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
5042 popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D ), aSubId, -1 );
5043 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5044 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
5046 popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
5047 popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5048 popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
5050 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
5051 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5052 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
5054 popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
5055 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5056 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
5058 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
5059 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5060 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
5062 popupMgr()->insert ( action( SMESHOp::OpEqualVolume ), aSubId, -1 );
5063 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5064 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
5066 popupMgr()->insert( separator(), anId, -1 );
5068 popupMgr()->insert( action( SMESHOp::OpShowScalarBar ), anId, -1 );
5069 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
5070 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone' && isScalarBarVisible", QtxPopupMgr::ToggleRule );
5071 popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
5072 popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
5074 popupMgr()->insert( separator(), anId, -1 );
5076 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
5078 popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
5079 popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
5081 popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
5082 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
5083 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isScalarBarVisible && isDistributionVisible", QtxPopupMgr::ToggleRule);
5085 #ifndef DISABLE_PLOT2DVIEWER
5086 popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
5087 popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
5090 //-------------------------------------------------
5092 //-------------------------------------------------
5093 popupMgr()->insert( separator(), -1, -1 );
5094 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
5095 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
5096 popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
5097 popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
5099 popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
5100 popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
5102 popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
5103 popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
5105 popupMgr()->insert( separator(), -1, -1 );
5107 //-------------------------------------------------
5109 //-------------------------------------------------
5110 popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
5111 popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
5113 popupMgr()->insert( separator(), -1, -1 );
5115 popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
5116 popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
5117 popupMgr()->insert( separator(), -1, -1 );
5119 popupMgr()->insert( action( SMESHOp::OpBreakLink), -1, -1 );
5120 popupMgr()->setRule( action( SMESHOp::OpBreakLink), "$component={'SHAPERSTUDY'} and client='ObjectBrowser' and canBreakLink", QtxPopupMgr::VisibleRule );
5122 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
5123 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
5125 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
5126 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
5129 //================================================================================
5131 * \brief Return true if SMESH or GEOM objects are selected.
5132 * Is called form LightApp_Module::activateModule() which clear selection if
5133 * not isSelectionCompatible()
5135 //================================================================================
5137 bool SMESHGUI::isSelectionCompatible()
5139 bool isCompatible = true;
5140 SALOME_ListIO selected;
5141 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
5142 Sel->selectedObjects( selected );
5144 SALOME_ListIteratorOfListIO It( selected );
5145 for ( ; isCompatible && It.More(); It.Next())
5147 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
5148 ( strcmp("SHAPERSTUDY", It.Value()->getComponentDataType()) == 0 ) ||
5149 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
5151 return isCompatible;
5155 bool SMESHGUI::reusableOperation( const int id )
5157 // compute, evaluate and precompute are not reusable operations
5158 return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate || id == SMESHOp::OpRecompute ) ? false : SalomeApp_Module::reusableOperation( id );
5161 bool SMESHGUI::activateModule( SUIT_Study* study )
5163 bool res = SalomeApp_Module::activateModule( study );
5165 setMenuShown( true );
5166 setToolShown( true );
5168 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
5169 PyGILState_STATE gstate = PyGILState_Ensure();
5170 PyObject* pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
5171 if ( !pluginsmanager ) {
5175 PyObject* result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toUtf8().data(),tr("SMESH_PLUGINS_OTHER").toUtf8().data());
5180 PyGILState_Release(gstate);
5181 // end of SMESH plugins loading
5183 // Reset actions accelerator keys
5184 action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
5186 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
5187 GetSMESHGen()->UpdateStudy();
5189 // get all view currently opened in the study and connect their signals to
5190 // the corresponding slots of the class.
5191 SUIT_Desktop* aDesk = study->application()->desktop();
5193 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
5194 SUIT_ViewWindow* wnd;
5195 foreach ( wnd, wndList )
5199 // remove actors whose objects are removed in GetSMESHGen()->UpdateStudy()
5200 SMESH::UpdateActorsAfterUpdateStudy(wnd);
5206 Py_XDECREF(pluginsmanager);
5210 bool SMESHGUI::deactivateModule( SUIT_Study* study )
5212 setMenuShown( false );
5213 setToolShown( false );
5215 EmitSignalCloseAllDialogs();
5217 // Unset actions accelerator keys
5218 action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
5220 return SalomeApp_Module::deactivateModule( study );
5223 void SMESHGUI::studyClosed( SUIT_Study* s )
5227 SMESH::RemoveVisuData();
5228 SalomeApp_Module::studyClosed( s );
5231 void SMESHGUI::OnGUIEvent()
5233 const QObject* obj = sender();
5234 if ( !obj || !obj->inherits( "QAction" ) )
5236 int id = actionId((QAction*)obj);
5241 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
5243 if ( CORBA::is_nil( myComponentSMESH ) )
5245 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
5246 return aGUI.myComponentSMESH;
5248 return myComponentSMESH;
5251 QString SMESHGUI::engineIOR() const
5253 CORBA::ORB_var anORB = getApp()->orb();
5254 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
5255 return QString( anIOR.in() );
5258 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
5260 SalomeApp_Module::contextMenuPopup( client, menu, title );
5262 selectionMgr()->selectedObjects( lst );
5263 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
5264 Handle(SALOME_InteractiveObject) io = lst.First();
5265 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
5266 _PTR(Study) study = appStudy->studyDS();
5267 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
5269 QString aName = SMESH::fromUtf8( obj->GetName());
5270 while ( !aName.isEmpty() && aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
5271 aName.remove(( aName.length() - 1 ), 1 );
5277 LightApp_Selection* SMESHGUI::createSelection() const
5279 return new SMESHGUI_Selection();
5282 void SMESHGUI::windows( QMap<int, int>& aMap ) const
5284 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
5285 aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
5286 #ifndef DISABLE_PYCONSOLE
5287 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
5291 void SMESHGUI::viewManagers( QStringList& list ) const
5293 list.append( SVTK_Viewer::Type() );
5296 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
5298 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
5299 SMESH::UpdateSelectionProp( this );
5301 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
5302 for(int i = 0; i < aViews.count() ; i++){
5303 SUIT_ViewWindow *sf = aViews[i];
5306 EmitSignalActivatedViewManager();
5310 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
5312 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
5313 myClippingPlaneInfoMap.erase( theViewManager );
5316 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
5318 theActor->AddObserver( SMESH::DeleteActorEvent,
5319 myEventCallbackCommand.GetPointer(),
5323 void SMESHGUI::ProcessEvents( vtkObject* theObject,
5324 unsigned long theEvent,
5325 void* theClientData,
5328 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
5329 if( theObject && (int) theEvent == SMESH::DeleteActorEvent ) {
5330 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
5331 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
5332 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
5333 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
5334 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
5335 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
5336 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
5337 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
5338 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
5339 SMESH::TActorList::iterator anIter3 = anActorList.begin();
5340 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
5341 if( anActor == *anIter3 ) {
5342 anActorList.erase( anIter3 );
5353 void SMESHGUI::createPreferences()
5355 // General tab ------------------------------------------------------------------------
5356 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
5358 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
5359 setPreferenceProperty( autoUpdate, "columns", 2 );
5360 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
5361 setPreferenceProperty( lim, "min", 0 );
5362 setPreferenceProperty( lim, "max", 100000000 );
5363 setPreferenceProperty( lim, "step", 1000 );
5364 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5365 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
5367 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
5368 setPreferenceProperty( dispgroup, "columns", 2 );
5370 addPreference( tr( "PREF_FITALL_ON_DISPLAYONLY" ), dispgroup, LightApp_Preferences::Bool, "SMESH", "fitall_on_displayonly" );
5372 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
5374 modes.append( tr("MEN_WIRE") );
5375 modes.append( tr("MEN_SHADE") );
5376 modes.append( tr("MEN_NODES") );
5377 modes.append( tr("MEN_SHRINK") );
5378 QList<QVariant> indices;
5379 indices.append( 0 );
5380 indices.append( 1 );
5381 indices.append( 2 );
5382 indices.append( 3 );
5383 setPreferenceProperty( dispmode, "strings", modes );
5384 setPreferenceProperty( dispmode, "indexes", indices );
5386 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
5387 setPreferenceProperty( arcgroup, "columns", 2 );
5388 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
5389 QStringList quadraticModes;
5390 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
5391 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
5393 indices.append( 0 );
5394 indices.append( 1 );
5395 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
5396 setPreferenceProperty( quadraticmode, "indexes", indices );
5398 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
5399 "SMESH", "max_angle" );
5400 setPreferenceProperty( maxAngle, "min", 1 );
5401 setPreferenceProperty( maxAngle, "max", 90 );
5403 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
5404 setPreferenceProperty( qaGroup, "columns", 2 );
5405 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
5406 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
5407 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
5408 setPreferenceProperty( prec, "min", 0 );
5409 setPreferenceProperty( prec, "max", 100 );
5410 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
5411 setPreferenceProperty( doubleNodesTol, "precision", 10 );
5412 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
5413 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
5414 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
5417 int cinc = addPreference(tr("PREF_CONTROLS_INCREMENT"), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_increment");
5418 setPreferenceProperty( cinc, "min", 0 );
5419 setPreferenceProperty( cinc, "max", 5 );
5422 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
5423 setPreferenceProperty( exportgroup, "columns", 2 );
5424 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
5425 addPreference( tr( "PREF_SHOW_WARN" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "show_warning" );
5426 int zTol = addPreference( tr( "PREF_ZTOLERANCE" ), exportgroup, LightApp_Preferences::DblSpin, "SMESH", "med_ztolerance" );
5427 setPreferenceProperty( zTol, "precision", 10 );
5428 setPreferenceProperty( zTol, "min", 0.0000000001 );
5429 setPreferenceProperty( zTol, "max", 1000000.0 );
5430 setPreferenceProperty( zTol, "step", 1. );
5431 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
5433 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
5434 setPreferenceProperty( computeGroup, "columns", 2 );
5435 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
5437 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5438 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5439 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5441 indices.append( 0 );
5442 indices.append( 1 );
5443 indices.append( 2 );
5444 setPreferenceProperty( notifyMode, "strings", modes );
5445 setPreferenceProperty( notifyMode, "indexes", indices );
5447 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5448 setPreferenceProperty( infoGroup, "columns", 2 );
5449 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5451 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5452 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5454 indices.append( 0 );
5455 indices.append( 1 );
5456 setPreferenceProperty( elemInfo, "strings", modes );
5457 setPreferenceProperty( elemInfo, "indexes", indices );
5458 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5459 setPreferenceProperty( nodesLim, "min", 0 );
5460 setPreferenceProperty( nodesLim, "max", 10000000 );
5461 setPreferenceProperty( nodesLim, "step", 10000 );
5462 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5463 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5464 setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5465 setPreferenceProperty( ctrlLim, "min", 0 );
5466 setPreferenceProperty( ctrlLim, "max", 10000000 );
5467 setPreferenceProperty( ctrlLim, "step", 1000 );
5468 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5469 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5470 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5471 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5472 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5474 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5475 setPreferenceProperty( segGroup, "columns", 2 );
5476 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5477 "SMESH", "segmentation" );
5478 setPreferenceProperty( segLen, "min", 1 );
5479 setPreferenceProperty( segLen, "max", 10000000 );
5480 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5481 "SMESH", "nb_segments_per_edge" );
5482 setPreferenceProperty( nbSeg, "min", 1 );
5483 setPreferenceProperty( nbSeg, "max", 10000000 );
5484 addPreference( tr( "PREF_USE_MESHGEMS_HYPOSET" ), segGroup, LightApp_Preferences::Bool, "SMESH", "use-meshgems-hypo-sets" );
5486 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5487 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5488 "SMESH", "forget_mesh_on_hyp_modif" );
5491 // Quantities with individual precision settings
5492 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5493 setPreferenceProperty( precGroup, "columns", 2 );
5495 const int nbQuantities = 6;
5496 int precs[nbQuantities], ii = 0;
5497 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5498 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5499 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5500 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5501 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5502 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5503 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5504 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5505 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5506 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5507 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5508 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5510 // Set property for precision value for spinboxes
5511 for ( ii = 0; ii < nbQuantities; ii++ ){
5512 setPreferenceProperty( precs[ii], "min", -14 );
5513 setPreferenceProperty( precs[ii], "max", 14 );
5514 setPreferenceProperty( precs[ii], "precision", 2 );
5517 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5518 setPreferenceProperty( previewGroup, "columns", 2 );
5519 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5520 setPreferenceProperty( chunkSize, "min", 1 );
5521 setPreferenceProperty( chunkSize, "max", 1000 );
5522 setPreferenceProperty( chunkSize, "step", 50 );
5524 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5525 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5527 // Mesh tab ------------------------------------------------------------------------
5528 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5529 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5530 setPreferenceProperty( nodeGroup, "columns", 3 );
5532 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5534 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5536 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5537 QList<QVariant> aMarkerTypeIndicesList;
5538 QList<QVariant> aMarkerTypeIconsList;
5539 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5540 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5541 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5542 aMarkerTypeIndicesList << i;
5543 aMarkerTypeIconsList << pixmap;
5545 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5546 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
5548 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5550 QList<QVariant> aMarkerScaleIndicesList;
5551 QStringList aMarkerScaleValuesList;
5552 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5553 aMarkerScaleIndicesList << i;
5554 //aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5555 aMarkerScaleValuesList << QString::number( i );
5557 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5558 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5560 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5561 //setPreferenceProperty( elemGroup, "columns", 2 );
5563 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5564 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5565 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5566 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5567 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5568 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5569 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5570 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5571 addPreference( tr( "PREF_PREVIEW_COLOR" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5574 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5575 setPreferenceProperty( grpGroup, "columns", 2 );
5577 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5578 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5580 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5581 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5582 /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5583 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5584 double ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5585 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5586 double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5587 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5588 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
5589 LightApp_Preferences::IntSpin, "SMESH", "element_width");
5590 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5591 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5592 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5593 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5595 setPreferenceProperty( size0d, "min", 1 );
5596 setPreferenceProperty( size0d, "max", 10 );
5598 // setPreferenceProperty( ballSize, "min", 1 );
5599 // setPreferenceProperty( ballSize, "max", 10 );
5601 setPreferenceProperty( ballDiameter, "min", 1e-7 );
5602 setPreferenceProperty( ballDiameter, "max", 1e9 );
5603 setPreferenceProperty( ballDiameter, "step", 0.1 );
5605 setPreferenceProperty( ballScale, "min", 1e-2 );
5606 setPreferenceProperty( ballScale, "max", 1e7 );
5607 setPreferenceProperty( ballScale, "step", 0.5 );
5609 setPreferenceProperty( elemW, "min", 1 );
5610 setPreferenceProperty( elemW, "max", 5 );
5612 setPreferenceProperty( outW, "min", 1 );
5613 setPreferenceProperty( outW, "max", 5 );
5615 setPreferenceProperty( shrink, "min", 0 );
5616 setPreferenceProperty( shrink, "max", 100 );
5618 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5619 setPreferenceProperty( numGroup, "columns", 2 );
5621 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5622 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5624 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5625 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5627 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5628 setPreferenceProperty( orientGroup, "columns", 1 );
5630 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5631 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5633 setPreferenceProperty( orientScale, "min", 0.05 );
5634 setPreferenceProperty( orientScale, "max", 0.5 );
5635 setPreferenceProperty( orientScale, "step", 0.05 );
5637 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5639 // Selection tab ------------------------------------------------------------------------
5640 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5642 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5643 setPreferenceProperty( selGroup, "columns", 2 );
5645 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5646 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5648 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5649 setPreferenceProperty( preGroup, "columns", 2 );
5651 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5653 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5654 setPreferenceProperty( precSelGroup, "columns", 2 );
5656 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5657 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5658 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5660 int sinc = addPreference(tr("PREF_SELECTION_INCREMENT"), selTab, LightApp_Preferences::IntSpin, "SMESH", "selection_increment");
5661 setPreferenceProperty( sinc, "min", 0 );
5662 setPreferenceProperty( sinc, "max", 5 );
5664 // Scalar Bar tab ------------------------------------------------------------------------
5665 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5666 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5667 setPreferenceProperty( fontGr, "columns", 2 );
5669 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5670 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5672 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5673 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5675 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5676 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5678 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5679 setPreferenceProperty( numcol, "min", 2 );
5680 setPreferenceProperty( numcol, "max", 256 );
5682 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5683 setPreferenceProperty( numlab, "min", 2 );
5684 setPreferenceProperty( numlab, "max", 65 );
5686 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5687 setPreferenceProperty( orientGr, "columns", 2 );
5688 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5689 QStringList orients;
5690 orients.append( tr( "SMESH_VERTICAL" ) );
5691 orients.append( tr( "SMESH_HORIZONTAL" ) );
5692 indices.clear(); indices.append( 0 ); indices.append( 1 );
5693 setPreferenceProperty( orient, "strings", orients );
5694 setPreferenceProperty( orient, "indexes", indices );
5696 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5697 setPreferenceProperty( posVSizeGr, "columns", 2 );
5698 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5699 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5700 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5701 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5702 setPreferenceProperty( xv, "step", 0.1 );
5703 setPreferenceProperty( xv, "min", 0.0 );
5704 setPreferenceProperty( xv, "max", 1.0 );
5705 setPreferenceProperty( yv, "step", 0.1 );
5706 setPreferenceProperty( yv, "min", 0.0 );
5707 setPreferenceProperty( yv, "max", 1.0 );
5708 setPreferenceProperty( wv, "step", 0.1 );
5709 setPreferenceProperty( wv, "min", 0.0 );
5710 setPreferenceProperty( wv, "max", 1.0 );
5711 setPreferenceProperty( hv, "min", 0.0 );
5712 setPreferenceProperty( hv, "max", 1.0 );
5713 setPreferenceProperty( hv, "step", 0.1 );
5715 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5716 setPreferenceProperty( posHSizeGr, "columns", 2 );
5717 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5718 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5719 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5720 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5721 setPreferenceProperty( xv, "min", 0.0 );
5722 setPreferenceProperty( xv, "max", 1.0 );
5723 setPreferenceProperty( xv, "step", 0.1 );
5724 setPreferenceProperty( xh, "min", 0.0 );
5725 setPreferenceProperty( xh, "max", 1.0 );
5726 setPreferenceProperty( xh, "step", 0.1 );
5727 setPreferenceProperty( yh, "min", 0.0 );
5728 setPreferenceProperty( yh, "max", 1.0 );
5729 setPreferenceProperty( yh, "step", 0.1 );
5730 setPreferenceProperty( wh, "min", 0.0 );
5731 setPreferenceProperty( wh, "max", 1.0 );
5732 setPreferenceProperty( wh, "step", 0.1 );
5733 setPreferenceProperty( hh, "min", 0.0 );
5734 setPreferenceProperty( hh, "max", 1.0 );
5735 setPreferenceProperty( hh, "step", 0.1 );
5737 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5738 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5739 setPreferenceProperty( distributionGr, "columns", 3 );
5741 types.append( tr( "SMESH_MONOCOLOR" ) );
5742 types.append( tr( "SMESH_MULTICOLOR" ) );
5743 indices.clear(); indices.append( 0 ); indices.append( 1 );
5744 setPreferenceProperty( coloringType, "strings", types );
5745 setPreferenceProperty( coloringType, "indexes", indices );
5746 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5748 // Adaptation tab ------------------------------------------------------------------------
5749 int adaptTab = addPreference( tr( "ADAPT_PREF_TAB_GENERAL" ) );
5751 // Refinement with HOMARD
5752 bloc = addPreference( tr( "ADAPT_PREF_PUBLICATION" ), adaptTab );
5753 setPreferenceProperty( bloc, "columns", 1 );
5754 pref = addPreference( tr( "ADAPT_PREF_PUBLICATION_MAILLAGE_IN" ), bloc, LightApp_Preferences::Bool, "HOMARD", "publish_mesh_in" );
5755 pref = addPreference( tr( "ADAPT_PREF_PUBLICATION_MAILLAGE_OUT" ), bloc, LightApp_Preferences::Bool, "HOMARD", "publish_mesh_out" );
5757 bloc = addPreference( tr( "ADAPT_PREF_YACS_MAX" ), adaptTab );
5758 setPreferenceProperty( bloc, "columns", 1 );
5759 pref = addPreference( tr( "ADAPT_PREF_YACS_MAX_ITER" ), bloc, LightApp_Preferences::IntSpin, "HOMARD", "yacs_max_iter" );
5760 setPreferenceProperty( pref, "min", 0 );
5761 setPreferenceProperty( pref, "max", 100000000 );
5762 setPreferenceProperty( pref, "step", 1 );
5763 pref = addPreference( tr( "ADAPT_PREF_YACS_MAX_NODE" ), bloc, LightApp_Preferences::IntSpin, "HOMARD", "yacs_max_node" );
5764 setPreferenceProperty( pref, "min", 0 );
5765 setPreferenceProperty( pref, "max", 100000000 );
5766 setPreferenceProperty( pref, "step", 1000 );
5767 pref = addPreference( tr( "ADAPT_PREF_YACS_MAX_ELEM" ), bloc, LightApp_Preferences::IntSpin, "HOMARD", "yacs_max_elem" );
5768 setPreferenceProperty( pref, "min", 0 );
5769 setPreferenceProperty( pref, "max", 100000000 );
5770 setPreferenceProperty( pref, "step", 1000 );
5771 bloc = addPreference( tr( "ADAPT_PREF_YACS_CONVERGENCE" ), adaptTab );
5772 setPreferenceProperty( bloc, "columns", 1 );
5773 pref = addPreference( tr( "ADAPT_PREF_YACS_TYPE_TEST" ), bloc, LightApp_Preferences::Selector, "HOMARD", "yacs_type_test" );
5774 QStringList aListOfTypeTest;
5775 aListOfTypeTest << "None";
5776 aListOfTypeTest << "VTest > VRef";
5777 aListOfTypeTest << "VTest < VRef";
5778 setPreferenceProperty( pref, "strings", aListOfTypeTest );
5782 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5784 if ( sect=="SMESH" ) {
5785 float sbX1 = 0.01, sbY1 = 0.01, sbW = 0.08, sbH = 0.08;
5786 float aTol = 1.00000009999999;
5787 std::string aWarning;
5788 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5790 if ( name == "selection_object_color" ||
5791 name == "selection_element_color" ||
5792 name == "highlight_color" ||
5793 name == "selection_precision_node" ||
5794 name == "selection_precision_element" ||
5795 name == "selection_precision_object" ||
5796 name == "selection_increment")
5798 SMESH::UpdateSelectionProp( this );
5800 else if (name == "scalar_bar_vertical_x" || name == "scalar_bar_vertical_width")
5802 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5803 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5804 if ( sbX1+sbW > aTol ) {
5805 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5808 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5809 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5812 else if (name == "scalar_bar_vertical_y" || name == "scalar_bar_vertical_height" )
5814 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5815 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5816 if ( sbY1 + sbH > aTol ) {
5817 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5818 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5819 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5822 else if (name == "scalar_bar_horizontal_x" || name == "scalar_bar_horizontal_width")
5824 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5825 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5826 if ( sbX1 + sbW > aTol ) {
5827 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5830 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5831 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5834 else if (name == "scalar_bar_horizontal_y" || name == "scalar_bar_horizontal_height")
5836 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5837 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5838 if ( sbY1 + sbH > aTol ) {
5839 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5842 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5843 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5846 else if ( name == "segmentation" )
5848 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5849 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5851 else if ( name == "nb_segments_per_edge" )
5853 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5854 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5856 else if ( name == "historical_python_dump" || name == "forget_mesh_on_hyp_modif" || name == "default_grp_color" )
5858 QString val = aResourceMgr->stringValue( "SMESH", name );
5859 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5861 else if ( name == "numbering_node_color" || name == "numbering_node_font" )
5863 SMESH::UpdateFontProp( this );
5865 else if ( name == "numbering_elem_color" || name == "numbering_elem_font" )
5867 SMESH::UpdateFontProp( this );
5870 if ( aWarning.size() != 0 ) {
5871 aWarning += "The default values are applied instead.";
5872 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5873 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5874 QObject::tr(aWarning.c_str()));
5879 //================================================================================
5881 * \brief Update something in accordance with update flags
5882 * \param theFlags - update flags
5884 * Update viewer or/and object browser etc. in accordance with update flags ( see
5885 * LightApp_UpdateFlags enumeration ).
5887 //================================================================================
5888 void SMESHGUI::update( const int flags )
5890 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5891 SMESH::UpdateView();
5893 SalomeApp_Module::update( flags );
5896 //================================================================================
5898 * \brief Set default selection mode
5900 * SLOT called when operation committed. Sets default selection mode
5902 //================================================================================
5903 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5905 SVTK_ViewWindow* vtkWnd =
5906 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5908 vtkWnd->SetSelectionMode( ActorSelection );
5911 //================================================================================
5913 * \brief Set default selection mode
5915 * SLOT called when operation aborted. Sets default selection mode
5917 //================================================================================
5918 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5920 SVTK_ViewWindow* vtkWnd =
5921 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5923 vtkWnd->SetSelectionMode( ActorSelection );
5926 //================================================================================
5928 * \brief Creates operation with given identifier
5929 * \param id - identifier of operation to be started
5930 * \return Pointer on created operation or NULL if operation is not created
5932 * Virtual method redefined from the base class creates operation with given id.
5933 * It is called called automatically from startOperation method of base class.
5935 //================================================================================
5936 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5938 LightApp_Operation* op = 0;
5939 // to do : create operation here
5942 case SMESHOp::OpSplitBiQuadratic:
5943 op = new SMESHGUI_SplitBiQuadOp();
5945 case SMESHOp::OpConvertMeshToQuadratic:
5946 op = new SMESHGUI_ConvToQuadOp();
5948 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5949 op = new SMESHGUI_Make2DFrom3DOp();
5951 case SMESHOp::OpReorientFaces:
5952 op = new SMESHGUI_ReorientFacesOp();
5954 case SMESHOp::OpCreateMesh:
5955 op = new SMESHGUI_MeshOp( true, true );
5957 case SMESHOp::OpCreateSubMesh:
5958 op = new SMESHGUI_MeshOp( true, false );
5960 case SMESHOp::OpEditMeshOrSubMesh:
5961 case SMESHOp::OpEditMesh:
5962 case SMESHOp::OpEditSubMesh:
5963 op = new SMESHGUI_MeshOp( false );
5965 case SMESHOp::OpCompute:
5966 case SMESHOp::OpComputeSubMesh:
5967 op = new SMESHGUI_ComputeOp();
5969 case SMESHOp::OpPreCompute:
5970 op = new SMESHGUI_PrecomputeOp();
5972 case SMESHOp::OpEvaluate:
5973 op = new SMESHGUI_EvaluateOp();
5975 case SMESHOp::OpMeshOrder:
5976 op = new SMESHGUI_MeshOrderOp();
5978 case SMESHOp::OpCreateGeometryGroup:
5979 op = new SMESHGUI_GroupOnShapeOp();
5981 case SMESHOp::OpFindElementByPoint:
5982 op = new SMESHGUI_FindElemByPointOp();
5984 case SMESHOp::OpMoveNode: // Make mesh pass through point
5985 op = new SMESHGUI_MakeNodeAtPointOp();
5987 case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
5988 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5990 case SMESHOp::OpUniformRefinement:
5991 case SMESHOp::OpHONewCase:
5992 case SMESHOp::OpHOCaseFollow:
5993 case SMESHOp::OpHONewIter:
5994 case SMESHOp::OpHOIterCompute:
5995 case SMESHOp::OpHOIterComputePublish:
5996 case SMESHOp::OpHOEdit:
5997 case SMESHOp::OpHODelete:
5998 case SMESHOp::OpMGAdapt:
6005 op = SalomeApp_Module::createOperation( id );
6009 //================================================================================
6011 * \brief Stops current operations and starts a given one
6012 * \param id - The id of the operation to start
6014 //================================================================================
6016 void SMESHGUI::switchToOperation(int id)
6018 activeStudy()->abortAllOperations();
6019 startOperation( id );
6022 LightApp_Displayer* SMESHGUI::displayer()
6025 myDisplayer = new SMESHGUI_Displayer( getApp() );
6029 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
6032 int aTolerance = 64;
6033 int anIterations = 0;
6039 if( anIterations % aPeriod == 0 )
6042 if( aTolerance < 1 )
6046 aHue = (int)( 360.0 * rand() / RAND_MAX );
6049 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
6050 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
6051 for( ; it != itEnd; ++it )
6053 SALOMEDS::Color anAutoColor = *it;
6054 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
6057 aQColor.getHsv( &h, &s, &v );
6058 if( abs( h - aHue ) < aTolerance )
6070 aColor.setHsv( aHue, 255, 255 );
6072 SALOMEDS::Color aSColor;
6073 aSColor.R = aColor.redF();
6074 aSColor.G = aColor.greenF();
6075 aSColor.B = aColor.blueF();
6080 const char* gSeparator = "_"; // character used to separate parameter names
6081 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
6082 const char* gPathSep = "|"; // character used to separate paths
6085 * \brief Store visual parameters
6087 * This method is called just before the study document is saved.
6088 * Store visual parameters in AttributeParameter attribute(s)
6090 void SMESHGUI::storeVisualParameters (int savePoint)
6093 Kernel_Utils::Localizer loc;
6095 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6096 if (!appStudy || !appStudy->studyDS())
6098 _PTR(Study) studyDS = appStudy->studyDS();
6100 // componentName is used for encoding of entries when storing them in IParameters
6101 std::string componentName = myComponentSMESH->ComponentDataType();
6102 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
6103 //if (!aSComponent) return;
6106 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6107 componentName.c_str(),
6109 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6111 // store custom markers
6112 if( !myMarkerMap.empty() )
6114 VTK::MarkerMap::const_iterator anIter = myMarkerMap.begin();
6115 for( ; anIter != myMarkerMap.end(); anIter++ )
6117 int anId = anIter->first;
6118 VTK::MarkerData aMarkerData = anIter->second;
6119 std::string aMarkerFileName = aMarkerData.first;
6120 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
6121 if( aMarkerTexture.size() < 3 )
6122 continue; // should contain at least width, height and the first value
6124 QString aPropertyName( "texture" );
6125 aPropertyName += gSeparator;
6126 aPropertyName += QString::number( anId );
6128 QString aPropertyValue = aMarkerFileName.c_str();
6129 aPropertyValue += gPathSep;
6131 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
6132 ushort aWidth = *aTextureIter++;
6133 ushort aHeight = *aTextureIter++;
6134 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
6135 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
6136 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
6137 aPropertyValue += QString::number( *aTextureIter );
6139 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
6143 // viewers counters are used for storing view_numbers in IParameters
6146 // main cycle to store parameters of displayed objects
6147 QList<SUIT_ViewManager*> lst;
6148 QList<SUIT_ViewManager*>::Iterator it;
6149 getApp()->viewManagers(lst);
6150 for (it = lst.begin(); it != lst.end(); it++)
6152 SUIT_ViewManager* vman = *it;
6153 QString vType = vman->getType();
6155 // saving VTK actors properties
6156 if (vType == SVTK_Viewer::Type())
6158 // store the clipping planes attached to the view manager
6159 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
6160 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
6161 if( anIter != myClippingPlaneInfoMap.end() )
6162 aClippingPlaneInfoList = anIter->second;
6164 if( !aClippingPlaneInfoList.empty() ) {
6165 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
6166 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
6168 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
6169 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
6171 QString aPropertyName( "ClippingPlane" );
6172 aPropertyName += gSeparator;
6173 aPropertyName += QString::number( vtkViewers );
6174 aPropertyName += gSeparator;
6175 aPropertyName += QString::number( anId );
6177 QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
6178 aPropertyValue += gDigitsSep;
6179 aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
6180 aPropertyValue += gDigitsSep;
6181 if ( aPlane->PlaneMode == SMESH::Absolute ) {
6182 aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
6183 aPropertyValue += gDigitsSep;
6184 aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
6185 aPropertyValue += gDigitsSep;
6186 aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
6187 aPropertyValue += gDigitsSep;
6188 aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
6189 aPropertyValue += gDigitsSep;
6190 aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
6191 aPropertyValue += gDigitsSep;
6192 aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
6193 aPropertyValue += gDigitsSep;
6194 aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
6196 else if ( aPlane->PlaneMode == SMESH::Relative ) {
6197 aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
6198 aPropertyValue += gDigitsSep;
6199 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
6200 aPropertyValue += gDigitsSep;
6201 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
6202 aPropertyValue += gDigitsSep;
6203 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
6206 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
6210 QVector<SUIT_ViewWindow*> views = vman->getViews();
6211 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
6213 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
6215 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
6216 vtkActorCollection* allActors = aCopy.GetActors();
6217 allActors->InitTraversal();
6218 while (vtkActor* actor = allActors->GetNextActor())
6220 if (actor->GetVisibility()) // store only visible actors
6222 SMESH_Actor* aSmeshActor = 0;
6223 if (actor->IsA("SMESH_Actor"))
6224 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
6225 if (aSmeshActor && aSmeshActor->hasIO())
6227 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
6230 // entry is "encoded" = it does NOT contain component address,
6231 // since it is a subject to change on next component loading
6232 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
6234 std::string param, vtkParam = vType.toLatin1().data();
6235 vtkParam += gSeparator;
6236 vtkParam += QString::number(vtkViewers).toLatin1().data();
6237 vtkParam += gSeparator;
6240 param = vtkParam + "Visibility";
6241 ip->setParameter(entry, param, "On");
6244 param = vtkParam + "Representation";
6245 ip->setParameter(entry, param, QString::number
6246 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
6249 param = vtkParam + "IsShrunk";
6250 ip->setParameter(entry, param, QString::number
6251 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
6253 // Displayed entities
6254 unsigned int aMode = aSmeshActor->GetEntityMode();
6255 bool isE = aMode & SMESH_Actor::eEdges;
6256 bool isF = aMode & SMESH_Actor::eFaces;
6257 bool isV = aMode & SMESH_Actor::eVolumes;
6258 bool is0d = aMode & SMESH_Actor::e0DElements;
6259 bool isB = aMode & SMESH_Actor::eBallElem;
6261 QString modeStr ("e");
6262 modeStr += gDigitsSep; modeStr += QString::number(isE);
6263 modeStr += gDigitsSep; modeStr += "f";
6264 modeStr += gDigitsSep; modeStr += QString::number(isF);
6265 modeStr += gDigitsSep; modeStr += "v";
6266 modeStr += gDigitsSep; modeStr += QString::number(isV);
6267 modeStr += gDigitsSep; modeStr += "0d";
6268 modeStr += gDigitsSep; modeStr += QString::number(is0d);
6269 modeStr += gDigitsSep; modeStr += "b";
6270 modeStr += gDigitsSep; modeStr += QString::number(isB);
6272 param = vtkParam + "Entities";
6273 ip->setParameter(entry, param, modeStr.toLatin1().data());
6279 aSmeshActor->GetSufaceColor(r, g, b, delta);
6280 QStringList colorStr;
6281 colorStr << "surface";
6282 colorStr << QString::number(r);
6283 colorStr << QString::number(g);
6284 colorStr << QString::number(b);
6286 colorStr << "backsurface";
6287 colorStr << QString::number(delta);
6289 aSmeshActor->GetVolumeColor(r, g, b, delta);
6290 colorStr << "volume";
6291 colorStr << QString::number(r);
6292 colorStr << QString::number(g);
6293 colorStr << QString::number(b);
6294 colorStr << QString::number(delta);
6296 aSmeshActor->GetEdgeColor(r, g, b);
6298 colorStr << QString::number(r);
6299 colorStr << QString::number(g);
6300 colorStr << QString::number(b);
6302 aSmeshActor->GetNodeColor(r, g, b);
6304 colorStr << QString::number(r);
6305 colorStr << QString::number(g);
6306 colorStr << QString::number(b);
6308 aSmeshActor->GetOutlineColor(r, g, b);
6309 colorStr << "outline";
6310 colorStr << QString::number(r);
6311 colorStr << QString::number(g);
6312 colorStr << QString::number(b);
6314 aSmeshActor->Get0DColor(r, g, b);
6315 colorStr << "elem0d";
6316 colorStr << QString::number(r);
6317 colorStr << QString::number(g);
6318 colorStr << QString::number(b);
6320 aSmeshActor->GetBallColor(r, g, b);
6322 colorStr << QString::number(r);
6323 colorStr << QString::number(g);
6324 colorStr << QString::number(b);
6326 aSmeshActor->GetFacesOrientationColor(r, g, b);
6327 colorStr << "orientation";
6328 colorStr << QString::number(r);
6329 colorStr << QString::number(g);
6330 colorStr << QString::number(b);
6332 param = vtkParam + "Colors";
6333 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
6336 QStringList sizeStr;
6338 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
6339 sizeStr << "outline";
6340 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
6341 sizeStr << "elem0d";
6342 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
6344 //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
6345 sizeStr << QString::number((double)aSmeshActor->GetBallSize());
6346 sizeStr << QString::number((double)aSmeshActor->GetBallScale());
6347 sizeStr << "shrink";
6348 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
6349 sizeStr << "orientation";
6350 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
6351 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
6353 param = vtkParam + "Sizes";
6354 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
6359 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
6360 if( aMarkerType == VTK::MT_USER ) {
6361 markerStr += "custom";
6362 markerStr += gDigitsSep;
6363 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
6367 markerStr += gDigitsSep;
6368 markerStr += QString::number( (int)aMarkerType );
6369 markerStr += gDigitsSep;
6370 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
6373 param = vtkParam + "PointMarker";
6374 ip->setParameter(entry, param, markerStr.toLatin1().data());
6377 param = vtkParam + "Opacity";
6378 ip->setParameter(entry, param,
6379 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
6382 param = vtkParam + "ClippingPlane";
6384 if( !aClippingPlaneInfoList.empty() ) {
6385 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
6386 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
6388 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
6389 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
6390 SMESH::TActorList::iterator anIter2 = anActorList.begin();
6391 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
6392 if( aSmeshActor == *anIter2 ) {
6393 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
6394 QString::number( anId ).toLatin1().constData() );
6401 ip->setParameter( entry, param, "Off" );
6402 } // if (io->hasEntry())
6403 } // SMESH_Actor && hasIO
6405 } // while.. actors traversal
6409 } // if (SVTK view model)
6410 } // for (viewManagers)
6413 // data structures for clipping planes processing
6417 bool isOpenGLClipping;
6418 vtkIdType RelativeOrientation;
6421 int AbsoluteOrientation;
6422 double X, Y, Z, Dx, Dy, Dz;
6424 typedef std::list<TPlaneData> TPlaneDataList;
6425 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
6427 typedef std::list<vtkActor*> TActorList;
6430 TActorList ActorList;
6431 SUIT_ViewManager* ViewManager;
6433 typedef std::list<TPlaneInfo> TPlaneInfoList;
6434 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
6437 * \brief Restore visual parameters
6439 * This method is called after the study document is opened.
6440 * Restore visual parameters from AttributeParameter attribute(s)
6442 void SMESHGUI::restoreVisualParameters (int savePoint)
6445 Kernel_Utils::Localizer loc;
6447 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6448 if (!appStudy || !appStudy->studyDS())
6450 _PTR(Study) studyDS = appStudy->studyDS();
6452 // componentName is used for encoding of entries when storing them in IParameters
6453 std::string componentName = myComponentSMESH->ComponentDataType();
6456 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6457 componentName.c_str(),
6459 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6461 // restore custom markers and map of clipping planes
6462 TPlaneDataMap aPlaneDataMap;
6464 std::vector<std::string> properties = ip->getProperties();
6465 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
6467 std::string property = *propIt;
6468 QString aPropertyName( property.c_str() );
6469 QString aPropertyValue( ip->getProperty( property ).c_str() );
6471 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
6472 if( aPropertyNameList.isEmpty() )
6475 QString aPropertyType = aPropertyNameList[0];
6476 if( aPropertyType == "texture" )
6478 if( aPropertyNameList.size() != 2 )
6482 int anId = aPropertyNameList[1].toInt( &ok );
6483 if( !ok || anId < 1 )
6486 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
6487 if( aPropertyValueList.size() != 2 )
6490 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
6491 QString aMarkerTextureString = aPropertyValueList[1];
6492 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
6493 if( aMarkerTextureStringList.size() != 3 )
6497 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6502 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6506 VTK::MarkerTexture aMarkerTexture;
6507 aMarkerTexture.push_back( aWidth );
6508 aMarkerTexture.push_back( aHeight );
6510 QString aMarkerTextureData = aMarkerTextureStringList[2];
6511 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6513 QChar aChar = aMarkerTextureData.at( i );
6514 if( aChar.isDigit() )
6515 aMarkerTexture.push_back( aChar.digitValue() );
6518 myMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6520 else if( aPropertyType == "ClippingPlane" )
6522 if( aPropertyNameList.size() != 3 )
6526 int aViewId = aPropertyNameList[1].toInt( &ok );
6527 if( !ok || aViewId < 0 )
6531 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6532 if( !ok || aClippingPlaneId < 0 )
6535 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6536 if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6539 TPlaneData aPlaneData;
6540 aPlaneData.AbsoluteOrientation = false;
6541 aPlaneData.RelativeOrientation = 0;
6542 aPlaneData.Distance = aPlaneData.Angle[0] = aPlaneData.Angle[1] = 0;
6543 aPlaneData.X = aPlaneData.Y = aPlaneData.Z = 0;
6544 aPlaneData.Dx = aPlaneData.Dy = aPlaneData.Dz = 0;
6546 aPlaneData.Id = aClippingPlaneId;
6549 aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6554 aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6558 if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6561 aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6566 aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6571 aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6576 aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6581 aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6586 aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6591 aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6595 else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6597 aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6602 aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6607 aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6612 aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6617 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6618 aPlaneDataList.push_back( aPlaneData );
6622 TPlaneInfoMap aPlaneInfoMap;
6624 std::vector<std::string> entries = ip->getEntries();
6626 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6628 // entry is a normal entry - it should be "decoded" (setting base address of component)
6629 QString entry (ip->decodeEntry(*entIt).c_str());
6631 // Check that the entry corresponds to a real object in the Study
6632 // as the object may be deleted or modified after the visual state is saved.
6633 _PTR(SObject) so = studyDS->FindObjectID(entry.toUtf8().data());
6634 if (!so) continue; //Skip the not existent entry
6636 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6637 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6639 std::vector<std::string>::iterator namesIt = paramNames.begin();
6640 std::vector<std::string>::iterator valuesIt = paramValues.begin();
6642 // actors are stored in a map after displaying of them for
6643 // quicker access in the future: map < viewID to actor >
6644 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6646 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6648 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6649 // '_' is used as separator and should not be used in viewer type or parameter names.
6650 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6651 if (lst.size() != 3)
6654 QString viewerTypStr = lst[0];
6655 QString viewIndexStr = lst[1];
6656 QString paramNameStr = lst[2];
6659 int viewIndex = viewIndexStr.toUInt(&ok);
6660 if (!ok) // bad conversion of view index to integer
6664 if (viewerTypStr == SVTK_Viewer::Type())
6666 SMESH_Actor* aSmeshActor = 0;
6667 if (vtkActors.IsBound(viewIndex))
6668 aSmeshActor = vtkActors.Find(viewIndex);
6670 QList<SUIT_ViewManager*> lst;
6671 getApp()->viewManagers(viewerTypStr, lst);
6673 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6674 SUIT_ViewManager* vman = NULL;
6675 if (viewIndex >= 0 && viewIndex < lst.count())
6676 vman = lst.at(viewIndex);
6678 if (paramNameStr == "Visibility")
6680 if (!aSmeshActor && displayer() && vman)
6682 SUIT_ViewModel* vmodel = vman->getViewModel();
6683 // SVTK view model can be casted to SALOME_View
6684 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6686 // store displayed actor in a temporary map for quicker
6687 // access later when restoring other parameters
6688 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6689 vtkRenderer* Renderer = vtkView->getRenderer();
6690 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6691 vtkActorCollection* theActors = aCopy.GetActors();
6692 theActors->InitTraversal();
6693 bool isFound = false;
6694 vtkActor *ac = theActors->GetNextActor();
6695 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6696 if (ac->IsA("SMESH_Actor")) {
6697 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6698 if (aGeomAc->hasIO()) {
6699 Handle(SALOME_InteractiveObject) io = aGeomAc->getIO();
6700 if (io->hasEntry() && strcmp(io->getEntry(), entry.toUtf8().data()) == 0) {
6702 vtkActors.Bind(viewIndex, aGeomAc);
6708 } // if (paramNameStr == "Visibility")
6711 // the rest properties "work" with SMESH_Actor
6714 QString val ((*valuesIt).c_str());
6717 if (paramNameStr == "Representation") {
6718 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6721 else if (paramNameStr == "IsShrunk") {
6723 if (!aSmeshActor->IsShrunk())
6724 aSmeshActor->SetShrink();
6727 if (aSmeshActor->IsShrunk())
6728 aSmeshActor->UnShrink();
6731 // Displayed entities
6732 else if (paramNameStr == "Entities") {
6733 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6734 int aEntityMode = SMESH_Actor::eAllEntity;
6735 for ( int i = 0; i < mode.count(); i+=2 ) {
6736 if ( i < mode.count()-1 ) {
6737 QString type = mode[i];
6738 bool val = mode[i+1].toInt();
6739 if ( type == "e" && !val )
6740 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6741 else if ( type == "f" && !val )
6742 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6743 else if ( type == "v" && !val )
6744 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6745 else if ( type == "0d" && !val )
6746 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6747 else if ( type == "b" && !val )
6748 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6751 aSmeshActor->SetEntityMode( aEntityMode );
6754 else if (paramNameStr == "Colors") {
6755 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6762 QColor outlineColor;
6763 QColor orientationColor;
6769 // below lines are required to get default values for delta coefficients
6770 // of backface color for faces and color of reversed volumes
6771 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
6772 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6773 for ( int i = 0; i < colors.count(); i++ ) {
6774 QString type = colors[i];
6775 if ( type == "surface" ) {
6776 // face color is set by 3 values r:g:b, where
6777 // - r,g,b - is rgb color components
6778 if ( i+1 >= colors.count() ) break; // format error
6779 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6780 if ( i+2 >= colors.count() ) break; // format error
6781 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6782 if ( i+3 >= colors.count() ) break; // format error
6783 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6784 faceColor.setRgbF( r, g, b );
6787 else if ( type == "backsurface" ) {
6788 // backface color can be defined in several ways
6789 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6790 // - in latest versions, it is set as delta coefficient
6791 bool rgbOk = false, deltaOk;
6792 if ( i+1 >= colors.count() ) break; // format error
6793 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6794 int delta = colors[i+1].toInt( &deltaOk );
6796 if ( i+1 < colors.count() ) // index is shifted to 1
6797 g = colors[i+1].toDouble( &rgbOk );
6798 if ( rgbOk ) i++; // shift index
6799 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6800 b = colors[i+1].toDouble( &rgbOk );
6802 // - as currently there's no way to set directly backsurface color as it was before,
6803 // we ignore old dump where r,g,b triple was set
6804 // - also we check that delta parameter is set properly
6805 if ( !rgbOk && deltaOk )
6808 else if ( type == "volume" ) {
6809 // volume color is set by 4 values r:g:b:delta, where
6810 // - r,g,b - is a normal volume rgb color components
6811 // - delta - is a reversed volume color delta coefficient
6812 if ( i+1 >= colors.count() ) break; // format error
6813 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6814 if ( i+2 >= colors.count() ) break; // format error
6815 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6816 if ( i+3 >= colors.count() ) break; // format error
6817 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6818 if ( i+4 >= colors.count() ) break; // format error
6819 int delta = colors[i+4].toInt( &bOk );
6820 if ( !bOk ) break; // format error
6821 volumeColor.setRgbF( r, g, b );
6825 else if ( type == "edge" ) {
6826 // edge color is set by 3 values r:g:b, where
6827 // - r,g,b - is rgb color components
6828 if ( i+1 >= colors.count() ) break; // format error
6829 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6830 if ( i+2 >= colors.count() ) break; // format error
6831 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6832 if ( i+3 >= colors.count() ) break; // format error
6833 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6834 edgeColor.setRgbF( r, g, b );
6837 else if ( type == "node" ) {
6838 // node color is set by 3 values r:g:b, where
6839 // - r,g,b - is rgb color components
6840 if ( i+1 >= colors.count() ) break; // format error
6841 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6842 if ( i+2 >= colors.count() ) break; // format error
6843 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6844 if ( i+3 >= colors.count() ) break; // format error
6845 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6846 nodeColor.setRgbF( r, g, b );
6849 else if ( type == "elem0d" ) {
6850 // 0d element color is set by 3 values r:g:b, where
6851 // - r,g,b - is rgb color components
6852 if ( i+1 >= colors.count() ) break; // format error
6853 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6854 if ( i+2 >= colors.count() ) break; // format error
6855 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6856 if ( i+3 >= colors.count() ) break; // format error
6857 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6858 elem0dColor.setRgbF( r, g, b );
6861 else if ( type == "ball" ) {
6862 // ball color is set by 3 values r:g:b, where
6863 // - r,g,b - is rgb color components
6864 if ( i+1 >= colors.count() ) break; // format error
6865 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6866 if ( i+2 >= colors.count() ) break; // format error
6867 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6868 if ( i+3 >= colors.count() ) break; // format error
6869 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6870 ballColor.setRgbF( r, g, b );
6873 else if ( type == "outline" ) {
6874 // outline color is set by 3 values r:g:b, where
6875 // - r,g,b - is rgb color components
6876 if ( i+1 >= colors.count() ) break; // format error
6877 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6878 if ( i+2 >= colors.count() ) break; // format error
6879 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6880 if ( i+3 >= colors.count() ) break; // format error
6881 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6882 outlineColor.setRgbF( r, g, b );
6885 else if ( type == "orientation" ) {
6886 // orientation color is set by 3 values r:g:b, where
6887 // - r,g,b - is rgb color components
6888 if ( i+1 >= colors.count() ) break; // format error
6889 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6890 if ( i+2 >= colors.count() ) break; // format error
6891 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6892 if ( i+3 >= colors.count() ) break; // format error
6893 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6894 orientationColor.setRgbF( r, g, b );
6899 if ( nodeColor.isValid() )
6900 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6902 if ( edgeColor.isValid() )
6903 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6905 if ( faceColor.isValid() )
6906 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6908 if ( volumeColor.isValid() )
6909 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6910 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6911 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6913 if ( elem0dColor.isValid() )
6914 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6916 if ( ballColor.isValid() )
6917 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6919 if ( outlineColor.isValid() )
6920 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6921 // orientation color
6922 if ( orientationColor.isValid() )
6923 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6926 else if (paramNameStr == "Sizes") {
6927 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6930 int outlineWidth = -1;
6931 int elem0dSize = -1;
6932 //int ballSize = -1;
6933 double ballDiameter = -1.0;
6934 double ballScale = -1.0;
6935 double shrinkSize = -1;
6936 double orientationSize = -1;
6937 bool orientation3d = false;
6938 for ( int i = 0; i < sizes.count(); i++ ) {
6939 QString type = sizes[i];
6940 if ( type == "line" ) {
6941 // line (wireframe) width is given as single integer value
6942 if ( i+1 >= sizes.count() ) break; // format error
6943 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6947 if ( type == "outline" ) {
6948 // outline width is given as single integer value
6949 if ( i+1 >= sizes.count() ) break; // format error
6950 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6954 else if ( type == "elem0d" ) {
6955 // 0d element size is given as single integer value
6956 if ( i+1 >= sizes.count() ) break; // format error
6957 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6961 else if ( type == "ball" ) {
6962 // balls are specified by two values: size:scale, where
6963 // - size - is a integer value specifying size
6964 // - scale - is a double value specifying scale factor
6965 if ( i+1 >= sizes.count() ) break; // format error
6966 //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6967 double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6968 if ( i+2 >= sizes.count() ) break; // format error
6969 double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6975 else if ( type == "shrink" ) {
6976 // shrink factor is given as single floating point value
6977 if ( i+1 >= sizes.count() ) break; // format error
6978 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6982 else if ( type == "orientation" ) {
6983 // orientation vectors are specified by two values size:3d, where
6984 // - size - is a floating point value specifying scale factor
6985 // - 3d - is a boolean
6986 if ( i+1 >= sizes.count() ) break; // format error
6987 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6988 if ( i+2 >= sizes.count() ) break; // format error
6989 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6990 orientationSize = v1;
6991 orientation3d = (bool)v2;
6995 // line (wireframe) width
6996 if ( lineWidth > 0 )
6997 aSmeshActor->SetLineWidth( lineWidth );
6999 if ( outlineWidth > 0 )
7000 aSmeshActor->SetOutlineWidth( outlineWidth );
7001 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
7002 aSmeshActor->SetOutlineWidth( lineWidth );
7004 if ( elem0dSize > 0 )
7005 aSmeshActor->Set0DSize( elem0dSize );
7007 /*if ( ballSize > 0 )
7008 aSmeshActor->SetBallSize( ballSize );*/
7010 if ( ballDiameter > 0 )
7011 aSmeshActor->SetBallSize( ballDiameter );
7013 if ( ballScale > 0.0 )
7014 aSmeshActor->SetBallScale( ballScale );
7016 if ( shrinkSize > 0 )
7017 aSmeshActor->SetShrinkFactor( shrinkSize );
7018 // orientation vectors
7019 if ( orientationSize > 0 ) {
7020 aSmeshActor->SetFacesOrientationScale( orientationSize );
7021 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
7025 else if (paramNameStr == "PointMarker") {
7026 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
7027 if( data.count() >= 2 ) {
7029 int aParam1 = data[1].toInt( &ok );
7031 if( data[0] == "std" && data.count() == 3 ) {
7032 int aParam2 = data[2].toInt( &ok );
7033 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
7035 else if( data[0] == "custom" ) {
7036 VTK::MarkerMap::const_iterator markerIt = myMarkerMap.find( aParam1 );
7037 if( markerIt != myMarkerMap.end() ) {
7038 VTK::MarkerData aMarkerData = markerIt->second;
7039 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
7046 else if (paramNameStr == "Opacity") {
7047 aSmeshActor->SetOpacity(val.toFloat());
7050 else if (paramNameStr.startsWith("ClippingPlane")) {
7051 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
7052 // old format - val looks like "Off" or "1:0:0:0.5:0:0"
7053 // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
7054 // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
7055 // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
7056 // new format - val looks like "Off" or "0" (plane id)
7057 // (note: in new format "Off" value is used only for consistency,
7058 // so it is processed together with values in old format)
7059 bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
7060 if( anIsOldFormat ) {
7061 if (paramNameStr == "ClippingPlane1" || val == "Off")
7062 aSmeshActor->RemoveAllClippingPlanes();
7064 QList<SUIT_ViewManager*> lst;
7065 getApp()->viewManagers(viewerTypStr, lst);
7066 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
7067 if (viewIndex >= 0 && viewIndex < lst.count()) {
7068 SUIT_ViewManager* vman = lst.at(viewIndex);
7069 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
7071 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
7073 SMESH::TActorList anActorList;
7074 anActorList.push_back( aSmeshActor );
7075 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
7076 aPlane->myViewWindow = vtkView;
7077 SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
7078 aPlane->PlaneMode = aMode;
7079 bool isOpenGLClipping = ( bool )vals[1].toInt();
7080 aPlane->IsOpenGLClipping = isOpenGLClipping;
7081 if ( aMode == SMESH::Absolute ) {
7082 aPlane->myAbsoluteOrientation = vals[2].toInt();
7083 aPlane->X = vals[3].toFloat();
7084 aPlane->Y = vals[4].toFloat();
7085 aPlane->Z = vals[5].toFloat();
7086 aPlane->Dx = vals[6].toFloat();
7087 aPlane->Dy = vals[7].toFloat();
7088 aPlane->Dz = vals[8].toFloat();
7090 else if ( aMode == SMESH::Relative ) {
7091 aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
7092 aPlane->myDistance = vals[3].toFloat();
7093 aPlane->myAngle[0] = vals[4].toFloat();
7094 aPlane->myAngle[1] = vals[5].toFloat();
7098 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
7099 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
7100 aClippingPlaneInfo.Plane = aPlane;
7101 aClippingPlaneInfo.ActorList = anActorList;
7102 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
7110 int aPlaneId = val.toInt( &ok );
7111 if( ok && aPlaneId >= 0 ) {
7112 bool anIsDefinedPlane = false;
7113 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
7114 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
7115 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
7116 TPlaneInfo& aPlaneInfo = *anIter;
7117 if( aPlaneInfo.PlaneId == aPlaneId ) {
7118 aPlaneInfo.ActorList.push_back( aSmeshActor );
7119 anIsDefinedPlane = true;
7123 if( !anIsDefinedPlane ) {
7124 TPlaneInfo aPlaneInfo;
7125 aPlaneInfo.PlaneId = aPlaneId;
7126 aPlaneInfo.ActorList.push_back( aSmeshActor );
7127 aPlaneInfo.ViewManager = vman;
7129 // to make the list sorted by plane id
7130 anIter = aPlaneInfoList.begin();
7131 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
7132 const TPlaneInfo& aPlaneInfoRef = *anIter;
7133 if( aPlaneInfoRef.PlaneId > aPlaneId )
7136 aPlaneInfoList.insert( anIter, aPlaneInfo );
7141 } // if (aSmeshActor)
7142 } // other parameters than Visibility
7144 } // for names/parameters iterator
7145 } // for entries iterator
7147 // take into account planes with empty list of actors referred to them
7148 QList<SUIT_ViewManager*> aVMList;
7149 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
7151 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
7152 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
7153 int aViewId = aPlaneDataIter->first;
7154 if( aViewId >= 0 && aViewId < aVMList.count() ) {
7155 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
7157 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
7159 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
7160 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
7161 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
7162 const TPlaneData& aPlaneData = *anIter2;
7163 int aPlaneId = aPlaneData.Id;
7165 bool anIsFound = false;
7166 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
7167 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
7168 const TPlaneInfo& aPlaneInfo = *anIter3;
7169 if( aPlaneInfo.PlaneId == aPlaneId ) {
7176 TPlaneInfo aPlaneInfo; // ActorList field is empty
7177 aPlaneInfo.PlaneId = aPlaneId;
7178 aPlaneInfo.ViewManager = aViewManager;
7180 // to make the list sorted by plane id
7181 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
7182 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
7183 const TPlaneInfo& aPlaneInfoRef = *anIter4;
7184 if( aPlaneInfoRef.PlaneId > aPlaneId )
7187 aPlaneInfoList.insert( anIter4, aPlaneInfo );
7193 // add clipping planes to actors according to the restored parameters
7194 // and update the clipping plane map
7195 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
7196 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
7197 int aViewId = anIter1->first;
7198 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
7200 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
7201 if( anIter2 == aPlaneDataMap.end() )
7203 const TPlaneDataList& aPlaneDataList = anIter2->second;
7205 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
7206 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
7207 const TPlaneInfo& aPlaneInfo = *anIter3;
7208 int aPlaneId = aPlaneInfo.PlaneId;
7209 const TActorList& anActorList = aPlaneInfo.ActorList;
7210 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
7214 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
7218 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
7220 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
7221 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
7222 const TPlaneData& aPlaneData = *anIter4;
7223 if( aPlaneData.Id == aPlaneId ) {
7224 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
7225 aPlane->myViewWindow = aViewWindow;
7226 aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
7227 aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
7228 if ( aPlane->PlaneMode == SMESH::Absolute ) {
7229 aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
7230 aPlane->X = aPlaneData.X;
7231 aPlane->Y = aPlaneData.Y;
7232 aPlane->Z = aPlaneData.Z;
7233 aPlane->Dx = aPlaneData.Dx;
7234 aPlane->Dy = aPlaneData.Dy;
7235 aPlane->Dz = aPlaneData.Dz;
7237 else if ( aPlane->PlaneMode == SMESH::Relative ) {
7238 aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
7239 aPlane->myDistance = aPlaneData.Distance;
7240 aPlane->myAngle[0] = aPlaneData.Angle[0];
7241 aPlane->myAngle[1] = aPlaneData.Angle[1];
7244 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
7245 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
7246 aClippingPlaneInfo.Plane = aPlane;
7247 aClippingPlaneInfo.ActorList = anActorList;
7248 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
7259 // update all VTK views
7260 QList<SUIT_ViewManager*> lst;
7261 getApp()->viewManagers(lst);
7262 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
7263 SUIT_ViewModel* vmodel = (*it)->getViewModel();
7264 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
7265 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
7266 // set OpenGL clipping planes
7267 VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
7268 vtkActorCollection* anAllActors = aCopy.GetActors();
7269 anAllActors->InitTraversal();
7270 while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
7271 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
7272 anActor->SetOpenGLClippingPlane();
7274 vtkView->getRenderer()->ResetCameraClippingRange();
7281 \brief Adds preferences for dfont of VTK viewer
7283 \param pIf group identifier
7284 \param param parameter
7285 \return identifier of preferences
7287 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
7289 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
7291 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
7294 fam.append( tr( "SMESH_FONT_ARIAL" ) );
7295 fam.append( tr( "SMESH_FONT_COURIER" ) );
7296 fam.append( tr( "SMESH_FONT_TIMES" ) );
7298 setPreferenceProperty( tfont, "fonts", fam );
7300 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
7301 if ( needSize ) f = f | QtxFontEdit::Size;
7302 setPreferenceProperty( tfont, "features", f );
7308 \brief Actions after hypothesis edition
7309 Updates object browser after hypothesis edition
7311 void SMESHGUI::onHypothesisEdit( int result )
7314 SMESHGUI::Modified();
7315 updateObjBrowser( true );
7319 \brief Actions after choosing menu of control modes
7320 Updates control mode actions according to current selection
7322 void SMESHGUI::onUpdateControlActions()
7324 SALOME_ListIO selected;
7325 if ( LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr() )
7326 aSel->selectedObjects( selected );
7328 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
7329 if ( selected.Extent() ) {
7330 if ( selected.First()->hasEntry() ) {
7331 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( selected.First()->getEntry() )) {
7332 aControl = anActor->GetControlMode();
7333 SALOME_ListIteratorOfListIO it(selected);
7334 for ( it.Next(); it.More(); it.Next() ) {
7335 Handle(SALOME_InteractiveObject) anIO = it.Value();
7336 if ( anIO->hasEntry() ) {
7337 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
7338 if ( aControl != anActor->GetControlMode() ) {
7339 aControl = SMESH_Actor::eNone;
7349 int anAction = ActionToControl( aControl, true );
7351 action( anAction )->setChecked( true );
7353 QMenu* send = (QMenu*)sender();
7354 QList<QAction*> actions = send->actions();
7355 for ( int i = 0; i < actions.size(); i++ )
7356 actions[i]->setChecked( false );
7362 \brief Signal handler closing(SUIT_ViewWindow*) of a view
7363 \param pview view being closed
7365 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
7366 #ifndef DISABLE_PLOT2DVIEWER
7367 //Crear all Plot2d Viewers if need.
7368 SMESH::ClearPlot2Viewers(pview);
7370 EmitSignalCloseView();
7373 void SMESHGUI::message( const QString& msg )
7376 QStringList data = msg.split("/");
7377 if ( data.count() > 0 ) {
7378 if ( data.first() == "mesh_loading" ) {
7380 QString entry = data.count() > 1 ? data[1] : QString();
7381 if ( entry.isEmpty() )
7384 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
7386 _PTR(SObject) obj = study->FindObjectID( entry.toUtf8().constData() );
7389 name = SMESH::fromUtf8(obj->GetName());
7390 if ( name.isEmpty() )
7393 if ( data.last() == "stop" )
7394 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
7396 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
7397 QApplication::processEvents();
7403 \brief Connects or disconnects signals about activating and cloning view on the module slots
7404 \param pview view which is connected/disconnected
7406 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
7410 SUIT_ViewManager* viewMgr = pview->getViewManager();
7412 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7413 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7415 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7416 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7421 \brief Return \c true if object can be renamed
7423 bool SMESHGUI::renameAllowed( const QString& entry) const {
7424 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7428 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7432 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
7437 if(appStudy->isComponent(entry) || obj->isReference())
7440 // check type to prevent renaming of inappropriate objects
7441 int aType = SMESHGUI_Selection::type(qPrintable(entry));
7442 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7443 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7444 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7445 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7446 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
7453 Rename object by entry.
7454 \param entry entry of the object
7455 \param name new name of the object
7456 \brief Return \c true if rename operation finished successfully, \c false otherwise.
7458 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
7460 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7464 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7469 _PTR(Study) aStudy = appStudy->studyDS();
7474 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
7476 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
7481 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
7482 _PTR(GenericAttribute) anAttr;
7483 _PTR(AttributeName) aName;
7485 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
7487 // check type to prevent renaming of inappropriate objects
7488 int aType = SMESHGUI_Selection::type( qPrintable(entry));
7489 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7490 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7491 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7492 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7493 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
7494 if ( !name.isEmpty() ) {
7495 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qUtf8Printable(name) );
7497 // update name of group object and its actor
7498 Handle(SALOME_InteractiveObject) IObject =
7499 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
7501 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
7502 if( !aGroupObject->_is_nil() ) {
7503 aGroupObject->SetName( qUtf8Printable(name) );
7504 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
7505 anActor->setName( qUtf8Printable(name) );
7515 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
7517 static QList<QColor> colors;
7519 if ( colors.isEmpty() ) {
7521 for (int s = 0; s < 2 ; s++)
7523 for (int v = 100; v >= 40; v = v - 20)
7525 for (int h = 0; h < 359 ; h = h + 60)
7527 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
7532 static int currentColor = randomize( colors.size() );
7534 SALOMEDS::Color color;
7535 color.R = (double)colors[currentColor].red() / 255.0;
7536 color.G = (double)colors[currentColor].green() / 255.0;
7537 color.B = (double)colors[currentColor].blue() / 255.0;
7539 currentColor = (currentColor+1) % colors.count();