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"));
3037 // Adaptation - begin
3038 case SMESHOp::OpUniformRefinement:
3039 case SMESHOp::OpHONewCase:
3040 case SMESHOp::OpHOCaseFollow:
3041 case SMESHOp::OpHONewIter:
3042 case SMESHOp::OpHOIterCompute:
3043 case SMESHOp::OpHOIterComputePublish:
3044 case SMESHOp::OpHOEdit:
3045 case SMESHOp::OpHODelete:
3046 case SMESHOp::OpMGAdapt:
3048 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
3049 SMESHGUI_AdaptDlg *objet = new SMESHGUI_AdaptDlg( this, theCommandID, aMesh);
3052 case SMESHOp::OpSplitBiQuadratic:
3053 case SMESHOp::OpConvertMeshToQuadratic:
3054 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
3055 case SMESHOp::OpReorientFaces:
3056 case SMESHOp::OpCreateGeometryGroup:
3058 if ( warnOnGeomModif() )
3059 break; // action forbiden as geometry modified
3060 startOperation( theCommandID );
3063 case SMESHOp::OpCreateGroup:
3067 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3071 if(isStudyLocked()) break;
3072 if ( warnOnGeomModif() )
3073 break; // action forbiden as geometry modified
3074 EmitSignalDeactivateDialog();
3075 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
3077 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3078 SALOME_ListIO selected;
3080 aSel->selectedObjects( selected );
3082 int nbSel = selected.Extent();
3084 // check if mesh is selected
3085 aMesh = SMESH::GetMeshByIO( selected.First() );
3087 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
3092 case SMESHOp::OpConstructGroup:
3096 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3100 if(isStudyLocked()) break;
3101 if ( warnOnGeomModif() )
3102 break; // action forbiden as geometry modified
3103 EmitSignalDeactivateDialog();
3105 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3106 SALOME_ListIO selected;
3108 aSel->selectedObjects( selected );
3110 int nbSel = selected.Extent();
3112 // check if submesh is selected
3113 Handle(SALOME_InteractiveObject) IObject = selected.First();
3114 if (IObject->hasEntry()) {
3115 _PTR(SObject) aSObj = SMESH::getStudy()->FindObjectID(IObject->getEntry());
3117 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
3118 if (!aSubMesh->_is_nil()) {
3120 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
3121 // get submesh elements list by types
3122 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
3123 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
3124 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
3125 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
3126 // create group for each type o elements
3127 QString aName = IObject->getName();
3128 QStringList anEntryList;
3129 if (aNodes->length() > 0) {
3130 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
3131 aGroup->Add(aNodes.inout());
3132 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3133 anEntryList.append( aSObject->GetID().c_str() );
3135 if (aEdges->length() > 0) {
3136 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
3137 aGroup->Add(aEdges.inout());
3138 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3139 anEntryList.append( aSObject->GetID().c_str() );
3141 if (aFaces->length() > 0) {
3142 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
3143 aGroup->Add(aFaces.inout());
3144 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3145 anEntryList.append( aSObject->GetID().c_str() );
3147 if (aVolumes->length() > 0) {
3148 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
3149 aGroup->Add(aVolumes.inout());
3150 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3151 anEntryList.append( aSObject->GetID().c_str() );
3154 anApp->browseObjects( anEntryList );
3156 catch(const SALOME::SALOME_Exception & S_ex){
3157 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3164 SUIT_MessageBox::warning(desktop(),
3165 tr("SMESH_WRN_WARNING"),
3166 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
3171 case SMESHOp::OpEditGroup:
3175 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3179 if(isStudyLocked()) break;
3180 if ( warnOnGeomModif() )
3181 break; // action forbiden as geometry modified
3182 EmitSignalDeactivateDialog();
3184 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3185 SALOME_ListIO selected;
3187 aSel->selectedObjects( selected );
3189 SALOME_ListIteratorOfListIO It (selected);
3190 int nbSelectedGroups = 0;
3191 for ( ; It.More(); It.Next() )
3193 SMESH::SMESH_GroupBase_var aGroup =
3194 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
3195 if (!aGroup->_is_nil()) {
3197 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
3201 if (nbSelectedGroups == 0)
3203 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
3209 case SMESHOp::OpAddElemGroupPopup: // Add elements to group
3211 if(isStudyLocked()) break;
3212 if (myState == 800) {
3213 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3214 if (aDlg) aDlg->onAdd();
3219 case SMESHOp::OpRemoveElemGroupPopup: // Remove elements from group
3221 if(isStudyLocked()) break;
3222 if (myState == 800) {
3223 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3224 if (aDlg) aDlg->onRemove();
3229 case SMESHOp::OpEditGeomGroupAsGroup:
3233 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3237 if(isStudyLocked()) break;
3238 EmitSignalDeactivateDialog();
3240 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3241 SALOME_ListIO selected;
3243 aSel->selectedObjects( selected );
3245 SALOME_ListIteratorOfListIO It (selected);
3246 for ( ; It.More(); It.Next() )
3248 SMESH::SMESH_GroupOnGeom_var aGroup =
3249 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
3250 if (!aGroup->_is_nil()) {
3251 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3256 SMESH::SMESH_GroupOnFilter_var aGroup =
3257 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
3258 if (!aGroup->_is_nil()) {
3259 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3267 case SMESHOp::OpUnionGroups:
3268 case SMESHOp::OpIntersectGroups:
3269 case SMESHOp::OpCutGroups:
3273 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3277 if ( isStudyLocked() )
3279 if ( warnOnGeomModif() )
3280 break; // action forbiden as geometry modified
3282 EmitSignalDeactivateDialog();
3284 SMESHGUI_GroupOpDlg* aDlg = 0;
3285 if ( theCommandID == SMESHOp::OpUnionGroups )
3286 aDlg = new SMESHGUI_UnionGroupsDlg( this );
3287 else if ( theCommandID == SMESHOp::OpIntersectGroups )
3288 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3290 aDlg = new SMESHGUI_CutGroupsDlg( this );
3297 case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
3299 if ( isStudyLocked() )
3301 if ( warnOnGeomModif() )
3302 break; // action forbiden as geometry modified
3304 EmitSignalDeactivateDialog();
3305 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3311 case SMESHOp::OpFaceGroupsByEdges: // Create face groups separated by sharp edges
3313 if ( isStudyLocked() )
3315 if ( warnOnGeomModif() )
3316 break; // action forbiden as geometry modified
3318 EmitSignalDeactivateDialog();
3319 SMESHGUI_FaceGroupsSeparatedByEdgesDlg* aDlg = new SMESHGUI_FaceGroupsSeparatedByEdgesDlg( this );
3325 case SMESHOp::OpDeleteGroup: // Delete groups with their contents
3329 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3333 if ( isStudyLocked() )
3336 EmitSignalDeactivateDialog();
3338 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3342 case SMESHOp::OpMeshInformation:
3343 case SMESHOp::OpWhatIs:
3345 int page = theCommandID == SMESHOp::OpMeshInformation ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3346 EmitSignalDeactivateDialog();
3347 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3348 SALOME_ListIO selected;
3350 aSel->selectedObjects( selected );
3352 if ( selected.Extent() > 1 ) { // a dlg for each IO
3353 SALOME_ListIteratorOfListIO It( selected );
3354 for ( ; It.More(); It.Next() ) {
3355 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3356 dlg->showInfo( It.Value() );
3361 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3367 case SMESHOp::OpFindElementByPoint:
3369 startOperation( theCommandID );
3373 case SMESHOp::OpEditHypothesis:
3375 if(isStudyLocked()) break;
3376 if ( warnOnGeomModif() )
3377 break; // action forbiden as geometry modified
3379 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3380 SALOME_ListIO selected;
3382 aSel->selectedObjects( selected );
3384 int nbSel = selected.Extent();
3387 Handle(SALOME_InteractiveObject) anIObject = selected.First();
3388 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3390 if ( !aHypothesis->_is_nil() )
3392 SMESHGUI_GenericHypothesisCreator* aCreator =
3393 SMESH::GetHypothesisCreator( SMESH::toQStr( aHypothesis->GetName() ));
3396 // set geometry of mesh and sub-mesh to aCreator
3397 aSel->selectedObjects( selected, "", /*convertReferences=*/false);
3398 if ( selected.Extent() == 1 )
3400 QString subGeomID, meshGeomID;
3401 Handle(SALOME_InteractiveObject) hypIO = selected.First();
3402 if ( SMESH::GetGeomEntries( hypIO, subGeomID, meshGeomID ))
3404 if ( subGeomID.isEmpty() ) subGeomID = meshGeomID;
3405 aCreator->setShapeEntry( subGeomID );
3406 aCreator->setMainShapeEntry( meshGeomID );
3410 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3420 case SMESHOp::OpUnassign: // REMOVE HYPOTHESIS / ALGORITHMS
3422 if(isStudyLocked()) break;
3423 if ( warnOnGeomModif() )
3424 break; // action forbiden as geometry modified
3425 SUIT_OverrideCursor wc;
3427 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3428 SALOME_ListIO selected;
3430 aSel->selectedObjects( selected, QString::null, false );
3432 SALOME_ListIteratorOfListIO It(selected);
3433 for (int i = 0; It.More(); It.Next(), i++) {
3434 Handle(SALOME_InteractiveObject) IObject = It.Value();
3435 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3438 aSel->setSelectedObjects( l1 );
3443 case SMESHOp::OpElem0D:
3444 case SMESHOp::OpBall:
3445 case SMESHOp::OpEdge:
3446 case SMESHOp::OpTriangle:
3447 case SMESHOp::OpQuadrangle:
3448 case SMESHOp::OpPolygon:
3449 case SMESHOp::OpTetrahedron:
3450 case SMESHOp::OpHexahedron:
3451 case SMESHOp::OpPentahedron:
3452 case SMESHOp::OpPyramid:
3453 case SMESHOp::OpHexagonalPrism:
3455 if(isStudyLocked()) break;
3456 if ( warnOnGeomModif() )
3457 break; // action forbiden as geometry modified
3459 EmitSignalDeactivateDialog();
3460 SMDSAbs_EntityType type = SMDSEntity_Edge;
3461 switch (theCommandID) {
3462 case SMESHOp::OpElem0D: type = SMDSEntity_0D; break;
3463 case SMESHOp::OpBall: type = SMDSEntity_Ball; break;
3464 case SMESHOp::OpTriangle: type = SMDSEntity_Triangle; break;
3465 case SMESHOp::OpQuadrangle: type = SMDSEntity_Quadrangle; break;
3466 case SMESHOp::OpTetrahedron: type = SMDSEntity_Tetra; break;
3467 case SMESHOp::OpPolygon: type = SMDSEntity_Polygon; break;
3468 case SMESHOp::OpHexahedron: type = SMDSEntity_Hexa; break;
3469 case SMESHOp::OpPentahedron: type = SMDSEntity_Penta; break;
3470 case SMESHOp::OpPyramid: type = SMDSEntity_Pyramid; break;
3471 case SMESHOp::OpHexagonalPrism: type = SMDSEntity_Hexagonal_Prism; break;
3474 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3477 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3481 case SMESHOp::OpPolyhedron:
3483 if(isStudyLocked()) break;
3484 if ( warnOnGeomModif() )
3485 break; // action forbiden as geometry modified
3487 EmitSignalDeactivateDialog();
3488 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3491 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3495 case SMESHOp::OpQuadraticEdge:
3496 case SMESHOp::OpQuadraticTriangle:
3497 case SMESHOp::OpBiQuadraticTriangle:
3498 case SMESHOp::OpQuadraticQuadrangle:
3499 case SMESHOp::OpBiQuadraticQuadrangle:
3500 case SMESHOp::OpQuadraticPolygon:
3501 case SMESHOp::OpQuadraticTetrahedron:
3502 case SMESHOp::OpQuadraticPyramid:
3503 case SMESHOp::OpQuadraticPentahedron:
3504 case SMESHOp::OpBiQuadraticPentahedron:
3505 case SMESHOp::OpQuadraticHexahedron:
3506 case SMESHOp::OpTriQuadraticHexahedron:
3508 if(isStudyLocked()) break;
3509 if ( warnOnGeomModif() )
3510 break; // action forbiden as geometry modified
3512 EmitSignalDeactivateDialog();
3513 SMDSAbs_EntityType type = SMDSEntity_Last;
3515 switch (theCommandID) {
3516 case SMESHOp::OpQuadraticEdge: type = SMDSEntity_Quad_Edge; break;
3517 case SMESHOp::OpQuadraticTriangle: type = SMDSEntity_Quad_Triangle; break;
3518 case SMESHOp::OpBiQuadraticTriangle: type = SMDSEntity_BiQuad_Triangle; break;
3519 case SMESHOp::OpQuadraticQuadrangle: type = SMDSEntity_Quad_Quadrangle; break;
3520 case SMESHOp::OpBiQuadraticQuadrangle: type = SMDSEntity_BiQuad_Quadrangle; break;
3521 case SMESHOp::OpQuadraticPolygon: type = SMDSEntity_Quad_Polygon; break;
3522 case SMESHOp::OpQuadraticTetrahedron: type = SMDSEntity_Quad_Tetra; break;
3523 case SMESHOp::OpQuadraticPyramid: type = SMDSEntity_Quad_Pyramid; break;
3524 case SMESHOp::OpQuadraticPentahedron: type = SMDSEntity_Quad_Penta; break;
3525 case SMESHOp::OpBiQuadraticPentahedron: type = SMDSEntity_BiQuad_Penta; break;
3526 case SMESHOp::OpQuadraticHexahedron: type = SMDSEntity_Quad_Hexa; break;
3527 case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
3530 if ( type != SMDSEntity_Last )
3531 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3534 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3535 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3539 case SMESHOp::OpRemoveNodes:
3541 if(isStudyLocked()) break;
3542 if ( warnOnGeomModif() )
3543 break; // action forbiden as geometry modified
3545 EmitSignalDeactivateDialog();
3546 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3549 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3550 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3554 case SMESHOp::OpRemoveElements: // REMOVES ELEMENTS
3556 if(isStudyLocked()) break;
3557 if ( warnOnGeomModif() )
3558 break; // action forbiden as geometry modified
3560 EmitSignalDeactivateDialog();
3561 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3565 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3566 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3570 case SMESHOp::OpClearMesh: {
3572 if(isStudyLocked()) break;
3573 if ( warnOnGeomModif() )
3574 break; // action forbiden as geometry modified
3576 SALOME_ListIO selected;
3577 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3578 aSel->selectedObjects( selected );
3580 SUIT_OverrideCursor wc;
3581 SALOME_ListIteratorOfListIO It (selected);
3582 for ( ; It.More(); It.Next() )
3584 Handle(SALOME_InteractiveObject) IOS = It.Value();
3585 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3586 if ( aMesh->_is_nil()) continue;
3589 if ( aMesh->NbNodes() == 0 ) // imported mesh is not empty
3590 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3591 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3592 // hide groups and submeshes
3593 _PTR(ChildIterator) anIter =
3594 SMESH::getStudy()->NewChildIterator( aMeshSObj );
3595 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3597 _PTR(SObject) so = anIter->Value();
3598 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3601 catch (const SALOME::SALOME_Exception& S_ex){
3603 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3607 SMESH::UpdateView();
3611 case SMESHOp::OpRemoveOrphanNodes:
3613 if(isStudyLocked()) break;
3614 if ( warnOnGeomModif() )
3615 break; // action forbiden as geometry modified
3616 SALOME_ListIO selected;
3617 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3618 aSel->selectedObjects( selected );
3619 if ( selected.Extent() == 1 ) {
3620 Handle(SALOME_InteractiveObject) anIO = selected.First();
3621 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3622 if ( !aMesh->_is_nil() ) {
3623 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3624 tr( "SMESH_WARNING" ),
3625 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3626 SUIT_MessageBox::Yes |
3627 SUIT_MessageBox::No,
3628 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3631 SUIT_OverrideCursor wc;
3632 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3633 int removed = aMeshEditor->RemoveOrphanNodes();
3634 SUIT_MessageBox::information(SMESHGUI::desktop(),
3635 tr("SMESH_INFORMATION"),
3636 tr("NB_NODES_REMOVED").arg(removed));
3637 if ( removed > 0 ) {
3638 SMESH::UpdateView();
3639 SMESHGUI::Modified();
3642 catch (const SALOME::SALOME_Exception& S_ex) {
3643 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3652 case SMESHOp::OpRenumberingNodes:
3654 if(isStudyLocked()) break;
3655 if ( warnOnGeomModif() )
3656 break; // action forbiden as geometry modified
3658 EmitSignalDeactivateDialog();
3659 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3663 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3664 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3668 case SMESHOp::OpRenumberingElements:
3670 if(isStudyLocked()) break;
3671 if ( warnOnGeomModif() )
3672 break; // action forbiden as geometry modified
3674 EmitSignalDeactivateDialog();
3675 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3679 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3680 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3684 case SMESHOp::OpTranslation:
3686 if(isStudyLocked()) break;
3687 if ( warnOnGeomModif() )
3688 break; // action forbiden as geometry modified
3690 EmitSignalDeactivateDialog();
3691 ( new SMESHGUI_TranslationDlg( this ) )->show();
3694 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3695 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3699 case SMESHOp::OpRotation:
3701 if(isStudyLocked()) break;
3702 if ( warnOnGeomModif() )
3703 break; // action forbiden as geometry modified
3705 EmitSignalDeactivateDialog();
3706 ( new SMESHGUI_RotationDlg( this ) )->show();
3709 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3710 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3714 case SMESHOp::OpSymmetry:
3716 if(isStudyLocked()) break;
3717 if ( warnOnGeomModif() )
3718 break; // action forbiden as geometry modified
3720 EmitSignalDeactivateDialog();
3721 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3724 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3725 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3729 case SMESHOp::OpScale:
3731 if(isStudyLocked()) break;
3732 if ( warnOnGeomModif() )
3733 break; // action forbiden as geometry modified
3735 EmitSignalDeactivateDialog();
3736 ( new SMESHGUI_ScaleDlg( this ) )->show();
3739 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3740 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3745 case SMESHOp::OpOffset:
3747 if(isStudyLocked()) break;
3748 if ( warnOnGeomModif() )
3749 break; // action forbiden as geometry modified
3751 EmitSignalDeactivateDialog();
3752 ( new SMESHGUI_OffsetDlg( this ) )->show();
3755 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3756 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3761 case SMESHOp::OpSewing:
3763 if(isStudyLocked()) break;
3764 if ( warnOnGeomModif() )
3765 break; // action forbiden as geometry modified
3767 EmitSignalDeactivateDialog();
3768 ( new SMESHGUI_SewingDlg( this ) )->show();
3771 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3772 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3776 case SMESHOp::OpMergeNodes:
3778 if(isStudyLocked()) break;
3779 if ( warnOnGeomModif() )
3780 break; // action forbiden as geometry modified
3782 EmitSignalDeactivateDialog();
3783 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3786 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3787 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3791 case SMESHOp::OpMergeElements:
3793 if (isStudyLocked()) break;
3794 if ( warnOnGeomModif() )
3795 break; // action forbiden as geometry modified
3797 EmitSignalDeactivateDialog();
3798 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3800 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3801 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3806 case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
3807 if ( warnOnGeomModif() )
3808 break; // action forbiden as geometry modified
3809 startOperation( SMESHOp::OpMoveNode );
3812 case SMESHOp::OpDuplicateNodes:
3814 if(isStudyLocked()) break;
3815 if ( warnOnGeomModif() )
3816 break; // action forbiden as geometry modified
3818 EmitSignalDeactivateDialog();
3819 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3822 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3823 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3828 case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
3829 if ( warnOnGeomModif() )
3830 break; // action forbiden as geometry modified
3831 startOperation( SMESHOp::OpElem0DOnElemNodes );
3834 case SMESHOp::OpSelectFiltersLibrary: // Library of selection filters
3836 static QList<int> aTypes;
3837 if ( aTypes.isEmpty() )
3839 aTypes.append( SMESH::NODE );
3840 aTypes.append( SMESH::EDGE );
3841 aTypes.append( SMESH::FACE );
3842 aTypes.append( SMESH::VOLUME );
3844 if (!myFilterLibraryDlg)
3845 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3846 else if (myFilterLibraryDlg->isHidden())
3847 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3848 myFilterLibraryDlg->raise();
3852 case SMESHOp::OpFreeNode:
3853 case SMESHOp::OpEqualNode:
3854 case SMESHOp::OpNodeConnectivityNb:
3855 case SMESHOp::OpFreeEdge:
3856 case SMESHOp::OpFreeBorder:
3857 case SMESHOp::OpLength:
3858 case SMESHOp::OpConnection:
3859 case SMESHOp::OpEqualEdge:
3860 case SMESHOp::OpFreeFace:
3861 case SMESHOp::OpBareBorderFace:
3862 case SMESHOp::OpOverConstrainedFace:
3863 case SMESHOp::OpLength2D:
3864 case SMESHOp::OpDeflection2D:
3865 case SMESHOp::OpConnection2D:
3866 case SMESHOp::OpArea:
3867 case SMESHOp::OpTaper:
3868 case SMESHOp::OpAspectRatio:
3869 case SMESHOp::OpMinimumAngle:
3870 case SMESHOp::OpWarpingAngle:
3871 case SMESHOp::OpSkew:
3872 case SMESHOp::OpMaxElementLength2D:
3873 case SMESHOp::OpEqualFace:
3874 case SMESHOp::OpAspectRatio3D:
3875 case SMESHOp::OpVolume:
3876 case SMESHOp::OpMaxElementLength3D:
3877 case SMESHOp::OpBareBorderVolume:
3878 case SMESHOp::OpOverConstrainedVolume:
3879 case SMESHOp::OpEqualVolume:
3882 LightApp_SelectionMgr* mgr = selectionMgr();
3883 SALOME_ListIO selected; mgr->selectedObjects( selected );
3885 if( !selected.IsEmpty() ) {
3886 SUIT_OverrideCursor wc;
3887 ::Control( theCommandID );
3890 SUIT_MessageBox::warning(desktop(),
3891 tr( "SMESH_WRN_WARNING" ),
3892 tr( "SMESH_BAD_SELECTION" ) );
3896 SUIT_MessageBox::warning(desktop(),
3897 tr( "SMESH_WRN_WARNING" ),
3898 tr( "NOT_A_VTK_VIEWER" ) );
3901 case SMESHOp::OpOverallMeshQuality:
3902 OverallMeshQuality();
3904 case SMESHOp::OpNumberingNodes:
3906 SUIT_OverrideCursor wc;
3907 LightApp_SelectionMgr* mgr = selectionMgr();
3908 SALOME_ListIO selected; mgr->selectedObjects( selected );
3910 SALOME_ListIteratorOfListIO it(selected);
3911 for( ; it.More(); it.Next()) {
3912 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3913 if(anIObject->hasEntry()) {
3914 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3915 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3921 case SMESHOp::OpNumberingElements:
3923 SUIT_OverrideCursor wc;
3924 LightApp_SelectionMgr* mgr = selectionMgr();
3925 SALOME_ListIO selected; mgr->selectedObjects( selected );
3927 SALOME_ListIteratorOfListIO it(selected);
3928 for( ; it.More(); it.Next()) {
3929 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3930 if(anIObject->hasEntry())
3931 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3932 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3937 case SMESHOp::OpPropertiesLength:
3938 case SMESHOp::OpPropertiesArea:
3939 case SMESHOp::OpPropertiesVolume:
3940 case SMESHOp::OpMinimumDistance:
3941 case SMESHOp::OpBoundingBox:
3942 case SMESHOp::OpAngle:
3944 int page = SMESHGUI_MeasureDlg::MinDistance;
3945 if ( theCommandID == SMESHOp::OpBoundingBox )
3946 page = SMESHGUI_MeasureDlg::BoundingBox;
3947 else if ( theCommandID == SMESHOp::OpPropertiesLength )
3948 page = SMESHGUI_MeasureDlg::Length;
3949 else if ( theCommandID == SMESHOp::OpPropertiesArea )
3950 page = SMESHGUI_MeasureDlg::Area;
3951 else if ( theCommandID == SMESHOp::OpPropertiesVolume )
3952 page = SMESHGUI_MeasureDlg::Volume;
3953 else if ( theCommandID == SMESHOp::OpAngle )
3954 page = SMESHGUI_MeasureDlg::Angle;
3956 EmitSignalDeactivateDialog();
3957 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3961 case SMESHOp::OpSortChild:
3964 case SMESHOp::OpBreakLink:
3965 ::breakShaperLink();
3970 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3971 //updateObjBrowser();
3975 //=============================================================================
3979 //=============================================================================
3980 bool SMESHGUI::OnMousePress( QMouseEvent * /*pe*/, SUIT_ViewWindow * /*wnd*/ )
3985 //=============================================================================
3989 //=============================================================================
3990 bool SMESHGUI::OnMouseMove( QMouseEvent * /*pe*/, SUIT_ViewWindow * /*wnd*/ )
3995 //=============================================================================
3999 //=============================================================================
4000 bool SMESHGUI::OnKeyPress( QKeyEvent * /*pe*/, SUIT_ViewWindow * /*wnd*/ )
4005 //=============================================================================
4006 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
4007 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
4009 //=============================================================================
4010 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
4011 SUIT_ViewWindow* wnd )
4013 if(theIO->hasEntry()){
4014 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
4015 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
4019 //=======================================================================
4020 // function : createSMESHAction
4022 //=======================================================================
4023 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
4024 const int key, const bool toggle, const QString& shortcutAction )
4027 QWidget* parent = application()->desktop();
4028 SUIT_ResourceMgr* resMgr = resourceMgr();
4030 if ( !icon_id.isEmpty() )
4031 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
4033 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICON_%1" ).arg( po_id ).toLatin1().data() ), false );
4034 if ( !pix.isNull() )
4035 icon = QIcon( pix );
4037 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
4038 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
4039 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
4041 createAction( id, tooltip, icon, menu, status_bar, key, parent,
4042 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
4045 //=======================================================================
4046 // function : createPopupItem
4048 //=======================================================================
4049 void SMESHGUI::createPopupItem( const int id,
4050 const QString& clients,
4051 const QString& types,
4052 const QString& theRule,
4055 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
4056 popupMgr()->insert( action( id ), pId, 0 );
4058 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4059 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4060 QString rule = "(%1) and (%2) and (%3)";
4061 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
4062 if( clients.isEmpty() )
4063 rule = rule.arg( QString( "true" ) );
4065 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
4066 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
4069 bool cont = myRules.contains( id );
4071 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
4073 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
4074 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
4077 //=======================================================================
4078 // function : initialize
4080 //=======================================================================
4081 void SMESHGUI::initialize( CAM_Application* app )
4083 SalomeApp_Module::initialize( app );
4085 // SUIT_ResourceMgr* mgr = app->resourceMgr();
4087 /* Automatic Update flag */
4088 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
4090 // ----- create actions --------------
4092 //createSMESHAction( SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
4093 createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_I) );
4094 createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
4095 createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL" );
4097 createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
4099 createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
4100 createSMESHAction( SMESHOp::OpImportGMF, "IMPORT_GMF" );
4101 createSMESHAction( SMESHOp::OpPopupImportUNV, "IMPORT_UNV");
4102 createSMESHAction( SMESHOp::OpPopupImportMED, "IMPORT_MED");
4103 createSMESHAction( SMESHOp::OpPopupImportSTL, "IMPORT_STL" );
4105 createSMESHAction( SMESHOp::OpPopupImportCGNS, "IMPORT_CGNS" );
4107 createSMESHAction( SMESHOp::OpPopupImportSAUV, "IMPORT_SAUV" );
4108 createSMESHAction( SMESHOp::OpPopupImportGMF, "IMPORT_GMF" );
4110 createSMESHAction( SMESHOp::OpExportDAT, "DAT" );
4111 createSMESHAction( SMESHOp::OpExportMED, "MED" );
4112 createSMESHAction( SMESHOp::OpExportUNV, "UNV" );
4113 createSMESHAction( SMESHOp::OpExportSTL, "STL" );
4115 createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
4117 createSMESHAction( SMESHOp::OpExportSAUV, "SAUV");
4118 createSMESHAction( SMESHOp::OpExportGMF, "GMF" );
4119 createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
4120 createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
4121 createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
4122 createSMESHAction( SMESHOp::OpPopupExportSTL, "STL" );
4124 createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
4126 createSMESHAction( SMESHOp::OpPopupExportSAUV, "SAUV");
4127 createSMESHAction( SMESHOp::OpPopupExportGMF, "GMF" );
4128 createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
4129 createSMESHAction( SMESHOp::OpDelete, "DELETE", "ICON_DELETE", Qt::Key_Delete );
4130 createSMESHAction( SMESHOp::OpSelectFiltersLibrary, "SEL_FILTER_LIB" );
4131 createSMESHAction( SMESHOp::OpCreateMesh, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
4132 createSMESHAction( SMESHOp::OpCreateSubMesh, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
4133 createSMESHAction( SMESHOp::OpEditMeshOrSubMesh, "EDIT_MESHSUBMESH", "ICON_DLG_EDIT_MESH" );
4134 createSMESHAction( SMESHOp::OpEditMesh, "EDIT_MESH", "ICON_DLG_EDIT_MESH" );
4135 createSMESHAction( SMESHOp::OpEditSubMesh, "EDIT_SUBMESH", "ICON_DLG_EDIT_MESH" );
4136 createSMESHAction( SMESHOp::OpBuildCompoundMesh, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
4137 createSMESHAction( SMESHOp::OpCopyMesh, "COPY_MESH", "ICON_COPY_MESH" );
4138 createSMESHAction( SMESHOp::OpCompute, "COMPUTE", "ICON_COMPUTE" );
4139 createSMESHAction( SMESHOp::OpComputeSubMesh, "COMPUTE_SUBMESH", "ICON_COMPUTE" );
4140 createSMESHAction( SMESHOp::OpRecompute, "RE_COMPUTE", "ICON_COMPUTE" );
4141 createSMESHAction( SMESHOp::OpPreCompute, "PRECOMPUTE", "ICON_PRECOMPUTE" );
4142 createSMESHAction( SMESHOp::OpShowErrors, "SHOW_ERRORS", "ICON_SHOW_ERRORS" );
4143 createSMESHAction( SMESHOp::OpEvaluate, "EVALUATE", "ICON_EVALUATE" );
4144 createSMESHAction( SMESHOp::OpMeshOrder, "MESH_ORDER", "ICON_MESH_ORDER");
4145 createSMESHAction( SMESHOp::OpCreateGroup, "CREATE_GROUP", "ICON_CREATE_GROUP" );
4146 createSMESHAction( SMESHOp::OpCreateGeometryGroup, "CREATE_GEO_GROUP", "ICON_CREATE_GEO_GROUP" );
4147 createSMESHAction( SMESHOp::OpConstructGroup, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
4148 createSMESHAction( SMESHOp::OpEditGroup, "EDIT_GROUP", "ICON_EDIT_GROUP" );
4149 createSMESHAction( SMESHOp::OpEditGeomGroupAsGroup, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
4150 createSMESHAction( SMESHOp::OpUnionGroups, "UN_GROUP", "ICON_UNION" );
4151 createSMESHAction( SMESHOp::OpIntersectGroups, "INT_GROUP", "ICON_INTERSECT" );
4152 createSMESHAction( SMESHOp::OpCutGroups, "CUT_GROUP", "ICON_CUT" );
4153 createSMESHAction( SMESHOp::OpGroupUnderlyingElem, "UNDERLYING_ELEMS", "ICON_UNDERLYING_ELEMS" );
4154 createSMESHAction( SMESHOp::OpFaceGroupsByEdges, "FACE_GROUPS_BY_EDGES", "ICON_FACE_GROUPS_BY_EDGES" );
4155 createSMESHAction( SMESHOp::OpAddElemGroupPopup, "ADD_TO_GROUP" );
4156 createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE_FROM_GROUP" );
4157 createSMESHAction( SMESHOp::OpDeleteGroup, "DEL_GROUP", "ICON_DEL_GROUP" );
4158 createSMESHAction( SMESHOp::OpMeshInformation , "ADV_INFO", "ICON_ADV_INFO" );
4159 //createSMESHAction( SMESHOp::OpStdInfo, "STD_INFO", "ICON_STD_INFO" );
4160 //createSMESHAction( SMESHOp::OpWhatIs, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4161 createSMESHAction( SMESHOp::OpFindElementByPoint, "FIND_ELEM", "ICON_FIND_ELEM" );
4163 createSMESHAction( SMESHOp::OpFreeNode, "FREE_NODE", "ICON_FREE_NODE", 0, true );
4164 createSMESHAction( SMESHOp::OpEqualNode, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
4165 createSMESHAction( SMESHOp::OpNodeConnectivityNb, "NODE_CONNECTIVITY_NB", "ICON_NODE_CONN_NB", 0, true );
4166 createSMESHAction( SMESHOp::OpFreeEdge, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
4167 createSMESHAction( SMESHOp::OpFreeBorder, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
4168 createSMESHAction( SMESHOp::OpLength, "LENGTH", "ICON_LENGTH", 0, true );
4169 createSMESHAction( SMESHOp::OpConnection, "CONNECTION", "ICON_CONNECTION", 0, true );
4170 createSMESHAction( SMESHOp::OpEqualEdge, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
4171 createSMESHAction( SMESHOp::OpFreeFace, "FREE_FACES", "ICON_FREE_FACES", 0, true );
4172 createSMESHAction( SMESHOp::OpBareBorderFace, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
4173 createSMESHAction( SMESHOp::OpOverConstrainedFace, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
4174 createSMESHAction( SMESHOp::OpLength2D, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
4175 createSMESHAction( SMESHOp::OpDeflection2D, "DEFLECTION_2D", "ICON_DEFLECTION_2D", 0, true );
4176 createSMESHAction( SMESHOp::OpConnection2D, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
4177 createSMESHAction( SMESHOp::OpArea, "AREA", "ICON_AREA", 0, true );
4178 createSMESHAction( SMESHOp::OpTaper, "TAPER", "ICON_TAPER", 0, true );
4179 createSMESHAction( SMESHOp::OpAspectRatio, "ASPECT", "ICON_ASPECT", 0, true );
4180 createSMESHAction( SMESHOp::OpMinimumAngle, "MIN_ANG", "ICON_ANGLE", 0, true );
4181 createSMESHAction( SMESHOp::OpWarpingAngle, "WARP", "ICON_WARP", 0, true );
4182 createSMESHAction( SMESHOp::OpSkew, "SKEW", "ICON_SKEW", 0, true );
4183 createSMESHAction( SMESHOp::OpMaxElementLength2D, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
4184 createSMESHAction( SMESHOp::OpEqualFace, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
4185 createSMESHAction( SMESHOp::OpAspectRatio3D, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
4186 createSMESHAction( SMESHOp::OpVolume, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
4187 createSMESHAction( SMESHOp::OpMaxElementLength3D, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
4188 createSMESHAction( SMESHOp::OpBareBorderVolume, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
4189 createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
4190 createSMESHAction( SMESHOp::OpEqualVolume, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
4191 createSMESHAction( SMESHOp::OpOverallMeshQuality, "OVERALL_MESH_QUALITY", "ICON_OVL_MESH_QUALITY" );
4193 createSMESHAction( SMESHOp::OpNode, "NODE", "ICON_DLG_NODE" );
4194 createSMESHAction( SMESHOp::OpElem0D, "ELEM0D", "ICON_DLG_ELEM0D" );
4195 createSMESHAction( SMESHOp::OpElem0DOnElemNodes, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
4196 createSMESHAction( SMESHOp::OpBall, "BALL", "ICON_DLG_BALL" );
4197 createSMESHAction( SMESHOp::OpEdge, "EDGE", "ICON_DLG_EDGE" );
4198 createSMESHAction( SMESHOp::OpTriangle, "TRIANGLE", "ICON_DLG_TRIANGLE" );
4199 createSMESHAction( SMESHOp::OpQuadrangle, "QUAD", "ICON_DLG_QUADRANGLE" );
4200 createSMESHAction( SMESHOp::OpPolygon, "POLYGON", "ICON_DLG_POLYGON" );
4201 createSMESHAction( SMESHOp::OpTetrahedron, "TETRA", "ICON_DLG_TETRAS" );
4202 createSMESHAction( SMESHOp::OpHexahedron, "HEXA", "ICON_DLG_HEXAS" );
4203 createSMESHAction( SMESHOp::OpPentahedron, "PENTA", "ICON_DLG_PENTA" );
4204 createSMESHAction( SMESHOp::OpPyramid , "PYRAMID", "ICON_DLG_PYRAMID" );
4205 createSMESHAction( SMESHOp::OpHexagonalPrism, "OCTA", "ICON_DLG_OCTA" );
4206 createSMESHAction( SMESHOp::OpPolyhedron, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
4207 createSMESHAction( SMESHOp::OpQuadraticEdge, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
4208 createSMESHAction( SMESHOp::OpQuadraticTriangle, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
4209 createSMESHAction( SMESHOp::OpBiQuadraticTriangle, "BIQUADRATIC_TRIANGLE", "ICON_DLG_BIQUADRATIC_TRIANGLE" );
4210 createSMESHAction( SMESHOp::OpQuadraticQuadrangle, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
4211 createSMESHAction( SMESHOp::OpBiQuadraticQuadrangle, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
4212 createSMESHAction( SMESHOp::OpQuadraticPolygon, "QUADRATIC_POLYGON", "ICON_DLG_QUADRATIC_POLYGON" );
4213 createSMESHAction( SMESHOp::OpQuadraticTetrahedron, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
4214 createSMESHAction( SMESHOp::OpQuadraticPyramid, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
4215 createSMESHAction( SMESHOp::OpQuadraticPentahedron, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
4216 createSMESHAction( SMESHOp::OpBiQuadraticPentahedron, "BIQUADRATIC_PENTAHEDRON", "ICON_DLG_BIQUADRATIC_PENTAHEDRON" );
4217 createSMESHAction( SMESHOp::OpQuadraticHexahedron, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
4218 createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
4220 createSMESHAction( SMESHOp::OpRemoveNodes, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
4221 createSMESHAction( SMESHOp::OpRemoveElements, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
4222 createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
4223 createSMESHAction( SMESHOp::OpClearMesh, "CLEAR_MESH", "ICON_CLEAR_MESH" );
4225 //createSMESHAction( SMESHOp::OpRenumberingNodes, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
4226 //createSMESHAction( SMESHOp::OpRenumberingElements, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
4228 createSMESHAction( SMESHOp::OpTranslation, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
4229 createSMESHAction( SMESHOp::OpRotation, "ROT", "ICON_DLG_MESH_ROTATION" );
4230 createSMESHAction( SMESHOp::OpSymmetry, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
4231 createSMESHAction( SMESHOp::OpScale, "SCALE", "ICON_DLG_MESH_SCALE" );
4232 createSMESHAction( SMESHOp::OpOffset, "OFFSET", "ICON_DLG_MESH_OFFSET" );
4233 createSMESHAction( SMESHOp::OpSewing, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
4234 createSMESHAction( SMESHOp::OpMergeNodes, "MERGE", "ICON_SMESH_MERGE_NODES" );
4235 createSMESHAction( SMESHOp::OpMergeElements, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
4236 createSMESHAction( SMESHOp::OpMoveNode, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
4237 createSMESHAction( SMESHOp::OpDuplicateNodes, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
4238 createSMESHAction( SMESHOp::OpDiagonalInversion, "INV", "ICON_DLG_MESH_DIAGONAL" );
4239 createSMESHAction( SMESHOp::OpUnionOfTwoTriangle, "UNION2", "ICON_UNION2TRI" );
4240 createSMESHAction( SMESHOp::OpOrientation, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
4241 createSMESHAction( SMESHOp::OpReorientFaces, "REORIENT_2D", "ICON_REORIENT_2D" );
4242 createSMESHAction( SMESHOp::OpUnionOfTriangles, "UNION", "ICON_UNIONTRI" );
4243 createSMESHAction( SMESHOp::OpCuttingOfQuadrangles, "CUT", "ICON_CUTQUAD" );
4244 createSMESHAction( SMESHOp::OpSplitVolumes, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
4245 createSMESHAction( SMESHOp::OpSplitBiQuadratic, "SPLIT_BIQUAD", "ICON_SPLIT_BIQUAD" );
4246 createSMESHAction( SMESHOp::OpSmoothing, "SMOOTH", "ICON_DLG_SMOOTHING" );
4247 createSMESHAction( SMESHOp::OpExtrusion, "EXTRUSION", "ICON_EXTRUSION" );
4248 createSMESHAction( SMESHOp::OpExtrusionAlongAPath, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
4249 createSMESHAction( SMESHOp::OpRevolution, "REVOLUTION", "ICON_REVOLUTION" );
4250 createSMESHAction( SMESHOp::OpPatternMapping, "MAP", "ICON_MAP" );
4251 createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
4252 createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D", "ICON_2D_FROM_3D" );
4254 createSMESHAction( SMESHOp::OpReset, "RESET" );
4255 createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
4256 createSMESHAction( SMESHOp::OpShowScalarBar, "SHOW_SCALAR_BAR","",0, true );
4257 createSMESHAction( SMESHOp::OpSaveDistribution, "SAVE_DISTRIBUTION" );
4258 createSMESHAction( SMESHOp::OpShowDistribution, "SHOW_DISTRIBUTION","",0, true );
4259 #ifndef DISABLE_PLOT2DVIEWER
4260 createSMESHAction( SMESHOp::OpPlotDistribution, "PLOT_DISTRIBUTION" );
4262 createSMESHAction( SMESHOp::OpDMWireframe, "WIRE", "ICON_WIRE", 0, true );
4263 createSMESHAction( SMESHOp::OpDMShading, "SHADE", "ICON_SHADE", 0, true );
4264 createSMESHAction( SMESHOp::OpDMNodes, "NODES", "ICON_POINTS", 0, true );
4265 createSMESHAction( SMESHOp::OpDMShrink, "SHRINK", "ICON_SHRINK", 0, true );
4266 createSMESHAction( SMESHOp::OpUpdate, "UPDATE", "ICON_UPDATE" );
4267 createSMESHAction( SMESHOp::OpDE0DElements, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
4268 createSMESHAction( SMESHOp::OpDEEdges, "EDGES", "ICON_DLG_EDGE", 0, true );
4269 createSMESHAction( SMESHOp::OpDEFaces, "FACES", "ICON_DLG_TRIANGLE", 0, true );
4270 createSMESHAction( SMESHOp::OpDEVolumes, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
4271 createSMESHAction( SMESHOp::OpDEBalls, "BALLS", "ICON_DLG_BALL", 0, true );
4272 createSMESHAction( SMESHOp::OpDEChoose, "CHOOSE", "ICON_DLG_CHOOSE", 0, false );
4273 createSMESHAction( SMESHOp::OpDEAllEntity, "ALL", "ICON_DLG_CHOOSE_ALL", 0, false );
4274 createSMESHAction( SMESHOp::OpOrientationOnFaces, "FACE_ORIENTATION", "", 0, true );
4276 createSMESHAction( SMESHOp::OpRepresentationLines, "LINE_REPRESENTATION", "", 0, true );
4277 createSMESHAction( SMESHOp::OpRepresentationArcs, "ARC_REPRESENTATION", "", 0, true );
4279 createSMESHAction( SMESHOp::OpEditHypothesis, "EDIT_HYPO" );
4280 createSMESHAction( SMESHOp::OpUnassign, "UNASSIGN" );
4281 createSMESHAction( SMESHOp::OpNumberingNodes, "NUM_NODES", "", 0, true );
4282 createSMESHAction( SMESHOp::OpNumberingElements, "NUM_ELEMENTS", "", 0, true );
4283 createSMESHAction( SMESHOp::OpProperties, "COLORS" );
4284 createSMESHAction( SMESHOp::OpTransparency, "TRANSP" );
4285 createSMESHAction( SMESHOp::OpClipping, "CLIP" );
4286 createSMESHAction( SMESHOp::OpAutoColor, "AUTO_COLOR" );
4287 createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
4289 // Adaptation - begin
4290 createSMESHAction( SMESHOp::OpUniformRefinement, "REF_ALL", "ICON_REF_ALL" );
4291 createSMESHAction( SMESHOp::OpHONewCase, "HOMARD_CREATE_CASE", "ICON_HOMARD_CREATE_CASE" );
4292 createSMESHAction( SMESHOp::OpHOCaseFollow, "HOMARD_FOLLOW_ITERATION", "ICON_HOMARD_FOLLOW_ITERATION" );
4293 createSMESHAction( SMESHOp::OpHONewIter, "HOMARD_NEW_ITERATION", "ICON_HOMARD_NEW_ITERATION" );
4294 createSMESHAction( SMESHOp::OpHOIterCompute, "HOMARD_COMPUTE", "ICON_HOMARD_COMPUTE" );
4295 createSMESHAction( SMESHOp::OpHOIterComputePublish, "HOMARD_COMPUTE_PUBLISH", "ICON_HOMARD_COMPUTE_PUBLISH" );
4296 createSMESHAction( SMESHOp::OpHOEdit, "EDIT", "ICON_DLG_EDIT_MESH" );
4297 createSMESHAction( SMESHOp::OpHODelete, "DELETE", "ICON_DELETE" );
4298 createSMESHAction( SMESHOp::OpMGAdapt, "MG_ADAPT", "ICON_MG_ADAPT" );
4301 createSMESHAction( SMESHOp::OpMinimumDistance, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
4302 createSMESHAction( SMESHOp::OpBoundingBox, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
4303 createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH", "ICON_MEASURE_LENGTH" );
4304 createSMESHAction( SMESHOp::OpPropertiesArea, "MEASURE_AREA", "ICON_MEASURE_AREA" );
4305 createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME", "ICON_MEASURE_VOLUME" );
4306 createSMESHAction( SMESHOp::OpAngle, "MEASURE_ANGLE", "ICON_MEASURE_ANGLE" );
4308 createSMESHAction( SMESHOp::OpHide, "HIDE", "ICON_HIDE" );
4309 createSMESHAction( SMESHOp::OpShow, "SHOW", "ICON_SHOW" );
4310 createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
4312 createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
4314 createSMESHAction( SMESHOp::OpBreakLink, "BREAK_SHAPER_LINK" );
4316 QList<int> aCtrlActions;
4317 aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode
4318 << SMESHOp::OpNodeConnectivityNb // node controls
4319 << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
4320 << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge // edge controls
4321 << SMESHOp::OpDeflection2D
4322 << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
4323 << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
4324 << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
4325 << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
4326 << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace // face controls
4327 << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
4328 << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
4329 << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume; // volume controls
4330 QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
4331 aCtrlGroup->setExclusive( true );
4332 for( int i = 0; i < aCtrlActions.size(); i++ )
4333 aCtrlGroup->addAction( action( aCtrlActions[i] ) );
4335 // ----- create menu --------------
4336 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
4337 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
4338 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
4339 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
4340 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
4341 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
4342 adaptId = createMenu( tr( "MEN_ADAPT" ), -1, 80, 10 ),
4343 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
4344 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
4346 createMenu( separator(), fileId );
4348 QMenu* nodeMenu = new QMenu(); QMenu* edgeMenu = new QMenu();
4349 QMenu* faceMenu = new QMenu(); QMenu* volumeMenu = new QMenu();
4350 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
4351 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
4352 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10, -1, nodeMenu ),
4353 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10, -1, edgeMenu ),
4354 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10, -1, faceMenu ),
4355 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10, -1, volumeMenu ),
4356 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
4357 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
4358 //renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
4359 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
4360 refHomardId = createMenu( tr( "MEN_REF_HOMARD" ), adaptId, -1, 10 ),
4361 basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
4363 //createMenu( SMESHOp::OpImportDAT, importId, -1 );
4364 createMenu( SMESHOp::OpImportUNV, importId, -1 );
4365 createMenu( SMESHOp::OpImportMED, importId, -1 );
4366 createMenu( SMESHOp::OpImportSTL, importId, -1 );
4368 createMenu( SMESHOp::OpImportCGNS, importId, -1 );
4370 createMenu( SMESHOp::OpImportSAUV, importId, -1 );
4371 createMenu( SMESHOp::OpImportGMF, importId, -1 );
4372 createMenu( SMESHOp::OpExportDAT, exportId, -1 );
4373 createMenu( SMESHOp::OpExportMED, exportId, -1 );
4374 createMenu( SMESHOp::OpExportUNV, exportId, -1 );
4375 createMenu( SMESHOp::OpExportSTL, exportId, -1 );
4377 createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
4379 createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
4380 createMenu( SMESHOp::OpExportGMF, exportId, -1 );
4381 createMenu( separator(), fileId, 10 );
4383 createMenu( SMESHOp::OpDelete, editId, -1 );
4385 createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
4387 createMenu( SMESHOp::OpCreateMesh, meshId, -1 ); // "Mesh" menu
4388 createMenu( SMESHOp::OpCreateSubMesh, meshId, -1 );
4389 createMenu( SMESHOp::OpEditMeshOrSubMesh, meshId, -1 );
4390 createMenu( SMESHOp::OpBuildCompoundMesh, meshId, -1 );
4391 createMenu( SMESHOp::OpCopyMesh, meshId, -1 );
4392 createMenu( separator(), meshId, -1 );
4393 createMenu( SMESHOp::OpCompute, meshId, -1 );
4394 createMenu( SMESHOp::OpPreCompute, meshId, -1 );
4395 createMenu( SMESHOp::OpEvaluate, meshId, -1 );
4396 createMenu( SMESHOp::OpMeshOrder, meshId, -1 );
4397 createMenu( separator(), meshId, -1 );
4398 createMenu( SMESHOp::OpCreateGroup, meshId, -1 );
4399 createMenu( SMESHOp::OpCreateGeometryGroup, meshId, -1 );
4400 createMenu( SMESHOp::OpConstructGroup, meshId, -1 );
4401 createMenu( SMESHOp::OpEditGroup, meshId, -1 );
4402 createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4403 createMenu( separator(), meshId, -1 );
4404 createMenu( SMESHOp::OpUnionGroups, meshId, -1 );
4405 createMenu( SMESHOp::OpIntersectGroups, meshId, -1 );
4406 createMenu( SMESHOp::OpCutGroups, meshId, -1 );
4407 createMenu( separator(), meshId, -1 );
4408 createMenu( SMESHOp::OpGroupUnderlyingElem, meshId, -1 );
4409 createMenu( SMESHOp::OpFaceGroupsByEdges, meshId, -1 );
4410 createMenu( separator(), meshId, -1 );
4411 createMenu( SMESHOp::OpMeshInformation, meshId, -1 );
4412 //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4413 //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4414 createMenu( SMESHOp::OpFindElementByPoint, meshId, -1 );
4415 createMenu( separator(), meshId, -1 );
4417 createMenu( SMESHOp::OpFreeNode, nodeId, -1 );
4418 createMenu( SMESHOp::OpEqualNode, nodeId, -1 );
4419 //createMenu( SMESHOp::OpNodeConnectivityNb, nodeId, -1 );
4420 createMenu( SMESHOp::OpFreeBorder, edgeId, -1 );
4421 createMenu( SMESHOp::OpLength, edgeId, -1 );
4422 createMenu( SMESHOp::OpConnection, edgeId, -1 );
4423 createMenu( SMESHOp::OpEqualEdge, edgeId, -1 );
4424 createMenu( SMESHOp::OpFreeEdge, faceId, -1 );
4425 createMenu( SMESHOp::OpFreeFace, faceId, -1 );
4426 createMenu( SMESHOp::OpBareBorderFace, faceId, -1 );
4427 createMenu( SMESHOp::OpOverConstrainedFace, faceId, -1 );
4428 createMenu( SMESHOp::OpLength2D, faceId, -1 );
4429 createMenu( SMESHOp::OpConnection2D, faceId, -1 );
4430 createMenu( SMESHOp::OpArea, faceId, -1 );
4431 createMenu( SMESHOp::OpTaper, faceId, -1 );
4432 createMenu( SMESHOp::OpAspectRatio, faceId, -1 );
4433 createMenu( SMESHOp::OpMinimumAngle, faceId, -1 );
4434 createMenu( SMESHOp::OpWarpingAngle, faceId, -1 );
4435 createMenu( SMESHOp::OpSkew, faceId, -1 );
4436 createMenu( SMESHOp::OpMaxElementLength2D, faceId, -1 );
4437 createMenu( SMESHOp::OpEqualFace, faceId, -1 );
4438 createMenu( SMESHOp::OpDeflection2D, faceId, -1 );
4439 createMenu( SMESHOp::OpAspectRatio3D, volumeId, -1 );
4440 createMenu( SMESHOp::OpVolume, volumeId, -1 );
4441 createMenu( SMESHOp::OpMaxElementLength3D, volumeId, -1 );
4442 createMenu( SMESHOp::OpBareBorderVolume, volumeId, -1 );
4443 createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4444 createMenu( SMESHOp::OpEqualVolume, volumeId, -1 );
4445 createMenu( separator(), ctrlId, -1 );
4446 createMenu( SMESHOp::OpReset, ctrlId, -1 );
4447 createMenu( separator(), ctrlId, -1 );
4448 createMenu( SMESHOp::OpOverallMeshQuality, ctrlId, -1 );
4450 createMenu( SMESHOp::OpNode, addId, -1 );
4451 createMenu( SMESHOp::OpElem0D, addId, -1 );
4452 createMenu( SMESHOp::OpElem0DOnElemNodes, addId, -1 );
4453 createMenu( SMESHOp::OpBall, addId, -1 );
4454 createMenu( SMESHOp::OpEdge, addId, -1 );
4455 createMenu( SMESHOp::OpTriangle, addId, -1 );
4456 createMenu( SMESHOp::OpQuadrangle, addId, -1 );
4457 createMenu( SMESHOp::OpPolygon, addId, -1 );
4458 createMenu( SMESHOp::OpTetrahedron, addId, -1 );
4459 createMenu( SMESHOp::OpHexahedron, addId, -1 );
4460 createMenu( SMESHOp::OpPentahedron, addId, -1 );
4461 createMenu( SMESHOp::OpPyramid, addId, -1 );
4462 createMenu( SMESHOp::OpHexagonalPrism, addId, -1 );
4463 createMenu( SMESHOp::OpPolyhedron, addId, -1 );
4464 createMenu( separator(), addId, -1 );
4465 createMenu( SMESHOp::OpQuadraticEdge, addId, -1 );
4466 createMenu( SMESHOp::OpQuadraticTriangle, addId, -1 );
4467 createMenu( SMESHOp::OpBiQuadraticTriangle , addId, -1 );
4468 createMenu( SMESHOp::OpQuadraticQuadrangle, addId, -1 );
4469 createMenu( SMESHOp::OpBiQuadraticQuadrangle, addId, -1 );
4470 createMenu( SMESHOp::OpQuadraticPolygon, addId, -1 );
4471 createMenu( SMESHOp::OpQuadraticTetrahedron, addId, -1 );
4472 createMenu( SMESHOp::OpQuadraticPyramid, addId, -1 );
4473 createMenu( SMESHOp::OpQuadraticPentahedron, addId, -1 );
4474 createMenu( SMESHOp::OpBiQuadraticPentahedron, addId, -1 );
4475 createMenu( SMESHOp::OpQuadraticHexahedron, addId, -1 );
4476 createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4478 createMenu( SMESHOp::OpRemoveNodes, removeId, -1 );
4479 createMenu( SMESHOp::OpRemoveElements, removeId, -1 );
4480 createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4481 createMenu( separator(), removeId, -1 );
4482 createMenu( SMESHOp::OpDeleteGroup, removeId, -1 );
4483 createMenu( separator(), removeId, -1 );
4484 createMenu( SMESHOp::OpClearMesh, removeId, -1 );
4486 //createMenu( SMESHOp::OpRenumberingNodes, renumId, -1 );
4487 //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4489 createMenu( SMESHOp::OpMergeNodes, transfId, -1 );
4490 createMenu( SMESHOp::OpMergeElements, transfId, -1 );
4491 createMenu( SMESHOp::OpTranslation, transfId, -1 );
4492 createMenu( SMESHOp::OpRotation, transfId, -1 );
4493 createMenu( SMESHOp::OpSymmetry, transfId, -1 );
4494 createMenu( SMESHOp::OpScale, transfId, -1 );
4495 createMenu( SMESHOp::OpOffset, transfId, -1 );
4496 createMenu( SMESHOp::OpSewing, transfId, -1 );
4497 createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4499 createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4500 createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4501 createMenu( SMESHOp::OpExtrusion, modifyId, -1 );
4502 createMenu( SMESHOp::OpExtrusionAlongAPath, modifyId, -1 );
4503 createMenu( SMESHOp::OpRevolution, modifyId, -1 );
4504 createMenu( SMESHOp::OpOrientation, modifyId, -1 );
4505 createMenu( SMESHOp::OpReorientFaces, modifyId, -1 );
4506 createMenu( SMESHOp::OpMoveNode, modifyId, -1 );
4507 createMenu( SMESHOp::OpDiagonalInversion, modifyId, -1 );
4508 createMenu( SMESHOp::OpUnionOfTwoTriangle, modifyId, -1 );
4509 createMenu( SMESHOp::OpUnionOfTriangles, modifyId, -1 );
4510 createMenu( SMESHOp::OpCuttingOfQuadrangles, modifyId, -1 );
4511 createMenu( SMESHOp::OpSplitVolumes, modifyId, -1 );
4512 createMenu( SMESHOp::OpSplitBiQuadratic, modifyId, -1 );
4513 createMenu( SMESHOp::OpSmoothing, modifyId, -1 );
4514 createMenu( SMESHOp::OpPatternMapping, modifyId, -1 );
4516 // Adaptation - begin
4517 createMenu( SMESHOp::OpUniformRefinement, adaptId, -1 );
4518 createMenu( SMESHOp::OpHONewCase, refHomardId, -1 );
4519 createMenu( SMESHOp::OpHOCaseFollow, refHomardId, -1 );
4520 createMenu( separator(), refHomardId, -1 );
4521 createMenu( SMESHOp::OpHONewIter, refHomardId, -1 );
4522 createMenu( SMESHOp::OpHOIterCompute, refHomardId, -1 );
4523 createMenu( SMESHOp::OpHOIterComputePublish, refHomardId, -1 );
4524 createMenu( separator(), refHomardId, -1 );
4525 createMenu( SMESHOp::OpHOEdit, refHomardId, -1 );
4526 createMenu( SMESHOp::OpHODelete, refHomardId, -1 );
4527 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 createTool( SMESHOp::OpCreateMesh, meshTb );
4546 createTool( SMESHOp::OpCreateSubMesh, meshTb );
4547 createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4548 createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4549 createTool( SMESHOp::OpCopyMesh, meshTb );
4550 createTool( separator(), meshTb );
4551 createTool( SMESHOp::OpCompute, meshTb );
4552 createTool( SMESHOp::OpPreCompute, meshTb );
4553 createTool( SMESHOp::OpEvaluate, meshTb );
4554 createTool( SMESHOp::OpMeshOrder, meshTb );
4556 int infoTb = createTool( tr( "TB_INFO" ), QString( "SMESHInformationToolbar" ) ) ;
4557 createTool( SMESHOp::OpMeshInformation, infoTb );
4558 //createTool( SMESHOp::OpStdInfo, meshTb );
4559 //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4560 createTool( SMESHOp::OpFindElementByPoint, infoTb );
4562 int groupTb = createTool( tr( "TB_GROUP" ), QString( "SMESHGroupToolbar" ) ) ;
4563 createTool( SMESHOp::OpCreateGroup, groupTb );
4564 createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4565 createTool( SMESHOp::OpConstructGroup, groupTb );
4566 createTool( SMESHOp::OpEditGroup, groupTb );
4568 int ctrl0dTb = createTool( tr( "TB_CTRL0D" ), QString( "SMESHNodeControlsToolbar" ) ) ;
4569 createTool( SMESHOp::OpFreeNode, ctrl0dTb );
4570 createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4571 //createTool( SMESHOp::OpNodeConnectivityNb, ctrl0dTb );
4573 int ctrl1dTb = createTool( tr( "TB_CTRL1D" ), QString( "SMESHEdgeControlsToolbar" ) ) ;
4574 createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4575 createTool( SMESHOp::OpLength, ctrl1dTb );
4576 createTool( SMESHOp::OpConnection, ctrl1dTb );
4577 createTool( SMESHOp::OpEqualEdge, ctrl1dTb );
4579 int ctrl2dTb = createTool( tr( "TB_CTRL2D" ), QString( "SMESHFaceControlsToolbar" ) ) ;
4580 createTool( SMESHOp::OpFreeEdge, ctrl2dTb );
4581 createTool( SMESHOp::OpFreeFace, ctrl2dTb );
4582 createTool( SMESHOp::OpBareBorderFace, ctrl2dTb );
4583 createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4584 createTool( SMESHOp::OpLength2D, ctrl2dTb );
4585 createTool( SMESHOp::OpConnection2D, ctrl2dTb );
4586 createTool( SMESHOp::OpArea, ctrl2dTb );
4587 createTool( SMESHOp::OpTaper, ctrl2dTb );
4588 createTool( SMESHOp::OpAspectRatio, ctrl2dTb );
4589 createTool( SMESHOp::OpMinimumAngle, ctrl2dTb );
4590 createTool( SMESHOp::OpWarpingAngle, ctrl2dTb );
4591 createTool( SMESHOp::OpSkew, ctrl2dTb );
4592 createTool( SMESHOp::OpMaxElementLength2D, ctrl2dTb );
4593 createTool( SMESHOp::OpEqualFace, ctrl2dTb );
4594 createTool( SMESHOp::OpDeflection2D, ctrl2dTb );
4596 int ctrl3dTb = createTool( tr( "TB_CTRL3D" ), QString( "SMESHVolumeControlsToolbar" ) ) ;
4597 createTool( SMESHOp::OpAspectRatio3D, ctrl3dTb );
4598 createTool( SMESHOp::OpVolume, ctrl3dTb );
4599 createTool( SMESHOp::OpMaxElementLength3D, ctrl3dTb );
4600 createTool( SMESHOp::OpBareBorderVolume, ctrl3dTb );
4601 createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
4602 createTool( SMESHOp::OpEqualVolume, ctrl3dTb );
4604 int addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ) ;
4605 createTool( SMESHOp::OpNode, addElemTb );
4606 createTool( SMESHOp::OpElem0D, addElemTb );
4607 createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4608 createTool( SMESHOp::OpBall, addElemTb );
4609 createTool( SMESHOp::OpEdge, addElemTb );
4610 createTool( SMESHOp::OpTriangle, addElemTb );
4611 createTool( SMESHOp::OpQuadrangle, addElemTb );
4612 createTool( SMESHOp::OpPolygon, addElemTb );
4613 createTool( SMESHOp::OpTetrahedron, addElemTb );
4614 createTool( SMESHOp::OpHexahedron, addElemTb );
4615 createTool( SMESHOp::OpPentahedron, addElemTb );
4616 createTool( SMESHOp::OpPyramid, addElemTb );
4617 createTool( SMESHOp::OpHexagonalPrism, addElemTb );
4618 createTool( SMESHOp::OpPolyhedron, addElemTb );
4620 int addNonElemTb = createTool( tr( "TB_ADDNON" ), QString( "SMESHAddElementToolbar" ) ) ;
4621 createTool( SMESHOp::OpQuadraticEdge, addNonElemTb );
4622 createTool( SMESHOp::OpQuadraticTriangle, addNonElemTb );
4623 createTool( SMESHOp::OpBiQuadraticTriangle, addNonElemTb );
4624 createTool( SMESHOp::OpQuadraticQuadrangle, addNonElemTb );
4625 createTool( SMESHOp::OpBiQuadraticQuadrangle, addNonElemTb );
4626 createTool( SMESHOp::OpQuadraticPolygon, addNonElemTb );
4627 createTool( SMESHOp::OpQuadraticTetrahedron, addNonElemTb );
4628 createTool( SMESHOp::OpQuadraticPyramid, addNonElemTb );
4629 createTool( SMESHOp::OpQuadraticPentahedron, addNonElemTb );
4630 createTool( SMESHOp::OpBiQuadraticPentahedron, addNonElemTb );
4631 createTool( SMESHOp::OpQuadraticHexahedron, addNonElemTb );
4632 createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4634 int remTb = createTool( tr( "TB_REM" ), QString( "SMESHRemoveToolbar" ) ) ;
4635 createTool( SMESHOp::OpRemoveNodes, remTb );
4636 createTool( SMESHOp::OpRemoveElements, remTb );
4637 createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4638 createTool( SMESHOp::OpClearMesh, remTb );
4640 // int renumbTb = createTool( tr( "TB_RENUMBER" ), QString( "SMESHRenumberingToolbar" ) ) ;
4641 //createTool( SMESHOp::OpRenumberingNodes, renumbTb );
4642 //createTool( SMESHOp::OpRenumberingElements, renumbTb );
4644 int transformTb = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ) ;
4645 createTool( SMESHOp::OpMergeNodes, transformTb );
4646 createTool( SMESHOp::OpMergeElements, transformTb );
4647 createTool( SMESHOp::OpTranslation, transformTb );
4648 createTool( SMESHOp::OpRotation, transformTb );
4649 createTool( SMESHOp::OpSymmetry, transformTb );
4650 createTool( SMESHOp::OpScale, transformTb );
4651 createTool( SMESHOp::OpOffset, transformTb );
4652 createTool( SMESHOp::OpSewing, transformTb );
4653 createTool( SMESHOp::OpDuplicateNodes, transformTb );
4655 int modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ) ;
4656 createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4657 createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4658 createTool( SMESHOp::OpExtrusion, modifyTb );
4659 createTool( SMESHOp::OpExtrusionAlongAPath, modifyTb );
4660 createTool( SMESHOp::OpRevolution, modifyTb );
4661 createTool( SMESHOp::OpOrientation, modifyTb );
4662 createTool( SMESHOp::OpReorientFaces, modifyTb );
4663 createTool( SMESHOp::OpMoveNode, modifyTb );
4664 createTool( SMESHOp::OpDiagonalInversion, modifyTb );
4665 createTool( SMESHOp::OpUnionOfTwoTriangle, modifyTb );
4666 createTool( SMESHOp::OpUnionOfTriangles, modifyTb );
4667 createTool( SMESHOp::OpCuttingOfQuadrangles, modifyTb );
4668 createTool( SMESHOp::OpSplitVolumes, modifyTb );
4669 createTool( SMESHOp::OpSplitBiQuadratic, modifyTb );
4670 createTool( SMESHOp::OpSmoothing, modifyTb );
4671 createTool( SMESHOp::OpPatternMapping, modifyTb );
4673 // Adaptation - begin
4674 int adaptTb = createTool( tr( "TB_ADAPTATION" ),QString( "SMESHAdaptationToolbar" ) ) ;
4675 createTool( SMESHOp::OpUniformRefinement, adaptTb );
4676 createTool( SMESHOp::OpHONewCase, adaptTb );
4677 createTool( SMESHOp::OpHOCaseFollow, adaptTb );
4678 createTool( SMESHOp::OpHONewIter, adaptTb );
4679 createTool( SMESHOp::OpHOIterCompute, adaptTb );
4680 createTool( SMESHOp::OpHOIterComputePublish, adaptTb );
4681 createTool( SMESHOp::OpMGAdapt, adaptTb );
4684 int measuremTb = createTool( tr( "TB_MEASUREM" ), QString( "SMESHMeasurementsToolbar" ) ) ;
4685 createTool( SMESHOp::OpMinimumDistance, measuremTb );
4687 int dispModeTb = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4688 createTool( SMESHOp::OpUpdate, dispModeTb );
4690 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4691 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4695 OB = "'ObjectBrowser'",
4696 View = "'" + SVTK_Viewer::Type() + "'",
4698 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4699 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4700 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4701 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4702 smesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::COMPONENT ) ),
4703 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4704 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4705 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4706 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4707 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4708 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4709 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4711 mesh_part = mesh + " " + subMesh + " " + group,
4712 mesh_group = mesh + " " + group,
4713 mesh_submesh = mesh + " " + subMesh,
4714 hyp_alg = hypo + " " + algo;
4716 // popup for object browser
4718 isInvisible("not( isVisible )"),
4719 isEmpty("numberOfNodes = 0"),
4720 isNotEmpty("numberOfNodes <> 0"),
4722 // has nodes, edges, etc in VISIBLE! actor
4723 hasNodes("(numberOfNodes > 0 ) && hasActor"),
4724 hasElems("(count( elemTypes ) > 0)"),
4725 hasDifferentElems("(count( elemTypes ) > 1)"),
4726 hasDifferentObjElems("(count( objElemTypes ) > 1)"),
4727 hasBalls("({'BallElem'} in elemTypes)"),
4728 hasElems0d("({'Elem0d'} in elemTypes)"),
4729 hasEdges("({'Edge'} in elemTypes)"),
4730 hasFaces("({'Face'} in elemTypes)"),
4731 hasVolumes("({'Volume'} in elemTypes)"),
4732 hasFacesOrVolumes("(({'Face'} in elemTypes) || ({'Volume'} in elemTypes)) ");
4734 createPopupItem( SMESHOp::OpEditMesh, OB, mesh, "&& selcount=1" );
4735 createPopupItem( SMESHOp::OpCreateSubMesh, OB, mesh, "&& hasGeomReference");
4736 createPopupItem( SMESHOp::OpMeshOrder, OB, mesh, "&& selcount=1 && hasAlgo && hasGeomReference" );
4737 createPopupItem( SMESHOp::OpEditSubMesh, OB, subMesh, "&& selcount=1 && hasGeomReference" );
4738 createPopupItem( SMESHOp::OpEditGroup, OB, group );
4739 createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4741 popupMgr()->insert( separator(), -1, 0 );
4742 createPopupItem( SMESHOp::OpCompute, OB, mesh, "&& selcount=1 && hasAlgo && isComputable" );
4743 createPopupItem( SMESHOp::OpRecompute, OB, mesh, "&& selcount=1 && hasAlgo && " + isNotEmpty );
4744 createPopupItem( SMESHOp::OpShowErrors, OB, mesh, "&& selcount=1 && hasErrors" );
4745 createPopupItem( SMESHOp::OpComputeSubMesh, OB, subMesh, "&& selcount=1 && hasAlgo && isComputable" );
4746 createPopupItem( SMESHOp::OpPreCompute, OB, mesh, "&& selcount=1 && hasAlgo && isPreComputable" );
4747 createPopupItem( SMESHOp::OpEvaluate, OB, mesh, "&& selcount=1 && hasAlgo && isComputable" );
4748 popupMgr()->insert( separator(), -1, 0 );
4749 createPopupItem( SMESHOp::OpFileInformation, OB, mesh, "&& selcount=1 && isImported" );
4750 createPopupItem( SMESHOp::OpMeshInformation, OB, mesh_part );
4751 createPopupItem( SMESHOp::OpFindElementByPoint,OB, mesh_group, "&& selcount=1 && " + hasElems );
4752 createPopupItem( SMESHOp::OpOverallMeshQuality,OB, mesh_part );
4753 popupMgr()->insert( separator(), -1, 0 );
4754 createPopupItem( SMESHOp::OpCreateGroup, OB, mesh, "&& selcount=1" );
4755 createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh, "&& selcount=1 && hasGeomReference" );
4756 createPopupItem( SMESHOp::OpConstructGroup, OB, subMesh );
4757 popupMgr()->insert( separator(), -1, 0 );
4758 createPopupItem( SMESHOp::OpEditHypothesis, OB, hypo, "&& isEditableHyp");
4759 createPopupItem( SMESHOp::OpUnassign, OB, hyp_alg );
4760 popupMgr()->insert( separator(), -1, 0 );
4761 createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh_submesh, "&& " + hasElems );
4762 createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh_group, "&& selcount=1 && dim>=2");
4763 popupMgr()->insert( separator(), -1, 0 );
4765 // Adaptation - begin
4766 createPopupItem( SMESHOp::OpUniformRefinement, OB, mesh );
4767 createPopupItem( SMESHOp::OpHONewCase, OB, mesh );
4768 // createPopupItem( SMESHOp::OpHOCaseFollow, OB, mesh );
4769 // createPopupItem( SMESHOp::OpHONewIter, OB, mesh );
4770 // createPopupItem( SMESHOp::OpHOIterCompute, OB, mesh );
4771 // createPopupItem( SMESHOp::OpHOIterComputePublish, OB, mesh );
4772 createPopupItem( SMESHOp::OpMGAdapt, OB, mesh );
4775 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4776 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4777 QString only_one_2D = only_one_non_empty + " && dim>1";
4779 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4780 popupMgr()->findMenu( anId )->menuAction()->setIcon( resourceMgr()->loadPixmap( "SMESH", tr( "ICON_EXPORT" )));
4781 createPopupItem( SMESHOp::OpPopupExportMED, OB, mesh_group, multiple_non_empty, anId );
4782 createPopupItem( SMESHOp::OpPopupExportUNV, OB, mesh_group, only_one_non_empty, anId );
4783 createPopupItem( SMESHOp::OpPopupExportSTL, OB, mesh_group, only_one_2D, anId );
4785 createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4787 createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, only_one_non_empty, anId );
4788 createPopupItem( SMESHOp::OpPopupExportGMF, OB, mesh_group, only_one_non_empty, anId );
4789 createPopupItem( SMESHOp::OpPopupExportDAT, OB, mesh_group, only_one_non_empty, anId );
4791 anId = popupMgr()->insert( tr( "MEN_IMPORT" ), -1, -1 ); // IMPORT submenu
4792 createPopupItem( SMESHOp::OpPopupImportMED, OB, smesh, "", anId );
4793 createPopupItem( SMESHOp::OpPopupImportUNV, OB, smesh, "", anId );
4794 createPopupItem( SMESHOp::OpPopupImportSTL, OB, smesh, "", anId );
4796 createPopupItem( SMESHOp::OpPopupImportCGNS, OB, smesh, "", anId );
4798 createPopupItem( SMESHOp::OpPopupImportSAUV, OB, smesh, "", anId );
4799 createPopupItem( SMESHOp::OpPopupImportGMF, OB, smesh, "", anId );
4800 createPopupItem( SMESHOp::OpPopupImportDAT, OB, smesh, "", anId );
4801 popupMgr()->insert( separator(), -1, 0 );
4803 createPopupItem( SMESHOp::OpClearMesh, OB, mesh );
4804 createPopupItem( SMESHOp::OpDelete, OB, mesh_part + " " + hyp_alg );
4805 createPopupItem( SMESHOp::OpDeleteGroup, OB, group );
4808 createPopupItem( SMESHOp::OpEditGroup, View, group );
4809 createPopupItem( SMESHOp::OpAddElemGroupPopup, View, elems, "&& guiState = 800" );
4810 createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems, "&& guiState = 800" );
4812 popupMgr()->insert( separator(), -1, 0 );
4813 createPopupItem( SMESHOp::OpMeshInformation, View, mesh_part );
4814 createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4815 createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh, "&& " + hasElems);
4816 popupMgr()->insert( separator(), -1, 0 );
4818 createPopupItem( SMESHOp::OpUpdate, OB + " " + View, mesh_part );
4819 createPopupItem( SMESHOp::OpAutoColor, OB + " " + View, mesh, "&& (not isAutoColor)" );
4820 createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4821 popupMgr()->insert( separator(), -1, 0 );
4823 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4824 QString aType = QString( "%1type in {%2}" ).arg( lc );
4825 aType = aType.arg( mesh_part );
4826 QString aMeshInVTK = aClient + "&&" + aType;
4828 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4829 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4830 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4832 //-------------------------------------------------
4834 //-------------------------------------------------
4835 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4837 popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4838 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4839 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4841 popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4842 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4843 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4845 popupMgr()->insert( separator(), -1, -1 );
4847 //-------------------------------------------------
4849 //-------------------------------------------------
4850 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4852 popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4853 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4854 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4856 popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4857 popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4858 popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4860 popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4861 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4862 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4864 popupMgr()->insert( separator(), anId, -1 );
4866 popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4867 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4868 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4870 //-------------------------------------------------
4872 //-------------------------------------------------
4873 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4875 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4877 popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4878 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4879 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4881 popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4882 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4883 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4885 popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4886 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4887 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4889 popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4890 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4891 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4893 popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4894 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4895 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4897 popupMgr()->insert( separator(), anId, -1 );
4899 popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4900 popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&& $type in {" + mesh + "} &&" + hasDifferentObjElems, QtxPopupMgr::VisibleRule );
4902 popupMgr()->insert( separator(), anId, -1 );
4904 popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4905 popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4908 //-------------------------------------------------
4909 // Representation of the 2D Quadratic elements
4910 //-------------------------------------------------
4911 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4912 popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4913 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "&& isVisible && isQuadratic",QtxPopupMgr::VisibleRule );
4914 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4916 popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4917 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "&& isVisible && isQuadratic", QtxPopupMgr::VisibleRule );
4918 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4920 //-------------------------------------------------
4921 // Orientation of faces
4922 //-------------------------------------------------
4923 popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4924 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4925 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4927 //-------------------------------------------------
4929 //-------------------------------------------------
4930 popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4931 popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4933 //-------------------------------------------------
4935 //-------------------------------------------------
4936 popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4937 popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4939 //-------------------------------------------------
4941 //-------------------------------------------------
4943 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4944 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4945 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4946 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4948 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4950 popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4951 popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4953 popupMgr()->insert( separator(), anId, -1 );
4955 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4957 popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4958 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4959 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4961 popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4962 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4963 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4965 // popupMgr()->insert( action( SMESHOp::OpNodeConnectivityNb ), aSubId, -1 );
4966 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4967 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), "controlMode = 'eNodeConnectivityNb'", QtxPopupMgr::ToggleRule );
4969 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4971 popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4972 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVTK + "&&" + hasEdges + "&&" + hasFacesOrVolumes, QtxPopupMgr::VisibleRule );
4973 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4975 popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4976 popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4977 popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4979 popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4980 popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4981 popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4982 popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4983 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4984 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4986 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4988 popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4989 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4990 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4992 popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4993 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4994 QtxPopupMgr::VisibleRule );
4995 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4997 popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4998 popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4999 popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
5001 popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
5002 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5003 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
5005 popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
5006 popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5007 popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
5009 popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
5010 popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5011 popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
5013 popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
5014 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5015 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
5017 popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
5018 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5019 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
5021 popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
5022 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5023 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
5025 popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
5026 popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5027 popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
5029 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
5030 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5031 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
5033 popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
5034 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5035 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
5037 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
5038 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5039 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
5041 popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
5042 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5043 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
5045 popupMgr()->insert ( action( SMESHOp::OpDeflection2D ), aSubId, -1 );
5046 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), aMeshInVtkHasFaces + " && hasGeomReference", QtxPopupMgr::VisibleRule );
5047 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), "controlMode = 'eDeflection2D'", QtxPopupMgr::ToggleRule );
5049 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
5051 popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D ), aSubId, -1 );
5052 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5053 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
5055 popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
5056 popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5057 popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
5059 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
5060 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5061 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
5063 popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
5064 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5065 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
5067 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
5068 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5069 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
5071 popupMgr()->insert ( action( SMESHOp::OpEqualVolume ), aSubId, -1 );
5072 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5073 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
5075 popupMgr()->insert( separator(), anId, -1 );
5077 popupMgr()->insert( action( SMESHOp::OpShowScalarBar ), anId, -1 );
5078 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
5079 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone' && isScalarBarVisible", QtxPopupMgr::ToggleRule );
5080 popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
5081 popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
5083 popupMgr()->insert( separator(), anId, -1 );
5085 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
5087 popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
5088 popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
5090 popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
5091 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
5092 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isScalarBarVisible && isDistributionVisible", QtxPopupMgr::ToggleRule);
5094 #ifndef DISABLE_PLOT2DVIEWER
5095 popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
5096 popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
5099 //-------------------------------------------------
5101 //-------------------------------------------------
5102 popupMgr()->insert( separator(), -1, -1 );
5103 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
5104 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
5105 popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
5106 popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
5108 popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
5109 popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
5111 popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
5112 popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
5114 popupMgr()->insert( separator(), -1, -1 );
5116 //-------------------------------------------------
5118 //-------------------------------------------------
5119 popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
5120 popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
5122 popupMgr()->insert( separator(), -1, -1 );
5124 popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
5125 popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
5126 popupMgr()->insert( separator(), -1, -1 );
5128 popupMgr()->insert( action( SMESHOp::OpBreakLink), -1, -1 );
5129 popupMgr()->setRule( action( SMESHOp::OpBreakLink), "$component={'SHAPERSTUDY'} and client='ObjectBrowser' and canBreakLink", QtxPopupMgr::VisibleRule );
5131 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
5132 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
5134 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
5135 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
5138 //================================================================================
5140 * \brief Return true if SMESH or GEOM objects are selected.
5141 * Is called form LightApp_Module::activateModule() which clear selection if
5142 * not isSelectionCompatible()
5144 //================================================================================
5146 bool SMESHGUI::isSelectionCompatible()
5148 bool isCompatible = true;
5149 SALOME_ListIO selected;
5150 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
5151 Sel->selectedObjects( selected );
5153 SALOME_ListIteratorOfListIO It( selected );
5154 for ( ; isCompatible && It.More(); It.Next())
5156 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
5157 ( strcmp("SHAPERSTUDY", It.Value()->getComponentDataType()) == 0 ) ||
5158 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
5160 return isCompatible;
5164 bool SMESHGUI::reusableOperation( const int id )
5166 // compute, evaluate and precompute are not reusable operations
5167 return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate || id == SMESHOp::OpRecompute ) ? false : SalomeApp_Module::reusableOperation( id );
5170 bool SMESHGUI::activateModule( SUIT_Study* study )
5172 bool res = SalomeApp_Module::activateModule( study );
5174 setMenuShown( true );
5175 setToolShown( true );
5177 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
5178 PyGILState_STATE gstate = PyGILState_Ensure();
5179 PyObject* pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
5180 if ( !pluginsmanager ) {
5184 PyObject* result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toUtf8().data(),tr("SMESH_PLUGINS_OTHER").toUtf8().data());
5189 PyGILState_Release(gstate);
5190 // end of SMESH plugins loading
5192 // Reset actions accelerator keys
5193 action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
5195 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
5196 GetSMESHGen()->UpdateStudy();
5198 // get all view currently opened in the study and connect their signals to
5199 // the corresponding slots of the class.
5200 SUIT_Desktop* aDesk = study->application()->desktop();
5202 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
5203 SUIT_ViewWindow* wnd;
5204 foreach ( wnd, wndList )
5208 // remove actors whose objects are removed in GetSMESHGen()->UpdateStudy()
5209 SMESH::UpdateActorsAfterUpdateStudy(wnd);
5215 Py_XDECREF(pluginsmanager);
5219 bool SMESHGUI::deactivateModule( SUIT_Study* study )
5221 setMenuShown( false );
5222 setToolShown( false );
5224 EmitSignalCloseAllDialogs();
5226 // Unset actions accelerator keys
5227 action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
5229 return SalomeApp_Module::deactivateModule( study );
5232 void SMESHGUI::studyClosed( SUIT_Study* s )
5236 SMESH::RemoveVisuData();
5237 SalomeApp_Module::studyClosed( s );
5240 void SMESHGUI::OnGUIEvent()
5242 const QObject* obj = sender();
5243 if ( !obj || !obj->inherits( "QAction" ) )
5245 int id = actionId((QAction*)obj);
5250 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
5252 if ( CORBA::is_nil( myComponentSMESH ) )
5254 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
5255 return aGUI.myComponentSMESH;
5257 return myComponentSMESH;
5260 QString SMESHGUI::engineIOR() const
5262 CORBA::ORB_var anORB = getApp()->orb();
5263 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
5264 return QString( anIOR.in() );
5267 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
5269 SalomeApp_Module::contextMenuPopup( client, menu, title );
5271 selectionMgr()->selectedObjects( lst );
5272 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
5273 Handle(SALOME_InteractiveObject) io = lst.First();
5274 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
5275 _PTR(Study) study = appStudy->studyDS();
5276 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
5278 QString aName = SMESH::fromUtf8( obj->GetName());
5279 while ( !aName.isEmpty() && aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
5280 aName.remove(( aName.length() - 1 ), 1 );
5286 LightApp_Selection* SMESHGUI::createSelection() const
5288 return new SMESHGUI_Selection();
5291 void SMESHGUI::windows( QMap<int, int>& aMap ) const
5293 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
5294 aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
5295 #ifndef DISABLE_PYCONSOLE
5296 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
5300 void SMESHGUI::viewManagers( QStringList& list ) const
5302 list.append( SVTK_Viewer::Type() );
5305 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
5307 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
5308 SMESH::UpdateSelectionProp( this );
5310 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
5311 for(int i = 0; i < aViews.count() ; i++){
5312 SUIT_ViewWindow *sf = aViews[i];
5315 EmitSignalActivatedViewManager();
5319 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
5321 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
5322 myClippingPlaneInfoMap.erase( theViewManager );
5325 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
5327 theActor->AddObserver( SMESH::DeleteActorEvent,
5328 myEventCallbackCommand.GetPointer(),
5332 void SMESHGUI::ProcessEvents( vtkObject* theObject,
5333 unsigned long theEvent,
5334 void* theClientData,
5335 void* /*theCallData*/ )
5337 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
5338 if( theObject && (int) theEvent == SMESH::DeleteActorEvent ) {
5339 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
5340 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
5341 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
5342 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
5343 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
5344 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
5345 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
5346 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
5347 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
5348 SMESH::TActorList::iterator anIter3 = anActorList.begin();
5349 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
5350 if( anActor == *anIter3 ) {
5351 anActorList.erase( anIter3 );
5362 void SMESHGUI::createPreferences()
5364 // General tab ------------------------------------------------------------------------
5365 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
5367 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
5368 setPreferenceProperty( autoUpdate, "columns", 2 );
5369 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
5370 setPreferenceProperty( lim, "min", 0 );
5371 setPreferenceProperty( lim, "max", 100000000 );
5372 setPreferenceProperty( lim, "step", 1000 );
5373 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5374 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
5376 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
5377 setPreferenceProperty( dispgroup, "columns", 2 );
5379 addPreference( tr( "PREF_FITALL_ON_DISPLAYONLY" ), dispgroup, LightApp_Preferences::Bool, "SMESH", "fitall_on_displayonly" );
5381 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
5383 modes.append( tr("MEN_WIRE") );
5384 modes.append( tr("MEN_SHADE") );
5385 modes.append( tr("MEN_NODES") );
5386 modes.append( tr("MEN_SHRINK") );
5387 QList<QVariant> indices;
5388 indices.append( 0 );
5389 indices.append( 1 );
5390 indices.append( 2 );
5391 indices.append( 3 );
5392 setPreferenceProperty( dispmode, "strings", modes );
5393 setPreferenceProperty( dispmode, "indexes", indices );
5395 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
5396 setPreferenceProperty( arcgroup, "columns", 2 );
5397 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
5398 QStringList quadraticModes;
5399 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
5400 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
5402 indices.append( 0 );
5403 indices.append( 1 );
5404 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
5405 setPreferenceProperty( quadraticmode, "indexes", indices );
5407 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
5408 "SMESH", "max_angle" );
5409 setPreferenceProperty( maxAngle, "min", 1 );
5410 setPreferenceProperty( maxAngle, "max", 90 );
5412 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
5413 setPreferenceProperty( qaGroup, "columns", 2 );
5414 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
5415 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
5416 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
5417 setPreferenceProperty( prec, "min", 0 );
5418 setPreferenceProperty( prec, "max", 100 );
5419 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
5420 setPreferenceProperty( doubleNodesTol, "precision", 10 );
5421 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
5422 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
5423 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
5426 int cinc = addPreference(tr("PREF_CONTROLS_INCREMENT"), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_increment");
5427 setPreferenceProperty( cinc, "min", 0 );
5428 setPreferenceProperty( cinc, "max", 5 );
5431 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
5432 setPreferenceProperty( exportgroup, "columns", 2 );
5433 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
5434 addPreference( tr( "PREF_SHOW_WARN" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "show_warning" );
5435 int zTol = addPreference( tr( "PREF_ZTOLERANCE" ), exportgroup, LightApp_Preferences::DblSpin, "SMESH", "med_ztolerance" );
5436 setPreferenceProperty( zTol, "precision", 10 );
5437 setPreferenceProperty( zTol, "min", 0.0000000001 );
5438 setPreferenceProperty( zTol, "max", 1000000.0 );
5439 setPreferenceProperty( zTol, "step", 1. );
5440 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
5442 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
5443 setPreferenceProperty( computeGroup, "columns", 2 );
5444 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
5446 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5447 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5448 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5450 indices.append( 0 );
5451 indices.append( 1 );
5452 indices.append( 2 );
5453 setPreferenceProperty( notifyMode, "strings", modes );
5454 setPreferenceProperty( notifyMode, "indexes", indices );
5456 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5457 setPreferenceProperty( infoGroup, "columns", 2 );
5458 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5460 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5461 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5463 indices.append( 0 );
5464 indices.append( 1 );
5465 setPreferenceProperty( elemInfo, "strings", modes );
5466 setPreferenceProperty( elemInfo, "indexes", indices );
5467 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5468 setPreferenceProperty( nodesLim, "min", 0 );
5469 setPreferenceProperty( nodesLim, "max", 10000000 );
5470 setPreferenceProperty( nodesLim, "step", 10000 );
5471 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5472 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5473 setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5474 setPreferenceProperty( ctrlLim, "min", 0 );
5475 setPreferenceProperty( ctrlLim, "max", 10000000 );
5476 setPreferenceProperty( ctrlLim, "step", 1000 );
5477 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5478 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5479 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5480 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5481 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5483 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5484 setPreferenceProperty( segGroup, "columns", 2 );
5485 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5486 "SMESH", "segmentation" );
5487 setPreferenceProperty( segLen, "min", 1 );
5488 setPreferenceProperty( segLen, "max", 10000000 );
5489 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5490 "SMESH", "nb_segments_per_edge" );
5491 setPreferenceProperty( nbSeg, "min", 1 );
5492 setPreferenceProperty( nbSeg, "max", 10000000 );
5493 addPreference( tr( "PREF_USE_MESHGEMS_HYPOSET" ), segGroup, LightApp_Preferences::Bool, "SMESH", "use-meshgems-hypo-sets" );
5495 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5496 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5497 "SMESH", "forget_mesh_on_hyp_modif" );
5500 // Quantities with individual precision settings
5501 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5502 setPreferenceProperty( precGroup, "columns", 2 );
5504 const int nbQuantities = 6;
5505 int precs[nbQuantities], ii = 0;
5506 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5507 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5508 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5509 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5510 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5511 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5512 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5513 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5514 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5515 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5516 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5517 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5519 // Set property for precision value for spinboxes
5520 for ( ii = 0; ii < nbQuantities; ii++ ){
5521 setPreferenceProperty( precs[ii], "min", -14 );
5522 setPreferenceProperty( precs[ii], "max", 14 );
5523 setPreferenceProperty( precs[ii], "precision", 2 );
5526 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5527 setPreferenceProperty( previewGroup, "columns", 2 );
5528 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5529 setPreferenceProperty( chunkSize, "min", 1 );
5530 setPreferenceProperty( chunkSize, "max", 1000 );
5531 setPreferenceProperty( chunkSize, "step", 50 );
5533 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5534 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5536 // Mesh tab ------------------------------------------------------------------------
5537 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5538 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5539 setPreferenceProperty( nodeGroup, "columns", 3 );
5541 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5543 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5545 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5546 QList<QVariant> aMarkerTypeIndicesList;
5547 QList<QVariant> aMarkerTypeIconsList;
5548 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5549 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5550 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5551 aMarkerTypeIndicesList << i;
5552 aMarkerTypeIconsList << pixmap;
5554 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5555 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
5557 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5559 QList<QVariant> aMarkerScaleIndicesList;
5560 QStringList aMarkerScaleValuesList;
5561 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5562 aMarkerScaleIndicesList << i;
5563 //aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5564 aMarkerScaleValuesList << QString::number( i );
5566 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5567 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5569 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5570 //setPreferenceProperty( elemGroup, "columns", 2 );
5572 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5573 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5574 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5575 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5576 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5577 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5578 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5579 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5580 addPreference( tr( "PREF_PREVIEW_COLOR" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5583 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5584 setPreferenceProperty( grpGroup, "columns", 2 );
5586 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5587 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5589 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5590 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5591 /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5592 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5593 double ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5594 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5595 double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5596 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5597 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
5598 LightApp_Preferences::IntSpin, "SMESH", "element_width");
5599 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5600 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5601 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5602 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5604 setPreferenceProperty( size0d, "min", 1 );
5605 setPreferenceProperty( size0d, "max", 10 );
5607 // setPreferenceProperty( ballSize, "min", 1 );
5608 // setPreferenceProperty( ballSize, "max", 10 );
5610 setPreferenceProperty( ballDiameter, "min", 1e-7 );
5611 setPreferenceProperty( ballDiameter, "max", 1e9 );
5612 setPreferenceProperty( ballDiameter, "step", 0.1 );
5614 setPreferenceProperty( ballScale, "min", 1e-2 );
5615 setPreferenceProperty( ballScale, "max", 1e7 );
5616 setPreferenceProperty( ballScale, "step", 0.5 );
5618 setPreferenceProperty( elemW, "min", 1 );
5619 setPreferenceProperty( elemW, "max", 5 );
5621 setPreferenceProperty( outW, "min", 1 );
5622 setPreferenceProperty( outW, "max", 5 );
5624 setPreferenceProperty( shrink, "min", 0 );
5625 setPreferenceProperty( shrink, "max", 100 );
5627 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5628 setPreferenceProperty( numGroup, "columns", 2 );
5630 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5631 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5633 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5634 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5636 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5637 setPreferenceProperty( orientGroup, "columns", 1 );
5639 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5640 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5642 setPreferenceProperty( orientScale, "min", 0.05 );
5643 setPreferenceProperty( orientScale, "max", 0.5 );
5644 setPreferenceProperty( orientScale, "step", 0.05 );
5646 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5648 // Selection tab ------------------------------------------------------------------------
5649 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5651 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5652 setPreferenceProperty( selGroup, "columns", 2 );
5654 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5655 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5657 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5658 setPreferenceProperty( preGroup, "columns", 2 );
5660 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5662 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5663 setPreferenceProperty( precSelGroup, "columns", 2 );
5665 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5666 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5667 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5669 int sinc = addPreference(tr("PREF_SELECTION_INCREMENT"), selTab, LightApp_Preferences::IntSpin, "SMESH", "selection_increment");
5670 setPreferenceProperty( sinc, "min", 0 );
5671 setPreferenceProperty( sinc, "max", 5 );
5673 // Scalar Bar tab ------------------------------------------------------------------------
5674 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5675 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5676 setPreferenceProperty( fontGr, "columns", 2 );
5678 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5679 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5681 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5682 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5684 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5685 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5687 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5688 setPreferenceProperty( numcol, "min", 2 );
5689 setPreferenceProperty( numcol, "max", 256 );
5691 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5692 setPreferenceProperty( numlab, "min", 2 );
5693 setPreferenceProperty( numlab, "max", 65 );
5695 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5696 setPreferenceProperty( orientGr, "columns", 2 );
5697 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5698 QStringList orients;
5699 orients.append( tr( "SMESH_VERTICAL" ) );
5700 orients.append( tr( "SMESH_HORIZONTAL" ) );
5701 indices.clear(); indices.append( 0 ); indices.append( 1 );
5702 setPreferenceProperty( orient, "strings", orients );
5703 setPreferenceProperty( orient, "indexes", indices );
5705 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5706 setPreferenceProperty( posVSizeGr, "columns", 2 );
5707 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5708 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5709 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5710 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5711 setPreferenceProperty( xv, "step", 0.1 );
5712 setPreferenceProperty( xv, "min", 0.0 );
5713 setPreferenceProperty( xv, "max", 1.0 );
5714 setPreferenceProperty( yv, "step", 0.1 );
5715 setPreferenceProperty( yv, "min", 0.0 );
5716 setPreferenceProperty( yv, "max", 1.0 );
5717 setPreferenceProperty( wv, "step", 0.1 );
5718 setPreferenceProperty( wv, "min", 0.0 );
5719 setPreferenceProperty( wv, "max", 1.0 );
5720 setPreferenceProperty( hv, "min", 0.0 );
5721 setPreferenceProperty( hv, "max", 1.0 );
5722 setPreferenceProperty( hv, "step", 0.1 );
5724 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5725 setPreferenceProperty( posHSizeGr, "columns", 2 );
5726 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5727 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5728 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5729 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5730 setPreferenceProperty( xv, "min", 0.0 );
5731 setPreferenceProperty( xv, "max", 1.0 );
5732 setPreferenceProperty( xv, "step", 0.1 );
5733 setPreferenceProperty( xh, "min", 0.0 );
5734 setPreferenceProperty( xh, "max", 1.0 );
5735 setPreferenceProperty( xh, "step", 0.1 );
5736 setPreferenceProperty( yh, "min", 0.0 );
5737 setPreferenceProperty( yh, "max", 1.0 );
5738 setPreferenceProperty( yh, "step", 0.1 );
5739 setPreferenceProperty( wh, "min", 0.0 );
5740 setPreferenceProperty( wh, "max", 1.0 );
5741 setPreferenceProperty( wh, "step", 0.1 );
5742 setPreferenceProperty( hh, "min", 0.0 );
5743 setPreferenceProperty( hh, "max", 1.0 );
5744 setPreferenceProperty( hh, "step", 0.1 );
5746 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5747 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5748 setPreferenceProperty( distributionGr, "columns", 3 );
5750 types.append( tr( "SMESH_MONOCOLOR" ) );
5751 types.append( tr( "SMESH_MULTICOLOR" ) );
5752 indices.clear(); indices.append( 0 ); indices.append( 1 );
5753 setPreferenceProperty( coloringType, "strings", types );
5754 setPreferenceProperty( coloringType, "indexes", indices );
5755 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5757 // Adaptation - begin
5758 // Adaptation tab ------------------------------------------------------------------------
5759 int adaptTab = addPreference( tr( "ADAPT_PREF_TAB_GENERAL" ) );
5761 // Refinement with HOMARD
5762 bloc = addPreference( tr( "ADAPT_PREF_HOMARD_PUBLICATION" ), adaptTab );
5763 setPreferenceProperty( bloc, "columns", 1 );
5764 pref = addPreference( tr( "ADAPT_PREF_HOMARD_PUBLICATION_MAILLAGE_IN" ), bloc, LightApp_Preferences::Bool, "HOMARD", "homard_publish_mesh_in" );
5765 pref = addPreference( tr( "ADAPT_PREF_HOMARD_PUBLICATION_MAILLAGE_OUT" ), bloc, LightApp_Preferences::Bool, "HOMARD", "homard_publish_mesh_out" );
5768 bloc = addPreference( tr( "ADAPT_PREF_HOMARD_YACS" ), adaptTab );
5769 setPreferenceProperty( bloc, "columns", 1 );
5770 pref = addPreference( tr( "ADAPT_PREF_HOMARD_YACS_MAX_ITER" ), bloc, LightApp_Preferences::IntSpin, "HOMARD", "homard_yacs_max_iter" );
5771 setPreferenceProperty( pref, "min", 0 );
5772 setPreferenceProperty( pref, "max", 100000000 );
5773 setPreferenceProperty( pref, "step", 1 );
5774 pref = addPreference( tr( "ADAPT_PREF_HOMARD_YACS_MAX_NODE" ), bloc, LightApp_Preferences::IntSpin, "HOMARD", "homard_yacs_max_node" );
5775 setPreferenceProperty( pref, "min", 0 );
5776 setPreferenceProperty( pref, "max", 100000000 );
5777 setPreferenceProperty( pref, "step", 1000 );
5778 pref = addPreference( tr( "ADAPT_PREF_HOMARD_YACS_MAX_ELEM" ), bloc, LightApp_Preferences::IntSpin, "HOMARD", "homard_yacs_max_elem" );
5779 setPreferenceProperty( pref, "min", 0 );
5780 setPreferenceProperty( pref, "max", 100000000 );
5781 setPreferenceProperty( pref, "step", 1000 );
5782 pref = addPreference( tr( "ADAPT_PREF_HOMARD_YACS_TYPE_CONVERGENCE" ), bloc, LightApp_Preferences::Selector, "HOMARD", "homard_yacs_type_test" );
5783 QStringList aListOfTypeTest;
5784 aListOfTypeTest << tr( "ADAPT_PREF_NONE" );
5785 aListOfTypeTest << "VTest > VRef";
5786 aListOfTypeTest << "VTest < VRef";
5787 setPreferenceProperty( pref, "strings", aListOfTypeTest );
5790 bloc = addPreference( tr( "ADAPT_PREF_MG_ADAPT" ), adaptTab );
5791 setPreferenceProperty( bloc, "columns", 1 );
5792 pref = addPreference( tr( "ADAPT_PREF_MG_ADAPT_FILE_MAILLAGE_OUT" ), bloc, LightApp_Preferences::Bool, "HOMARD", "mg_adapt_file_mesh_out" );
5793 pref = addPreference( tr( "ADAPT_PREF_MG_ADAPT_PUBLICATION_MAILLAGE_OUT" ), bloc, LightApp_Preferences::Bool, "HOMARD", "mg_adapt_publish_mesh_out" );
5794 pref = addPreference( tr( "ADAPT_PREF_MG_ADAPT_SIZE_MAP" ), bloc, LightApp_Preferences::Selector, "HOMARD", "mg_adapt_size_map" );
5795 QStringList aListOfSizeMap;
5796 aListOfSizeMap << tr( "ADAPT_PREF_MG_ADAPT_SIZE_MAP_LOCAL" );
5797 aListOfSizeMap << tr( "ADAPT_PREF_MG_ADAPT_SIZE_MAP_BACKGROUND" );
5798 aListOfSizeMap << tr( "ADAPT_PREF_NONE" );;
5799 setPreferenceProperty( pref, "strings", aListOfSizeMap );
5800 pref = addPreference( tr( "ADAPT_PREF_MG_ADAPT_TIME_STEP" ), bloc, LightApp_Preferences::Selector, "HOMARD", "mg_adapt_time_step" );
5801 QStringList aListOfTimeStep;
5802 aListOfTimeStep << tr( "ADAPT_PREF_NONE" );
5803 aListOfTimeStep << tr( "ADAPT_PREF_MG_ADAPT_TIME_STEP_LAST" );
5804 aListOfTimeStep << tr( "ADAPT_PREF_MG_ADAPT_TIME_STEP_C" );;
5805 setPreferenceProperty( pref, "strings", aListOfTimeStep );
5810 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5812 if ( sect=="SMESH" ) {
5813 float sbX1 = 0.01, sbY1 = 0.01, sbW = 0.08, sbH = 0.08;
5814 float aTol = 1.00000009999999;
5815 std::string aWarning;
5816 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5818 if ( name == "selection_object_color" ||
5819 name == "selection_element_color" ||
5820 name == "highlight_color" ||
5821 name == "selection_precision_node" ||
5822 name == "selection_precision_element" ||
5823 name == "selection_precision_object" ||
5824 name == "selection_increment")
5826 SMESH::UpdateSelectionProp( this );
5828 else if (name == "scalar_bar_vertical_x" || name == "scalar_bar_vertical_width")
5830 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5831 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5832 if ( sbX1+sbW > aTol ) {
5833 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5836 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5837 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5840 else if (name == "scalar_bar_vertical_y" || name == "scalar_bar_vertical_height" )
5842 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5843 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5844 if ( sbY1 + sbH > aTol ) {
5845 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5846 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5847 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5850 else if (name == "scalar_bar_horizontal_x" || name == "scalar_bar_horizontal_width")
5852 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5853 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5854 if ( sbX1 + sbW > aTol ) {
5855 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5858 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5859 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5862 else if (name == "scalar_bar_horizontal_y" || name == "scalar_bar_horizontal_height")
5864 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5865 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5866 if ( sbY1 + sbH > aTol ) {
5867 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5870 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5871 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5874 else if ( name == "segmentation" )
5876 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5877 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5879 else if ( name == "nb_segments_per_edge" )
5881 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5882 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5884 else if ( name == "historical_python_dump" || name == "forget_mesh_on_hyp_modif" || name == "default_grp_color" )
5886 QString val = aResourceMgr->stringValue( "SMESH", name );
5887 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5889 else if ( name == "numbering_node_color" || name == "numbering_node_font" )
5891 SMESH::UpdateFontProp( this );
5893 else if ( name == "numbering_elem_color" || name == "numbering_elem_font" )
5895 SMESH::UpdateFontProp( this );
5898 if ( aWarning.size() != 0 ) {
5899 aWarning += "The default values are applied instead.";
5900 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5901 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5902 QObject::tr(aWarning.c_str()));
5907 //================================================================================
5909 * \brief Update something in accordance with update flags
5910 * \param theFlags - update flags
5912 * Update viewer or/and object browser etc. in accordance with update flags ( see
5913 * LightApp_UpdateFlags enumeration ).
5915 //================================================================================
5916 void SMESHGUI::update( const int flags )
5918 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5919 SMESH::UpdateView();
5921 SalomeApp_Module::update( flags );
5924 //================================================================================
5926 * \brief Set default selection mode
5928 * SLOT called when operation committed. Sets default selection mode
5930 //================================================================================
5931 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5933 SVTK_ViewWindow* vtkWnd =
5934 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5936 vtkWnd->SetSelectionMode( ActorSelection );
5939 //================================================================================
5941 * \brief Set default selection mode
5943 * SLOT called when operation aborted. Sets default selection mode
5945 //================================================================================
5946 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5948 SVTK_ViewWindow* vtkWnd =
5949 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5951 vtkWnd->SetSelectionMode( ActorSelection );
5954 //================================================================================
5956 * \brief Creates operation with given identifier
5957 * \param id - identifier of operation to be started
5958 * \return Pointer on created operation or NULL if operation is not created
5960 * Virtual method redefined from the base class creates operation with given id.
5961 * It is called called automatically from startOperation method of base class.
5963 //================================================================================
5964 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5966 LightApp_Operation* op = 0;
5967 // to do : create operation here
5970 case SMESHOp::OpSplitBiQuadratic:
5971 op = new SMESHGUI_SplitBiQuadOp();
5973 case SMESHOp::OpConvertMeshToQuadratic:
5974 op = new SMESHGUI_ConvToQuadOp();
5976 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5977 op = new SMESHGUI_Make2DFrom3DOp();
5979 case SMESHOp::OpReorientFaces:
5980 op = new SMESHGUI_ReorientFacesOp();
5982 case SMESHOp::OpCreateMesh:
5983 op = new SMESHGUI_MeshOp( true, true );
5985 case SMESHOp::OpCreateSubMesh:
5986 op = new SMESHGUI_MeshOp( true, false );
5988 case SMESHOp::OpEditMeshOrSubMesh:
5989 case SMESHOp::OpEditMesh:
5990 case SMESHOp::OpEditSubMesh:
5991 op = new SMESHGUI_MeshOp( false );
5993 case SMESHOp::OpCompute:
5994 case SMESHOp::OpComputeSubMesh:
5995 op = new SMESHGUI_ComputeOp();
5997 case SMESHOp::OpShowErrors:
5998 op = new SMESHGUI_ShowErrorsOp();
6000 case SMESHOp::OpPreCompute:
6001 op = new SMESHGUI_PrecomputeOp();
6003 case SMESHOp::OpEvaluate:
6004 op = new SMESHGUI_EvaluateOp();
6006 case SMESHOp::OpMeshOrder:
6007 op = new SMESHGUI_MeshOrderOp();
6009 case SMESHOp::OpCreateGeometryGroup:
6010 op = new SMESHGUI_GroupOnShapeOp();
6012 case SMESHOp::OpFindElementByPoint:
6013 op = new SMESHGUI_FindElemByPointOp();
6015 case SMESHOp::OpMoveNode: // Make mesh pass through point
6016 op = new SMESHGUI_MakeNodeAtPointOp();
6018 case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
6019 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
6021 // Adaptation - begin
6022 case SMESHOp::OpUniformRefinement:
6023 case SMESHOp::OpHONewCase:
6024 case SMESHOp::OpHOCaseFollow:
6025 case SMESHOp::OpHONewIter:
6026 case SMESHOp::OpHOIterCompute:
6027 case SMESHOp::OpHOIterComputePublish:
6028 case SMESHOp::OpHOEdit:
6029 case SMESHOp::OpHODelete:
6030 case SMESHOp::OpMGAdapt:
6038 op = SalomeApp_Module::createOperation( id );
6042 //================================================================================
6044 * \brief Stops current operations and starts a given one
6045 * \param id - The id of the operation to start
6047 //================================================================================
6049 void SMESHGUI::switchToOperation(int id)
6051 activeStudy()->abortAllOperations();
6052 startOperation( id );
6055 LightApp_Displayer* SMESHGUI::displayer()
6058 myDisplayer = new SMESHGUI_Displayer( getApp() );
6062 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
6065 int aTolerance = 64;
6066 int anIterations = 0;
6072 if( anIterations % aPeriod == 0 )
6075 if( aTolerance < 1 )
6079 aHue = (int)( 360.0 * rand() / RAND_MAX );
6082 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
6083 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
6084 for( ; it != itEnd; ++it )
6086 SALOMEDS::Color anAutoColor = *it;
6087 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
6090 aQColor.getHsv( &h, &s, &v );
6091 if( abs( h - aHue ) < aTolerance )
6103 aColor.setHsv( aHue, 255, 255 );
6105 SALOMEDS::Color aSColor;
6106 aSColor.R = aColor.redF();
6107 aSColor.G = aColor.greenF();
6108 aSColor.B = aColor.blueF();
6113 const char* gSeparator = "_"; // character used to separate parameter names
6114 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
6115 const char* gPathSep = "|"; // character used to separate paths
6118 * \brief Store visual parameters
6120 * This method is called just before the study document is saved.
6121 * Store visual parameters in AttributeParameter attribute(s)
6123 void SMESHGUI::storeVisualParameters (int savePoint)
6126 Kernel_Utils::Localizer loc;
6128 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6129 if (!appStudy || !appStudy->studyDS())
6131 _PTR(Study) studyDS = appStudy->studyDS();
6133 // componentName is used for encoding of entries when storing them in IParameters
6134 std::string componentName = myComponentSMESH->ComponentDataType();
6135 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
6136 //if (!aSComponent) return;
6139 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6140 componentName.c_str(),
6142 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6144 // store custom markers
6145 if( !myMarkerMap.empty() )
6147 VTK::MarkerMap::const_iterator anIter = myMarkerMap.begin();
6148 for( ; anIter != myMarkerMap.end(); anIter++ )
6150 int anId = anIter->first;
6151 VTK::MarkerData aMarkerData = anIter->second;
6152 std::string aMarkerFileName = aMarkerData.first;
6153 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
6154 if( aMarkerTexture.size() < 3 )
6155 continue; // should contain at least width, height and the first value
6157 QString aPropertyName( "texture" );
6158 aPropertyName += gSeparator;
6159 aPropertyName += QString::number( anId );
6161 QString aPropertyValue = aMarkerFileName.c_str();
6162 aPropertyValue += gPathSep;
6164 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
6165 ushort aWidth = *aTextureIter++;
6166 ushort aHeight = *aTextureIter++;
6167 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
6168 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
6169 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
6170 aPropertyValue += QString::number( *aTextureIter );
6172 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
6176 // viewers counters are used for storing view_numbers in IParameters
6179 // main cycle to store parameters of displayed objects
6180 QList<SUIT_ViewManager*> lst;
6181 QList<SUIT_ViewManager*>::Iterator it;
6182 getApp()->viewManagers(lst);
6183 for (it = lst.begin(); it != lst.end(); it++)
6185 SUIT_ViewManager* vman = *it;
6186 QString vType = vman->getType();
6188 // saving VTK actors properties
6189 if (vType == SVTK_Viewer::Type())
6191 // store the clipping planes attached to the view manager
6192 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
6193 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
6194 if( anIter != myClippingPlaneInfoMap.end() )
6195 aClippingPlaneInfoList = anIter->second;
6197 if( !aClippingPlaneInfoList.empty() ) {
6198 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
6199 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
6201 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
6202 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
6204 QString aPropertyName( "ClippingPlane" );
6205 aPropertyName += gSeparator;
6206 aPropertyName += QString::number( vtkViewers );
6207 aPropertyName += gSeparator;
6208 aPropertyName += QString::number( anId );
6210 QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
6211 aPropertyValue += gDigitsSep;
6212 aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
6213 aPropertyValue += gDigitsSep;
6214 if ( aPlane->PlaneMode == SMESH::Absolute ) {
6215 aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
6216 aPropertyValue += gDigitsSep;
6217 aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
6218 aPropertyValue += gDigitsSep;
6219 aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
6220 aPropertyValue += gDigitsSep;
6221 aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
6222 aPropertyValue += gDigitsSep;
6223 aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
6224 aPropertyValue += gDigitsSep;
6225 aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
6226 aPropertyValue += gDigitsSep;
6227 aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
6229 else if ( aPlane->PlaneMode == SMESH::Relative ) {
6230 aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
6231 aPropertyValue += gDigitsSep;
6232 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
6233 aPropertyValue += gDigitsSep;
6234 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
6235 aPropertyValue += gDigitsSep;
6236 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
6239 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
6243 QVector<SUIT_ViewWindow*> views = vman->getViews();
6244 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
6246 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
6248 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
6249 vtkActorCollection* allActors = aCopy.GetActors();
6250 allActors->InitTraversal();
6251 while (vtkActor* actor = allActors->GetNextActor())
6253 if (actor->GetVisibility()) // store only visible actors
6255 SMESH_Actor* aSmeshActor = 0;
6256 if (actor->IsA("SMESH_Actor"))
6257 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
6258 if (aSmeshActor && aSmeshActor->hasIO())
6260 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
6263 // entry is "encoded" = it does NOT contain component address,
6264 // since it is a subject to change on next component loading
6265 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
6267 std::string param, vtkParam = vType.toLatin1().data();
6268 vtkParam += gSeparator;
6269 vtkParam += QString::number(vtkViewers).toLatin1().data();
6270 vtkParam += gSeparator;
6273 param = vtkParam + "Visibility";
6274 ip->setParameter(entry, param, "On");
6277 param = vtkParam + "Representation";
6278 ip->setParameter(entry, param, QString::number
6279 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
6282 param = vtkParam + "IsShrunk";
6283 ip->setParameter(entry, param, QString::number
6284 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
6286 // Displayed entities
6287 unsigned int aMode = aSmeshActor->GetEntityMode();
6288 bool isE = aMode & SMESH_Actor::eEdges;
6289 bool isF = aMode & SMESH_Actor::eFaces;
6290 bool isV = aMode & SMESH_Actor::eVolumes;
6291 bool is0d = aMode & SMESH_Actor::e0DElements;
6292 bool isB = aMode & SMESH_Actor::eBallElem;
6294 QString modeStr ("e");
6295 modeStr += gDigitsSep; modeStr += QString::number(isE);
6296 modeStr += gDigitsSep; modeStr += "f";
6297 modeStr += gDigitsSep; modeStr += QString::number(isF);
6298 modeStr += gDigitsSep; modeStr += "v";
6299 modeStr += gDigitsSep; modeStr += QString::number(isV);
6300 modeStr += gDigitsSep; modeStr += "0d";
6301 modeStr += gDigitsSep; modeStr += QString::number(is0d);
6302 modeStr += gDigitsSep; modeStr += "b";
6303 modeStr += gDigitsSep; modeStr += QString::number(isB);
6305 param = vtkParam + "Entities";
6306 ip->setParameter(entry, param, modeStr.toLatin1().data());
6312 aSmeshActor->GetSufaceColor(r, g, b, delta);
6313 QStringList colorStr;
6314 colorStr << "surface";
6315 colorStr << QString::number(r);
6316 colorStr << QString::number(g);
6317 colorStr << QString::number(b);
6319 colorStr << "backsurface";
6320 colorStr << QString::number(delta);
6322 aSmeshActor->GetVolumeColor(r, g, b, delta);
6323 colorStr << "volume";
6324 colorStr << QString::number(r);
6325 colorStr << QString::number(g);
6326 colorStr << QString::number(b);
6327 colorStr << QString::number(delta);
6329 aSmeshActor->GetEdgeColor(r, g, b);
6331 colorStr << QString::number(r);
6332 colorStr << QString::number(g);
6333 colorStr << QString::number(b);
6335 aSmeshActor->GetNodeColor(r, g, b);
6337 colorStr << QString::number(r);
6338 colorStr << QString::number(g);
6339 colorStr << QString::number(b);
6341 aSmeshActor->GetOutlineColor(r, g, b);
6342 colorStr << "outline";
6343 colorStr << QString::number(r);
6344 colorStr << QString::number(g);
6345 colorStr << QString::number(b);
6347 aSmeshActor->Get0DColor(r, g, b);
6348 colorStr << "elem0d";
6349 colorStr << QString::number(r);
6350 colorStr << QString::number(g);
6351 colorStr << QString::number(b);
6353 aSmeshActor->GetBallColor(r, g, b);
6355 colorStr << QString::number(r);
6356 colorStr << QString::number(g);
6357 colorStr << QString::number(b);
6359 aSmeshActor->GetFacesOrientationColor(r, g, b);
6360 colorStr << "orientation";
6361 colorStr << QString::number(r);
6362 colorStr << QString::number(g);
6363 colorStr << QString::number(b);
6365 param = vtkParam + "Colors";
6366 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
6369 QStringList sizeStr;
6371 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
6372 sizeStr << "outline";
6373 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
6374 sizeStr << "elem0d";
6375 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
6377 //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
6378 sizeStr << QString::number((double)aSmeshActor->GetBallSize());
6379 sizeStr << QString::number((double)aSmeshActor->GetBallScale());
6380 sizeStr << "shrink";
6381 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
6382 sizeStr << "orientation";
6383 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
6384 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
6386 param = vtkParam + "Sizes";
6387 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
6392 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
6393 if( aMarkerType == VTK::MT_USER ) {
6394 markerStr += "custom";
6395 markerStr += gDigitsSep;
6396 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
6400 markerStr += gDigitsSep;
6401 markerStr += QString::number( (int)aMarkerType );
6402 markerStr += gDigitsSep;
6403 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
6406 param = vtkParam + "PointMarker";
6407 ip->setParameter(entry, param, markerStr.toLatin1().data());
6410 param = vtkParam + "Opacity";
6411 ip->setParameter(entry, param,
6412 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
6415 param = vtkParam + "ClippingPlane";
6417 if( !aClippingPlaneInfoList.empty() ) {
6418 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
6419 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
6421 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
6422 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
6423 SMESH::TActorList::iterator anIter2 = anActorList.begin();
6424 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
6425 if( aSmeshActor == *anIter2 ) {
6426 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
6427 QString::number( anId ).toLatin1().constData() );
6434 ip->setParameter( entry, param, "Off" );
6435 } // if (io->hasEntry())
6436 } // SMESH_Actor && hasIO
6438 } // while.. actors traversal
6442 } // if (SVTK view model)
6443 } // for (viewManagers)
6446 // data structures for clipping planes processing
6450 bool isOpenGLClipping;
6451 vtkIdType RelativeOrientation;
6454 int AbsoluteOrientation;
6455 double X, Y, Z, Dx, Dy, Dz;
6457 typedef std::list<TPlaneData> TPlaneDataList;
6458 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
6460 typedef std::list<vtkActor*> TActorList;
6463 TActorList ActorList;
6464 SUIT_ViewManager* ViewManager;
6466 typedef std::list<TPlaneInfo> TPlaneInfoList;
6467 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
6470 * \brief Restore visual parameters
6472 * This method is called after the study document is opened.
6473 * Restore visual parameters from AttributeParameter attribute(s)
6475 void SMESHGUI::restoreVisualParameters (int savePoint)
6478 Kernel_Utils::Localizer loc;
6480 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6481 if (!appStudy || !appStudy->studyDS())
6483 _PTR(Study) studyDS = appStudy->studyDS();
6485 // componentName is used for encoding of entries when storing them in IParameters
6486 std::string componentName = myComponentSMESH->ComponentDataType();
6489 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6490 componentName.c_str(),
6492 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6494 // restore custom markers and map of clipping planes
6495 TPlaneDataMap aPlaneDataMap;
6497 std::vector<std::string> properties = ip->getProperties();
6498 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
6500 std::string property = *propIt;
6501 QString aPropertyName( property.c_str() );
6502 QString aPropertyValue( ip->getProperty( property ).c_str() );
6504 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
6505 if( aPropertyNameList.isEmpty() )
6508 QString aPropertyType = aPropertyNameList[0];
6509 if( aPropertyType == "texture" )
6511 if( aPropertyNameList.size() != 2 )
6515 int anId = aPropertyNameList[1].toInt( &ok );
6516 if( !ok || anId < 1 )
6519 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
6520 if( aPropertyValueList.size() != 2 )
6523 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
6524 QString aMarkerTextureString = aPropertyValueList[1];
6525 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
6526 if( aMarkerTextureStringList.size() != 3 )
6530 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6535 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6539 VTK::MarkerTexture aMarkerTexture;
6540 aMarkerTexture.push_back( aWidth );
6541 aMarkerTexture.push_back( aHeight );
6543 QString aMarkerTextureData = aMarkerTextureStringList[2];
6544 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6546 QChar aChar = aMarkerTextureData.at( i );
6547 if( aChar.isDigit() )
6548 aMarkerTexture.push_back( aChar.digitValue() );
6551 myMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6553 else if( aPropertyType == "ClippingPlane" )
6555 if( aPropertyNameList.size() != 3 )
6559 int aViewId = aPropertyNameList[1].toInt( &ok );
6560 if( !ok || aViewId < 0 )
6564 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6565 if( !ok || aClippingPlaneId < 0 )
6568 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6569 if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6572 TPlaneData aPlaneData;
6573 aPlaneData.AbsoluteOrientation = false;
6574 aPlaneData.RelativeOrientation = 0;
6575 aPlaneData.Distance = aPlaneData.Angle[0] = aPlaneData.Angle[1] = 0;
6576 aPlaneData.X = aPlaneData.Y = aPlaneData.Z = 0;
6577 aPlaneData.Dx = aPlaneData.Dy = aPlaneData.Dz = 0;
6579 aPlaneData.Id = aClippingPlaneId;
6582 aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6587 aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6591 if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6594 aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6599 aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6604 aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6609 aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6614 aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6619 aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6624 aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6628 else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6630 aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6635 aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6640 aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6645 aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6650 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6651 aPlaneDataList.push_back( aPlaneData );
6655 TPlaneInfoMap aPlaneInfoMap;
6657 std::vector<std::string> entries = ip->getEntries();
6659 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6661 // entry is a normal entry - it should be "decoded" (setting base address of component)
6662 QString entry (ip->decodeEntry(*entIt).c_str());
6664 // Check that the entry corresponds to a real object in the Study
6665 // as the object may be deleted or modified after the visual state is saved.
6666 _PTR(SObject) so = studyDS->FindObjectID(entry.toUtf8().data());
6667 if (!so) continue; //Skip the not existent entry
6669 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6670 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6672 std::vector<std::string>::iterator namesIt = paramNames.begin();
6673 std::vector<std::string>::iterator valuesIt = paramValues.begin();
6675 // actors are stored in a map after displaying of them for
6676 // quicker access in the future: map < viewID to actor >
6677 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6679 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6681 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6682 // '_' is used as separator and should not be used in viewer type or parameter names.
6683 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6684 if (lst.size() != 3)
6687 QString viewerTypStr = lst[0];
6688 QString viewIndexStr = lst[1];
6689 QString paramNameStr = lst[2];
6692 int viewIndex = viewIndexStr.toUInt(&ok);
6693 if (!ok) // bad conversion of view index to integer
6697 if (viewerTypStr == SVTK_Viewer::Type())
6699 SMESH_Actor* aSmeshActor = 0;
6700 if (vtkActors.IsBound(viewIndex))
6701 aSmeshActor = vtkActors.Find(viewIndex);
6703 QList<SUIT_ViewManager*> lst;
6704 getApp()->viewManagers(viewerTypStr, lst);
6706 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6707 SUIT_ViewManager* vman = NULL;
6708 if (viewIndex >= 0 && viewIndex < lst.count())
6709 vman = lst.at(viewIndex);
6711 if (paramNameStr == "Visibility")
6713 if (!aSmeshActor && displayer() && vman)
6715 SUIT_ViewModel* vmodel = vman->getViewModel();
6716 // SVTK view model can be casted to SALOME_View
6717 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6719 // store displayed actor in a temporary map for quicker
6720 // access later when restoring other parameters
6721 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6722 vtkRenderer* Renderer = vtkView->getRenderer();
6723 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6724 vtkActorCollection* theActors = aCopy.GetActors();
6725 theActors->InitTraversal();
6726 bool isFound = false;
6727 vtkActor *ac = theActors->GetNextActor();
6728 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6729 if (ac->IsA("SMESH_Actor")) {
6730 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6731 if (aGeomAc->hasIO()) {
6732 Handle(SALOME_InteractiveObject) io = aGeomAc->getIO();
6733 if (io->hasEntry() && strcmp(io->getEntry(), entry.toUtf8().data()) == 0) {
6735 vtkActors.Bind(viewIndex, aGeomAc);
6741 } // if (paramNameStr == "Visibility")
6744 // the rest properties "work" with SMESH_Actor
6747 QString val ((*valuesIt).c_str());
6750 if (paramNameStr == "Representation") {
6751 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6754 else if (paramNameStr == "IsShrunk") {
6756 if (!aSmeshActor->IsShrunk())
6757 aSmeshActor->SetShrink();
6760 if (aSmeshActor->IsShrunk())
6761 aSmeshActor->UnShrink();
6764 // Displayed entities
6765 else if (paramNameStr == "Entities") {
6766 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6767 int aEntityMode = SMESH_Actor::eAllEntity;
6768 for ( int i = 0; i < mode.count(); i+=2 ) {
6769 if ( i < mode.count()-1 ) {
6770 QString type = mode[i];
6771 bool val = mode[i+1].toInt();
6772 if ( type == "e" && !val )
6773 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6774 else if ( type == "f" && !val )
6775 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6776 else if ( type == "v" && !val )
6777 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6778 else if ( type == "0d" && !val )
6779 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6780 else if ( type == "b" && !val )
6781 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6784 aSmeshActor->SetEntityMode( aEntityMode );
6787 else if (paramNameStr == "Colors") {
6788 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6795 QColor outlineColor;
6796 QColor orientationColor;
6802 // below lines are required to get default values for delta coefficients
6803 // of backface color for faces and color of reversed volumes
6804 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
6805 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6806 for ( int i = 0; i < colors.count(); i++ ) {
6807 QString type = colors[i];
6808 if ( type == "surface" ) {
6809 // face color is set by 3 values r:g:b, where
6810 // - r,g,b - is rgb color components
6811 if ( i+1 >= colors.count() ) break; // format error
6812 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6813 if ( i+2 >= colors.count() ) break; // format error
6814 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6815 if ( i+3 >= colors.count() ) break; // format error
6816 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6817 faceColor.setRgbF( r, g, b );
6820 else if ( type == "backsurface" ) {
6821 // backface color can be defined in several ways
6822 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6823 // - in latest versions, it is set as delta coefficient
6824 bool rgbOk = false, deltaOk;
6825 if ( i+1 >= colors.count() ) break; // format error
6826 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6827 int delta = colors[i+1].toInt( &deltaOk );
6829 if ( i+1 < colors.count() ) // index is shifted to 1
6830 g = colors[i+1].toDouble( &rgbOk );
6831 if ( rgbOk ) i++; // shift index
6832 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6833 b = colors[i+1].toDouble( &rgbOk );
6835 // - as currently there's no way to set directly backsurface color as it was before,
6836 // we ignore old dump where r,g,b triple was set
6837 // - also we check that delta parameter is set properly
6838 if ( !rgbOk && deltaOk )
6841 else if ( type == "volume" ) {
6842 // volume color is set by 4 values r:g:b:delta, where
6843 // - r,g,b - is a normal volume rgb color components
6844 // - delta - is a reversed volume color delta coefficient
6845 if ( i+1 >= colors.count() ) break; // format error
6846 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6847 if ( i+2 >= colors.count() ) break; // format error
6848 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6849 if ( i+3 >= colors.count() ) break; // format error
6850 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6851 if ( i+4 >= colors.count() ) break; // format error
6852 int delta = colors[i+4].toInt( &bOk );
6853 if ( !bOk ) break; // format error
6854 volumeColor.setRgbF( r, g, b );
6858 else if ( type == "edge" ) {
6859 // edge color is set by 3 values r:g:b, where
6860 // - r,g,b - is rgb color components
6861 if ( i+1 >= colors.count() ) break; // format error
6862 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6863 if ( i+2 >= colors.count() ) break; // format error
6864 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6865 if ( i+3 >= colors.count() ) break; // format error
6866 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6867 edgeColor.setRgbF( r, g, b );
6870 else if ( type == "node" ) {
6871 // node color is set by 3 values r:g:b, where
6872 // - r,g,b - is rgb color components
6873 if ( i+1 >= colors.count() ) break; // format error
6874 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6875 if ( i+2 >= colors.count() ) break; // format error
6876 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6877 if ( i+3 >= colors.count() ) break; // format error
6878 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6879 nodeColor.setRgbF( r, g, b );
6882 else if ( type == "elem0d" ) {
6883 // 0d element color is set by 3 values r:g:b, where
6884 // - r,g,b - is rgb color components
6885 if ( i+1 >= colors.count() ) break; // format error
6886 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6887 if ( i+2 >= colors.count() ) break; // format error
6888 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6889 if ( i+3 >= colors.count() ) break; // format error
6890 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6891 elem0dColor.setRgbF( r, g, b );
6894 else if ( type == "ball" ) {
6895 // ball color is set by 3 values r:g:b, where
6896 // - r,g,b - is rgb color components
6897 if ( i+1 >= colors.count() ) break; // format error
6898 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6899 if ( i+2 >= colors.count() ) break; // format error
6900 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6901 if ( i+3 >= colors.count() ) break; // format error
6902 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6903 ballColor.setRgbF( r, g, b );
6906 else if ( type == "outline" ) {
6907 // outline color is set by 3 values r:g:b, where
6908 // - r,g,b - is rgb color components
6909 if ( i+1 >= colors.count() ) break; // format error
6910 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6911 if ( i+2 >= colors.count() ) break; // format error
6912 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6913 if ( i+3 >= colors.count() ) break; // format error
6914 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6915 outlineColor.setRgbF( r, g, b );
6918 else if ( type == "orientation" ) {
6919 // orientation color is set by 3 values r:g:b, where
6920 // - r,g,b - is rgb color components
6921 if ( i+1 >= colors.count() ) break; // format error
6922 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6923 if ( i+2 >= colors.count() ) break; // format error
6924 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6925 if ( i+3 >= colors.count() ) break; // format error
6926 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6927 orientationColor.setRgbF( r, g, b );
6932 if ( nodeColor.isValid() )
6933 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6935 if ( edgeColor.isValid() )
6936 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6938 if ( faceColor.isValid() )
6939 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6941 if ( volumeColor.isValid() )
6942 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6943 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6944 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6946 if ( elem0dColor.isValid() )
6947 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6949 if ( ballColor.isValid() )
6950 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6952 if ( outlineColor.isValid() )
6953 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6954 // orientation color
6955 if ( orientationColor.isValid() )
6956 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6959 else if (paramNameStr == "Sizes") {
6960 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6963 int outlineWidth = -1;
6964 int elem0dSize = -1;
6965 //int ballSize = -1;
6966 double ballDiameter = -1.0;
6967 double ballScale = -1.0;
6968 double shrinkSize = -1;
6969 double orientationSize = -1;
6970 bool orientation3d = false;
6971 for ( int i = 0; i < sizes.count(); i++ ) {
6972 QString type = sizes[i];
6973 if ( type == "line" ) {
6974 // line (wireframe) width is given as single integer value
6975 if ( i+1 >= sizes.count() ) break; // format error
6976 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6980 if ( type == "outline" ) {
6981 // outline width is given as single integer value
6982 if ( i+1 >= sizes.count() ) break; // format error
6983 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6987 else if ( type == "elem0d" ) {
6988 // 0d element size is given as single integer value
6989 if ( i+1 >= sizes.count() ) break; // format error
6990 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6994 else if ( type == "ball" ) {
6995 // balls are specified by two values: size:scale, where
6996 // - size - is a integer value specifying size
6997 // - scale - is a double value specifying scale factor
6998 if ( i+1 >= sizes.count() ) break; // format error
6999 //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
7000 double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
7001 if ( i+2 >= sizes.count() ) break; // format error
7002 double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
7008 else if ( type == "shrink" ) {
7009 // shrink factor is given as single floating point value
7010 if ( i+1 >= sizes.count() ) break; // format error
7011 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
7015 else if ( type == "orientation" ) {
7016 // orientation vectors are specified by two values size:3d, where
7017 // - size - is a floating point value specifying scale factor
7018 // - 3d - is a boolean
7019 if ( i+1 >= sizes.count() ) break; // format error
7020 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
7021 if ( i+2 >= sizes.count() ) break; // format error
7022 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
7023 orientationSize = v1;
7024 orientation3d = (bool)v2;
7028 // line (wireframe) width
7029 if ( lineWidth > 0 )
7030 aSmeshActor->SetLineWidth( lineWidth );
7032 if ( outlineWidth > 0 )
7033 aSmeshActor->SetOutlineWidth( outlineWidth );
7034 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
7035 aSmeshActor->SetOutlineWidth( lineWidth );
7037 if ( elem0dSize > 0 )
7038 aSmeshActor->Set0DSize( elem0dSize );
7040 /*if ( ballSize > 0 )
7041 aSmeshActor->SetBallSize( ballSize );*/
7043 if ( ballDiameter > 0 )
7044 aSmeshActor->SetBallSize( ballDiameter );
7046 if ( ballScale > 0.0 )
7047 aSmeshActor->SetBallScale( ballScale );
7049 if ( shrinkSize > 0 )
7050 aSmeshActor->SetShrinkFactor( shrinkSize );
7051 // orientation vectors
7052 if ( orientationSize > 0 ) {
7053 aSmeshActor->SetFacesOrientationScale( orientationSize );
7054 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
7058 else if (paramNameStr == "PointMarker") {
7059 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
7060 if( data.count() >= 2 ) {
7062 int aParam1 = data[1].toInt( &ok );
7064 if( data[0] == "std" && data.count() == 3 ) {
7065 int aParam2 = data[2].toInt( &ok );
7066 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
7068 else if( data[0] == "custom" ) {
7069 VTK::MarkerMap::const_iterator markerIt = myMarkerMap.find( aParam1 );
7070 if( markerIt != myMarkerMap.end() ) {
7071 VTK::MarkerData aMarkerData = markerIt->second;
7072 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
7079 else if (paramNameStr == "Opacity") {
7080 aSmeshActor->SetOpacity(val.toFloat());
7083 else if (paramNameStr.startsWith("ClippingPlane")) {
7084 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
7085 // old format - val looks like "Off" or "1:0:0:0.5:0:0"
7086 // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
7087 // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
7088 // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
7089 // new format - val looks like "Off" or "0" (plane id)
7090 // (note: in new format "Off" value is used only for consistency,
7091 // so it is processed together with values in old format)
7092 bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
7093 if( anIsOldFormat ) {
7094 if (paramNameStr == "ClippingPlane1" || val == "Off")
7095 aSmeshActor->RemoveAllClippingPlanes();
7097 QList<SUIT_ViewManager*> lst;
7098 getApp()->viewManagers(viewerTypStr, lst);
7099 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
7100 if (viewIndex >= 0 && viewIndex < lst.count()) {
7101 SUIT_ViewManager* vman = lst.at(viewIndex);
7102 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
7104 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
7106 SMESH::TActorList anActorList;
7107 anActorList.push_back( aSmeshActor );
7108 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
7109 aPlane->myViewWindow = vtkView;
7110 SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
7111 aPlane->PlaneMode = aMode;
7112 bool isOpenGLClipping = ( bool )vals[1].toInt();
7113 aPlane->IsOpenGLClipping = isOpenGLClipping;
7114 if ( aMode == SMESH::Absolute ) {
7115 aPlane->myAbsoluteOrientation = vals[2].toInt();
7116 aPlane->X = vals[3].toFloat();
7117 aPlane->Y = vals[4].toFloat();
7118 aPlane->Z = vals[5].toFloat();
7119 aPlane->Dx = vals[6].toFloat();
7120 aPlane->Dy = vals[7].toFloat();
7121 aPlane->Dz = vals[8].toFloat();
7123 else if ( aMode == SMESH::Relative ) {
7124 aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
7125 aPlane->myDistance = vals[3].toFloat();
7126 aPlane->myAngle[0] = vals[4].toFloat();
7127 aPlane->myAngle[1] = vals[5].toFloat();
7131 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
7132 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
7133 aClippingPlaneInfo.Plane = aPlane;
7134 aClippingPlaneInfo.ActorList = anActorList;
7135 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
7143 int aPlaneId = val.toInt( &ok );
7144 if( ok && aPlaneId >= 0 ) {
7145 bool anIsDefinedPlane = false;
7146 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
7147 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
7148 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
7149 TPlaneInfo& aPlaneInfo = *anIter;
7150 if( aPlaneInfo.PlaneId == aPlaneId ) {
7151 aPlaneInfo.ActorList.push_back( aSmeshActor );
7152 anIsDefinedPlane = true;
7156 if( !anIsDefinedPlane ) {
7157 TPlaneInfo aPlaneInfo;
7158 aPlaneInfo.PlaneId = aPlaneId;
7159 aPlaneInfo.ActorList.push_back( aSmeshActor );
7160 aPlaneInfo.ViewManager = vman;
7162 // to make the list sorted by plane id
7163 anIter = aPlaneInfoList.begin();
7164 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
7165 const TPlaneInfo& aPlaneInfoRef = *anIter;
7166 if( aPlaneInfoRef.PlaneId > aPlaneId )
7169 aPlaneInfoList.insert( anIter, aPlaneInfo );
7174 } // if (aSmeshActor)
7175 } // other parameters than Visibility
7177 } // for names/parameters iterator
7178 } // for entries iterator
7180 // take into account planes with empty list of actors referred to them
7181 QList<SUIT_ViewManager*> aVMList;
7182 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
7184 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
7185 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
7186 int aViewId = aPlaneDataIter->first;
7187 if( aViewId >= 0 && aViewId < aVMList.count() ) {
7188 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
7190 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
7192 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
7193 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
7194 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
7195 const TPlaneData& aPlaneData = *anIter2;
7196 int aPlaneId = aPlaneData.Id;
7198 bool anIsFound = false;
7199 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
7200 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
7201 const TPlaneInfo& aPlaneInfo = *anIter3;
7202 if( aPlaneInfo.PlaneId == aPlaneId ) {
7209 TPlaneInfo aPlaneInfo; // ActorList field is empty
7210 aPlaneInfo.PlaneId = aPlaneId;
7211 aPlaneInfo.ViewManager = aViewManager;
7213 // to make the list sorted by plane id
7214 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
7215 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
7216 const TPlaneInfo& aPlaneInfoRef = *anIter4;
7217 if( aPlaneInfoRef.PlaneId > aPlaneId )
7220 aPlaneInfoList.insert( anIter4, aPlaneInfo );
7226 // add clipping planes to actors according to the restored parameters
7227 // and update the clipping plane map
7228 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
7229 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
7230 int aViewId = anIter1->first;
7231 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
7233 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
7234 if( anIter2 == aPlaneDataMap.end() )
7236 const TPlaneDataList& aPlaneDataList = anIter2->second;
7238 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
7239 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
7240 const TPlaneInfo& aPlaneInfo = *anIter3;
7241 int aPlaneId = aPlaneInfo.PlaneId;
7242 const TActorList& anActorList = aPlaneInfo.ActorList;
7243 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
7247 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
7251 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
7253 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
7254 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
7255 const TPlaneData& aPlaneData = *anIter4;
7256 if( aPlaneData.Id == aPlaneId ) {
7257 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
7258 aPlane->myViewWindow = aViewWindow;
7259 aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
7260 aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
7261 if ( aPlane->PlaneMode == SMESH::Absolute ) {
7262 aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
7263 aPlane->X = aPlaneData.X;
7264 aPlane->Y = aPlaneData.Y;
7265 aPlane->Z = aPlaneData.Z;
7266 aPlane->Dx = aPlaneData.Dx;
7267 aPlane->Dy = aPlaneData.Dy;
7268 aPlane->Dz = aPlaneData.Dz;
7270 else if ( aPlane->PlaneMode == SMESH::Relative ) {
7271 aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
7272 aPlane->myDistance = aPlaneData.Distance;
7273 aPlane->myAngle[0] = aPlaneData.Angle[0];
7274 aPlane->myAngle[1] = aPlaneData.Angle[1];
7277 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
7278 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
7279 aClippingPlaneInfo.Plane = aPlane;
7280 aClippingPlaneInfo.ActorList = anActorList;
7281 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
7292 // update all VTK views
7293 QList<SUIT_ViewManager*> lst;
7294 getApp()->viewManagers(lst);
7295 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
7296 SUIT_ViewModel* vmodel = (*it)->getViewModel();
7297 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
7298 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
7299 // set OpenGL clipping planes
7300 VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
7301 vtkActorCollection* anAllActors = aCopy.GetActors();
7302 anAllActors->InitTraversal();
7303 while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
7304 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
7305 anActor->SetOpenGLClippingPlane();
7307 vtkView->getRenderer()->ResetCameraClippingRange();
7314 \brief Adds preferences for dfont of VTK viewer
7316 \param pIf group identifier
7317 \param param parameter
7318 \return identifier of preferences
7320 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
7322 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
7324 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
7327 fam.append( tr( "SMESH_FONT_ARIAL" ) );
7328 fam.append( tr( "SMESH_FONT_COURIER" ) );
7329 fam.append( tr( "SMESH_FONT_TIMES" ) );
7331 setPreferenceProperty( tfont, "fonts", fam );
7333 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
7334 if ( needSize ) f = f | QtxFontEdit::Size;
7335 setPreferenceProperty( tfont, "features", f );
7341 \brief Actions after hypothesis edition
7342 Updates object browser after hypothesis edition
7344 void SMESHGUI::onHypothesisEdit( int result )
7347 SMESHGUI::Modified();
7348 updateObjBrowser( true );
7352 \brief Actions after choosing menu of control modes
7353 Updates control mode actions according to current selection
7355 void SMESHGUI::onUpdateControlActions()
7357 SALOME_ListIO selected;
7358 if ( LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr() )
7359 aSel->selectedObjects( selected );
7361 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
7362 if ( selected.Extent() ) {
7363 if ( selected.First()->hasEntry() ) {
7364 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( selected.First()->getEntry() )) {
7365 aControl = anActor->GetControlMode();
7366 SALOME_ListIteratorOfListIO it(selected);
7367 for ( it.Next(); it.More(); it.Next() ) {
7368 Handle(SALOME_InteractiveObject) anIO = it.Value();
7369 if ( anIO->hasEntry() ) {
7370 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
7371 if ( aControl != anActor->GetControlMode() ) {
7372 aControl = SMESH_Actor::eNone;
7382 int anAction = ActionToControl( aControl, true );
7384 action( anAction )->setChecked( true );
7386 QMenu* send = (QMenu*)sender();
7387 QList<QAction*> actions = send->actions();
7388 for ( int i = 0; i < actions.size(); i++ )
7389 actions[i]->setChecked( false );
7395 \brief Signal handler closing(SUIT_ViewWindow*) of a view
7396 \param pview view being closed
7398 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
7399 #ifndef DISABLE_PLOT2DVIEWER
7400 //Crear all Plot2d Viewers if need.
7401 SMESH::ClearPlot2Viewers(pview);
7403 EmitSignalCloseView();
7406 void SMESHGUI::message( const QString& msg )
7409 QStringList data = msg.split("/");
7410 if ( data.count() > 0 ) {
7411 if ( data.first() == "mesh_loading" ) {
7413 QString entry = data.count() > 1 ? data[1] : QString();
7414 if ( entry.isEmpty() )
7417 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
7419 _PTR(SObject) obj = study->FindObjectID( entry.toUtf8().constData() );
7422 name = SMESH::fromUtf8(obj->GetName());
7423 if ( name.isEmpty() )
7426 if ( data.last() == "stop" )
7427 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
7429 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
7430 QApplication::processEvents();
7436 \brief Connects or disconnects signals about activating and cloning view on the module slots
7437 \param pview view which is connected/disconnected
7439 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
7443 SUIT_ViewManager* viewMgr = pview->getViewManager();
7445 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7446 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7448 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7449 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7454 \brief Return \c true if object can be renamed
7456 bool SMESHGUI::renameAllowed( const QString& entry) const {
7457 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7461 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7465 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
7470 if(appStudy->isComponent(entry) || obj->isReference())
7473 // check type to prevent renaming of inappropriate objects
7474 int aType = SMESHGUI_Selection::type(qPrintable(entry));
7475 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7476 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7477 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7478 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7479 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
7486 Rename object by entry.
7487 \param entry entry of the object
7488 \param name new name of the object
7489 \brief Return \c true if rename operation finished successfully, \c false otherwise.
7491 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
7493 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7497 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7502 _PTR(Study) aStudy = appStudy->studyDS();
7507 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
7509 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
7514 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
7515 _PTR(GenericAttribute) anAttr;
7516 _PTR(AttributeName) aName;
7518 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
7520 // check type to prevent renaming of inappropriate objects
7521 int aType = SMESHGUI_Selection::type( qPrintable(entry));
7522 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7523 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7524 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7525 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7526 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
7527 if ( !name.isEmpty() ) {
7528 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qUtf8Printable(name) );
7530 // update name of group object and its actor
7531 Handle(SALOME_InteractiveObject) IObject =
7532 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
7534 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
7535 if( !aGroupObject->_is_nil() ) {
7536 aGroupObject->SetName( qUtf8Printable(name) );
7537 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
7538 anActor->setName( qUtf8Printable(name) );
7548 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
7550 static QList<QColor> colors;
7552 if ( colors.isEmpty() ) {
7554 for (int s = 0; s < 2 ; s++)
7556 for (int v = 100; v >= 40; v = v - 20)
7558 for (int h = 0; h < 359 ; h = h + 60)
7560 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
7565 static int currentColor = randomize( colors.size() );
7567 SALOMEDS::Color color;
7568 color.R = (double)colors[currentColor].red() / 255.0;
7569 color.G = (double)colors[currentColor].green() / 255.0;
7570 color.B = (double)colors[currentColor].blue() / 255.0;
7572 currentColor = (currentColor+1) % colors.count();