1 // Copyright (C) 2007-2020 CEA/DEN, EDF R&D, OPEN CASCADE
3 // Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
6 // This library is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU Lesser General Public
8 // License as published by the Free Software Foundation; either
9 // version 2.1 of the License, or (at your option) any later version.
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 // Lesser General Public License for more details.
16 // You should have received a copy of the GNU Lesser General Public
17 // License along with this library; if not, write to the Free Software
18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
22 // File : SMESHGUI.cxx
23 // Author : Nicolas REJNERI, Open CASCADE S.A.S.
25 #include <Standard_math.hxx> // E.A. must be included before Python.h to fix compilation on windows
27 #undef HAVE_FINITE // VSR: avoid compilation warning on Linux : "HAVE_FINITE" redefined
33 #include "SMESHGUI_Add0DElemsOnAllNodesDlg.h"
34 #include "SMESHGUI_AddMeshElementDlg.h"
35 #include "SMESHGUI_AddQuadraticElementDlg.h"
36 #include "SMESHGUI_BuildCompoundDlg.h"
37 #include "SMESHGUI_ClippingDlg.h"
38 #include "SMESHGUI_ComputeDlg.h"
39 #include "SMESHGUI_ConvToQuadOp.h"
40 #include "SMESHGUI_CopyMeshDlg.h"
41 #include "SMESHGUI_CreatePolyhedralVolumeDlg.h"
42 #include "SMESHGUI_DeleteGroupDlg.h"
43 #include "SMESHGUI_DisplayEntitiesDlg.h"
44 #include "SMESHGUI_Displayer.h"
45 #include "SMESHGUI_DuplicateNodesDlg.h"
46 #include "SMESHGUI_ExtrusionAlongPathDlg.h"
47 #include "SMESHGUI_ExtrusionDlg.h"
48 #include "SMESHGUI_FaceGroupsSeparatedByEdgesDlg.h"
49 #include "SMESHGUI_FieldSelectorWdg.h"
50 #include "SMESHGUI_FileInfoDlg.h"
51 #include "SMESHGUI_FileValidator.h"
52 #include "SMESHGUI_FilterDlg.h"
53 #include "SMESHGUI_FilterLibraryDlg.h"
54 #include "SMESHGUI_FilterUtils.h"
55 #include "SMESHGUI_FindElemByPointDlg.h"
56 #include "SMESHGUI_GEOMGenUtils.h"
57 #include "SMESHGUI_GroupDlg.h"
58 #include "SMESHGUI_GroupOnShapeDlg.h"
59 #include "SMESHGUI_GroupOpDlg.h"
60 #include "SMESHGUI_GroupUtils.h"
61 #include "SMESHGUI_Hypotheses.h"
62 #include "SMESHGUI_HypothesesUtils.h"
63 #include "SMESHGUI_Make2DFrom3DOp.h"
64 #include "SMESHGUI_MakeNodeAtPointDlg.h"
65 #include "SMESHGUI_Measurements.h"
66 #include "SMESHGUI_MergeDlg.h"
67 #include "SMESHGUI_MeshInfo.h"
68 #include "SMESHGUI_MeshOp.h"
69 #include "SMESHGUI_MeshOrderOp.h"
70 #include "SMESHGUI_MeshPatternDlg.h"
71 #include "SMESHGUI_MeshUtils.h"
72 #include "SMESHGUI_MultiEditDlg.h"
73 #include "SMESHGUI_NodesDlg.h"
74 #include "SMESHGUI_OffsetDlg.h"
75 #include "SMESHGUI_Operations.h"
76 #include "SMESHGUI_PatternUtils.h"
77 #include "SMESHGUI_Preferences_ScalarBarDlg.h"
78 #include "SMESHGUI_PropertiesDlg.h"
79 #include "SMESHGUI_RemoveElementsDlg.h"
80 #include "SMESHGUI_RemoveNodesDlg.h"
81 #include "SMESHGUI_RenumberingDlg.h"
82 #include "SMESHGUI_ReorientFacesDlg.h"
83 #include "SMESHGUI_RevolutionDlg.h"
84 #include "SMESHGUI_RotationDlg.h"
85 #include "SMESHGUI_ScaleDlg.h"
86 #include "SMESHGUI_Selection.h"
87 #include "SMESHGUI_SewingDlg.h"
88 #include "SMESHGUI_SingleEditDlg.h"
89 #include "SMESHGUI_SmoothingDlg.h"
90 #include "SMESHGUI_SpinBox.h"
91 #include "SMESHGUI_SplitBiQuad.h"
92 #include "SMESHGUI_SymmetryDlg.h"
93 #include "SMESHGUI_TranslationDlg.h"
94 #include "SMESHGUI_TransparencyDlg.h"
95 #include "SMESHGUI_Utils.h"
96 #include "SMESHGUI_VTKUtils.h"
98 #include "SMESH_version.h"
100 #include "SMESH_Actor.h"
101 #include "SMESH_ActorUtils.h"
102 #include "SMESH_Client.hxx"
103 #include "SMESH_Comment.hxx"
104 #include "SMESH_ControlsDef.hxx"
105 #include "SMESH_ScalarBarActor.h"
106 #include "SMESH_TypeFilter.hxx"
108 // SALOME GUI includes
109 #include <LightApp_DataOwner.h>
110 #include <LightApp_NameDlg.h>
111 #include <LightApp_Preferences.h>
112 #include <LightApp_SelectionMgr.h>
113 #include <LightApp_UpdateFlags.h>
114 #include <QtxFontEdit.h>
115 #include <QtxPopupMgr.h>
116 #include <SALOME_ListIO.hxx>
117 #include <SUIT_Desktop.h>
118 #include <SUIT_FileDlg.h>
119 #include <SUIT_MessageBox.h>
120 #include <SUIT_OverrideCursor.h>
121 #include <SUIT_ResourceMgr.h>
122 #include <SUIT_Session.h>
123 #include <SVTK_Renderer.h>
124 #include <SVTK_ViewManager.h>
125 #include <SVTK_ViewModel.h>
126 #include <SVTK_ViewWindow.h>
127 #include <SalomeApp_Application.h>
128 #include <SalomeApp_CheckFileDlg.h>
129 #include <SalomeApp_DataObject.h>
130 #include <SalomeApp_Study.h>
131 #include <SalomeApp_Tools.h>
132 #include <VTKViewer_Algorithm.h>
134 #ifndef DISABLE_PLOT2DVIEWER
135 #include <SPlot2d_ViewModel.h>
136 #include <SPlot2d_Histogram.h>
140 #include <SALOMEconfig.h>
141 #include CORBA_CLIENT_HEADER(SALOMEDS_Attributes)
142 #include CORBA_CLIENT_HEADER(SMESH_MeshEditor)
143 #include CORBA_CLIENT_HEADER(SMESH_Measurements)
144 #include CORBA_CLIENT_HEADER(SMESH_Mesh)
147 // #define INCLUDE_MENUITEM_DEF // VSR commented ????????
148 #include <QApplication>
150 #include <QDialogButtonBox>
154 #include <QTextStream>
158 #include <boost/shared_ptr.hpp>
161 #include <vtkCallbackCommand.h>
162 #include <vtkCamera.h>
163 #include <vtkLookupTable.h>
164 #include <vtkPlane.h>
165 #include <vtkRenderer.h>
167 // SALOME KERNEL includes
168 #include <SALOMEDSClient_ClientFactory.hxx>
169 #include <SALOMEDSClient_IParameters.hxx>
170 #include <SALOMEDSClient_SComponent.hxx>
171 #include <SALOMEDSClient_StudyBuilder.hxx>
172 #include <SALOMEDS_Study.hxx>
173 #include <SALOMEDS_SObject.hxx>
174 #include "utilities.h"
175 #include <SALOME_LifeCycleCORBA.hxx>
178 #include <Standard_ErrorHandler.hxx>
179 #include <NCollection_DataMap.hxx>
180 #include <NCollection_DoubleMap.hxx>
182 #include <Basics_Utils.hxx>
184 // Below macro, when uncommented, switches on simplified (more performant) algorithm
185 // of auto-color picking up
186 #define SIMPLE_AUTOCOLOR
191 //=============================================================
192 void ImportMeshesFromFile(SMESH::SMESH_Gen_ptr theComponentMesh,
195 void ExportMeshToFile(int theCommandID);
197 void SetDisplayMode(int theCommandID, VTK::MarkerMap& theMarkerMap);
199 void SetDisplayEntity(int theCommandID);
201 int ActionToControl( int theID, bool theReversed = false );
203 void Control( int theCommandID );
206 //================================================================================
208 * \brief Reads meshes from file
210 //================================================================================
212 void ImportMeshesFromFile( SMESH::SMESH_Gen_ptr theComponentMesh,
216 std::string myExtension;
218 if ( theCommandID == SMESHOp::OpImportMED ||
219 theCommandID == SMESHOp::OpPopupImportMED ) {
220 filter.append( QObject::tr( "MED_FILES_FILTER" ) + " (*.*med)" );
221 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
223 else if ( theCommandID == SMESHOp::OpImportUNV ||
224 theCommandID == SMESHOp::OpPopupImportUNV ) {
225 filter.append( QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)" );
227 else if ( theCommandID == SMESHOp::OpImportDAT ||
228 theCommandID == SMESHOp::OpPopupImportDAT ) {
229 filter.append( QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)" );
231 else if ( theCommandID == SMESHOp::OpImportSTL ||
232 theCommandID == SMESHOp::OpPopupImportSTL ) {
233 filter.append( QObject::tr( "STL_FILES_FILTER" ) + " (*.stl)" );
235 else if ( theCommandID == SMESHOp::OpImportCGNS ||
236 theCommandID == SMESHOp::OpPopupImportCGNS ) {
237 filter.append( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
239 else if ( theCommandID == SMESHOp::OpImportSAUV ||
240 theCommandID == SMESHOp::OpPopupImportSAUV ) {
241 filter.append( QObject::tr( "SAUV_FILES_FILTER" ) + " (*.sauv *.sauve)" );
242 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
244 else if ( theCommandID == SMESHOp::OpImportGMF ||
245 theCommandID == SMESHOp::OpPopupImportGMF ) {
246 filter.append( QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" );
247 filter.append( QObject::tr( "GMF_BINARY_FILES_FILTER") + " (*.meshb)" );
250 QString anInitialPath = "";
251 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
252 anInitialPath = QDir::currentPath();
254 QStringList filenames;
255 bool toCreateGroups = true;
257 // if ( theCommandID == SMESHOp::OpImportGMF ) { // GMF
258 // SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg
259 // ( SMESHGUI::desktop(), true, QObject::tr("SMESH_REQUIRED_GROUPS"), true, true );
260 // fd->setWindowTitle( QObject::tr( "SMESH_IMPORT_MESH" ) );
261 // fd->setNameFilters( filter );
262 // fd->SetChecked( true );
264 // filenames << fd->selectedFile();
265 // toCreateGroups = fd->IsChecked();
271 filenames = SUIT_FileDlg::getOpenFileNames( SMESHGUI::desktop(),
274 QObject::tr( "SMESH_IMPORT_MESH" ) );
276 if ( filenames.count() > 0 )
278 SUIT_OverrideCursor wc;
279 _PTR(Study) aStudy = SMESH::getStudy();
282 QStringList anEntryList;
283 bool isEmpty = false;
284 for ( QStringList::ConstIterator it = filenames.begin(); it != filenames.end(); ++it )
286 QString filename = *it;
287 SMESH::mesh_array_var aMeshes = new SMESH::mesh_array;
289 switch ( theCommandID ) {
290 case SMESHOp::OpImportDAT:
291 case SMESHOp::OpPopupImportDAT:
293 // DAT format (currently unsupported)
294 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
295 arg( QObject::tr( "SMESH_ERR_NOT_SUPPORTED_FORMAT" ) ) );
298 case SMESHOp::OpImportUNV:
299 case SMESHOp::OpPopupImportUNV:
302 aMeshes->length( 1 );
303 aMeshes[0] = theComponentMesh->CreateMeshesFromUNV( filename.toUtf8().constData() );
304 if ( aMeshes[0]->_is_nil() )
305 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
306 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
309 case SMESHOp::OpImportMED:
310 case SMESHOp::OpPopupImportMED:
313 SMESH::DriverMED_ReadStatus res;
314 aMeshes = theComponentMesh->CreateMeshesFromMED( filename.toUtf8().constData(), res );
315 if ( res != SMESH::DRS_OK ) {
316 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
317 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
321 case SMESHOp::OpImportSTL:
322 case SMESHOp::OpPopupImportSTL:
325 aMeshes->length( 1 );
326 aMeshes[0] = theComponentMesh->CreateMeshesFromSTL( filename.toUtf8().constData() );
327 if ( aMeshes[0]->_is_nil() ) {
328 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
329 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
333 case SMESHOp::OpImportCGNS:
334 case SMESHOp::OpPopupImportCGNS:
337 SMESH::DriverMED_ReadStatus res;
338 aMeshes = theComponentMesh->CreateMeshesFromCGNS( filename.toUtf8().constData(), res );
339 if ( res != SMESH::DRS_OK ) {
340 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
341 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
345 case SMESHOp::OpImportSAUV:
346 case SMESHOp::OpPopupImportSAUV:
349 SMESH::DriverMED_ReadStatus res;
350 aMeshes = theComponentMesh->CreateMeshesFromSAUV( filename.toUtf8().constData(), res );
351 if ( res != SMESH::DRS_OK ) {
352 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
353 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
357 case SMESHOp::OpImportGMF:
358 case SMESHOp::OpPopupImportGMF:
361 SMESH::ComputeError_var res;
362 aMeshes->length( 1 );
363 aMeshes[0] = theComponentMesh->CreateMeshesFromGMF( filename.toUtf8().constData(),
366 if ( res->code != SMESH::DRS_OK ) {
367 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
368 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res->code ).toLatin1().data() ) ) );
369 if ( strlen( res->comment.in() ) > 0 ) {
370 errors.back() += ": ";
371 errors.back() += res->comment.in();
378 catch ( const SALOME::SALOME_Exception& S_ex ) {
379 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
380 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
383 for ( int i = 0, iEnd = aMeshes->length(); i < iEnd; i++ )
385 _PTR(SObject) aMeshSO = SMESH::FindSObject( aMeshes[i] );
387 _PTR(StudyBuilder) aBuilder = aStudy->NewBuilder();
388 _PTR(AttributePixMap) aPixmap = aBuilder->FindOrCreateAttribute( aMeshSO, "AttributePixMap" );
389 aPixmap->SetPixMap( "ICON_SMESH_TREE_MESH_IMPORTED" );
390 if ( theCommandID == SMESHOp::OpImportUNV ) // mesh names aren't taken from the file for UNV import
391 SMESH::SetName( aMeshSO, QFileInfo(filename).fileName() );
393 anEntryList.append( aMeshSO->GetID().c_str() );
401 // update Object browser
402 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
404 // browse to the published meshes
405 if( LightApp_Application* anApp =
406 dynamic_cast<LightApp_Application*>( SUIT_Session::session()->activeApplication() ) )
407 anApp->browseObjects( anEntryList );
409 // show Error message box if there were errors
410 if ( errors.count() > 0 ) {
411 SUIT_MessageBox::critical( SMESHGUI::desktop(),
412 QObject::tr( "SMESH_ERROR" ),
413 QObject::tr( "SMESH_IMPORT_ERRORS" ) + "\n" + errors.join( "\n" ) );
416 // show warning message box, if some imported mesh is empty
418 SUIT_MessageBox::warning( SMESHGUI::desktop(),
419 QObject::tr( "SMESH_WRN_WARNING" ),
420 QObject::tr( "SMESH_DRS_SOME_EMPTY" ) );
425 //================================================================================
427 * \brief Export selected meshes or groups into a file
429 //================================================================================
431 void ExportMeshToFile( int theCommandID )
433 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
434 SALOME_ListIO selected;
436 aSel->selectedObjects( selected );
438 const bool isDAT = ( theCommandID == SMESHOp::OpExportDAT ||
439 theCommandID == SMESHOp::OpPopupExportDAT );
440 const bool isMED = ( theCommandID == SMESHOp::OpExportMED ||
441 theCommandID == SMESHOp::OpPopupExportMED );
442 const bool isUNV = ( theCommandID == SMESHOp::OpExportUNV ||
443 theCommandID == SMESHOp::OpPopupExportUNV );
444 const bool isSTL = ( theCommandID == SMESHOp::OpExportSTL ||
445 theCommandID == SMESHOp::OpPopupExportSTL );
446 const bool isCGNS= ( theCommandID == SMESHOp::OpExportCGNS ||
447 theCommandID == SMESHOp::OpPopupExportCGNS );
448 const bool isSAUV= ( theCommandID == SMESHOp::OpExportSAUV ||
449 theCommandID == SMESHOp::OpPopupExportSAUV );
450 const bool isGMF = ( theCommandID == SMESHOp::OpExportGMF ||
451 theCommandID == SMESHOp::OpPopupExportGMF );
453 const bool multiMeshSupported = ( isMED || isCGNS ); // file can hold several meshes
454 if ( selected.Extent() == 0 || ( selected.Extent() > 1 && !multiMeshSupported ))
456 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
457 bool aCheckWarn = true;
459 aCheckWarn = resMgr->booleanValue( "SMESH", "show_warning", false );
460 // get mesh object from selection and check duplication of their names
461 bool hasDuplicatedMeshNames = false;
462 QList< QPair< SMESH::SMESH_IDSource_var, QString > > aMeshList;
463 QList< QPair< SMESH::SMESH_IDSource_var, QString > >::iterator aMeshIter;
464 SALOME_ListIteratorOfListIO It( selected );
465 for( ; It.More(); It.Next() )
467 Handle(SALOME_InteractiveObject) anIObject = It.Value();
468 SMESH::SMESH_IDSource_var aMeshItem =
469 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIObject);
470 if ( aMeshItem->_is_nil() ) {
471 SUIT_MessageBox::warning( SMESHGUI::desktop(),
472 QObject::tr( "SMESH_WRN_WARNING" ),
473 QObject::tr( "SMESH_BAD_MESH_SELECTION" ));
476 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( aMeshItem );
477 if ( aCheckWarn && !aGroup->_is_nil() )
479 QMessageBox msgBox(SUIT_MessageBox::Warning,
480 QObject::tr("SMESH_WRN_WARNING"),
481 QObject::tr("SMESH_EXPORT_ONLY_GPOUP"),
482 QMessageBox::StandardButton::NoButton,
483 SMESHGUI::desktop());
484 QCheckBox dontShowCheckBox(QObject::tr("SMESH_WRN_SHOW_DLG_CHECKBOX"));
485 msgBox.addButton(QMessageBox::Ok);
486 msgBox.addButton(QMessageBox::Cancel);
487 msgBox.setDefaultButton(QMessageBox::Cancel);
488 QGridLayout* lt = qobject_cast<QGridLayout*>(msgBox.layout());
489 QDialogButtonBox* btnbox = msgBox.findChild<QDialogButtonBox*>();
490 lt->addWidget(&dontShowCheckBox, lt->rowCount(), lt->columnCount()-1, lt->rowCount(), lt->columnCount());
491 lt->addWidget(btnbox, lt->rowCount(), 0, lt->rowCount(), lt->columnCount());
492 if ( msgBox.exec() != QMessageBox::Ok )
495 if ( dontShowCheckBox.checkState() == Qt::Checked && resMgr )
496 resMgr->setValue( "SMESH", "show_warning", false);
499 QString aMeshName = anIObject->getName();
501 // check for name duplications
502 if ( !hasDuplicatedMeshNames )
503 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
504 if( aMeshName == (*aMeshIter).second ) {
505 hasDuplicatedMeshNames = true;
510 aMeshList.append( QPair< SMESH::SMESH_IDSource_var, QString >( aMeshItem, aMeshName ) );
513 if( hasDuplicatedMeshNames && isMED ) {
514 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
515 QObject::tr("SMESH_WRN_WARNING"),
516 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_MESH_NAMES"),
517 QObject::tr("SMESH_BUT_YES"),
518 QObject::tr("SMESH_BUT_NO"), 0, 1);
523 aMeshIter = aMeshList.begin();
524 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
525 SMESH::SMESH_Mesh_var aMesh = aMeshOrGroup->GetMesh();
526 QString aMeshName = (*aMeshIter).second;
528 if ( isMED || isCGNS || isSAUV ) // formats where group names must be unique
530 // check for equal group names within each mesh
531 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
532 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
533 if ( !aMeshItem->_is_nil() && aMeshItem->HasDuplicatedGroupNamesMED()) {
534 int aRet = SUIT_MessageBox::warning
535 (SMESHGUI::desktop(),
536 QObject::tr("SMESH_WRN_WARNING"),
537 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_GRP").arg((*aMeshIter).second),
538 QObject::tr("SMESH_BUT_YES"),
539 QObject::tr("SMESH_BUT_NO"), 0, 1);
546 // Warn the user about presence of not supported elements
548 std::vector< SMESH::EntityType > notSupportedElemTypes, presentNotSupported;
552 notSupportedElemTypes.push_back( SMESH::Entity_0D );
553 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
558 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
559 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
560 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
561 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
562 notSupportedElemTypes.push_back( SMESH::Entity_Pyramid );
563 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
564 notSupportedElemTypes.push_back( SMESH::Entity_0D );
565 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
570 notSupportedElemTypes.push_back( SMESH::Entity_Edge );
571 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Edge );
572 notSupportedElemTypes.push_back( SMESH::Entity_0D );
573 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
578 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
583 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
584 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Triangle );
585 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Quadrangle );
586 notSupportedElemTypes.push_back( SMESH::Entity_TriQuad_Hexa );
587 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
588 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
589 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
590 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
595 notSupportedElemTypes.push_back( SMESH::Entity_0D );
596 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
597 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
598 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Pyramid );
599 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Penta );
600 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Penta );
601 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
602 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
603 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
604 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
606 if ( ! notSupportedElemTypes.empty() )
608 SMESH::long_array_var nbElems = aMeshOrGroup->GetMeshInfo();
609 for ( size_t iType = 0; iType < notSupportedElemTypes.size(); ++iType )
610 if ( nbElems[ notSupportedElemTypes[ iType ]] > 0 )
611 presentNotSupported.push_back( notSupportedElemTypes[ iType ]);
613 if ( !presentNotSupported.empty() )
616 const char* typeMsg[] = {
617 "SMESH_NODES", "SMESH_ELEMS0D","SMESH_EDGES","SMESH_QUADRATIC_EDGES",
618 "SMESH_TRIANGLES", "SMESH_QUADRATIC_TRIANGLES", "SMESH_BIQUADRATIC_TRIANGLES",
619 "SMESH_QUADRANGLES","SMESH_QUADRATIC_QUADRANGLES", "SMESH_BIQUADRATIC_QUADRANGLES",
620 "SMESH_POLYGONS","SMESH_QUADRATIC_POLYGONS",
621 "SMESH_TETRAHEDRA","SMESH_QUADRATIC_TETRAHEDRONS","SMESH_PYRAMIDS",
622 "SMESH_QUADRATIC_PYRAMIDS","SMESH_HEXAHEDRA","SMESH_QUADRATIC_HEXAHEDRONS",
623 "SMESH_TRIQUADRATIC_HEXAHEDRONS","SMESH_PENTAHEDRA","SMESH_QUADRATIC_PENTAHEDRONS",
624 "SMESH_BIQUADRATIC_PENTAHEDRONS",
625 "SMESH_OCTAHEDRA","SMESH_POLYEDRONS","SMESH_QUADRATIC_POLYEDRONS","SMESH_BALLS"
627 // is typeMsg complete? (compilation failure mains that enum SMDSAbs_EntityType changed)
628 const int nbTypes = sizeof( typeMsg ) / sizeof( const char* );
629 int _assert[( nbTypes == SMESH::Entity_Last ) ? 2 : -1 ]; _assert[0]=_assert[1]=0;
631 QString andStr = " " + QObject::tr("SMESH_AND") + " ", comma(", ");
632 for ( size_t iType = 0; iType < presentNotSupported.size(); ++iType ) {
633 typeNames += QObject::tr( typeMsg[ presentNotSupported[ iType ]]);
634 if ( iType != presentNotSupported.size() - 1 )
635 typeNames += ( iType == presentNotSupported.size() - 2 ) ? andStr : comma;
637 int aRet = SUIT_MessageBox::warning
638 (SMESHGUI::desktop(),
639 QObject::tr("SMESH_WRN_WARNING"),
640 QObject::tr("EXPORT_NOT_SUPPORTED").arg(aMeshName).arg(format).arg(typeNames),
641 QObject::tr("SMESH_BUT_YES"),
642 QObject::tr("SMESH_BUT_NO"), 0, 1);
647 // Get parameters of export operation
650 int aFormat =-1; // for MED version used for write
651 bool isOkToWrite = true; // to check MED file version compatibility before adding a mesh in an existing file
653 // Init the parameters with the default values
654 bool aIsASCII_STL = true;
655 bool toCreateGroups = false;
657 toCreateGroups = resMgr->booleanValue( "SMESH", "auto_groups", false );
658 bool toOverwrite = true;
659 bool toFindOutDim = true;
660 double zTol = resMgr ? resMgr->doubleValue( "SMESH", "med_ztolerance", 0. ) : 0.;
662 QString aFilter, aTitle = QObject::tr("SMESH_EXPORT_MESH");
663 QString anInitialPath = "";
664 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
665 anInitialPath = QDir::currentPath();
667 QList< QPair< GEOM::ListOfFields_var, QString > > aFieldList;
669 // Get a file name to write in and additional options
670 if ( isUNV || isDAT || isGMF ) // Export w/o options
673 aFilter = QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)";
675 aFilter = QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)";
677 aFilter = QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" +
678 ";;" + QObject::tr( "GMF_BINARY_FILES_FILTER" ) + " (*.meshb)";
679 if ( anInitialPath.isEmpty() ) anInitialPath = SUIT_FileDlg::getLastVisitedPath();
680 aFilename = SUIT_FileDlg::getFileName(SMESHGUI::desktop(),
681 anInitialPath + QString("/") + aMeshName,
682 aFilter, aTitle, false);
684 else if ( isCGNS )// Export to CGNS
686 const char* theByTypeResource = "cgns_group_elems_by_type";
687 toCreateGroups = SMESHGUI::resourceMgr()->booleanValue( "SMESH", theByTypeResource, false );
689 QStringList checkBoxes;
690 checkBoxes << QObject::tr("CGNS_EXPORT_ELEMS_BY_TYPE");
692 SalomeApp_CheckFileDlg* fd =
693 new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true );
694 fd->setWindowTitle( aTitle );
695 fd->setNameFilter( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
696 if ( !anInitialPath.isEmpty() )
697 fd->setDirectory( anInitialPath );
698 fd->selectFile(aMeshName);
699 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
700 fd->setValidator( fv );
701 fd->SetChecked( toCreateGroups, 0 );
704 aFilename = fd->selectedFile();
705 toOverwrite = fv->isOverwrite(aFilename);
706 toCreateGroups = fd->IsChecked(0);
707 SMESHGUI::resourceMgr()->setValue("SMESH", theByTypeResource, toCreateGroups );
711 else if ( isSTL ) // Export to STL
713 QMap<QString, int> aFilterMap;
714 aFilterMap.insert( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)", 1 );
715 aFilterMap.insert( QObject::tr( "STL_BIN_FILES_FILTER" ) + " (*.stl)", 0 );
718 QMap<QString, int>::const_iterator it = aFilterMap.begin();
719 for ( ; it != aFilterMap.end(); ++it )
720 filters.push_back( it.key() );
722 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
723 fd->setWindowTitle( aTitle );
724 fd->setNameFilters( filters );
725 fd->selectNameFilter( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
726 if ( !anInitialPath.isEmpty() )
727 fd->setDirectory( anInitialPath );
728 fd->selectFile(aMeshName);
732 aFilename = fd->selectedFile();
733 aIsASCII_STL = (aFilterMap[fd->selectedNameFilter()]) == 1 ? true: false;
738 else if ( isMED || isSAUV ) // Export to MED or SAUV
740 int defaultVersion = 0;
741 QMap<QString, int> aFilterMap;
743 //filters << QObject::tr( "MED_FILES_FILTER" ) + " (*.med)";
744 //QString vmed (aMesh->GetVersionString(-1, 2));
745 SMESH::long_array_var mvok = aMesh->GetMEDVersionsCompatibleForAppend();
746 if ( mvok->length() > 0)
747 defaultVersion = mvok[0]; // the current version to set the default filter on it
748 for ( CORBA::ULong i = 0; i < mvok->length(); ++i )
750 QString vs = (char*)( SMESH_Comment( mvok[i]/10 ) << "." << mvok[i]%10 );
751 MESSAGE("MED version: " << vs.toStdString());
752 aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( vs ) + " (*.med)", mvok[i]);
756 aFilterMap.insert("All files (*)", -1 );
757 aFilterMap.insert("SAUV files (*.sauv)", defaultVersion ); // 0 = default filter (defaultVersion)
758 aFilterMap.insert("SAUV files (*.sauve)", -1 );
761 QMap<QString, int>::const_iterator it = aFilterMap.begin();
762 QString aDefaultFilter = it.key();
763 for ( ; it != aFilterMap.end(); ++it ) {
764 filters.push_back( it.key() );
765 if (it.value() == defaultVersion) // explicit default for MED = current MED version
766 aDefaultFilter = it.key();
768 QStringList checkBoxes;
769 checkBoxes << QObject::tr("SMESH_AUTO_GROUPS") << QObject::tr("SMESH_AUTO_DIM");
771 SMESHGUI_FieldSelectorWdg* fieldSelWdg = new SMESHGUI_FieldSelectorWdg();
772 QList< QWidget* > wdgList;
773 if ( fieldSelWdg->GetAllFields( aMeshList, aFieldList ))
774 wdgList.append( fieldSelWdg );
776 QWidget* zTolWdg = new QWidget();
777 QCheckBox* zTolCheck = new QCheckBox( QObject::tr( "SMESH_ZTOLERANCE" ), zTolWdg );
778 SMESHGUI_SpinBox* zTolSpin = new SMESHGUI_SpinBox( zTolWdg );
779 QHBoxLayout* zTolLayout = new QHBoxLayout( zTolWdg );
780 zTolLayout->addWidget( zTolCheck );
781 zTolLayout->addWidget( zTolSpin );
782 zTolLayout->setMargin( 0 );
783 zTolSpin->RangeStepAndValidator( 0, 1e+100, 1., "length_precision" );
784 zTolSpin->setValue( zTol );
785 QObject::connect( zTolCheck, SIGNAL( toggled(bool)), zTolSpin, SLOT( setEnabled(bool)));
786 zTolCheck->setChecked( resMgr->booleanValue( "SMESH", "enable_ztolerance", false ));
787 zTolSpin ->setEnabled( zTolCheck->isChecked() );
788 wdgList.append( zTolWdg );
790 SalomeApp_CheckFileDlg* fd =
791 new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true, wdgList );
792 fd->setWindowTitle( aTitle );
793 fd->setNameFilters( filters );
794 fd->selectNameFilter( aDefaultFilter );
795 fd->SetChecked( toCreateGroups, 0 );
796 fd->SetChecked( toFindOutDim, 1 );
797 if ( !anInitialPath.isEmpty() )
798 fd->setDirectory( anInitialPath );
799 fd->selectFile(aMeshName);
802 QListView *lview = fd->findChild<QListView*>("listView");
804 lview->setMinimumHeight(200);
806 QTreeView *tview = fd->findChild<QTreeView*>("treeView");
808 tview->setMinimumHeight(200);
811 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
812 fd->setValidator( fv );
817 //MESSAGE("******* Loop on file dialog ***********");
820 aFilename = fd->selectedFile();
822 aFilename = QString::null;
825 aFormat = aFilterMap[fd->selectedNameFilter()];
826 //MESSAGE("selected version: " << aFormat << " file: " << aFilename.toUtf8().constData());
827 toOverwrite = fv->isOverwrite(aFilename);
828 //MESSAGE("toOverwrite:" << toOverwrite);
830 if ( !aFilename.isEmpty() ) {
832 // append is only possible if the existing file format is compatible
833 bool isVersionOk = SMESHGUI::GetSMESHGen()->CheckWriteCompatibility( aFilename.toUtf8().constData() );
834 MESSAGE("Append check, isVersionOk:" << isVersionOk);
835 if ( !isVersionOk ) {
836 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
837 QObject::tr("SMESH_WRN_WARNING"),
838 QObject::tr("SMESH_EXPORT_MED_VERSION_COLLISION").arg(aFilename),
839 QObject::tr("SMESH_BUT_YES"),
840 QObject::tr("SMESH_BUT_NO"), 0, 1);
844 //MESSAGE("incompatible MED file version for add, overwrite accepted");
850 //MESSAGE("incompatible MED file version for add, overwrite refused");
853 QStringList aMeshNamesCollisionList;
854 SMESH::string_array_var aMeshNames = SMESHGUI::GetSMESHGen()->GetMeshNames( aFilename.toUtf8().constData() );
855 for( int i = 0, n = aMeshNames->length(); i < n; i++ ) {
856 QString anExistingMeshName( aMeshNames[ i ] );
857 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
858 QString anExportMeshName = (*aMeshIter).second;
859 if( anExportMeshName == anExistingMeshName ) {
860 aMeshNamesCollisionList.append( anExportMeshName );
865 if( !aMeshNamesCollisionList.isEmpty() ) {
867 QString aMeshNamesCollisionString = aMeshNamesCollisionList.join( ", " );
868 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
869 QObject::tr("SMESH_WRN_WARNING"),
870 QObject::tr("SMESH_EXPORT_MED_MESH_NAMES_COLLISION").arg(aMeshNamesCollisionString),
871 QObject::tr("SMESH_BUT_YES"),
872 QObject::tr("SMESH_BUT_NO"),
873 QObject::tr("SMESH_BUT_CANCEL"), 0, 2);
874 MESSAGE("answer collision name " << aRet);
885 toCreateGroups = fd->IsChecked(0);
886 toFindOutDim = fd->IsChecked(1);
887 zTol = zTolCheck->isChecked() ? zTolSpin->value() : -1;
888 fieldSelWdg->GetSelectedFields();
889 if ( resMgr ) resMgr->setValue( "SMESH", "enable_ztolerance", zTolCheck->isChecked() );
891 if ( !fieldSelWdg->parent() )
893 if ( !zTolWdg->parent() )
904 if ( !aFilename.isEmpty() ) {
905 // Check whether the file already exists and delete it if yes
906 QFile aFile( aFilename );
907 if ( aFile.exists() && toOverwrite )
909 SUIT_OverrideCursor wc;
912 // Renumbering is not needed since SMDS redesign in V6.2.0 (Nov 2010)
913 // bool Renumber = false;
914 // // PAL 14172 : Check of we have to renumber or not from the preferences before export
916 // Renumber= resMgr->booleanValue("renumbering");
918 // SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
919 // aMeshEditor->RenumberNodes();
920 // aMeshEditor->RenumberElements();
921 // if ( SMESHGUI::automaticUpdate() )
922 // SMESH::UpdateView();
924 if ( isMED && isOkToWrite)
926 MESSAGE("OK to write MED file "<< aFilename.toUtf8().constData());
927 aMeshIter = aMeshList.begin();
928 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
930 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
931 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
932 const GEOM::ListOfFields& fields = aFieldList[ aMeshIndex ].first.in();
933 const QString& geoAssFields = aFieldList[ aMeshIndex ].second;
934 const bool hasFields = ( fields.length() || !geoAssFields.isEmpty() );
935 if ( !hasFields && aMeshOrGroup->_is_equivalent( aMeshItem ) && zTol < 0 )
936 aMeshItem->ExportMED( aFilename.toUtf8().data(), toCreateGroups, aFormat,
937 toOverwrite && aMeshIndex == 0, toFindOutDim );
939 aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toUtf8().data(),
940 toCreateGroups, aFormat,
941 toOverwrite && aMeshIndex == 0, toFindOutDim,
942 fields, geoAssFields.toLatin1().data(), zTol );
947 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ )
949 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
950 if( !aMeshItem->_is_nil() )
951 aMeshItem->ExportSAUV( aFilename.toUtf8().data(), toCreateGroups );
956 if ( aMeshOrGroup->_is_equivalent( aMesh ))
957 aMesh->ExportDAT( aFilename.toUtf8().data() );
959 aMesh->ExportPartToDAT( aMeshOrGroup, aFilename.toUtf8().data() );
963 if ( aMeshOrGroup->_is_equivalent( aMesh ))
964 aMesh->ExportUNV( aFilename.toUtf8().data() );
966 aMesh->ExportPartToUNV( aMeshOrGroup, aFilename.toUtf8().data() );
970 if ( aMeshOrGroup->_is_equivalent( aMesh ))
971 aMesh->ExportSTL( aFilename.toUtf8().data(), aIsASCII_STL );
973 aMesh->ExportPartToSTL( aMeshOrGroup, aFilename.toUtf8().data(), aIsASCII_STL );
977 aMeshIter = aMeshList.begin();
978 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
980 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
981 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
982 aMeshItem->ExportCGNS( aMeshOrGroup,
983 aFilename.toUtf8().data(),
984 toOverwrite && aMeshIndex == 0,
990 toCreateGroups = true;
991 aMesh->ExportGMF( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups );
994 catch (const SALOME::SALOME_Exception& S_ex){
996 SUIT_MessageBox::warning(SMESHGUI::desktop(),
997 QObject::tr("SMESH_WRN_WARNING"),
998 QObject::tr("SMESH_EXPORT_FAILED") + SalomeApp_Tools::ExceptionToString(S_ex));
1004 inline void InverseEntityMode(unsigned int& theOutputMode,
1005 unsigned int theMode)
1007 bool anIsNotPresent = ~theOutputMode & theMode;
1009 theOutputMode |= theMode;
1011 theOutputMode &= ~theMode;
1014 void SetDisplayEntity(int theCommandID)
1016 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1017 SALOME_ListIO selected;
1019 aSel->selectedObjects( selected );
1021 if ( selected.Extent() >= 1 ) {
1022 SUIT_OverrideCursor wc;
1023 SALOME_ListIteratorOfListIO It( selected );
1024 for( ; It.More(); It.Next()){
1025 Handle(SALOME_InteractiveObject) IObject = It.Value();
1026 if(IObject->hasEntry()){
1027 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1028 unsigned int aMode = anActor->GetEntityMode();
1029 switch(theCommandID){
1030 case SMESHOp::OpDE0DElements: InverseEntityMode(aMode,SMESH_Actor::e0DElements); break;
1031 case SMESHOp::OpDEEdges: InverseEntityMode(aMode,SMESH_Actor::eEdges); break;
1032 case SMESHOp::OpDEFaces: InverseEntityMode(aMode,SMESH_Actor::eFaces); break;
1033 case SMESHOp::OpDEVolumes: InverseEntityMode(aMode,SMESH_Actor::eVolumes); break;
1034 case SMESHOp::OpDEBalls: InverseEntityMode(aMode,SMESH_Actor::eBallElem); break;
1035 case SMESHOp::OpDEAllEntity: aMode = SMESH_Actor::eAllEntity; break;
1038 anActor->SetEntityMode(aMode);
1047 SalomeApp_Application* app =
1048 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1052 LightApp_SelectionMgr* aSel = app->selectionMgr();
1053 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1054 if ( !aSel || !appStudy )
1057 SALOME_ListIO selected;
1058 aSel->selectedObjects( selected );
1059 if ( selected.IsEmpty() )
1062 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1064 _PTR(Study) aStudy = appStudy->studyDS();
1065 _PTR(SObject) aMainSObject = aStudy->FindObjectID( anIObject->getEntry() );
1066 SMESH::SMESH_Mesh_var aMainObject = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1067 if ( aMainObject->_is_nil() )
1070 SUIT_OverrideCursor wc;
1072 aMainObject->SetAutoColor( true ); // mesh groups are re-colored here
1074 QList<SALOMEDS::Color> aReservedColors;
1076 SMESH::ListOfGroups aListOfGroups = *aMainObject->GetGroups();
1077 for ( int i = 0, n = aListOfGroups.length(); i < n; i++ )
1079 SMESH::SMESH_GroupBase_var aGroupObject = aListOfGroups[i];
1081 #ifdef SIMPLE_AUTOCOLOR // simplified algorithm for auto-colors
1082 SALOMEDS::Color aColor = SMESHGUI::getPredefinedUniqueColor();
1083 #else // old algorithm for auto-colors
1084 SALOMEDS::Color aColor = SMESHGUI::getUniqueColor( aReservedColors );
1085 aReservedColors.append( aColor );
1086 #endif // SIMPLE_AUTOCOLOR
1087 aGroupObject->SetColor( aColor );
1089 _PTR(SObject) aGroupSObject = SMESH::FindSObject(aGroupObject);
1090 if ( aGroupSObject ) {
1093 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry(aGroupSObject->GetID().c_str())) {
1094 switch ( aGroupObject->GetType ()) {
1096 anActor->SetNodeColor( aColor.R, aColor.G, aColor.B ); break;
1098 anActor->SetEdgeColor( aColor.R, aColor.G, aColor.B ); break;
1100 anActor->Set0DColor( aColor.R, aColor.G, aColor.B ); break;
1102 anActor->SetBallColor( aColor.R, aColor.G, aColor.B ); break;
1104 SMESH::GetColor("SMESH", "volume_color", c, delta, "255,0,170|-100");
1105 anActor->SetVolumeColor( aColor.R, aColor.G, aColor.B, delta ); break;
1108 SMESH::GetColor("SMESH", "fill_color", c, delta, "0,170,255|-100");
1109 anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B, delta );
1115 SMESH::RepaintCurrentView();
1118 void OverallMeshQuality()
1120 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1121 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1122 SALOME_ListIO selected;
1124 aSel->selectedObjects( selected );
1126 if ( selected.IsEmpty() ) return;
1127 SALOME_ListIteratorOfListIO It( selected );
1128 for ( ; It.More(); It.Next() ) {
1129 SMESHGUI_CtrlInfoDlg* ctrlDlg = new SMESHGUI_CtrlInfoDlg( SMESHGUI::desktop() );
1130 ctrlDlg->showInfo( It.Value() );
1135 QString functorToString( SMESH::Controls::FunctorPtr f )
1137 QString type = QObject::tr( "UNKNOWN_CONTROL" );
1138 if ( dynamic_cast< SMESH::Controls::Volume* >( f.get() ) )
1139 type = QObject::tr( "VOLUME_3D_ELEMENTS" );
1140 else if ( dynamic_cast< SMESH::Controls::MaxElementLength2D* >( f.get() ) )
1141 type = QObject::tr( "MAX_ELEMENT_LENGTH_2D" );
1142 else if ( dynamic_cast< SMESH::Controls::MaxElementLength3D* >( f.get() ) )
1143 type = QObject::tr( "MAX_ELEMENT_LENGTH_3D" );
1144 else if ( dynamic_cast< SMESH::Controls::MinimumAngle* >( f.get() ) )
1145 type = QObject::tr( "MINIMUMANGLE_ELEMENTS" );
1146 else if ( dynamic_cast< SMESH::Controls::AspectRatio* >( f.get() ) )
1147 type = QObject::tr( "ASPECTRATIO_ELEMENTS" );
1148 else if ( dynamic_cast< SMESH::Controls::AspectRatio3D* >( f.get() ) )
1149 type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" );
1150 else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) )
1151 type = QObject::tr( "WARP_ELEMENTS" );
1152 else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) )
1153 type = QObject::tr( "TAPER_ELEMENTS" );
1154 else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) )
1155 type = QObject::tr( "SKEW_ELEMENTS" );
1156 else if ( dynamic_cast< SMESH::Controls::Area* >( f.get() ) )
1157 type = QObject::tr( "AREA_ELEMENTS" );
1158 else if ( dynamic_cast< SMESH::Controls::Length* >( f.get() ) )
1159 type = QObject::tr( "LENGTH_EDGES" );
1160 else if ( dynamic_cast< SMESH::Controls::Length2D* >( f.get() ) )
1161 type = QObject::tr( "LENGTH2D_EDGES" );
1162 else if ( dynamic_cast< SMESH::Controls::Deflection2D* >( f.get() ) )
1163 type = QObject::tr( "DEFLECTION2D_FACES" );
1164 else if ( dynamic_cast< SMESH::Controls::MultiConnection* >( f.get() ) )
1165 type = QObject::tr( "MULTI_BORDERS" );
1166 else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) )
1167 type = QObject::tr( "MULTI2D_BORDERS" );
1168 else if ( dynamic_cast< SMESH::Controls::FreeNodes* >( f.get() ) )
1169 type = QObject::tr( "FREE_NODES" );
1170 else if ( dynamic_cast< SMESH::Controls::FreeEdges* >( f.get() ) )
1171 type = QObject::tr( "FREE_EDGES" );
1172 else if ( dynamic_cast< SMESH::Controls::FreeBorders* >( f.get() ) )
1173 type = QObject::tr( "FREE_BORDERS" );
1174 else if ( dynamic_cast< SMESH::Controls::FreeFaces* >( f.get() ) )
1175 type = QObject::tr( "FREE_FACES" );
1176 else if ( dynamic_cast< SMESH::Controls::BareBorderVolume* >( f.get() ) )
1177 type = QObject::tr( "BARE_BORDER_VOLUME" );
1178 else if ( dynamic_cast< SMESH::Controls::BareBorderFace* >( f.get() ) )
1179 type = QObject::tr( "BARE_BORDER_FACE" );
1180 else if ( dynamic_cast< SMESH::Controls::OverConstrainedVolume* >( f.get() ) )
1181 type = QObject::tr( "OVER_CONSTRAINED_VOLUME" );
1182 else if ( dynamic_cast< SMESH::Controls::OverConstrainedFace* >( f.get() ) )
1183 type = QObject::tr( "OVER_CONSTRAINED_FACE" );
1184 else if ( dynamic_cast< SMESH::Controls::CoincidentNodes* >( f.get() ) )
1185 type = QObject::tr( "EQUAL_NODE" );
1186 else if ( dynamic_cast< SMESH::Controls::CoincidentElements1D* >( f.get() ) )
1187 type = QObject::tr( "EQUAL_EDGE" );
1188 else if ( dynamic_cast< SMESH::Controls::CoincidentElements2D* >( f.get() ) )
1189 type = QObject::tr( "EQUAL_FACE" );
1190 else if ( dynamic_cast< SMESH::Controls::CoincidentElements3D* >( f.get() ) )
1191 type = QObject::tr( "EQUAL_VOLUME" );
1192 else if ( dynamic_cast< SMESH::Controls::NodeConnectivityNumber* >( f.get() ) )
1193 type = QObject::tr( "NODE_CONNECTIVITY_NB" );
1197 void SaveDistribution()
1199 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1200 SALOME_ListIO selected;
1202 aSel->selectedObjects( selected );
1204 if ( selected.Extent() == 1 ) {
1205 Handle(SALOME_InteractiveObject) anIO = selected.First();
1206 if ( anIO->hasEntry() ) {
1207 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1209 anActor->GetScalarBarActor() &&
1210 anActor->GetControlMode() != SMESH_Actor::eNone )
1212 SMESH_ScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor();
1213 SMESH::Controls::FunctorPtr aFunctor = anActor->GetFunctor();
1214 if ( aScalarBarActor && aFunctor ) {
1215 SMESH::Controls::NumericalFunctor* aNumFun =
1216 dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
1218 std::vector<int> elements;
1219 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
1220 if ( mesh->_is_nil() ) {
1221 SMESH::SMESH_IDSource_var idSource =
1222 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
1223 if ( !idSource->_is_nil() )
1225 SMESH::long_array_var ids = idSource->GetIDs();
1226 elements.resize( ids->length() );
1227 for ( unsigned i = 0; i < elements.size(); ++i )
1228 elements[i] = ids[i];
1231 int nbIntervals = aScalarBarActor->GetMaximumNumberOfColors();
1232 vtkLookupTable* lookupTable =
1233 static_cast<vtkLookupTable*>(aScalarBarActor->GetLookupTable());
1234 double * minmax = lookupTable->GetRange();
1235 bool isLogarithmic = lookupTable->GetScale() == VTK_SCALE_LOG10;
1236 std::vector<int> nbEvents;
1237 std::vector<double> funValues;
1238 aNumFun->GetHistogram( nbIntervals, nbEvents, funValues,
1239 elements, minmax, isLogarithmic );
1240 QString anInitialPath = "";
1241 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
1242 anInitialPath = QDir::currentPath();
1243 QString aMeshName = anIO->getName();
1245 filter.append( QObject::tr( "TEXT_FILES_FILTER" ) + " (*.txt)" );
1246 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
1247 QString aFilename = anInitialPath + "/" + aMeshName + "_" +
1248 functorToString( aFunctor ).toLower().simplified().replace( QRegExp( " |-" ), "_" ) + ".txt";
1249 aFilename = SUIT_FileDlg::getFileName( SMESHGUI::desktop(),
1252 QObject::tr( "SMESH_SAVE_DISTRIBUTION" ),
1254 if ( !aFilename.isEmpty() ) {
1255 QFile f( aFilename );
1256 if ( f.open( QFile::WriteOnly | QFile::Truncate ) ) {
1257 QTextStream out( &f );
1258 out << "# Mesh: " << aMeshName << endl;
1259 out << "# Control: " << functorToString( aFunctor ) << endl;
1261 out.setFieldWidth( 10 );
1262 for ( int i = 0; i < (int)qMin( nbEvents.size(), funValues.size()-1 ); i++ )
1263 out << funValues[i] << "\t" << funValues[i+1] << "\t" << nbEvents[i] << endl;
1274 void ShowElement( int theCommandID )
1276 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1277 SALOME_ListIO selected;
1279 aSel->selectedObjects( selected );
1281 if ( selected.Extent() == 1 ) {
1282 Handle(SALOME_InteractiveObject) anIO = selected.First();
1283 if ( anIO->hasEntry() ) {
1284 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1286 anActor->GetScalarBarActor() &&
1287 anActor->GetControlMode() != SMESH_Actor::eNone )
1289 SMESH_ScalarBarActor *aScalarBarActor = anActor->GetScalarBarActor();
1290 if ( theCommandID == SMESHOp::OpShowDistribution ) {
1291 aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility());
1293 else if ( theCommandID == SMESHOp::OpShowScalarBar ) {
1294 aScalarBarActor->SetVisibility( !aScalarBarActor->GetVisibility());
1301 #ifndef DISABLE_PLOT2DVIEWER
1302 void PlotDistribution()
1304 SalomeApp_Application* app =
1305 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1309 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1310 SALOME_ListIO selected;
1312 aSel->selectedObjects( selected );
1314 if ( selected.Extent() == 1 ) {
1315 Handle(SALOME_InteractiveObject) anIO = selected.First();
1316 if ( anIO->hasEntry() ) {
1317 //Find Actor by entry before getting Plot2d viewer,
1318 //because after call getViewManager( Plot2d_Viewer::Type(), true ) active window is Plot2d Viewer
1319 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1321 SUIT_ViewManager* aViewManager =
1322 app->getViewManager( Plot2d_Viewer::Type(), true ); // create if necessary
1326 SPlot2d_Viewer* aView = dynamic_cast<SPlot2d_Viewer*>(aViewManager->getViewModel());
1330 Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
1334 if ( anActor && anActor->GetControlMode() != SMESH_Actor::eNone )
1336 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1337 QString functorName = functorToString( anActor->GetFunctor());
1338 QString aHistogramName("%1 : %2");
1339 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1340 aHistogram->setName(aHistogramName);
1341 aHistogram->setHorTitle(functorName);
1342 aHistogram->setVerTitle(QObject::tr("DISTRIBUTION_NB_ENT"));
1343 aPlot->displayObject(aHistogram, true);
1348 #endif //DISABLE_PLOT2DVIEWER
1350 void DisableAutoColor()
1352 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1353 SALOME_ListIO selected;
1355 aSel->selectedObjects( selected );
1357 if ( selected.Extent() ) {
1358 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1359 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1360 if ( !aMesh->_is_nil() ) {
1361 aMesh->SetAutoColor( false );
1368 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1369 SALOME_ListIO selected;
1371 aSel->selectedObjects( selected );
1372 if ( selected.Extent() )
1374 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1375 _PTR(Study) aStudy = SMESH::getStudy();
1376 _PTR(SObject) aSObj = aStudy->FindObjectID(anIObject->getEntry());
1378 if ( aStudy->GetUseCaseBuilder()->SortChildren( aSObj, true/*AscendingOrder*/ ) ) {
1379 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1386 // Break link with Shaper model
1387 void breakShaperLink()
1389 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1390 SALOME_ListIO selected;
1392 aSel->selectedObjects(selected);
1393 if (selected.Extent()) {
1394 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1395 _PTR(Study) aStudy = SMESH::getStudy();
1396 std::string aEntry = anIObject->getEntry();
1397 _PTR(SObject) aSObj = aStudy->FindObjectID(aEntry);
1399 std::string aName = aSObj->GetName();
1400 QMessageBox::StandardButton aRes = SUIT_MessageBox::warning(SMESHGUI::desktop(),
1401 QObject::tr("SMESH_WRN_WARNING"),
1402 QObject::tr("MSG_BREAK_SHAPER_LINK").arg(aName.c_str()),
1403 SUIT_MessageBox::Yes | SUIT_MessageBox::No, SUIT_MessageBox::No);
1404 if (aRes == SUIT_MessageBox::Yes) {
1405 SUIT_DataOwnerPtrList aList;
1406 aSel->selected(aList, "ObjectBrowser", true);
1407 SUIT_DataOwner* aOwn = aList.first();
1408 LightApp_DataOwner* sowner = dynamic_cast<LightApp_DataOwner*>(aOwn);
1409 QString aREntry = sowner->entry();
1411 static GEOM::GEOM_Gen_var geomGen;
1412 if (CORBA::is_nil(geomGen)) {
1413 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>
1414 (SUIT_Session::session()->activeApplication());
1416 SALOME_LifeCycleCORBA* ls = new SALOME_LifeCycleCORBA(app->namingService());
1417 Engines::EngineComponent_var comp =
1418 ls->FindOrLoad_Component("FactoryServer", "SHAPERSTUDY");
1419 geomGen = GEOM::GEOM_Gen::_narrow(comp);
1422 if (!CORBA::is_nil(geomGen))
1424 geomGen->BreakLink(aREntry.toStdString().c_str());
1425 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1427 // remove actors whose objects are removed by BreakLink()
1428 QList<SUIT_ViewWindow*> wndList = SMESHGUI::desktop()->windows();
1429 SUIT_ViewWindow* wnd;
1430 foreach(wnd, wndList)
1431 SMESH::UpdateActorsAfterUpdateStudy(wnd);
1439 //================================================================================
1441 * \brief Return true if a mesh icon == ICON_SMESH_TREE_GEOM_MODIF
1442 * which means that the mesh can't be modified. It should be either re-computed
1443 * or breakShaperLink()'ed. Warn the user about it.
1445 //================================================================================
1447 bool warnOnGeomModif()
1449 SALOME_ListIO selected;
1450 if ( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
1451 aSel->selectedObjects(selected,"",/*convertReferences=*/false);
1453 SALOME_ListIteratorOfListIO It( selected );
1454 for ( ; It.More(); It.Next() )
1456 Handle(SALOME_InteractiveObject) io = It.Value();
1457 if ( !io->hasEntry() ) continue;
1458 _PTR(SObject) so = SMESH::getStudy()->FindObjectID( io->getEntry() );
1459 SMESH::SMESH_Mesh_var mesh;
1460 while ( mesh->_is_nil() && so && so->GetID() != "0:" )
1462 CORBA::Object_var obj = SMESH::SObjectToObject( so );
1463 SMESH::SMESH_IDSource_var isrc = SMESH::SMESH_IDSource::_narrow( obj );
1464 if ( isrc->_is_nil() )
1465 so = so->GetFather();
1467 mesh = isrc->GetMesh();
1469 if ( mesh->_is_nil() ) continue;
1470 so = SMESH::FindSObject( mesh );
1471 if ( !so ) continue;
1472 _PTR(GenericAttribute) attr;
1473 so->FindAttribute( attr, "AttributePixMap" );
1474 _PTR(AttributePixMap) pixmap = attr;
1475 if ( !pixmap ) continue;
1477 if ( pixmap->GetPixMap() == "ICON_SMESH_TREE_GEOM_MODIF" )
1479 SUIT_MessageBox::warning(SMESHGUI::desktop(),
1480 QObject::tr("SMESH_WRN_WARNING"),
1481 QObject::tr("MSG_WARN_ON_GEOM_MODIF"));
1488 void SetDisplayMode(int theCommandID, VTK::MarkerMap& theMarkerMap)
1490 SALOME_ListIO selected;
1491 SalomeApp_Application* app =
1492 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1496 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1497 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1498 if ( !aSel || !appStudy )
1501 if ( theCommandID == SMESHOp::OpClipping ) { // Clipping dialog can be activated without selection
1502 if ( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
1503 aModule->EmitSignalDeactivateDialog();
1504 if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
1505 (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
1510 aSel->selectedObjects( selected );
1512 if ( selected.Extent() >= 1 )
1514 switch ( theCommandID ) {
1515 case SMESHOp::OpTransparency:
1517 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1518 (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
1521 case SMESHOp::OpProperties:
1524 QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
1525 QColor orientationColor, outlineColor, volumeColor;
1526 int deltaF = 0, deltaV = 0;
1529 double ballScale = 1.0;
1531 int outlineWidth = 1;
1532 double shrinkCoef = 0.0;
1533 double orientationScale = 0.0;
1534 bool orientation3d = false;
1535 VTK::MarkerType markerType = VTK::MT_NONE;
1536 VTK::MarkerScale markerScale = VTK::MS_NONE;
1538 bool hasNodes = false;
1539 int presentEntities = 0;
1540 bool firstTime = true;
1542 SALOME_ListIteratorOfListIO It( selected );
1543 for ( ; It.More(); It.Next() ) {
1544 Handle(SALOME_InteractiveObject) IObject = It.Value();
1545 if ( !IObject->hasEntry() ) continue;
1546 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1547 if ( !anActor || !anActor->GetObject() ) continue;
1550 // nodes: color, marker
1551 anActor->GetNodeColor( color[0], color[1], color[2] );
1552 nodeColor.setRgbF( color[0], color[1], color[2] );
1553 markerType = anActor->GetMarkerType();
1554 markerScale = anActor->GetMarkerScale();
1555 markerId = anActor->GetMarkerTexture();
1556 // edges: color, width
1557 anActor->GetEdgeColor( color[0], color[1], color[2] );
1558 edgeColor.setRgbF( color[0], color[1], color[2] );
1559 edgeWidth = qMax( (int)anActor->GetLineWidth(), 1 ); // minimum allowed width is 1
1560 // faces: front color, back color (delta)
1561 anActor->GetSufaceColor( color[0], color[1], color[2], deltaF );
1562 faceColor.setRgbF( color[0], color[1], color[2] );
1563 // faces: front color, back color (delta)
1564 anActor->GetVolumeColor( color[0], color[1], color[2], deltaV );
1565 volumeColor.setRgbF( color[0], color[1], color[2] );
1566 // 0d elements: color, size
1567 anActor->Get0DColor( color[0], color[1], color[2] );
1568 elem0dColor.setRgbF( color[0], color[1], color[2] );
1569 elem0dSize = qMax( (int)anActor->Get0DSize(), 1 ); // minimum allowed size is 1
1570 // balls: color, size
1571 anActor->GetBallColor( color[0], color[1], color[2] );
1572 ballColor.setRgbF( color[0], color[1], color[2] );
1573 //ballSize = qMax( (int)anActor->GetBallSize(), 1 ); // minimum allowed size is 1
1574 ballScale = qMax( (double)anActor->GetBallScale(), 1e-2 ); // minimum allowed scale is 1e-2
1576 anActor->GetOutlineColor( color[0], color[1], color[2] );
1577 outlineColor.setRgbF( color[0], color[1], color[2] );
1578 outlineWidth = qMax( (int)anActor->GetOutlineWidth(), 1 ); // minimum allowed width is 1
1579 // orientation vectors: color, scale, 3d flag
1580 anActor->GetFacesOrientationColor( color[0], color[1], color[2] );
1581 orientationColor.setRgbF( color[0], color[1], color[2] );
1582 orientationScale = anActor->GetFacesOrientationScale();
1583 orientation3d = anActor->GetFacesOrientation3DVectors();
1585 shrinkCoef = anActor->GetShrinkFactor();
1588 firstTime = false; // we only take properties from first object (for performance reasons)
1591 hasNodes = anActor->GetObject()->GetNbEntities( SMDSAbs_Node );
1592 if ( !(presentEntities & SMESH_Actor::eEdges) && anActor->GetObject()->GetNbEntities( SMDSAbs_Edge ) )
1593 presentEntities = presentEntities | SMESH_Actor::eEdges;
1594 if ( !(presentEntities & SMESH_Actor::eFaces) && anActor->GetObject()->GetNbEntities( SMDSAbs_Face ) )
1595 presentEntities = presentEntities | SMESH_Actor::eFaces;
1596 if ( !(presentEntities & SMESH_Actor::eVolumes) && anActor->GetObject()->GetNbEntities( SMDSAbs_Volume ) )
1597 presentEntities = presentEntities | SMESH_Actor::eVolumes;
1598 if ( !(presentEntities & SMESH_Actor::e0DElements) && anActor->GetObject()->GetNbEntities( SMDSAbs_0DElement ) )
1599 presentEntities = presentEntities | SMESH_Actor::e0DElements;
1600 if ( !(presentEntities & SMESH_Actor::eBallElem) && anActor->GetObject()->GetNbEntities( SMDSAbs_Ball ) )
1601 presentEntities = presentEntities | SMESH_Actor::eBallElem;
1603 // as we know that all types of elements are present, we can exit the loop
1604 if ( presentEntities == SMESH_Actor::eAllEntity )
1608 SMESHGUI_PropertiesDlg dlg( theMarkerMap, SMESHGUI::desktop() );
1609 // nodes: color, marker
1610 dlg.setNodeColor( nodeColor );
1611 if( markerType != VTK::MT_USER )
1612 dlg.setNodeMarker( markerType, markerScale );
1614 dlg.setNodeCustomMarker( markerId );
1615 // edges: color, line width
1616 dlg.setEdgeColor( edgeColor );
1617 dlg.setEdgeWidth( edgeWidth );
1618 // faces: front color, back color
1619 dlg.setFaceColor( faceColor, deltaF );
1620 // volumes: normal color, reversed color
1621 dlg.setVolumeColor( volumeColor, deltaV );
1622 // outlines: color, line width
1623 dlg.setOutlineColor( outlineColor );
1624 dlg.setOutlineWidth( outlineWidth );
1625 // 0d elements: color, size
1626 dlg.setElem0dColor( elem0dColor );
1627 dlg.setElem0dSize( elem0dSize );
1628 // balls: color, size
1629 dlg.setBallColor( ballColor );
1630 //dlg.setBallSize( ballSize );
1631 dlg.setBallScale( ballScale );
1632 // orientation: color, scale, 3d flag
1633 dlg.setOrientationColor( orientationColor );
1634 dlg.setOrientationSize( int( orientationScale * 100. ) );
1635 dlg.setOrientation3d( orientation3d );
1636 // shrink: scale factor
1637 dlg.setShrinkCoef( int( shrinkCoef * 100. ) );
1638 // hide unused controls
1639 dlg.showControls( presentEntities, hasNodes );
1642 nodeColor = dlg.nodeColor();
1643 markerType = dlg.nodeMarkerType();
1644 markerScale = dlg.nodeMarkerScale();
1645 markerId = dlg.nodeMarkerId();
1646 edgeColor = dlg.edgeColor();
1647 edgeWidth = dlg.edgeWidth();
1648 faceColor = dlg.faceColor();
1649 deltaF = dlg.faceColorDelta();
1650 volumeColor = dlg.volumeColor();
1651 deltaV = dlg.volumeColorDelta();
1652 outlineColor = dlg.outlineColor();
1653 outlineWidth = dlg.outlineWidth();
1654 elem0dColor = dlg.elem0dColor();
1655 elem0dSize = dlg.elem0dSize();
1656 ballColor = dlg.ballColor();
1657 // ballSize = dlg.ballSize();
1658 ballScale = dlg.ballScale();
1659 orientationColor = dlg.orientationColor();
1660 orientationScale = dlg.orientationSize() / 100.;
1661 orientation3d = dlg.orientation3d();
1662 shrinkCoef = dlg.shrinkCoef() / 100.;
1664 // store point markers that might be changed by the user
1665 theMarkerMap = dlg.customMarkers();
1667 // set properties from dialog box to the presentations
1668 SALOME_ListIteratorOfListIO It( selected );
1669 for ( ; It.More(); It.Next() ) {
1670 Handle(SALOME_InteractiveObject) IObject = It.Value();
1671 if ( !IObject->hasEntry() ) continue;
1672 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1673 if ( !anActor ) continue;
1675 // nodes: color, marker
1676 anActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
1677 if ( markerType != VTK::MT_USER ) {
1678 anActor->SetMarkerStd( markerType, markerScale );
1681 VTK::MarkerMap::const_iterator iter = theMarkerMap.find( markerId );
1682 if ( iter != theMarkerMap.end() )
1683 anActor->SetMarkerTexture( markerId, iter->second.second );
1685 // volumes: normal color, reversed color (delta)
1686 anActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
1687 // faces: front color, back color (delta)
1688 anActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
1689 // edges: color, width
1690 anActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
1691 anActor->SetLineWidth( edgeWidth );
1693 anActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
1694 anActor->SetOutlineWidth( outlineWidth );
1695 // 0D elements: color, size
1696 anActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
1697 anActor->Set0DSize( elem0dSize );
1698 // balls: color, size
1699 anActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
1700 // anActor->SetBallSize( ballSize );
1701 anActor->SetBallScale( ballScale );
1702 // orientation: color, scale, 3d flag
1703 anActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
1704 anActor->SetFacesOrientationScale( orientationScale );
1705 anActor->SetFacesOrientation3DVectors( orientation3d );
1707 anActor->SetShrinkFactor( shrinkCoef );
1709 // for groups, set also proper color
1710 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1711 if ( !aGroupObject->_is_nil() ) {
1712 SMESH::ElementType anElementType = aGroupObject->GetType();
1714 switch( anElementType ) {
1716 aColor = nodeColor; break;
1718 aColor = edgeColor; break;
1720 aColor = faceColor; break;
1722 aColor = volumeColor; break;
1724 aColor = elem0dColor; break;
1726 aColor = ballColor; break;
1730 if ( aColor.isValid() ) {
1731 SALOMEDS::Color aGroupColor;
1732 aGroupColor.R = aColor.redF();
1733 aGroupColor.G = aColor.greenF();
1734 aGroupColor.B = aColor.blueF();
1735 aGroupObject->SetColor( aGroupColor );
1737 } // if ( !aGroupObject->_is_nil() )
1738 } // for ( ; It.More(); It.Next() )
1739 SMESH::RepaintCurrentView();
1740 } // if ( dlg.exec() )
1742 } // case SMESHOp::OpProperties:
1743 } // switch(theCommandID)
1744 SUIT_OverrideCursor wc;
1745 SALOME_ListIteratorOfListIO It( selected );
1746 for( ; It.More(); It.Next()){
1747 Handle(SALOME_InteractiveObject) IObject = It.Value();
1748 if(IObject->hasEntry()){
1749 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1750 switch(theCommandID){
1751 case SMESHOp::OpDMWireframe:
1752 anActor->SetRepresentation(SMESH_Actor::eEdge);
1754 case SMESHOp::OpDMShading:
1755 anActor->SetRepresentation(SMESH_Actor::eSurface);
1757 case SMESHOp::OpDMShrink:
1758 if(anActor->IsShrunk())
1759 anActor->UnShrink();
1761 anActor->SetShrink();
1763 case SMESHOp::OpDMNodes:
1764 anActor->SetRepresentation(SMESH_Actor::ePoint);
1766 case SMESHOp::OpRepresentationLines:
1767 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1768 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1770 case SMESHOp::OpRepresentationArcs:
1771 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1772 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1778 SMESH::RepaintCurrentView();
1782 int ActionToControl( int theID, bool theReversed )
1784 NCollection_DoubleMap<int,int> ActionControl;
1785 ActionControl.Bind( 0, SMESH_Actor::eNone );
1786 ActionControl.Bind( SMESHOp::OpFreeNode, SMESH_Actor::eFreeNodes );
1787 ActionControl.Bind( SMESHOp::OpEqualNode, SMESH_Actor::eCoincidentNodes );
1788 ActionControl.Bind( SMESHOp::OpNodeConnectivityNb, SMESH_Actor::eNodeConnectivityNb );
1789 ActionControl.Bind( SMESHOp::OpFreeEdge, SMESH_Actor::eFreeEdges );
1790 ActionControl.Bind( SMESHOp::OpFreeBorder, SMESH_Actor::eFreeBorders );
1791 ActionControl.Bind( SMESHOp::OpLength, SMESH_Actor::eLength );
1792 ActionControl.Bind( SMESHOp::OpConnection, SMESH_Actor::eMultiConnection );
1793 ActionControl.Bind( SMESHOp::OpEqualEdge, SMESH_Actor::eCoincidentElems1D );
1794 ActionControl.Bind( SMESHOp::OpFreeFace, SMESH_Actor::eFreeFaces );
1795 ActionControl.Bind( SMESHOp::OpBareBorderFace, SMESH_Actor::eBareBorderFace );
1796 ActionControl.Bind( SMESHOp::OpOverConstrainedFace, SMESH_Actor::eOverConstrainedFace );
1797 ActionControl.Bind( SMESHOp::OpLength2D, SMESH_Actor::eLength2D );
1798 ActionControl.Bind( SMESHOp::OpDeflection2D, SMESH_Actor::eDeflection2D );
1799 ActionControl.Bind( SMESHOp::OpConnection2D, SMESH_Actor::eMultiConnection2D );
1800 ActionControl.Bind( SMESHOp::OpArea, SMESH_Actor::eArea );
1801 ActionControl.Bind( SMESHOp::OpTaper, SMESH_Actor::eTaper );
1802 ActionControl.Bind( SMESHOp::OpAspectRatio, SMESH_Actor::eAspectRatio );
1803 ActionControl.Bind( SMESHOp::OpMinimumAngle, SMESH_Actor::eMinimumAngle );
1804 ActionControl.Bind( SMESHOp::OpWarpingAngle, SMESH_Actor::eWarping );
1805 ActionControl.Bind( SMESHOp::OpSkew, SMESH_Actor::eSkew );
1806 ActionControl.Bind( SMESHOp::OpMaxElementLength2D, SMESH_Actor::eMaxElementLength2D );
1807 ActionControl.Bind( SMESHOp::OpEqualFace, SMESH_Actor::eCoincidentElems2D );
1808 ActionControl.Bind( SMESHOp::OpAspectRatio3D, SMESH_Actor::eAspectRatio3D );
1809 ActionControl.Bind( SMESHOp::OpVolume, SMESH_Actor::eVolume3D );
1810 ActionControl.Bind( SMESHOp::OpMaxElementLength3D, SMESH_Actor::eMaxElementLength3D );
1811 ActionControl.Bind( SMESHOp::OpBareBorderVolume, SMESH_Actor::eBareBorderVolume );
1812 ActionControl.Bind( SMESHOp::OpOverConstrainedVolume, SMESH_Actor::eOverConstrainedVolume );
1813 ActionControl.Bind( SMESHOp::OpEqualVolume, SMESH_Actor::eCoincidentElems3D );
1816 return ActionControl.IsBound2( theID ) ? ActionControl.Find2( theID ) : 0;
1817 return ActionControl.IsBound1( theID ) ? ActionControl.Find1( theID ) : 0;
1820 void Control( int theCommandID )
1822 SMESH_Actor::eControl aControl = SMESH_Actor::eControl( ActionToControl( theCommandID ));
1823 _PTR(Study) aStudy = SMESH::getStudy();
1825 SALOME_ListIO selected;
1826 if ( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
1827 aSel->selectedObjects( selected );
1829 if ( !selected.IsEmpty() ) {
1830 SALOME_ListIteratorOfListIO It(selected);
1831 for ( ; It.More(); It.Next())
1833 Handle(SALOME_InteractiveObject) anIO = It.Value();
1834 if ( !anIO.IsNull() ) {
1835 _PTR(SObject) SO = aStudy->FindObjectID( It.Value()->getEntry() );
1837 CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
1838 SMESH::SMESH_IDSource_var anIDSrc = SMESH::SMESH_IDSource::_narrow( aObject );
1839 if ( !anIDSrc->_is_nil() ) {
1840 SMESH_Actor *anActor = SMESH::FindActorByEntry( anIO->getEntry());
1841 if (( !anActor && selected.Extent() == 1 ) &&
1842 ( anActor = SMESH::CreateActor( anIO->getEntry() )))
1844 anActor->SetControlMode( aControl );
1845 SMESH::DisplayActor( SMESH::GetCurrentVtkView(), anActor );
1846 SMESH::UpdateView ( SMESH::eDisplay, anIO->getEntry() );
1850 if ( anActor->GetControlMode() != aControl )
1851 anActor->SetControlMode( aControl );
1852 QString functorName = functorToString( anActor->GetFunctor() );
1853 int anEntitiesCount = anActor->GetNumberControlEntities();
1854 if (anEntitiesCount >= 0)
1855 functorName = functorName + ": " + QString::number(anEntitiesCount);
1856 anActor->GetScalarBarActor()->SetTitle( functorName.toUtf8().constData() );
1857 SMESH::RepaintCurrentView();
1858 #ifndef DISABLE_PLOT2DVIEWER
1859 if ( anActor->GetPlot2Histogram() ) {
1860 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1861 QString aHistogramName("%1 : %2");
1862 aHistogramName = aHistogramName.arg( anIO->getName() ).arg( functorName );
1863 aHistogram->setName( aHistogramName );
1864 aHistogram->setHorTitle( functorName );
1865 SMESH::ProcessIn2DViewers( anActor );
1877 bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1878 SMESH::MeshObjectType theType,
1879 const QString theInTypeName,
1880 QString & theOutTypeName)
1882 SMESH_TypeFilter aTypeFilter( theType );
1884 if ( !theIO.IsNull() )
1886 entry = theIO->getEntry();
1887 LightApp_DataOwner owner( entry );
1888 if ( aTypeFilter.isOk( &owner )) {
1889 theOutTypeName = theInTypeName;
1897 QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1899 _PTR(Study) aStudy = SMESH::getStudy();
1900 _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1902 _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1903 CORBA::String_var anID = aSComp->GetID().c_str();
1904 if ( !strcmp(anID.in(),theIO->getEntry()) )
1910 CheckOIType ( theIO, SMESH::HYPOTHESIS, "Hypothesis", aTypeName ) ||
1911 CheckOIType ( theIO, SMESH::ALGORITHM, "Algorithm", aTypeName ) ||
1912 CheckOIType ( theIO, SMESH::MESH, "Mesh", aTypeName ) ||
1913 CheckOIType ( theIO, SMESH::SUBMESH, "SubMesh", aTypeName ) ||
1914 CheckOIType ( theIO, SMESH::GROUP, "Group", aTypeName )
1922 // QString CheckHomogeneousSelection()
1924 // LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1925 // SALOME_ListIO selected;
1927 // aSel->selectedObjects( selected );
1929 // QString RefType = CheckTypeObject(selected.First());
1930 // SALOME_ListIteratorOfListIO It(selected);
1931 // for ( ; It.More(); It.Next())
1933 // Handle(SALOME_InteractiveObject) IObject = It.Value();
1934 // QString Type = CheckTypeObject(IObject);
1935 // if ( Type.compare(RefType) != 0 )
1936 // return "Heterogeneous Selection";
1942 uint randomize( uint size )
1944 static bool initialized = false;
1945 if ( !initialized ) {
1946 qsrand( QDateTime::currentDateTime().toTime_t() );
1950 v = uint( (double)( v ) / RAND_MAX * size );
1951 v = qMax( uint(0), qMin ( v, size-1 ) );
1957 void SMESHGUI::OnEditDelete()
1959 // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1960 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1961 SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1963 _PTR(Study) aStudy = SMESH::getStudy();
1964 _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1965 _PTR(GenericAttribute) anAttr;
1966 _PTR(AttributeIOR) anIOR;
1968 const int objectCountLimit = 30; // PAL23599
1969 int objectCount = 0;
1971 QString aParentComponent = QString::null;
1973 for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1975 Handle(SALOME_InteractiveObject) anIO = anIt.Value();
1976 if ( anIO.IsNull() ) continue;
1978 QString father = "unknown", name;
1980 _PTR(SObject) aSO = aStudy->FindObjectID( anIO->getEntry() );
1982 father = QString::fromStdString( aSO->GetFatherComponent()->ComponentDataType() );
1983 // check if object is reference
1984 _PTR(SObject) aRefSObj;
1985 if ( aSO->ReferencedObject( aRefSObj ) ) {
1986 name = QString::fromStdString ( aRefSObj->GetName() );
1987 father = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1990 name = anIO->getName();
1993 if ( objectCount < objectCountLimit ) { // avoid occupying the whole screen
1994 aNameList.append("\n - ");
1995 aNameList.append( name );
1998 if( aParentComponent.isNull() )
1999 aParentComponent = father;
2000 else if( !aParentComponent.isEmpty() && aParentComponent!=father )
2001 aParentComponent = "";
2003 if ( objectCount >= objectCountLimit )
2004 aNameList.append("\n - ...");
2006 if ( objectCount == 0 )
2007 return; // No Valid Objects Selected
2009 if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
2010 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2011 QObject::tr("ERR_ERROR"),
2012 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
2015 // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
2016 if (SUIT_MessageBox::warning
2017 (SMESHGUI::desktop(),
2018 QObject::tr("SMESH_WRN_WARNING"),
2019 QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
2020 SUIT_MessageBox::Yes | SUIT_MessageBox::No,
2021 SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
2024 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2026 // Put one level of sub-objects of the selected SO's into a list
2027 // in order to get objects inside folders like "Assigned Algorithms"
2028 std::list< _PTR(SObject) > listSO;
2029 SALOME_ListIteratorOfListIO It(selected);
2030 for( ; It.More(); It.Next()) // loop on selected IO's
2032 Handle(SALOME_InteractiveObject) IObject = It.Value();
2033 if(IObject->hasEntry()) {
2034 _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
2036 // disable removal of "SMESH" component object
2037 if(aSO->FindAttribute(anAttr, "AttributeIOR")){
2039 if ( engineIOR() == anIOR->Value().c_str() )
2042 //Check the referenced object
2043 _PTR(SObject) aRefSObject;
2044 if ( aSO && aSO->ReferencedObject( aRefSObject ) )
2045 aSO = aRefSObject; // Delete main Object instead of reference
2047 listSO.push_back( aSO );
2049 _PTR(ChildIterator) it = aStudy->NewChildIterator( aSO );
2050 for (it->InitEx(false); it->More(); it->Next())
2051 listSO.push_back( it->Value() );
2054 // Check if none of objects to delete is referred from outside
2055 std::list< _PTR(SObject) >::reverse_iterator ritSO;
2056 std::vector< _PTR(SObject) > subSO;
2057 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
2059 _PTR(SObject) SO = *ritSO;
2060 if ( !SO ) continue;
2062 int nbChildren = SO->GetLastChildTag();
2064 subSO.reserve( 1 + nbChildren );
2065 subSO.push_back( SO );
2066 if ( nbChildren > 0 )
2068 _PTR(ChildIterator) it = aStudy->NewChildIterator( SO );
2069 for ( it->InitEx( true ); it->More(); it->Next() )
2070 subSO.push_back( it->Value() );
2072 for ( size_t i = 0; i < subSO.size(); ++i )
2074 std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( subSO[i] );
2075 for ( size_t j = 0; j < aReferences.size(); j++ ) {
2076 _PTR(SComponent) aComponent = aReferences[j]->GetFatherComponent();
2077 std::string type = aComponent->ComponentDataType();
2078 if ( type != "SMESH" )
2080 SUIT_MessageBox::warning( anApp->desktop(),
2081 QObject::tr("WRN_WARNING"),
2082 QObject::tr("DEP_OBJECT") );
2083 return; // outside SMESH, there is an object depending on a SMESH object
2089 // Treat SO's in the list starting from the back
2090 aStudyBuilder->NewCommand(); // There is a transaction
2091 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
2093 _PTR(SObject) SO = *ritSO;
2094 if ( !SO ) continue;
2095 std::string anEntry = SO->GetID();
2097 /** Erase graphical object and remove all its data **/
2098 if ( SO->FindAttribute( anAttr, "AttributeIOR" )) {
2099 SMESH::RemoveVisualObjectWithActors( anEntry.c_str(), true);
2101 /** Remove an object from data structures **/
2102 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
2103 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
2104 if ( !aGroup->_is_nil() ) { // DELETE GROUP
2105 SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
2106 aMesh->RemoveGroup( aGroup );
2108 else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
2109 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2110 aMesh->RemoveSubMesh( aSubMesh );
2113 Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
2114 ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
2115 QString objType = CheckTypeObject(IObject);
2116 if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
2117 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
2118 aStudyBuilder->RemoveObjectWithChildren( SO );
2120 else {// default action: remove SObject from the study
2121 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
2122 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
2124 aStudyBuilder->RemoveObjectWithChildren( SO );
2128 } /* listSO back loop */
2130 aStudyBuilder->CommitCommand();
2132 /* Clear any previous selection */
2134 aSel->setSelectedObjects( l1 );
2136 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
2140 SMESHGUI_EXPORT CAM_Module* createModule()
2142 return new SMESHGUI();
2145 SMESHGUI_EXPORT char* getModuleVersion() {
2146 return (char*)SMESH_VERSION_STR;
2150 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
2152 //=============================================================================
2156 //=============================================================================
2157 SMESHGUI::SMESHGUI() :
2158 SalomeApp_Module( "SMESH" )
2160 if ( CORBA::is_nil( myComponentSMESH ) )
2162 CORBA::Boolean anIsEmbeddedMode;
2163 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
2164 //MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
2166 // 0019923: EDF 765 SMESH : default values of hypothesis
2167 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
2168 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
2169 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
2170 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
2171 myComponentSMESH->SetDefaultNbSegments( nbSeg );
2173 const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif", "default_grp_color" };
2174 for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
2175 if ( aResourceMgr->hasValue( "SMESH", options[i] ))
2177 QString val = aResourceMgr->stringValue( "SMESH", options[i] );
2178 myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
2182 myActiveDialogBox = 0;
2183 myFilterLibraryDlg = 0;
2187 myEventCallbackCommand = vtkCallbackCommand::New();
2188 myEventCallbackCommand->Delete();
2189 myEventCallbackCommand->SetClientData( this );
2190 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
2193 /* load resources for all available meshers */
2194 SMESH::InitAvailableHypotheses();
2197 //=============================================================================
2201 //=============================================================================
2202 SMESHGUI::~SMESHGUI()
2206 //=============================================================================
2210 //=============================================================================
2211 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
2213 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2215 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
2220 //=============================================================================
2224 //=============================================================================
2225 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
2227 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2231 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2232 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2233 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2234 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2235 return autoUpdate && !exceeded;
2238 //=============================================================================
2242 //=============================================================================
2243 bool SMESHGUI::automaticUpdate( SMESH::SMESH_IDSource_ptr theMesh,
2244 int* entities, bool* limitExceeded, int* hidden, long* nbElements )
2246 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2250 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2251 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2252 bool incrementalLimit = resMgr->booleanValue( "SMESH", "incremental_limit", false );
2254 SMESH::long_array_var info = theMesh->GetMeshInfo();
2255 long nbOdElems = info[SMDSEntity_0D];
2256 long nbEdges = info[SMDSEntity_Edge] + info[SMDSEntity_Quad_Edge];
2257 long nbFaces = info[SMDSEntity_Triangle] + info[SMDSEntity_Quad_Triangle] + info[SMDSEntity_BiQuad_Triangle] +
2258 info[SMDSEntity_Quadrangle] + info[SMDSEntity_Quad_Quadrangle] + info[SMDSEntity_BiQuad_Quadrangle] +
2259 info[SMDSEntity_Polygon] + info[SMDSEntity_Quad_Polygon];
2260 long nbVolumes = info[SMDSEntity_Tetra] + info[SMDSEntity_Quad_Tetra] +
2261 info[SMDSEntity_Hexa] + info[SMDSEntity_Quad_Hexa] + info[SMDSEntity_TriQuad_Hexa] +
2262 info[SMDSEntity_Pyramid] + info[SMDSEntity_Quad_Pyramid] +
2263 info[SMDSEntity_Penta] + info[SMDSEntity_Quad_Penta] + info[SMDSEntity_BiQuad_Penta] +
2264 info[SMDSEntity_Polyhedra] +
2265 info[SMDSEntity_Hexagonal_Prism];
2266 long nbBalls = info[SMDSEntity_Ball];
2268 long requestedSize = nbOdElems + nbBalls + nbEdges + nbFaces + nbVolumes;
2269 *nbElements = requestedSize;
2271 *entities = SMESH_Actor::eAllEntity;
2274 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2276 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2278 if ( incrementalLimit ) {
2281 if ( nbOdElems > 0 ) {
2282 if ( total + nbOdElems > updateLimit ) {
2283 *entities = *entities & ~SMESH_Actor::e0DElements;
2284 *hidden = *hidden | SMESH_Actor::e0DElements;
2291 if ( nbEdges > 0 ) {
2292 if ( total + nbEdges > updateLimit ) {
2293 *entities = *entities & ~SMESH_Actor::eEdges;
2294 *hidden = *hidden | SMESH_Actor::eEdges;
2301 if ( nbFaces > 0 ) {
2302 if ( total + nbFaces > updateLimit ) {
2303 *entities = *entities & ~SMESH_Actor::eFaces;
2304 *hidden = *hidden | SMESH_Actor::eFaces;
2311 if ( nbVolumes > 0 ) {
2312 if ( total + nbVolumes > updateLimit ) {
2313 *entities = *entities & ~SMESH_Actor::eVolumes;
2314 *hidden = *hidden | SMESH_Actor::eVolumes;
2321 if ( nbBalls > 0 ) {
2322 if ( total + nbBalls > updateLimit ) {
2323 *entities = *entities & ~SMESH_Actor::eBallElem;
2324 *hidden = *hidden | SMESH_Actor::eBallElem;
2332 return autoUpdate && !exceeded;
2335 //=============================================================================
2339 //=============================================================================
2340 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
2342 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
2345 //=============================================================================
2349 //=============================================================================
2350 SMESHGUI* SMESHGUI::GetSMESHGUI()
2352 SMESHGUI* smeshMod = 0;
2353 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
2356 CAM_Module* module = app->module( "Mesh" );
2357 smeshMod = dynamic_cast<SMESHGUI*>( module );
2365 Standard_EXPORT SMESHGUI* GetComponentGUI()
2367 return SMESHGUI::GetSMESHGUI();
2371 //=============================================================================
2375 //=============================================================================
2376 void SMESHGUI::SetState(int aState)
2381 //=============================================================================
2385 //=============================================================================
2386 void SMESHGUI::ResetState()
2391 //=============================================================================
2395 //=============================================================================
2396 void SMESHGUI::EmitSignalDeactivateDialog()
2398 emit SignalDeactivateActiveDialog();
2401 //=============================================================================
2405 //=============================================================================
2406 void SMESHGUI::EmitSignalStudyFrameChanged()
2408 emit SignalStudyFrameChanged();
2411 //=============================================================================
2415 //=============================================================================
2416 void SMESHGUI::EmitSignalCloseAllDialogs()
2418 emit SignalCloseAllDialogs();
2421 //=============================================================================
2425 //=============================================================================
2426 void SMESHGUI::EmitSignalVisibilityChanged()
2428 emit SignalVisibilityChanged();
2431 //=============================================================================
2435 //=============================================================================
2436 void SMESHGUI::EmitSignalCloseView()
2438 emit SignalCloseView();
2441 //=============================================================================
2445 //=============================================================================
2446 void SMESHGUI::EmitSignalActivatedViewManager()
2448 emit SignalActivatedViewManager();
2451 //=============================================================================
2455 //=============================================================================
2456 QDialog *SMESHGUI::GetActiveDialogBox()
2458 return myActiveDialogBox;
2461 //=============================================================================
2465 //=============================================================================
2466 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2468 myActiveDialogBox = (QDialog *) aDlg;
2472 //=============================================================================
2476 //=============================================================================
2477 SUIT_Desktop* SMESHGUI::desktop()
2479 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2481 return app->desktop();
2486 //=============================================================================
2490 //=============================================================================
2491 SalomeApp_Study* SMESHGUI::activeStudy()
2493 SUIT_Application* app = SUIT_Session::session()->activeApplication();
2495 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2500 //=============================================================================
2504 //=============================================================================
2505 void SMESHGUI::Modified( bool theIsUpdateActions )
2507 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2508 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2509 appStudy->Modified();
2510 if( theIsUpdateActions )
2511 app->updateActions();
2516 //=============================================================================
2520 //=============================================================================
2521 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2523 /* Here the position is on the bottom right corner - 10 */
2524 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2526 SUIT_Desktop *PP = desktop();
2527 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2528 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2533 * \brief Verifies whether study of operation is locked
2534 * \param theMess - specifies whether message box must be shown if study is locked
2535 * \return State of study.
2537 * Verifies whether study of operation is locked. If second parameter is TRUE and study
2538 * is locked when corresponding message box appears
2540 bool SMESHGUI::isStudyLocked( bool theMessage )
2542 if ( SMESH::getStudy()->GetProperties()->IsLocked() )
2545 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2546 QObject::tr( "WRN_WARNING" ),
2547 QObject::tr( "WRN_STUDY_LOCKED" ) );
2553 //=============================================================================
2557 //=============================================================================
2558 bool SMESHGUI::OnGUIEvent( int theCommandID )
2560 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2564 SUIT_ResourceMgr* mgr = resourceMgr();
2568 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2569 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2571 //QAction* act = action( theCommandID );
2573 switch (theCommandID) {
2574 case SMESHOp::OpDelete:
2575 if(isStudyLocked()) break;
2578 case SMESHOp::OpImportDAT:
2579 case SMESHOp::OpImportUNV:
2580 case SMESHOp::OpImportMED:
2581 case SMESHOp::OpImportSTL:
2582 case SMESHOp::OpImportCGNS:
2583 case SMESHOp::OpImportSAUV:
2584 case SMESHOp::OpImportGMF:
2585 case SMESHOp::OpPopupImportDAT:
2586 case SMESHOp::OpPopupImportUNV:
2587 case SMESHOp::OpPopupImportMED:
2588 case SMESHOp::OpPopupImportSTL:
2589 case SMESHOp::OpPopupImportCGNS:
2590 case SMESHOp::OpPopupImportSAUV:
2591 case SMESHOp::OpPopupImportGMF:
2593 if(isStudyLocked()) break;
2594 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2598 case SMESHOp::OpFileInformation:
2600 SALOME_ListIO selected;
2601 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2603 aSel->selectedObjects( selected );
2604 if( selected.Extent() )
2606 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2607 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2608 if ( !aMesh->_is_nil() )
2610 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2616 case SMESHOp::OpExportDAT:
2617 case SMESHOp::OpExportMED:
2618 case SMESHOp::OpExportUNV:
2619 case SMESHOp::OpExportSTL:
2620 case SMESHOp::OpExportCGNS:
2621 case SMESHOp::OpExportSAUV:
2622 case SMESHOp::OpExportGMF:
2623 case SMESHOp::OpPopupExportDAT:
2624 case SMESHOp::OpPopupExportMED:
2625 case SMESHOp::OpPopupExportUNV:
2626 case SMESHOp::OpPopupExportSTL:
2627 case SMESHOp::OpPopupExportCGNS:
2628 case SMESHOp::OpPopupExportSAUV:
2629 case SMESHOp::OpPopupExportGMF:
2631 ::ExportMeshToFile(theCommandID);
2635 case SMESHOp::OpReset: // SCALAR BAR
2637 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2638 SALOME_ListIO selected;
2640 aSel->selectedObjects( selected );
2642 SALOME_ListIteratorOfListIO it(selected);
2643 for( ; it.More(); it.Next()) {
2644 Handle(SALOME_InteractiveObject) anIO = it.Value();
2645 if( anIO->hasEntry() ) {
2646 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2647 anActor->SetControlMode( SMESH_Actor::eNone );
2648 #ifndef DISABLE_PLOT2DVIEWER
2649 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2651 anActor->UpdateFilter();
2655 SMESH::UpdateView();
2658 case SMESHOp::OpScalarBarProperties:
2660 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2663 case SMESHOp::OpShowScalarBar:
2665 // show/hide scalar bar
2666 ::ShowElement(theCommandID);
2669 case SMESHOp::OpSaveDistribution:
2671 // dump control distribution data to the text file
2672 ::SaveDistribution();
2676 case SMESHOp::OpShowDistribution:
2678 // show/hide distribution
2679 ::ShowElement(theCommandID);
2683 #ifndef DISABLE_PLOT2DVIEWER
2684 case SMESHOp::OpPlotDistribution:
2686 // plot distribution
2687 ::PlotDistribution();
2693 case SMESHOp::OpAutoColor:
2697 case SMESHOp::OpDisableAutoColor:
2698 ::DisableAutoColor();
2701 case SMESHOp::OpClipping:
2702 case SMESHOp::OpTransparency:
2703 case SMESHOp::OpProperties: // Display preferences (colors, shrink size, line width, ...)
2706 case SMESHOp::OpDMWireframe:
2707 case SMESHOp::OpDMShading:
2708 case SMESHOp::OpDMNodes:
2709 case SMESHOp::OpDMShrink:
2710 ::SetDisplayMode(theCommandID, myMarkerMap);
2713 //2D quadratic representation
2714 case SMESHOp::OpRepresentationLines:
2715 case SMESHOp::OpRepresentationArcs:
2716 ::SetDisplayMode(theCommandID, myMarkerMap);
2720 case SMESHOp::OpDE0DElements:
2721 case SMESHOp::OpDEEdges:
2722 case SMESHOp::OpDEFaces:
2723 case SMESHOp::OpDEVolumes:
2724 case SMESHOp::OpDEBalls:
2725 case SMESHOp::OpDEAllEntity:
2726 ::SetDisplayEntity(theCommandID);
2729 // Choose entities to be displayed
2730 case SMESHOp::OpDEChoose:
2732 ( new SMESHGUI_DisplayEntitiesDlg( SMESHGUI::desktop() ) )->exec();
2736 case SMESHOp::OpOrientationOnFaces:
2738 SUIT_OverrideCursor wc;
2739 LightApp_SelectionMgr* mgr = selectionMgr();
2740 SALOME_ListIO selected; mgr->selectedObjects( selected );
2742 SALOME_ListIteratorOfListIO it(selected);
2743 for( ; it.More(); it.Next()) {
2744 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2745 if(anIObject->hasEntry()) {
2746 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2747 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2754 case SMESHOp::OpUpdate:
2756 if(isStudyLocked()) break;
2757 SUIT_OverrideCursor wc;
2760 SMESH::UpdateView();
2762 catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2763 SMESH::OnVisuException();
2765 catch (...) { // PAL16774 (Crash after display of many groups)
2766 SMESH::OnVisuException();
2770 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2771 aSel->selectedObjects( l );
2772 aSel->setSelectedObjects( l );
2776 case SMESHOp::OpHide:
2777 case SMESHOp::OpShow:
2778 case SMESHOp::OpShowOnly:
2780 SUIT_OverrideCursor wc;
2781 SMESH::EDisplaing anAction;
2782 switch (theCommandID) {
2783 case SMESHOp::OpHide: anAction = SMESH::eErase; break;
2784 case SMESHOp::OpShow: anAction = SMESH::eDisplay; break;
2785 case SMESHOp::OpShowOnly: anAction = SMESH::eDisplayOnly; break;
2788 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2789 SALOME_ListIO sel_objects, to_process;
2791 aSel->selectedObjects( sel_objects );
2793 if ( theCommandID==SMESHOp::OpShowOnly )
2795 //MESSAGE("anAction = SMESH::eDisplayOnly");
2796 startOperation( myEraseAll );
2799 extractContainers( sel_objects, to_process );
2804 SALOME_ListIteratorOfListIO It( to_process );
2805 for ( ; It.More(); It.Next())
2807 Handle(SALOME_InteractiveObject) IOS = It.Value();
2808 if ( IOS->hasEntry() )
2810 if ( !SMESH::UpdateView( anAction, IOS->getEntry() )) {
2811 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2812 break; // PAL16774 (Crash after display of many groups)
2814 if (anAction == SMESH::eDisplayOnly)
2815 anAction = SMESH::eDisplay;
2820 // PAL13338 + PAL15161 -->
2821 if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !isStudyLocked()) {
2822 SMESH::UpdateView();
2823 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2825 // PAL13338 + PAL15161 <--
2827 catch (...) { // PAL16774 (Crash after display of many groups)
2828 SMESH::OnVisuException();
2831 if (anAction == SMESH::eErase) {
2833 aSel->setSelectedObjects( l1 );
2836 aSel->setSelectedObjects( to_process );
2838 if ( vtkwnd && vtkwnd->GetRenderer() && !isStudyLocked() &&
2839 ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) )
2840 vtkwnd->GetRenderer()->AdjustActors();
2845 case SMESHOp::OpNode:
2847 if(isStudyLocked()) break;
2850 EmitSignalDeactivateDialog();
2852 ( new SMESHGUI_NodesDlg( this ) )->show();
2855 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"),tr("SMESH_WRN_VIEWER_VTK"));
2860 case SMESHOp::OpEditMeshOrSubMesh:
2861 case SMESHOp::OpEditMesh:
2862 case SMESHOp::OpEditSubMesh:
2863 case SMESHOp::OpMeshOrder:
2864 case SMESHOp::OpCreateSubMesh:
2865 if ( warnOnGeomModif() )
2866 break; // action forbiden as geometry modified
2868 case SMESHOp::OpCreateMesh:
2869 case SMESHOp::OpCompute:
2870 case SMESHOp::OpComputeSubMesh:
2871 case SMESHOp::OpPreCompute:
2872 case SMESHOp::OpEvaluate:
2873 startOperation( theCommandID );
2875 case SMESHOp::OpCopyMesh:
2877 if (isStudyLocked()) break;
2878 EmitSignalDeactivateDialog();
2879 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2882 case SMESHOp::OpBuildCompoundMesh:
2884 if (isStudyLocked()) break;
2885 EmitSignalDeactivateDialog();
2886 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2890 case SMESHOp::OpDiagonalInversion:
2891 case SMESHOp::OpUnionOfTwoTriangle:
2895 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2899 if ( isStudyLocked() )
2901 if ( warnOnGeomModif() )
2902 break; // action forbiden as geometry modified
2904 /*Standard_Boolean aRes;
2905 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2906 if ( aMesh->_is_nil() )
2908 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2909 tr( "SMESH_BAD_SELECTION" ) );
2913 EmitSignalDeactivateDialog();
2914 if ( theCommandID == SMESHOp::OpDiagonalInversion )
2915 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2917 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2920 case SMESHOp::OpOrientation:
2921 case SMESHOp::OpUnionOfTriangles:
2922 case SMESHOp::OpCuttingOfQuadrangles:
2923 case SMESHOp::OpSplitVolumes:
2927 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2931 if ( isStudyLocked() )
2933 if ( warnOnGeomModif() )
2934 break; // action forbiden as geometry modified
2936 EmitSignalDeactivateDialog();
2937 SMESHGUI_MultiEditDlg* aDlg = NULL;
2938 if ( theCommandID == SMESHOp::OpOrientation )
2939 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2940 else if ( theCommandID == SMESHOp::OpUnionOfTriangles )
2941 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2942 else if ( theCommandID == SMESHOp::OpSplitVolumes )
2943 aDlg = new SMESHGUI_SplitVolumesDlg(this);
2945 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2950 case SMESHOp::OpSmoothing:
2952 if(isStudyLocked()) break;
2953 if ( warnOnGeomModif() )
2954 break; // action forbiden as geometry modified
2956 EmitSignalDeactivateDialog();
2957 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2960 SUIT_MessageBox::warning(desktop(), tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2964 case SMESHOp::OpExtrusion:
2966 if (isStudyLocked()) break;
2967 if ( warnOnGeomModif() )
2968 break; // action forbiden as geometry modified
2970 EmitSignalDeactivateDialog();
2971 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2973 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2977 case SMESHOp::OpExtrusionAlongAPath:
2979 if (isStudyLocked()) break;
2980 if ( warnOnGeomModif() )
2981 break; // action forbiden as geometry modified
2983 EmitSignalDeactivateDialog();
2984 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2986 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2990 case SMESHOp::OpRevolution:
2992 if(isStudyLocked()) break;
2993 if ( warnOnGeomModif() )
2994 break; // action forbiden as geometry modified
2996 EmitSignalDeactivateDialog();
2997 ( new SMESHGUI_RevolutionDlg( this ) )->show();
3000 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3004 case SMESHOp::OpPatternMapping:
3006 if ( isStudyLocked() )
3008 if ( warnOnGeomModif() )
3009 break; // action forbiden as geometry modified
3012 EmitSignalDeactivateDialog();
3013 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
3016 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3020 case SMESHOp::OpSplitBiQuadratic:
3022 case SMESHOp::OpUniformRefinement:
3023 case SMESHOp::OpHONewCase:
3024 case SMESHOp::OpHOCaseFollow:
3025 case SMESHOp::OpHONewIter:
3026 case SMESHOp::OpHOIterCompute:
3027 case SMESHOp::OpHOIterComputePublish:
3028 case SMESHOp::OpHOEdit:
3029 case SMESHOp::OpHODelete:
3030 case SMESHOp::OpMGAdapt:
3032 case SMESHOp::OpConvertMeshToQuadratic:
3033 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
3034 case SMESHOp::OpReorientFaces:
3035 case SMESHOp::OpCreateGeometryGroup:
3037 if ( warnOnGeomModif() )
3038 break; // action forbiden as geometry modified
3039 startOperation( theCommandID );
3042 case SMESHOp::OpCreateGroup:
3046 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3050 if(isStudyLocked()) break;
3051 if ( warnOnGeomModif() )
3052 break; // action forbiden as geometry modified
3053 EmitSignalDeactivateDialog();
3054 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
3056 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3057 SALOME_ListIO selected;
3059 aSel->selectedObjects( selected );
3061 int nbSel = selected.Extent();
3063 // check if mesh is selected
3064 aMesh = SMESH::GetMeshByIO( selected.First() );
3066 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
3071 case SMESHOp::OpConstructGroup:
3075 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3079 if(isStudyLocked()) break;
3080 if ( warnOnGeomModif() )
3081 break; // action forbiden as geometry modified
3082 EmitSignalDeactivateDialog();
3084 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3085 SALOME_ListIO selected;
3087 aSel->selectedObjects( selected );
3089 int nbSel = selected.Extent();
3091 // check if submesh is selected
3092 Handle(SALOME_InteractiveObject) IObject = selected.First();
3093 if (IObject->hasEntry()) {
3094 _PTR(SObject) aSObj = SMESH::getStudy()->FindObjectID(IObject->getEntry());
3096 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
3097 if (!aSubMesh->_is_nil()) {
3099 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
3100 // get submesh elements list by types
3101 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
3102 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
3103 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
3104 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
3105 // create group for each type o elements
3106 QString aName = IObject->getName();
3107 QStringList anEntryList;
3108 if (aNodes->length() > 0) {
3109 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
3110 aGroup->Add(aNodes.inout());
3111 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3112 anEntryList.append( aSObject->GetID().c_str() );
3114 if (aEdges->length() > 0) {
3115 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
3116 aGroup->Add(aEdges.inout());
3117 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3118 anEntryList.append( aSObject->GetID().c_str() );
3120 if (aFaces->length() > 0) {
3121 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
3122 aGroup->Add(aFaces.inout());
3123 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3124 anEntryList.append( aSObject->GetID().c_str() );
3126 if (aVolumes->length() > 0) {
3127 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
3128 aGroup->Add(aVolumes.inout());
3129 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3130 anEntryList.append( aSObject->GetID().c_str() );
3133 anApp->browseObjects( anEntryList );
3135 catch(const SALOME::SALOME_Exception & S_ex){
3136 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3143 SUIT_MessageBox::warning(desktop(),
3144 tr("SMESH_WRN_WARNING"),
3145 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
3150 case SMESHOp::OpEditGroup:
3154 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3158 if(isStudyLocked()) break;
3159 if ( warnOnGeomModif() )
3160 break; // action forbiden as geometry modified
3161 EmitSignalDeactivateDialog();
3163 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3164 SALOME_ListIO selected;
3166 aSel->selectedObjects( selected );
3168 SALOME_ListIteratorOfListIO It (selected);
3169 int nbSelectedGroups = 0;
3170 for ( ; It.More(); It.Next() )
3172 SMESH::SMESH_GroupBase_var aGroup =
3173 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
3174 if (!aGroup->_is_nil()) {
3176 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
3180 if (nbSelectedGroups == 0)
3182 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
3188 case SMESHOp::OpAddElemGroupPopup: // Add elements to group
3190 if(isStudyLocked()) break;
3191 if (myState == 800) {
3192 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3193 if (aDlg) aDlg->onAdd();
3198 case SMESHOp::OpRemoveElemGroupPopup: // Remove elements from group
3200 if(isStudyLocked()) break;
3201 if (myState == 800) {
3202 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3203 if (aDlg) aDlg->onRemove();
3208 case SMESHOp::OpEditGeomGroupAsGroup:
3212 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3216 if(isStudyLocked()) break;
3217 EmitSignalDeactivateDialog();
3219 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3220 SALOME_ListIO selected;
3222 aSel->selectedObjects( selected );
3224 SALOME_ListIteratorOfListIO It (selected);
3225 for ( ; It.More(); It.Next() )
3227 SMESH::SMESH_GroupOnGeom_var aGroup =
3228 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
3229 if (!aGroup->_is_nil()) {
3230 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3235 SMESH::SMESH_GroupOnFilter_var aGroup =
3236 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
3237 if (!aGroup->_is_nil()) {
3238 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3246 case SMESHOp::OpUnionGroups:
3247 case SMESHOp::OpIntersectGroups:
3248 case SMESHOp::OpCutGroups:
3252 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3256 if ( isStudyLocked() )
3258 if ( warnOnGeomModif() )
3259 break; // action forbiden as geometry modified
3261 EmitSignalDeactivateDialog();
3263 SMESHGUI_GroupOpDlg* aDlg = 0;
3264 if ( theCommandID == SMESHOp::OpUnionGroups )
3265 aDlg = new SMESHGUI_UnionGroupsDlg( this );
3266 else if ( theCommandID == SMESHOp::OpIntersectGroups )
3267 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3269 aDlg = new SMESHGUI_CutGroupsDlg( this );
3276 case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
3278 if ( isStudyLocked() )
3280 if ( warnOnGeomModif() )
3281 break; // action forbiden as geometry modified
3283 EmitSignalDeactivateDialog();
3284 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3290 case SMESHOp::OpFaceGroupsByEdges: // Create face groups separated by sharp edges
3292 if ( isStudyLocked() )
3294 if ( warnOnGeomModif() )
3295 break; // action forbiden as geometry modified
3297 EmitSignalDeactivateDialog();
3298 SMESHGUI_FaceGroupsSeparatedByEdgesDlg* aDlg = new SMESHGUI_FaceGroupsSeparatedByEdgesDlg( this );
3304 case SMESHOp::OpDeleteGroup: // Delete groups with their contents
3308 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3312 if ( isStudyLocked() )
3315 EmitSignalDeactivateDialog();
3317 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3321 case SMESHOp::OpMeshInformation:
3322 case SMESHOp::OpWhatIs:
3324 int page = theCommandID == SMESHOp::OpMeshInformation ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3325 EmitSignalDeactivateDialog();
3326 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3327 SALOME_ListIO selected;
3329 aSel->selectedObjects( selected );
3331 if ( selected.Extent() > 1 ) { // a dlg for each IO
3332 SALOME_ListIteratorOfListIO It( selected );
3333 for ( ; It.More(); It.Next() ) {
3334 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3335 dlg->showInfo( It.Value() );
3340 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3346 case SMESHOp::OpFindElementByPoint:
3348 startOperation( theCommandID );
3352 case SMESHOp::OpEditHypothesis:
3354 if(isStudyLocked()) break;
3355 if ( warnOnGeomModif() )
3356 break; // action forbiden as geometry modified
3358 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3359 SALOME_ListIO selected;
3361 aSel->selectedObjects( selected );
3363 int nbSel = selected.Extent();
3366 Handle(SALOME_InteractiveObject) anIObject = selected.First();
3367 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3369 if ( !aHypothesis->_is_nil() )
3371 SMESHGUI_GenericHypothesisCreator* aCreator =
3372 SMESH::GetHypothesisCreator( SMESH::toQStr( aHypothesis->GetName() ));
3375 // set geometry of mesh and sub-mesh to aCreator
3376 aSel->selectedObjects( selected, "", /*convertReferences=*/false);
3377 if ( selected.Extent() == 1 )
3379 QString subGeomID, meshGeomID;
3380 Handle(SALOME_InteractiveObject) hypIO = selected.First();
3381 if ( SMESH::GetGeomEntries( hypIO, subGeomID, meshGeomID ))
3383 if ( subGeomID.isEmpty() ) subGeomID = meshGeomID;
3384 aCreator->setShapeEntry( subGeomID );
3385 aCreator->setMainShapeEntry( meshGeomID );
3389 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3399 case SMESHOp::OpUnassign: // REMOVE HYPOTHESIS / ALGORITHMS
3401 if(isStudyLocked()) break;
3402 if ( warnOnGeomModif() )
3403 break; // action forbiden as geometry modified
3404 SUIT_OverrideCursor wc;
3406 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3407 SALOME_ListIO selected;
3409 aSel->selectedObjects( selected, QString::null, false );
3411 SALOME_ListIteratorOfListIO It(selected);
3412 for (int i = 0; It.More(); It.Next(), i++) {
3413 Handle(SALOME_InteractiveObject) IObject = It.Value();
3414 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3417 aSel->setSelectedObjects( l1 );
3422 case SMESHOp::OpElem0D:
3423 case SMESHOp::OpBall:
3424 case SMESHOp::OpEdge:
3425 case SMESHOp::OpTriangle:
3426 case SMESHOp::OpQuadrangle:
3427 case SMESHOp::OpPolygon:
3428 case SMESHOp::OpTetrahedron:
3429 case SMESHOp::OpHexahedron:
3430 case SMESHOp::OpPentahedron:
3431 case SMESHOp::OpPyramid:
3432 case SMESHOp::OpHexagonalPrism:
3434 if(isStudyLocked()) break;
3435 if ( warnOnGeomModif() )
3436 break; // action forbiden as geometry modified
3438 EmitSignalDeactivateDialog();
3439 SMDSAbs_EntityType type = SMDSEntity_Edge;
3440 switch (theCommandID) {
3441 case SMESHOp::OpElem0D: type = SMDSEntity_0D; break;
3442 case SMESHOp::OpBall: type = SMDSEntity_Ball; break;
3443 case SMESHOp::OpTriangle: type = SMDSEntity_Triangle; break;
3444 case SMESHOp::OpQuadrangle: type = SMDSEntity_Quadrangle; break;
3445 case SMESHOp::OpTetrahedron: type = SMDSEntity_Tetra; break;
3446 case SMESHOp::OpPolygon: type = SMDSEntity_Polygon; break;
3447 case SMESHOp::OpHexahedron: type = SMDSEntity_Hexa; break;
3448 case SMESHOp::OpPentahedron: type = SMDSEntity_Penta; break;
3449 case SMESHOp::OpPyramid: type = SMDSEntity_Pyramid; break;
3450 case SMESHOp::OpHexagonalPrism: type = SMDSEntity_Hexagonal_Prism; break;
3453 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3456 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3460 case SMESHOp::OpPolyhedron:
3462 if(isStudyLocked()) break;
3463 if ( warnOnGeomModif() )
3464 break; // action forbiden as geometry modified
3466 EmitSignalDeactivateDialog();
3467 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3470 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3474 case SMESHOp::OpQuadraticEdge:
3475 case SMESHOp::OpQuadraticTriangle:
3476 case SMESHOp::OpBiQuadraticTriangle:
3477 case SMESHOp::OpQuadraticQuadrangle:
3478 case SMESHOp::OpBiQuadraticQuadrangle:
3479 case SMESHOp::OpQuadraticPolygon:
3480 case SMESHOp::OpQuadraticTetrahedron:
3481 case SMESHOp::OpQuadraticPyramid:
3482 case SMESHOp::OpQuadraticPentahedron:
3483 case SMESHOp::OpBiQuadraticPentahedron:
3484 case SMESHOp::OpQuadraticHexahedron:
3485 case SMESHOp::OpTriQuadraticHexahedron:
3487 if(isStudyLocked()) break;
3488 if ( warnOnGeomModif() )
3489 break; // action forbiden as geometry modified
3491 EmitSignalDeactivateDialog();
3492 SMDSAbs_EntityType type = SMDSEntity_Last;
3494 switch (theCommandID) {
3495 case SMESHOp::OpQuadraticEdge: type = SMDSEntity_Quad_Edge; break;
3496 case SMESHOp::OpQuadraticTriangle: type = SMDSEntity_Quad_Triangle; break;
3497 case SMESHOp::OpBiQuadraticTriangle: type = SMDSEntity_BiQuad_Triangle; break;
3498 case SMESHOp::OpQuadraticQuadrangle: type = SMDSEntity_Quad_Quadrangle; break;
3499 case SMESHOp::OpBiQuadraticQuadrangle: type = SMDSEntity_BiQuad_Quadrangle; break;
3500 case SMESHOp::OpQuadraticPolygon: type = SMDSEntity_Quad_Polygon; break;
3501 case SMESHOp::OpQuadraticTetrahedron: type = SMDSEntity_Quad_Tetra; break;
3502 case SMESHOp::OpQuadraticPyramid: type = SMDSEntity_Quad_Pyramid; break;
3503 case SMESHOp::OpQuadraticPentahedron: type = SMDSEntity_Quad_Penta; break;
3504 case SMESHOp::OpBiQuadraticPentahedron: type = SMDSEntity_BiQuad_Penta; break;
3505 case SMESHOp::OpQuadraticHexahedron: type = SMDSEntity_Quad_Hexa; break;
3506 case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
3509 if ( type != SMDSEntity_Last )
3510 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3513 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3514 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3518 case SMESHOp::OpRemoveNodes:
3520 if(isStudyLocked()) break;
3521 if ( warnOnGeomModif() )
3522 break; // action forbiden as geometry modified
3524 EmitSignalDeactivateDialog();
3525 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3528 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3529 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3533 case SMESHOp::OpRemoveElements: // REMOVES ELEMENTS
3535 if(isStudyLocked()) break;
3536 if ( warnOnGeomModif() )
3537 break; // action forbiden as geometry modified
3539 EmitSignalDeactivateDialog();
3540 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3544 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3545 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3549 case SMESHOp::OpClearMesh: {
3551 if(isStudyLocked()) break;
3552 if ( warnOnGeomModif() )
3553 break; // action forbiden as geometry modified
3555 SALOME_ListIO selected;
3556 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3557 aSel->selectedObjects( selected );
3559 SUIT_OverrideCursor wc;
3560 SALOME_ListIteratorOfListIO It (selected);
3561 for ( ; It.More(); It.Next() )
3563 Handle(SALOME_InteractiveObject) IOS = It.Value();
3564 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3565 if ( aMesh->_is_nil()) continue;
3568 if ( aMesh->NbNodes() == 0 ) // imported mesh is not empty
3569 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3570 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3571 // hide groups and submeshes
3572 _PTR(ChildIterator) anIter =
3573 SMESH::getStudy()->NewChildIterator( aMeshSObj );
3574 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3576 _PTR(SObject) so = anIter->Value();
3577 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3580 catch (const SALOME::SALOME_Exception& S_ex){
3582 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3586 SMESH::UpdateView();
3590 case SMESHOp::OpRemoveOrphanNodes:
3592 if(isStudyLocked()) break;
3593 if ( warnOnGeomModif() )
3594 break; // action forbiden as geometry modified
3595 SALOME_ListIO selected;
3596 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3597 aSel->selectedObjects( selected );
3598 if ( selected.Extent() == 1 ) {
3599 Handle(SALOME_InteractiveObject) anIO = selected.First();
3600 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3601 if ( !aMesh->_is_nil() ) {
3602 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3603 tr( "SMESH_WARNING" ),
3604 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3605 SUIT_MessageBox::Yes |
3606 SUIT_MessageBox::No,
3607 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3610 SUIT_OverrideCursor wc;
3611 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3612 int removed = aMeshEditor->RemoveOrphanNodes();
3613 SUIT_MessageBox::information(SMESHGUI::desktop(),
3614 tr("SMESH_INFORMATION"),
3615 tr("NB_NODES_REMOVED").arg(removed));
3616 if ( removed > 0 ) {
3617 SMESH::UpdateView();
3618 SMESHGUI::Modified();
3621 catch (const SALOME::SALOME_Exception& S_ex) {
3622 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3631 case SMESHOp::OpRenumberingNodes:
3633 if(isStudyLocked()) break;
3634 if ( warnOnGeomModif() )
3635 break; // action forbiden as geometry modified
3637 EmitSignalDeactivateDialog();
3638 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3642 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3643 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3647 case SMESHOp::OpRenumberingElements:
3649 if(isStudyLocked()) break;
3650 if ( warnOnGeomModif() )
3651 break; // action forbiden as geometry modified
3653 EmitSignalDeactivateDialog();
3654 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3658 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3659 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3663 case SMESHOp::OpTranslation:
3665 if(isStudyLocked()) break;
3666 if ( warnOnGeomModif() )
3667 break; // action forbiden as geometry modified
3669 EmitSignalDeactivateDialog();
3670 ( new SMESHGUI_TranslationDlg( this ) )->show();
3673 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3674 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3678 case SMESHOp::OpRotation:
3680 if(isStudyLocked()) break;
3681 if ( warnOnGeomModif() )
3682 break; // action forbiden as geometry modified
3684 EmitSignalDeactivateDialog();
3685 ( new SMESHGUI_RotationDlg( this ) )->show();
3688 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3689 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3693 case SMESHOp::OpSymmetry:
3695 if(isStudyLocked()) break;
3696 if ( warnOnGeomModif() )
3697 break; // action forbiden as geometry modified
3699 EmitSignalDeactivateDialog();
3700 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3703 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3704 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3708 case SMESHOp::OpScale:
3710 if(isStudyLocked()) break;
3711 if ( warnOnGeomModif() )
3712 break; // action forbiden as geometry modified
3714 EmitSignalDeactivateDialog();
3715 ( new SMESHGUI_ScaleDlg( this ) )->show();
3718 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3719 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3724 case SMESHOp::OpOffset:
3726 if(isStudyLocked()) break;
3727 if ( warnOnGeomModif() )
3728 break; // action forbiden as geometry modified
3730 EmitSignalDeactivateDialog();
3731 ( new SMESHGUI_OffsetDlg( this ) )->show();
3734 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3735 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3740 case SMESHOp::OpSewing:
3742 if(isStudyLocked()) break;
3743 if ( warnOnGeomModif() )
3744 break; // action forbiden as geometry modified
3746 EmitSignalDeactivateDialog();
3747 ( new SMESHGUI_SewingDlg( this ) )->show();
3750 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3751 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3755 case SMESHOp::OpMergeNodes:
3757 if(isStudyLocked()) break;
3758 if ( warnOnGeomModif() )
3759 break; // action forbiden as geometry modified
3761 EmitSignalDeactivateDialog();
3762 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3765 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3766 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3770 case SMESHOp::OpMergeElements:
3772 if (isStudyLocked()) break;
3773 if ( warnOnGeomModif() )
3774 break; // action forbiden as geometry modified
3776 EmitSignalDeactivateDialog();
3777 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3779 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3780 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3785 case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
3786 if ( warnOnGeomModif() )
3787 break; // action forbiden as geometry modified
3788 startOperation( SMESHOp::OpMoveNode );
3791 case SMESHOp::OpDuplicateNodes:
3793 if(isStudyLocked()) break;
3794 if ( warnOnGeomModif() )
3795 break; // action forbiden as geometry modified
3797 EmitSignalDeactivateDialog();
3798 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3801 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3802 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3807 case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
3808 if ( warnOnGeomModif() )
3809 break; // action forbiden as geometry modified
3810 startOperation( SMESHOp::OpElem0DOnElemNodes );
3813 case SMESHOp::OpSelectFiltersLibrary: // Library of selection filters
3815 static QList<int> aTypes;
3816 if ( aTypes.isEmpty() )
3818 aTypes.append( SMESH::NODE );
3819 aTypes.append( SMESH::EDGE );
3820 aTypes.append( SMESH::FACE );
3821 aTypes.append( SMESH::VOLUME );
3823 if (!myFilterLibraryDlg)
3824 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3825 else if (myFilterLibraryDlg->isHidden())
3826 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3827 myFilterLibraryDlg->raise();
3831 case SMESHOp::OpFreeNode:
3832 case SMESHOp::OpEqualNode:
3833 case SMESHOp::OpNodeConnectivityNb:
3834 case SMESHOp::OpFreeEdge:
3835 case SMESHOp::OpFreeBorder:
3836 case SMESHOp::OpLength:
3837 case SMESHOp::OpConnection:
3838 case SMESHOp::OpEqualEdge:
3839 case SMESHOp::OpFreeFace:
3840 case SMESHOp::OpBareBorderFace:
3841 case SMESHOp::OpOverConstrainedFace:
3842 case SMESHOp::OpLength2D:
3843 case SMESHOp::OpDeflection2D:
3844 case SMESHOp::OpConnection2D:
3845 case SMESHOp::OpArea:
3846 case SMESHOp::OpTaper:
3847 case SMESHOp::OpAspectRatio:
3848 case SMESHOp::OpMinimumAngle:
3849 case SMESHOp::OpWarpingAngle:
3850 case SMESHOp::OpSkew:
3851 case SMESHOp::OpMaxElementLength2D:
3852 case SMESHOp::OpEqualFace:
3853 case SMESHOp::OpAspectRatio3D:
3854 case SMESHOp::OpVolume:
3855 case SMESHOp::OpMaxElementLength3D:
3856 case SMESHOp::OpBareBorderVolume:
3857 case SMESHOp::OpOverConstrainedVolume:
3858 case SMESHOp::OpEqualVolume:
3861 LightApp_SelectionMgr* mgr = selectionMgr();
3862 SALOME_ListIO selected; mgr->selectedObjects( selected );
3864 if( !selected.IsEmpty() ) {
3865 SUIT_OverrideCursor wc;
3866 ::Control( theCommandID );
3869 SUIT_MessageBox::warning(desktop(),
3870 tr( "SMESH_WRN_WARNING" ),
3871 tr( "SMESH_BAD_SELECTION" ) );
3875 SUIT_MessageBox::warning(desktop(),
3876 tr( "SMESH_WRN_WARNING" ),
3877 tr( "NOT_A_VTK_VIEWER" ) );
3880 case SMESHOp::OpOverallMeshQuality:
3881 OverallMeshQuality();
3883 case SMESHOp::OpNumberingNodes:
3885 SUIT_OverrideCursor wc;
3886 LightApp_SelectionMgr* mgr = selectionMgr();
3887 SALOME_ListIO selected; mgr->selectedObjects( selected );
3889 SALOME_ListIteratorOfListIO it(selected);
3890 for( ; it.More(); it.Next()) {
3891 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3892 if(anIObject->hasEntry()) {
3893 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3894 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3900 case SMESHOp::OpNumberingElements:
3902 SUIT_OverrideCursor wc;
3903 LightApp_SelectionMgr* mgr = selectionMgr();
3904 SALOME_ListIO selected; mgr->selectedObjects( selected );
3906 SALOME_ListIteratorOfListIO it(selected);
3907 for( ; it.More(); it.Next()) {
3908 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3909 if(anIObject->hasEntry())
3910 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3911 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3916 case SMESHOp::OpPropertiesLength:
3917 case SMESHOp::OpPropertiesArea:
3918 case SMESHOp::OpPropertiesVolume:
3919 case SMESHOp::OpMinimumDistance:
3920 case SMESHOp::OpBoundingBox:
3921 case SMESHOp::OpAngle:
3923 int page = SMESHGUI_MeasureDlg::MinDistance;
3924 if ( theCommandID == SMESHOp::OpBoundingBox )
3925 page = SMESHGUI_MeasureDlg::BoundingBox;
3926 else if ( theCommandID == SMESHOp::OpPropertiesLength )
3927 page = SMESHGUI_MeasureDlg::Length;
3928 else if ( theCommandID == SMESHOp::OpPropertiesArea )
3929 page = SMESHGUI_MeasureDlg::Area;
3930 else if ( theCommandID == SMESHOp::OpPropertiesVolume )
3931 page = SMESHGUI_MeasureDlg::Volume;
3932 else if ( theCommandID == SMESHOp::OpAngle )
3933 page = SMESHGUI_MeasureDlg::Angle;
3935 EmitSignalDeactivateDialog();
3936 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3940 case SMESHOp::OpSortChild:
3943 case SMESHOp::OpBreakLink:
3944 ::breakShaperLink();
3949 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3950 //updateObjBrowser();
3954 //=============================================================================
3958 //=============================================================================
3959 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3964 //=============================================================================
3968 //=============================================================================
3969 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3974 //=============================================================================
3978 //=============================================================================
3979 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3984 //=============================================================================
3985 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3986 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3988 //=============================================================================
3989 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3990 SUIT_ViewWindow* wnd )
3992 if(theIO->hasEntry()){
3993 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3994 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3998 //=======================================================================
3999 // function : createSMESHAction
4001 //=======================================================================
4002 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
4003 const int key, const bool toggle, const QString& shortcutAction )
4006 QWidget* parent = application()->desktop();
4007 SUIT_ResourceMgr* resMgr = resourceMgr();
4009 if ( !icon_id.isEmpty() )
4010 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
4012 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
4013 if ( !pix.isNull() )
4014 icon = QIcon( pix );
4016 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
4017 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
4018 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
4020 createAction( id, tooltip, icon, menu, status_bar, key, parent,
4021 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
4024 //=======================================================================
4025 // function : createPopupItem
4027 //=======================================================================
4028 void SMESHGUI::createPopupItem( const int id,
4029 const QString& clients,
4030 const QString& types,
4031 const QString& theRule,
4034 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
4035 popupMgr()->insert( action( id ), pId, 0 );
4037 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4038 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4039 QString rule = "(%1) and (%2) and (%3)";
4040 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
4041 if( clients.isEmpty() )
4042 rule = rule.arg( QString( "true" ) );
4044 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
4045 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
4048 bool cont = myRules.contains( id );
4050 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
4052 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
4053 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
4056 //=======================================================================
4057 // function : initialize
4059 //=======================================================================
4060 void SMESHGUI::initialize( CAM_Application* app )
4062 SalomeApp_Module::initialize( app );
4064 // SUIT_ResourceMgr* mgr = app->resourceMgr();
4066 /* Automatic Update flag */
4067 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
4069 // ----- create actions --------------
4071 //createSMESHAction( SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
4072 createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_I) );
4073 createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
4074 createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL" );
4076 createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
4078 createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
4079 createSMESHAction( SMESHOp::OpImportGMF, "IMPORT_GMF" );
4080 createSMESHAction( SMESHOp::OpPopupImportUNV, "IMPORT_UNV");
4081 createSMESHAction( SMESHOp::OpPopupImportMED, "IMPORT_MED");
4082 createSMESHAction( SMESHOp::OpPopupImportSTL, "IMPORT_STL" );
4084 createSMESHAction( SMESHOp::OpPopupImportCGNS, "IMPORT_CGNS" );
4086 createSMESHAction( SMESHOp::OpPopupImportSAUV, "IMPORT_SAUV" );
4087 createSMESHAction( SMESHOp::OpPopupImportGMF, "IMPORT_GMF" );
4089 createSMESHAction( SMESHOp::OpExportDAT, "DAT" );
4090 createSMESHAction( SMESHOp::OpExportMED, "MED" );
4091 createSMESHAction( SMESHOp::OpExportUNV, "UNV" );
4092 createSMESHAction( SMESHOp::OpExportSTL, "STL" );
4094 createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
4096 createSMESHAction( SMESHOp::OpExportSAUV, "SAUV");
4097 createSMESHAction( SMESHOp::OpExportGMF, "GMF" );
4098 createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
4099 createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
4100 createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
4101 createSMESHAction( SMESHOp::OpPopupExportSTL, "STL" );
4103 createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
4105 createSMESHAction( SMESHOp::OpPopupExportSAUV, "SAUV");
4106 createSMESHAction( SMESHOp::OpPopupExportGMF, "GMF" );
4107 createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
4108 createSMESHAction( SMESHOp::OpDelete, "DELETE", "ICON_DELETE", Qt::Key_Delete );
4109 createSMESHAction( SMESHOp::OpSelectFiltersLibrary, "SEL_FILTER_LIB" );
4110 createSMESHAction( SMESHOp::OpCreateMesh, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
4111 createSMESHAction( SMESHOp::OpCreateSubMesh, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
4112 createSMESHAction( SMESHOp::OpEditMeshOrSubMesh, "EDIT_MESHSUBMESH", "ICON_DLG_EDIT_MESH" );
4113 createSMESHAction( SMESHOp::OpEditMesh, "EDIT_MESH", "ICON_DLG_EDIT_MESH" );
4114 createSMESHAction( SMESHOp::OpEditSubMesh, "EDIT_SUBMESH", "ICON_DLG_EDIT_MESH" );
4115 createSMESHAction( SMESHOp::OpBuildCompoundMesh, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
4116 createSMESHAction( SMESHOp::OpCopyMesh, "COPY_MESH", "ICON_COPY_MESH" );
4117 createSMESHAction( SMESHOp::OpCompute, "COMPUTE", "ICON_COMPUTE" );
4118 createSMESHAction( SMESHOp::OpComputeSubMesh, "COMPUTE_SUBMESH", "ICON_COMPUTE" );
4119 createSMESHAction( SMESHOp::OpPreCompute, "PRECOMPUTE", "ICON_PRECOMPUTE" );
4120 createSMESHAction( SMESHOp::OpEvaluate, "EVALUATE", "ICON_EVALUATE" );
4121 createSMESHAction( SMESHOp::OpMeshOrder, "MESH_ORDER", "ICON_MESH_ORDER");
4122 createSMESHAction( SMESHOp::OpCreateGroup, "CREATE_GROUP", "ICON_CREATE_GROUP" );
4123 createSMESHAction( SMESHOp::OpCreateGeometryGroup, "CREATE_GEO_GROUP", "ICON_CREATE_GEO_GROUP" );
4124 createSMESHAction( SMESHOp::OpConstructGroup, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
4125 createSMESHAction( SMESHOp::OpEditGroup, "EDIT_GROUP", "ICON_EDIT_GROUP" );
4126 createSMESHAction( SMESHOp::OpEditGeomGroupAsGroup, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
4127 createSMESHAction( SMESHOp::OpUnionGroups, "UN_GROUP", "ICON_UNION" );
4128 createSMESHAction( SMESHOp::OpIntersectGroups, "INT_GROUP", "ICON_INTERSECT" );
4129 createSMESHAction( SMESHOp::OpCutGroups, "CUT_GROUP", "ICON_CUT" );
4130 createSMESHAction( SMESHOp::OpGroupUnderlyingElem, "UNDERLYING_ELEMS", "ICON_UNDERLYING_ELEMS" );
4131 createSMESHAction( SMESHOp::OpFaceGroupsByEdges, "FACE_GROUPS_BY_EDGES", "ICON_FACE_GROUPS_BY_EDGES" );
4132 createSMESHAction( SMESHOp::OpAddElemGroupPopup, "ADD_TO_GROUP" );
4133 createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE_FROM_GROUP" );
4134 createSMESHAction( SMESHOp::OpDeleteGroup, "DEL_GROUP", "ICON_DEL_GROUP" );
4135 createSMESHAction( SMESHOp::OpMeshInformation , "ADV_INFO", "ICON_ADV_INFO" );
4136 //createSMESHAction( SMESHOp::OpStdInfo, "STD_INFO", "ICON_STD_INFO" );
4137 //createSMESHAction( SMESHOp::OpWhatIs, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4138 createSMESHAction( SMESHOp::OpFindElementByPoint, "FIND_ELEM", "ICON_FIND_ELEM" );
4140 createSMESHAction( SMESHOp::OpFreeNode, "FREE_NODE", "ICON_FREE_NODE", 0, true );
4141 createSMESHAction( SMESHOp::OpEqualNode, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
4142 createSMESHAction( SMESHOp::OpNodeConnectivityNb, "NODE_CONNECTIVITY_NB", "ICON_NODE_CONN_NB", 0, true );
4143 createSMESHAction( SMESHOp::OpFreeEdge, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
4144 createSMESHAction( SMESHOp::OpFreeBorder, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
4145 createSMESHAction( SMESHOp::OpLength, "LENGTH", "ICON_LENGTH", 0, true );
4146 createSMESHAction( SMESHOp::OpConnection, "CONNECTION", "ICON_CONNECTION", 0, true );
4147 createSMESHAction( SMESHOp::OpEqualEdge, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
4148 createSMESHAction( SMESHOp::OpFreeFace, "FREE_FACES", "ICON_FREE_FACES", 0, true );
4149 createSMESHAction( SMESHOp::OpBareBorderFace, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
4150 createSMESHAction( SMESHOp::OpOverConstrainedFace, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
4151 createSMESHAction( SMESHOp::OpLength2D, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
4152 createSMESHAction( SMESHOp::OpDeflection2D, "DEFLECTION_2D", "ICON_DEFLECTION_2D", 0, true );
4153 createSMESHAction( SMESHOp::OpConnection2D, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
4154 createSMESHAction( SMESHOp::OpArea, "AREA", "ICON_AREA", 0, true );
4155 createSMESHAction( SMESHOp::OpTaper, "TAPER", "ICON_TAPER", 0, true );
4156 createSMESHAction( SMESHOp::OpAspectRatio, "ASPECT", "ICON_ASPECT", 0, true );
4157 createSMESHAction( SMESHOp::OpMinimumAngle, "MIN_ANG", "ICON_ANGLE", 0, true );
4158 createSMESHAction( SMESHOp::OpWarpingAngle, "WARP", "ICON_WARP", 0, true );
4159 createSMESHAction( SMESHOp::OpSkew, "SKEW", "ICON_SKEW", 0, true );
4160 createSMESHAction( SMESHOp::OpMaxElementLength2D, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
4161 createSMESHAction( SMESHOp::OpEqualFace, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
4162 createSMESHAction( SMESHOp::OpAspectRatio3D, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
4163 createSMESHAction( SMESHOp::OpVolume, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
4164 createSMESHAction( SMESHOp::OpMaxElementLength3D, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
4165 createSMESHAction( SMESHOp::OpBareBorderVolume, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
4166 createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
4167 createSMESHAction( SMESHOp::OpEqualVolume, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
4168 createSMESHAction( SMESHOp::OpOverallMeshQuality, "OVERALL_MESH_QUALITY", "ICON_OVL_MESH_QUALITY" );
4170 createSMESHAction( SMESHOp::OpNode, "NODE", "ICON_DLG_NODE" );
4171 createSMESHAction( SMESHOp::OpElem0D, "ELEM0D", "ICON_DLG_ELEM0D" );
4172 createSMESHAction( SMESHOp::OpElem0DOnElemNodes, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
4173 createSMESHAction( SMESHOp::OpBall, "BALL", "ICON_DLG_BALL" );
4174 createSMESHAction( SMESHOp::OpEdge, "EDGE", "ICON_DLG_EDGE" );
4175 createSMESHAction( SMESHOp::OpTriangle, "TRIANGLE", "ICON_DLG_TRIANGLE" );
4176 createSMESHAction( SMESHOp::OpQuadrangle, "QUAD", "ICON_DLG_QUADRANGLE" );
4177 createSMESHAction( SMESHOp::OpPolygon, "POLYGON", "ICON_DLG_POLYGON" );
4178 createSMESHAction( SMESHOp::OpTetrahedron, "TETRA", "ICON_DLG_TETRAS" );
4179 createSMESHAction( SMESHOp::OpHexahedron, "HEXA", "ICON_DLG_HEXAS" );
4180 createSMESHAction( SMESHOp::OpPentahedron, "PENTA", "ICON_DLG_PENTA" );
4181 createSMESHAction( SMESHOp::OpPyramid , "PYRAMID", "ICON_DLG_PYRAMID" );
4182 createSMESHAction( SMESHOp::OpHexagonalPrism, "OCTA", "ICON_DLG_OCTA" );
4183 createSMESHAction( SMESHOp::OpPolyhedron, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
4184 createSMESHAction( SMESHOp::OpQuadraticEdge, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
4185 createSMESHAction( SMESHOp::OpQuadraticTriangle, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
4186 createSMESHAction( SMESHOp::OpBiQuadraticTriangle, "BIQUADRATIC_TRIANGLE", "ICON_DLG_BIQUADRATIC_TRIANGLE" );
4187 createSMESHAction( SMESHOp::OpQuadraticQuadrangle, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
4188 createSMESHAction( SMESHOp::OpBiQuadraticQuadrangle, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
4189 createSMESHAction( SMESHOp::OpQuadraticPolygon, "QUADRATIC_POLYGON", "ICON_DLG_QUADRATIC_POLYGON" );
4190 createSMESHAction( SMESHOp::OpQuadraticTetrahedron, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
4191 createSMESHAction( SMESHOp::OpQuadraticPyramid, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
4192 createSMESHAction( SMESHOp::OpQuadraticPentahedron, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
4193 createSMESHAction( SMESHOp::OpBiQuadraticPentahedron, "BIQUADRATIC_PENTAHEDRON", "ICON_DLG_BIQUADRATIC_PENTAHEDRON" );
4194 createSMESHAction( SMESHOp::OpQuadraticHexahedron, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
4195 createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
4197 createSMESHAction( SMESHOp::OpRemoveNodes, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
4198 createSMESHAction( SMESHOp::OpRemoveElements, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
4199 createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
4200 createSMESHAction( SMESHOp::OpClearMesh, "CLEAR_MESH", "ICON_CLEAR_MESH" );
4202 //createSMESHAction( SMESHOp::OpRenumberingNodes, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
4203 //createSMESHAction( SMESHOp::OpRenumberingElements, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
4205 createSMESHAction( SMESHOp::OpTranslation, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
4206 createSMESHAction( SMESHOp::OpRotation, "ROT", "ICON_DLG_MESH_ROTATION" );
4207 createSMESHAction( SMESHOp::OpSymmetry, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
4208 createSMESHAction( SMESHOp::OpScale, "SCALE", "ICON_DLG_MESH_SCALE" );
4209 createSMESHAction( SMESHOp::OpOffset, "OFFSET", "ICON_DLG_MESH_OFFSET" );
4210 createSMESHAction( SMESHOp::OpSewing, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
4211 createSMESHAction( SMESHOp::OpMergeNodes, "MERGE", "ICON_SMESH_MERGE_NODES" );
4212 createSMESHAction( SMESHOp::OpMergeElements, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
4213 createSMESHAction( SMESHOp::OpMoveNode, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
4214 createSMESHAction( SMESHOp::OpDuplicateNodes, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
4215 createSMESHAction( SMESHOp::OpDiagonalInversion, "INV", "ICON_DLG_MESH_DIAGONAL" );
4216 createSMESHAction( SMESHOp::OpUnionOfTwoTriangle, "UNION2", "ICON_UNION2TRI" );
4217 createSMESHAction( SMESHOp::OpOrientation, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
4218 createSMESHAction( SMESHOp::OpReorientFaces, "REORIENT_2D", "ICON_REORIENT_2D" );
4219 createSMESHAction( SMESHOp::OpUnionOfTriangles, "UNION", "ICON_UNIONTRI" );
4220 createSMESHAction( SMESHOp::OpCuttingOfQuadrangles, "CUT", "ICON_CUTQUAD" );
4221 createSMESHAction( SMESHOp::OpSplitVolumes, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
4222 createSMESHAction( SMESHOp::OpSplitBiQuadratic, "SPLIT_BIQUAD", "ICON_SPLIT_BIQUAD" );
4223 createSMESHAction( SMESHOp::OpSmoothing, "SMOOTH", "ICON_DLG_SMOOTHING" );
4224 createSMESHAction( SMESHOp::OpExtrusion, "EXTRUSION", "ICON_EXTRUSION" );
4225 createSMESHAction( SMESHOp::OpExtrusionAlongAPath, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
4226 createSMESHAction( SMESHOp::OpRevolution, "REVOLUTION", "ICON_REVOLUTION" );
4227 createSMESHAction( SMESHOp::OpPatternMapping, "MAP", "ICON_MAP" );
4228 createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
4229 createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D", "ICON_2D_FROM_3D" );
4231 createSMESHAction( SMESHOp::OpReset, "RESET" );
4232 createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
4233 createSMESHAction( SMESHOp::OpShowScalarBar, "SHOW_SCALAR_BAR","",0, true );
4234 createSMESHAction( SMESHOp::OpSaveDistribution, "SAVE_DISTRIBUTION" );
4235 createSMESHAction( SMESHOp::OpShowDistribution, "SHOW_DISTRIBUTION","",0, true );
4236 #ifndef DISABLE_PLOT2DVIEWER
4237 createSMESHAction( SMESHOp::OpPlotDistribution, "PLOT_DISTRIBUTION" );
4239 createSMESHAction( SMESHOp::OpDMWireframe, "WIRE", "ICON_WIRE", 0, true );
4240 createSMESHAction( SMESHOp::OpDMShading, "SHADE", "ICON_SHADE", 0, true );
4241 createSMESHAction( SMESHOp::OpDMNodes, "NODES", "ICON_POINTS", 0, true );
4242 createSMESHAction( SMESHOp::OpDMShrink, "SHRINK", "ICON_SHRINK", 0, true );
4243 createSMESHAction( SMESHOp::OpUpdate, "UPDATE", "ICON_UPDATE" );
4244 createSMESHAction( SMESHOp::OpDE0DElements, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
4245 createSMESHAction( SMESHOp::OpDEEdges, "EDGES", "ICON_DLG_EDGE", 0, true );
4246 createSMESHAction( SMESHOp::OpDEFaces, "FACES", "ICON_DLG_TRIANGLE", 0, true );
4247 createSMESHAction( SMESHOp::OpDEVolumes, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
4248 createSMESHAction( SMESHOp::OpDEBalls, "BALLS", "ICON_DLG_BALL", 0, true );
4249 createSMESHAction( SMESHOp::OpDEChoose, "CHOOSE", "ICON_DLG_CHOOSE", 0, false );
4250 createSMESHAction( SMESHOp::OpDEAllEntity, "ALL", "ICON_DLG_CHOOSE_ALL", 0, false );
4251 createSMESHAction( SMESHOp::OpOrientationOnFaces, "FACE_ORIENTATION", "", 0, true );
4253 createSMESHAction( SMESHOp::OpRepresentationLines, "LINE_REPRESENTATION", "", 0, true );
4254 createSMESHAction( SMESHOp::OpRepresentationArcs, "ARC_REPRESENTATION", "", 0, true );
4256 createSMESHAction( SMESHOp::OpEditHypothesis, "EDIT_HYPO" );
4257 createSMESHAction( SMESHOp::OpUnassign, "UNASSIGN" );
4258 createSMESHAction( SMESHOp::OpNumberingNodes, "NUM_NODES", "", 0, true );
4259 createSMESHAction( SMESHOp::OpNumberingElements, "NUM_ELEMENTS", "", 0, true );
4260 createSMESHAction( SMESHOp::OpProperties, "COLORS" );
4261 createSMESHAction( SMESHOp::OpTransparency, "TRANSP" );
4262 createSMESHAction( SMESHOp::OpClipping, "CLIP" );
4263 createSMESHAction( SMESHOp::OpAutoColor, "AUTO_COLOR" );
4264 createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
4267 createSMESHAction( SMESHOp::OpUniformRefinement, "REF_ALL", "ICON_REF_ALL" );
4268 createSMESHAction( SMESHOp::OpHONewCase, "HOMARD_CREATE_CASE", "ICON_HOMARD_CREATE_CASE" );
4269 createSMESHAction( SMESHOp::OpHOCaseFollow, "HOMARD_FOLLOW_ITERATION", "ICON_HOMARD_FOLLOW_ITERATION" );
4270 createSMESHAction( SMESHOp::OpHONewIter, "HOMARD_NEW_ITERATION", "ICON_HOMARD_NEW_ITERATION" );
4271 createSMESHAction( SMESHOp::OpHOIterCompute, "HOMARD_COMPUTE", "ICON_HOMARD_COMPUTE" );
4272 createSMESHAction( SMESHOp::OpHOIterComputePublish, "HOMARD_COMPUTE_PUBLISH", "ICON_HOMARD_COMPUTE_PUBLISH" );
4273 createSMESHAction( SMESHOp::OpHOEdit, "EDIT", "ICON_DLG_EDIT_MESH" );
4274 createSMESHAction( SMESHOp::OpHODelete, "DELETE", "ICON_DELETE" );
4275 createSMESHAction( SMESHOp::OpMGAdapt, "MG_ADAPT", "ICON_MG_ADAPT" );
4277 createSMESHAction( SMESHOp::OpMinimumDistance, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
4278 createSMESHAction( SMESHOp::OpBoundingBox, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
4279 createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH", "ICON_MEASURE_LENGTH" );
4280 createSMESHAction( SMESHOp::OpPropertiesArea, "MEASURE_AREA", "ICON_MEASURE_AREA" );
4281 createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME", "ICON_MEASURE_VOLUME" );
4282 createSMESHAction( SMESHOp::OpAngle, "MEASURE_ANGLE", "ICON_MEASURE_ANGLE" );
4284 createSMESHAction( SMESHOp::OpHide, "HIDE", "ICON_HIDE" );
4285 createSMESHAction( SMESHOp::OpShow, "SHOW", "ICON_SHOW" );
4286 createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
4288 createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
4290 createSMESHAction( SMESHOp::OpBreakLink, "BREAK_SHAPER_LINK" );
4292 QList<int> aCtrlActions;
4293 aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode
4294 << SMESHOp::OpNodeConnectivityNb // node controls
4295 << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
4296 << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge // edge controls
4297 << SMESHOp::OpDeflection2D
4298 << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
4299 << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
4300 << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
4301 << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
4302 << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace // face controls
4303 << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
4304 << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
4305 << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume; // volume controls
4306 QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
4307 aCtrlGroup->setExclusive( true );
4308 for( int i = 0; i < aCtrlActions.size(); i++ )
4309 aCtrlGroup->addAction( action( aCtrlActions[i] ) );
4311 // ----- create menu --------------
4312 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
4313 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
4314 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
4315 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
4316 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
4317 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
4318 adaptId = createMenu( tr( "MEN_ADAPT" ), -1, 80, 10 ),
4319 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
4320 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
4322 createMenu( separator(), fileId );
4324 QMenu* nodeMenu = new QMenu(); QMenu* edgeMenu = new QMenu();
4325 QMenu* faceMenu = new QMenu(); QMenu* volumeMenu = new QMenu();
4326 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
4327 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
4328 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10, -1, nodeMenu ),
4329 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10, -1, edgeMenu ),
4330 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10, -1, faceMenu ),
4331 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10, -1, volumeMenu ),
4332 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
4333 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
4334 //renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
4335 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
4336 refHomardId = createMenu( tr( "MEN_REF_HOMARD" ), adaptId, -1, 10 ),
4337 basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
4339 //createMenu( SMESHOp::OpImportDAT, importId, -1 );
4340 createMenu( SMESHOp::OpImportUNV, importId, -1 );
4341 createMenu( SMESHOp::OpImportMED, importId, -1 );
4342 createMenu( SMESHOp::OpImportSTL, importId, -1 );
4344 createMenu( SMESHOp::OpImportCGNS, importId, -1 );
4346 createMenu( SMESHOp::OpImportSAUV, importId, -1 );
4347 createMenu( SMESHOp::OpImportGMF, importId, -1 );
4348 createMenu( SMESHOp::OpExportDAT, exportId, -1 );
4349 createMenu( SMESHOp::OpExportMED, exportId, -1 );
4350 createMenu( SMESHOp::OpExportUNV, exportId, -1 );
4351 createMenu( SMESHOp::OpExportSTL, exportId, -1 );
4353 createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
4355 createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
4356 createMenu( SMESHOp::OpExportGMF, exportId, -1 );
4357 createMenu( separator(), fileId, 10 );
4359 createMenu( SMESHOp::OpDelete, editId, -1 );
4361 createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
4363 createMenu( SMESHOp::OpCreateMesh, meshId, -1 ); // "Mesh" menu
4364 createMenu( SMESHOp::OpCreateSubMesh, meshId, -1 );
4365 createMenu( SMESHOp::OpEditMeshOrSubMesh, meshId, -1 );
4366 createMenu( SMESHOp::OpBuildCompoundMesh, meshId, -1 );
4367 createMenu( SMESHOp::OpCopyMesh, meshId, -1 );
4368 createMenu( separator(), meshId, -1 );
4369 createMenu( SMESHOp::OpCompute, meshId, -1 );
4370 createMenu( SMESHOp::OpPreCompute, meshId, -1 );
4371 createMenu( SMESHOp::OpEvaluate, meshId, -1 );
4372 createMenu( SMESHOp::OpMeshOrder, meshId, -1 );
4373 createMenu( separator(), meshId, -1 );
4374 createMenu( SMESHOp::OpCreateGroup, meshId, -1 );
4375 createMenu( SMESHOp::OpCreateGeometryGroup, meshId, -1 );
4376 createMenu( SMESHOp::OpConstructGroup, meshId, -1 );
4377 createMenu( SMESHOp::OpEditGroup, meshId, -1 );
4378 createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4379 createMenu( separator(), meshId, -1 );
4380 createMenu( SMESHOp::OpUnionGroups, meshId, -1 );
4381 createMenu( SMESHOp::OpIntersectGroups, meshId, -1 );
4382 createMenu( SMESHOp::OpCutGroups, meshId, -1 );
4383 createMenu( separator(), meshId, -1 );
4384 createMenu( SMESHOp::OpGroupUnderlyingElem, meshId, -1 );
4385 createMenu( SMESHOp::OpFaceGroupsByEdges, meshId, -1 );
4386 createMenu( separator(), meshId, -1 );
4387 createMenu( SMESHOp::OpMeshInformation, meshId, -1 );
4388 //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4389 //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4390 createMenu( SMESHOp::OpFindElementByPoint, meshId, -1 );
4391 createMenu( separator(), meshId, -1 );
4393 createMenu( SMESHOp::OpFreeNode, nodeId, -1 );
4394 createMenu( SMESHOp::OpEqualNode, nodeId, -1 );
4395 //createMenu( SMESHOp::OpNodeConnectivityNb, nodeId, -1 );
4396 createMenu( SMESHOp::OpFreeBorder, edgeId, -1 );
4397 createMenu( SMESHOp::OpLength, edgeId, -1 );
4398 createMenu( SMESHOp::OpConnection, edgeId, -1 );
4399 createMenu( SMESHOp::OpEqualEdge, edgeId, -1 );
4400 createMenu( SMESHOp::OpFreeEdge, faceId, -1 );
4401 createMenu( SMESHOp::OpFreeFace, faceId, -1 );
4402 createMenu( SMESHOp::OpBareBorderFace, faceId, -1 );
4403 createMenu( SMESHOp::OpOverConstrainedFace, faceId, -1 );
4404 createMenu( SMESHOp::OpLength2D, faceId, -1 );
4405 createMenu( SMESHOp::OpConnection2D, faceId, -1 );
4406 createMenu( SMESHOp::OpArea, faceId, -1 );
4407 createMenu( SMESHOp::OpTaper, faceId, -1 );
4408 createMenu( SMESHOp::OpAspectRatio, faceId, -1 );
4409 createMenu( SMESHOp::OpMinimumAngle, faceId, -1 );
4410 createMenu( SMESHOp::OpWarpingAngle, faceId, -1 );
4411 createMenu( SMESHOp::OpSkew, faceId, -1 );
4412 createMenu( SMESHOp::OpMaxElementLength2D, faceId, -1 );
4413 createMenu( SMESHOp::OpEqualFace, faceId, -1 );
4414 createMenu( SMESHOp::OpDeflection2D, faceId, -1 );
4415 createMenu( SMESHOp::OpAspectRatio3D, volumeId, -1 );
4416 createMenu( SMESHOp::OpVolume, volumeId, -1 );
4417 createMenu( SMESHOp::OpMaxElementLength3D, volumeId, -1 );
4418 createMenu( SMESHOp::OpBareBorderVolume, volumeId, -1 );
4419 createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4420 createMenu( SMESHOp::OpEqualVolume, volumeId, -1 );
4421 createMenu( separator(), ctrlId, -1 );
4422 createMenu( SMESHOp::OpReset, ctrlId, -1 );
4423 createMenu( separator(), ctrlId, -1 );
4424 createMenu( SMESHOp::OpOverallMeshQuality, ctrlId, -1 );
4426 createMenu( SMESHOp::OpNode, addId, -1 );
4427 createMenu( SMESHOp::OpElem0D, addId, -1 );
4428 createMenu( SMESHOp::OpElem0DOnElemNodes, addId, -1 );
4429 createMenu( SMESHOp::OpBall, addId, -1 );
4430 createMenu( SMESHOp::OpEdge, addId, -1 );
4431 createMenu( SMESHOp::OpTriangle, addId, -1 );
4432 createMenu( SMESHOp::OpQuadrangle, addId, -1 );
4433 createMenu( SMESHOp::OpPolygon, addId, -1 );
4434 createMenu( SMESHOp::OpTetrahedron, addId, -1 );
4435 createMenu( SMESHOp::OpHexahedron, addId, -1 );
4436 createMenu( SMESHOp::OpPentahedron, addId, -1 );
4437 createMenu( SMESHOp::OpPyramid, addId, -1 );
4438 createMenu( SMESHOp::OpHexagonalPrism, addId, -1 );
4439 createMenu( SMESHOp::OpPolyhedron, addId, -1 );
4440 createMenu( separator(), addId, -1 );
4441 createMenu( SMESHOp::OpQuadraticEdge, addId, -1 );
4442 createMenu( SMESHOp::OpQuadraticTriangle, addId, -1 );
4443 createMenu( SMESHOp::OpBiQuadraticTriangle , addId, -1 );
4444 createMenu( SMESHOp::OpQuadraticQuadrangle, addId, -1 );
4445 createMenu( SMESHOp::OpBiQuadraticQuadrangle, addId, -1 );
4446 createMenu( SMESHOp::OpQuadraticPolygon, addId, -1 );
4447 createMenu( SMESHOp::OpQuadraticTetrahedron, addId, -1 );
4448 createMenu( SMESHOp::OpQuadraticPyramid, addId, -1 );
4449 createMenu( SMESHOp::OpQuadraticPentahedron, addId, -1 );
4450 createMenu( SMESHOp::OpBiQuadraticPentahedron, addId, -1 );
4451 createMenu( SMESHOp::OpQuadraticHexahedron, addId, -1 );
4452 createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4454 createMenu( SMESHOp::OpRemoveNodes, removeId, -1 );
4455 createMenu( SMESHOp::OpRemoveElements, removeId, -1 );
4456 createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4457 createMenu( separator(), removeId, -1 );
4458 createMenu( SMESHOp::OpDeleteGroup, removeId, -1 );
4459 createMenu( separator(), removeId, -1 );
4460 createMenu( SMESHOp::OpClearMesh, removeId, -1 );
4462 //createMenu( SMESHOp::OpRenumberingNodes, renumId, -1 );
4463 //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4465 createMenu( SMESHOp::OpMergeNodes, transfId, -1 );
4466 createMenu( SMESHOp::OpMergeElements, transfId, -1 );
4467 createMenu( SMESHOp::OpTranslation, transfId, -1 );
4468 createMenu( SMESHOp::OpRotation, transfId, -1 );
4469 createMenu( SMESHOp::OpSymmetry, transfId, -1 );
4470 createMenu( SMESHOp::OpScale, transfId, -1 );
4471 createMenu( SMESHOp::OpOffset, transfId, -1 );
4472 createMenu( SMESHOp::OpSewing, transfId, -1 );
4473 createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4475 createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4476 createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4477 createMenu( SMESHOp::OpExtrusion, modifyId, -1 );
4478 createMenu( SMESHOp::OpExtrusionAlongAPath, modifyId, -1 );
4479 createMenu( SMESHOp::OpRevolution, modifyId, -1 );
4480 createMenu( SMESHOp::OpOrientation, modifyId, -1 );
4481 createMenu( SMESHOp::OpReorientFaces, modifyId, -1 );
4482 createMenu( SMESHOp::OpMoveNode, modifyId, -1 );
4483 createMenu( SMESHOp::OpDiagonalInversion, modifyId, -1 );
4484 createMenu( SMESHOp::OpUnionOfTwoTriangle, modifyId, -1 );
4485 createMenu( SMESHOp::OpUnionOfTriangles, modifyId, -1 );
4486 createMenu( SMESHOp::OpCuttingOfQuadrangles, modifyId, -1 );
4487 createMenu( SMESHOp::OpSplitVolumes, modifyId, -1 );
4488 createMenu( SMESHOp::OpSplitBiQuadratic, modifyId, -1 );
4489 createMenu( SMESHOp::OpSmoothing, modifyId, -1 );
4490 createMenu( SMESHOp::OpPatternMapping, modifyId, -1 );
4492 createMenu( SMESHOp::OpUniformRefinement, adaptId, -1 );
4493 createMenu( SMESHOp::OpHONewCase, refHomardId, -1 );
4494 createMenu( SMESHOp::OpHOCaseFollow, refHomardId, -1 );
4495 createMenu( separator(), refHomardId, -1 );
4496 createMenu( SMESHOp::OpHONewIter, refHomardId, -1 );
4497 createMenu( SMESHOp::OpHOIterCompute, refHomardId, -1 );
4498 createMenu( SMESHOp::OpHOIterComputePublish, refHomardId, -1 );
4499 createMenu( separator(), refHomardId, -1 );
4500 createMenu( SMESHOp::OpHOEdit, refHomardId, -1 );
4501 createMenu( SMESHOp::OpHODelete, refHomardId, -1 );
4502 createMenu( SMESHOp::OpMGAdapt, adaptId, -1 );
4504 createMenu( SMESHOp::OpMinimumDistance, measureId, -1 );
4505 createMenu( SMESHOp::OpBoundingBox, measureId, -1 );
4506 createMenu( SMESHOp::OpAngle, measureId, -1 );
4507 createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4508 createMenu( SMESHOp::OpPropertiesArea, basicPropId, -1 );
4509 createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4510 createMenu( SMESHOp::OpUpdate, viewId, -1 );
4512 connect( nodeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4513 connect( edgeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4514 connect( faceMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4515 connect( volumeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4517 // ----- create toolbars --------------
4518 int meshTb = createTool( tr( "TB_MESH" ), QString( "SMESHMeshToolbar" ) ),
4519 info = createTool( tr( "TB_INFO" ), QString( "SMESHInformationToolbar" ) ),
4520 groupTb = createTool( tr( "TB_GROUP" ), QString( "SMESHGroupToolbar" ) ),
4521 ctrl0dTb = createTool( tr( "TB_CTRL0D" ), QString( "SMESHNodeControlsToolbar" ) ),
4522 ctrl1dTb = createTool( tr( "TB_CTRL1D" ), QString( "SMESHEdgeControlsToolbar" ) ),
4523 ctrl2dTb = createTool( tr( "TB_CTRL2D" ), QString( "SMESHFaceControlsToolbar" ) ),
4524 ctrl3dTb = createTool( tr( "TB_CTRL3D" ), QString( "SMESHVolumeControlsToolbar" ) ),
4525 addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ),
4526 addNonElemTb = createTool( tr( "TB_ADDNON" ), QString( "SMESHAddElementToolbar" ) ),
4527 remTb = createTool( tr( "TB_REM" ), QString( "SMESHRemoveToolbar" ) ),
4528 //renumbTb = createTool( tr( "TB_RENUMBER" ), QString( "SMESHRenumberingToolbar" ) ),
4529 transformTb = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ),
4530 modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ),
4531 // adaptTb = createTool( tr( "TB_ADAPTATION" ),QString( "SMESHAdaptationToolbar" ) ),
4532 measuremTb = createTool( tr( "TB_MEASUREM" ), QString( "SMESHMeasurementsToolbar" ) ),
4533 dispModeTb = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4535 createTool( SMESHOp::OpCreateMesh, meshTb );
4536 createTool( SMESHOp::OpCreateSubMesh, meshTb );
4537 createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4538 createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4539 createTool( SMESHOp::OpCopyMesh, meshTb );
4540 createTool( separator(), meshTb );
4541 createTool( SMESHOp::OpCompute, meshTb );
4542 createTool( SMESHOp::OpPreCompute, meshTb );
4543 createTool( SMESHOp::OpEvaluate, meshTb );
4544 createTool( SMESHOp::OpMeshOrder, meshTb );
4546 createTool( SMESHOp::OpCreateGroup, groupTb );
4547 createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4548 createTool( SMESHOp::OpConstructGroup, groupTb );
4549 createTool( SMESHOp::OpEditGroup, groupTb );
4551 createTool( SMESHOp::OpMeshInformation, info );
4552 //createTool( SMESHOp::OpStdInfo, meshTb );
4553 //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4554 createTool( SMESHOp::OpFindElementByPoint, info );
4556 createTool( SMESHOp::OpFreeNode, ctrl0dTb );
4557 createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4558 //createTool( SMESHOp::OpNodeConnectivityNb, ctrl0dTb );
4560 createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4561 createTool( SMESHOp::OpLength, ctrl1dTb );
4562 createTool( SMESHOp::OpConnection, ctrl1dTb );
4563 createTool( SMESHOp::OpEqualEdge, ctrl1dTb );
4565 createTool( SMESHOp::OpFreeEdge, ctrl2dTb );
4566 createTool( SMESHOp::OpFreeFace, ctrl2dTb );
4567 createTool( SMESHOp::OpBareBorderFace, ctrl2dTb );
4568 createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4569 createTool( SMESHOp::OpLength2D, ctrl2dTb );
4570 createTool( SMESHOp::OpConnection2D, ctrl2dTb );
4571 createTool( SMESHOp::OpArea, ctrl2dTb );
4572 createTool( SMESHOp::OpTaper, ctrl2dTb );
4573 createTool( SMESHOp::OpAspectRatio, ctrl2dTb );
4574 createTool( SMESHOp::OpMinimumAngle, ctrl2dTb );
4575 createTool( SMESHOp::OpWarpingAngle, ctrl2dTb );
4576 createTool( SMESHOp::OpSkew, ctrl2dTb );
4577 createTool( SMESHOp::OpMaxElementLength2D, ctrl2dTb );
4578 createTool( SMESHOp::OpEqualFace, ctrl2dTb );
4579 createTool( SMESHOp::OpDeflection2D, ctrl2dTb );
4581 createTool( SMESHOp::OpAspectRatio3D, ctrl3dTb );
4582 createTool( SMESHOp::OpVolume, ctrl3dTb );
4583 createTool( SMESHOp::OpMaxElementLength3D, ctrl3dTb );
4584 createTool( SMESHOp::OpBareBorderVolume, ctrl3dTb );
4585 createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
4586 createTool( SMESHOp::OpEqualVolume, ctrl3dTb );
4588 createTool( SMESHOp::OpNode, addElemTb );
4589 createTool( SMESHOp::OpElem0D, addElemTb );
4590 createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4591 createTool( SMESHOp::OpBall, addElemTb );
4592 createTool( SMESHOp::OpEdge, addElemTb );
4593 createTool( SMESHOp::OpTriangle, addElemTb );
4594 createTool( SMESHOp::OpQuadrangle, addElemTb );
4595 createTool( SMESHOp::OpPolygon, addElemTb );
4596 createTool( SMESHOp::OpTetrahedron, addElemTb );
4597 createTool( SMESHOp::OpHexahedron, addElemTb );
4598 createTool( SMESHOp::OpPentahedron, addElemTb );
4599 createTool( SMESHOp::OpPyramid, addElemTb );
4600 createTool( SMESHOp::OpHexagonalPrism, addElemTb );
4601 createTool( SMESHOp::OpPolyhedron, addElemTb );
4603 createTool( SMESHOp::OpQuadraticEdge, addNonElemTb );
4604 createTool( SMESHOp::OpQuadraticTriangle, addNonElemTb );
4605 createTool( SMESHOp::OpBiQuadraticTriangle, addNonElemTb );
4606 createTool( SMESHOp::OpQuadraticQuadrangle, addNonElemTb );
4607 createTool( SMESHOp::OpBiQuadraticQuadrangle, addNonElemTb );
4608 createTool( SMESHOp::OpQuadraticPolygon, addNonElemTb );
4609 createTool( SMESHOp::OpQuadraticTetrahedron, addNonElemTb );
4610 createTool( SMESHOp::OpQuadraticPyramid, addNonElemTb );
4611 createTool( SMESHOp::OpQuadraticPentahedron, addNonElemTb );
4612 createTool( SMESHOp::OpBiQuadraticPentahedron, addNonElemTb );
4613 createTool( SMESHOp::OpQuadraticHexahedron, addNonElemTb );
4614 createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4616 createTool( SMESHOp::OpRemoveNodes, remTb );
4617 createTool( SMESHOp::OpRemoveElements, remTb );
4618 createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4619 createTool( SMESHOp::OpClearMesh, remTb );
4621 //createTool( SMESHOp::OpRenumberingNodes, renumbTb );
4622 //createTool( SMESHOp::OpRenumberingElements, renumbTb );
4624 createTool( SMESHOp::OpMergeNodes, transformTb );
4625 createTool( SMESHOp::OpMergeElements, transformTb );
4626 createTool( SMESHOp::OpTranslation, transformTb );
4627 createTool( SMESHOp::OpRotation, transformTb );
4628 createTool( SMESHOp::OpSymmetry, transformTb );
4629 createTool( SMESHOp::OpScale, transformTb );
4630 createTool( SMESHOp::OpOffset, transformTb );
4631 createTool( SMESHOp::OpSewing, transformTb );
4632 createTool( SMESHOp::OpDuplicateNodes, transformTb );
4634 createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4635 createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4636 createTool( SMESHOp::OpExtrusion, modifyTb );
4637 createTool( SMESHOp::OpExtrusionAlongAPath, modifyTb );
4638 createTool( SMESHOp::OpRevolution, modifyTb );
4639 createTool( SMESHOp::OpOrientation, modifyTb );
4640 createTool( SMESHOp::OpReorientFaces, modifyTb );
4641 createTool( SMESHOp::OpMoveNode, modifyTb );
4642 createTool( SMESHOp::OpDiagonalInversion, modifyTb );
4643 createTool( SMESHOp::OpUnionOfTwoTriangle, modifyTb );
4644 createTool( SMESHOp::OpUnionOfTriangles, modifyTb );
4645 createTool( SMESHOp::OpCuttingOfQuadrangles, modifyTb );
4646 createTool( SMESHOp::OpSplitVolumes, modifyTb );
4647 createTool( SMESHOp::OpSplitBiQuadratic, modifyTb );
4648 createTool( SMESHOp::OpSmoothing, modifyTb );
4649 createTool( SMESHOp::OpPatternMapping, modifyTb );
4651 // createTool( SMESHOp::OpUniformRefinement, adaptTb );
4652 // createTool( SMESHOp::OpHOMARDRefinement, adaptTb );
4653 // createTool( SMESHOp::OpMGAdapt, adaptTb );
4655 createTool( SMESHOp::OpMinimumDistance, measuremTb );
4657 createTool( SMESHOp::OpUpdate, dispModeTb );
4659 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4660 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4664 OB = "'ObjectBrowser'",
4665 View = "'" + SVTK_Viewer::Type() + "'",
4667 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4668 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4669 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4670 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4671 smesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::COMPONENT ) ),
4672 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4673 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4674 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4675 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4676 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4677 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4678 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4680 mesh_part = mesh + " " + subMesh + " " + group,
4681 mesh_group = mesh + " " + group,
4682 mesh_submesh = mesh + " " + subMesh,
4683 hyp_alg = hypo + " " + algo;
4685 // popup for object browser
4687 isInvisible("not( isVisible )"),
4688 isEmpty("numberOfNodes = 0"),
4689 isNotEmpty("numberOfNodes <> 0"),
4691 // has nodes, edges, etc in VISIBLE! actor
4692 hasNodes("(numberOfNodes > 0 ) && hasActor"),
4693 hasElems("(count( elemTypes ) > 0)"),
4694 hasDifferentElems("(count( elemTypes ) > 1)"),
4695 hasDifferentObjElems("(count( objElemTypes ) > 1)"),
4696 hasBalls("({'BallElem'} in elemTypes)"),
4697 hasElems0d("({'Elem0d'} in elemTypes)"),
4698 hasEdges("({'Edge'} in elemTypes)"),
4699 hasFaces("({'Face'} in elemTypes)"),
4700 hasVolumes("({'Volume'} in elemTypes)"),
4701 hasFacesOrVolumes("(({'Face'} in elemTypes) || ({'Volume'} in elemTypes)) ");
4703 createPopupItem( SMESHOp::OpFileInformation, OB, mesh, "&& selcount=1 && isImported" );
4704 createPopupItem( SMESHOp::OpCreateSubMesh, OB, mesh, "&& hasGeomReference");
4705 createPopupItem( SMESHOp::OpEditMesh, OB, mesh, "&& selcount=1" );
4706 createPopupItem( SMESHOp::OpEditSubMesh, OB, subMesh, "&& selcount=1 && hasGeomReference" );
4707 createPopupItem( SMESHOp::OpEditGroup, OB, group );
4708 createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4710 popupMgr()->insert( separator(), -1, 0 );
4711 createPopupItem( SMESHOp::OpCompute, OB, mesh, "&& selcount=1 && isComputable" );
4712 createPopupItem( SMESHOp::OpComputeSubMesh, OB, subMesh, "&& selcount=1 && isComputable" );
4713 createPopupItem( SMESHOp::OpPreCompute, OB, mesh, "&& selcount=1 && isPreComputable" );
4714 createPopupItem( SMESHOp::OpEvaluate, OB, mesh, "&& selcount=1 && isComputable" );
4715 createPopupItem( SMESHOp::OpMeshOrder, OB, mesh, "&& selcount=1 && isComputable && hasGeomReference" );
4716 createPopupItem( SMESHOp::OpUpdate, OB, mesh_part );
4717 createPopupItem( SMESHOp::OpMeshInformation, OB, mesh_part );
4718 createPopupItem( SMESHOp::OpFindElementByPoint,OB, mesh_group, "&& selcount=1" );
4719 createPopupItem( SMESHOp::OpOverallMeshQuality,OB, mesh_part );
4720 popupMgr()->insert( separator(), -1, 0 );
4721 createPopupItem( SMESHOp::OpCreateGroup, OB, mesh, "&& selcount=1" );
4722 createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh, "&& selcount=1 && hasGeomReference" );
4723 createPopupItem( SMESHOp::OpConstructGroup, OB, subMesh );
4724 popupMgr()->insert( separator(), -1, 0 );
4725 createPopupItem( SMESHOp::OpEditHypothesis, OB, hypo, "&& isEditableHyp");
4726 createPopupItem( SMESHOp::OpUnassign, OB, hyp_alg );
4727 popupMgr()->insert( separator(), -1, 0 );
4728 createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh_submesh );
4729 createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh_group, "&& selcount=1 && dim>=2");
4730 popupMgr()->insert( separator(), -1, 0 );
4731 createPopupItem( SMESHOp::OpClearMesh, OB, mesh );
4732 //popupMgr()->insert( separator(), -1, 0 );
4733 // createPopupItem( SMESHOp::OpUniformRefinement, OB, mesh );
4734 // createPopupItem( SMESHOp::OpHOMARDRefinement, OB, mesh );
4735 // createPopupItem( SMESHOp::OpMGAdapt, OB, mesh );
4737 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4738 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4739 QString only_one_2D = only_one_non_empty + " && dim>1";
4741 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4742 createPopupItem( SMESHOp::OpPopupExportMED, OB, mesh_group, multiple_non_empty, anId );
4743 createPopupItem( SMESHOp::OpPopupExportUNV, OB, mesh_group, only_one_non_empty, anId );
4744 createPopupItem( SMESHOp::OpPopupExportSTL, OB, mesh_group, only_one_2D, anId );
4746 createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4748 createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, only_one_non_empty, anId );
4749 createPopupItem( SMESHOp::OpPopupExportGMF, OB, mesh_group, only_one_non_empty, anId );
4750 createPopupItem( SMESHOp::OpPopupExportDAT, OB, mesh_group, only_one_non_empty, anId );
4751 createPopupItem( SMESHOp::OpDelete, OB, mesh_part + " " + hyp_alg );
4752 createPopupItem( SMESHOp::OpDeleteGroup, OB, group );
4754 anId = popupMgr()->insert( tr( "MEN_IMPORT" ), -1, -1 ); // IMPORT submenu
4755 createPopupItem( SMESHOp::OpPopupImportMED, OB, smesh, "", anId );
4756 createPopupItem( SMESHOp::OpPopupImportUNV, OB, smesh, "", anId );
4757 createPopupItem( SMESHOp::OpPopupImportSTL, OB, smesh, "", anId );
4759 createPopupItem( SMESHOp::OpPopupImportCGNS, OB, smesh, "", anId );
4761 createPopupItem( SMESHOp::OpPopupImportSAUV, OB, smesh, "", anId );
4762 createPopupItem( SMESHOp::OpPopupImportGMF, OB, smesh, "", anId );
4763 createPopupItem( SMESHOp::OpPopupImportDAT, OB, smesh, "", anId );
4764 popupMgr()->insert( separator(), -1, 0 );
4767 createPopupItem( SMESHOp::OpEditGroup, View, group );
4768 createPopupItem( SMESHOp::OpAddElemGroupPopup, View, elems, "&& guiState = 800" );
4769 createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems, "&& guiState = 800" );
4771 popupMgr()->insert( separator(), -1, 0 );
4772 createPopupItem( SMESHOp::OpUpdate, View, mesh_part );
4773 createPopupItem( SMESHOp::OpMeshInformation, View, mesh_part );
4774 createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4775 createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh );
4776 popupMgr()->insert( separator(), -1, 0 );
4778 createPopupItem( SMESHOp::OpAutoColor, OB + " " + View, mesh, "&& (not isAutoColor)" );
4779 createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4780 popupMgr()->insert( separator(), -1, 0 );
4782 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4783 QString aType = QString( "%1type in {%2}" ).arg( lc );
4784 aType = aType.arg( mesh_part );
4785 QString aMeshInVTK = aClient + "&&" + aType;
4787 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4788 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4789 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4791 //-------------------------------------------------
4793 //-------------------------------------------------
4794 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4796 popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4797 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4798 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4800 popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4801 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4802 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4804 popupMgr()->insert( separator(), -1, -1 );
4806 //-------------------------------------------------
4808 //-------------------------------------------------
4809 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4811 popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4812 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4813 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4815 popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4816 popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4817 popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4819 popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4820 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4821 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4823 popupMgr()->insert( separator(), anId, -1 );
4825 popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4826 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4827 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4829 //-------------------------------------------------
4831 //-------------------------------------------------
4832 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4834 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4836 popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4837 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4838 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4840 popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4841 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4842 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4844 popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4845 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4846 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4848 popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4849 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4850 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4852 popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4853 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4854 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4856 popupMgr()->insert( separator(), anId, -1 );
4858 popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4859 popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&& $type in {" + mesh + "} &&" + hasDifferentObjElems, QtxPopupMgr::VisibleRule );
4861 popupMgr()->insert( separator(), anId, -1 );
4863 popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4864 popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4867 //-------------------------------------------------
4868 // Representation of the 2D Quadratic elements
4869 //-------------------------------------------------
4870 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4871 popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4872 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "&& isVisible && isQuadratic",QtxPopupMgr::VisibleRule );
4873 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4875 popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4876 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "&& isVisible && isQuadratic", QtxPopupMgr::VisibleRule );
4877 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4879 //-------------------------------------------------
4880 // Orientation of faces
4881 //-------------------------------------------------
4882 popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4883 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4884 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4886 //-------------------------------------------------
4888 //-------------------------------------------------
4889 popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4890 popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4892 //-------------------------------------------------
4894 //-------------------------------------------------
4895 popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4896 popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4898 //-------------------------------------------------
4900 //-------------------------------------------------
4902 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4903 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4904 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4905 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4907 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4909 popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4910 popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4912 popupMgr()->insert( separator(), anId, -1 );
4914 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4916 popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4917 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4918 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4920 popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4921 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4922 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4924 // popupMgr()->insert( action( SMESHOp::OpNodeConnectivityNb ), aSubId, -1 );
4925 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4926 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), "controlMode = 'eNodeConnectivityNb'", QtxPopupMgr::ToggleRule );
4928 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4930 popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4931 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVTK + "&&" + hasEdges + "&&" + hasFacesOrVolumes, QtxPopupMgr::VisibleRule );
4932 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4934 popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4935 popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4936 popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4938 popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4939 popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4940 popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4941 popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4942 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4943 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4945 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4947 popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4948 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4949 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4951 popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4952 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4953 QtxPopupMgr::VisibleRule );
4954 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4956 popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4957 popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4958 popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4960 popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4961 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4962 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4964 popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
4965 popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4966 popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4968 popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
4969 popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4970 popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4972 popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
4973 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4974 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4976 popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
4977 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4978 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4980 popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
4981 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4982 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4984 popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
4985 popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4986 popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4988 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
4989 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4990 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4992 popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
4993 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4994 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4996 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
4997 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4998 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
5000 popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
5001 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
5002 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
5004 popupMgr()->insert ( action( SMESHOp::OpDeflection2D ), aSubId, -1 );
5005 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), aMeshInVtkHasFaces + " && hasGeomReference", QtxPopupMgr::VisibleRule );
5006 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), "controlMode = 'eDeflection2D'", QtxPopupMgr::ToggleRule );
5008 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
5010 popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D ), aSubId, -1 );
5011 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5012 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
5014 popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
5015 popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5016 popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
5018 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
5019 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5020 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
5022 popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
5023 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5024 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
5026 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
5027 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5028 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
5030 popupMgr()->insert ( action( SMESHOp::OpEqualVolume ), aSubId, -1 );
5031 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5032 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
5034 popupMgr()->insert( separator(), anId, -1 );
5036 popupMgr()->insert( action( SMESHOp::OpShowScalarBar ), anId, -1 );
5037 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
5038 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone' && isScalarBarVisible", QtxPopupMgr::ToggleRule );
5039 popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
5040 popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
5042 popupMgr()->insert( separator(), anId, -1 );
5044 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
5046 popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
5047 popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
5049 popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
5050 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
5051 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isScalarBarVisible && isDistributionVisible", QtxPopupMgr::ToggleRule);
5053 #ifndef DISABLE_PLOT2DVIEWER
5054 popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
5055 popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
5058 //-------------------------------------------------
5060 //-------------------------------------------------
5061 popupMgr()->insert( separator(), -1, -1 );
5062 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
5063 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
5064 popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
5065 popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
5067 popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
5068 popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
5070 popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
5071 popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
5073 popupMgr()->insert( separator(), -1, -1 );
5075 //-------------------------------------------------
5077 //-------------------------------------------------
5078 popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
5079 popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
5081 popupMgr()->insert( separator(), -1, -1 );
5083 popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
5084 popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
5085 popupMgr()->insert( separator(), -1, -1 );
5087 popupMgr()->insert( action( SMESHOp::OpBreakLink), -1, -1 );
5088 popupMgr()->setRule( action( SMESHOp::OpBreakLink), "$component={'SHAPERSTUDY'} and client='ObjectBrowser' and canBreakLink", QtxPopupMgr::VisibleRule );
5090 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
5091 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
5093 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
5094 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
5097 //================================================================================
5099 * \brief Return true if SMESH or GEOM objects are selected.
5100 * Is called form LightApp_Module::activateModule() which clear selection if
5101 * not isSelectionCompatible()
5103 //================================================================================
5105 bool SMESHGUI::isSelectionCompatible()
5107 bool isCompatible = true;
5108 SALOME_ListIO selected;
5109 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
5110 Sel->selectedObjects( selected );
5112 SALOME_ListIteratorOfListIO It( selected );
5113 for ( ; isCompatible && It.More(); It.Next())
5115 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
5116 ( strcmp("SHAPERSTUDY", It.Value()->getComponentDataType()) == 0 ) ||
5117 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
5119 return isCompatible;
5123 bool SMESHGUI::reusableOperation( const int id )
5125 // compute, evaluate and precompute are not reusable operations
5126 return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate ) ? false : SalomeApp_Module::reusableOperation( id );
5129 bool SMESHGUI::activateModule( SUIT_Study* study )
5131 bool res = SalomeApp_Module::activateModule( study );
5133 setMenuShown( true );
5134 setToolShown( true );
5136 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
5137 PyGILState_STATE gstate = PyGILState_Ensure();
5138 PyObject* pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
5139 if ( !pluginsmanager ) {
5143 PyObject* result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toUtf8().data(),tr("SMESH_PLUGINS_OTHER").toUtf8().data());
5148 PyGILState_Release(gstate);
5149 // end of SMESH plugins loading
5151 // Reset actions accelerator keys
5152 action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
5154 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
5155 GetSMESHGen()->UpdateStudy();
5157 // get all view currently opened in the study and connect their signals to
5158 // the corresponding slots of the class.
5159 SUIT_Desktop* aDesk = study->application()->desktop();
5161 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
5162 SUIT_ViewWindow* wnd;
5163 foreach ( wnd, wndList )
5167 // remove actors whose objects are removed in GetSMESHGen()->UpdateStudy()
5168 SMESH::UpdateActorsAfterUpdateStudy(wnd);
5174 Py_XDECREF(pluginsmanager);
5178 bool SMESHGUI::deactivateModule( SUIT_Study* study )
5180 setMenuShown( false );
5181 setToolShown( false );
5183 EmitSignalCloseAllDialogs();
5185 // Unset actions accelerator keys
5186 action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
5188 return SalomeApp_Module::deactivateModule( study );
5191 void SMESHGUI::studyClosed( SUIT_Study* s )
5195 SMESH::RemoveVisuData();
5196 SalomeApp_Module::studyClosed( s );
5199 void SMESHGUI::OnGUIEvent()
5201 const QObject* obj = sender();
5202 if ( !obj || !obj->inherits( "QAction" ) )
5204 int id = actionId((QAction*)obj);
5209 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
5211 if ( CORBA::is_nil( myComponentSMESH ) )
5213 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
5214 return aGUI.myComponentSMESH;
5216 return myComponentSMESH;
5219 QString SMESHGUI::engineIOR() const
5221 CORBA::ORB_var anORB = getApp()->orb();
5222 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
5223 return QString( anIOR.in() );
5226 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
5228 SalomeApp_Module::contextMenuPopup( client, menu, title );
5230 selectionMgr()->selectedObjects( lst );
5231 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
5232 Handle(SALOME_InteractiveObject) io = lst.First();
5233 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
5234 _PTR(Study) study = appStudy->studyDS();
5235 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
5237 QString aName = SMESH::fromUtf8( obj->GetName());
5238 while ( !aName.isEmpty() && aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
5239 aName.remove(( aName.length() - 1 ), 1 );
5245 LightApp_Selection* SMESHGUI::createSelection() const
5247 return new SMESHGUI_Selection();
5250 void SMESHGUI::windows( QMap<int, int>& aMap ) const
5252 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
5253 aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
5254 #ifndef DISABLE_PYCONSOLE
5255 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
5259 void SMESHGUI::viewManagers( QStringList& list ) const
5261 list.append( SVTK_Viewer::Type() );
5264 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
5266 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
5267 SMESH::UpdateSelectionProp( this );
5269 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
5270 for(int i = 0; i < aViews.count() ; i++){
5271 SUIT_ViewWindow *sf = aViews[i];
5274 EmitSignalActivatedViewManager();
5278 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
5280 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
5281 myClippingPlaneInfoMap.erase( theViewManager );
5284 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
5286 theActor->AddObserver( SMESH::DeleteActorEvent,
5287 myEventCallbackCommand.GetPointer(),
5291 void SMESHGUI::ProcessEvents( vtkObject* theObject,
5292 unsigned long theEvent,
5293 void* theClientData,
5296 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
5297 if( theObject && (int) theEvent == SMESH::DeleteActorEvent ) {
5298 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
5299 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
5300 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
5301 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
5302 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
5303 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
5304 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
5305 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
5306 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
5307 SMESH::TActorList::iterator anIter3 = anActorList.begin();
5308 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
5309 if( anActor == *anIter3 ) {
5310 anActorList.erase( anIter3 );
5321 void SMESHGUI::createPreferences()
5323 // General tab ------------------------------------------------------------------------
5324 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
5326 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
5327 setPreferenceProperty( autoUpdate, "columns", 2 );
5328 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
5329 setPreferenceProperty( lim, "min", 0 );
5330 setPreferenceProperty( lim, "max", 100000000 );
5331 setPreferenceProperty( lim, "step", 1000 );
5332 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5333 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
5335 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
5336 setPreferenceProperty( dispgroup, "columns", 2 );
5338 addPreference( tr( "PREF_FITALL_ON_DISPLAYONLY" ), dispgroup, LightApp_Preferences::Bool, "SMESH", "fitall_on_displayonly" );
5340 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
5342 modes.append( tr("MEN_WIRE") );
5343 modes.append( tr("MEN_SHADE") );
5344 modes.append( tr("MEN_NODES") );
5345 modes.append( tr("MEN_SHRINK") );
5346 QList<QVariant> indices;
5347 indices.append( 0 );
5348 indices.append( 1 );
5349 indices.append( 2 );
5350 indices.append( 3 );
5351 setPreferenceProperty( dispmode, "strings", modes );
5352 setPreferenceProperty( dispmode, "indexes", indices );
5354 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
5355 setPreferenceProperty( arcgroup, "columns", 2 );
5356 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
5357 QStringList quadraticModes;
5358 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
5359 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
5361 indices.append( 0 );
5362 indices.append( 1 );
5363 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
5364 setPreferenceProperty( quadraticmode, "indexes", indices );
5366 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
5367 "SMESH", "max_angle" );
5368 setPreferenceProperty( maxAngle, "min", 1 );
5369 setPreferenceProperty( maxAngle, "max", 90 );
5371 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
5372 setPreferenceProperty( qaGroup, "columns", 2 );
5373 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
5374 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
5375 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
5376 setPreferenceProperty( prec, "min", 0 );
5377 setPreferenceProperty( prec, "max", 100 );
5378 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
5379 setPreferenceProperty( doubleNodesTol, "precision", 10 );
5380 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
5381 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
5382 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
5385 int cinc = addPreference(tr("PREF_CONTROLS_INCREMENT"), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_increment");
5386 setPreferenceProperty( cinc, "min", 0 );
5387 setPreferenceProperty( cinc, "max", 5 );
5390 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
5391 setPreferenceProperty( exportgroup, "columns", 2 );
5392 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
5393 addPreference( tr( "PREF_SHOW_WARN" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "show_warning" );
5394 int zTol = addPreference( tr( "PREF_ZTOLERANCE" ), exportgroup, LightApp_Preferences::DblSpin, "SMESH", "med_ztolerance" );
5395 setPreferenceProperty( zTol, "precision", 10 );
5396 setPreferenceProperty( zTol, "min", 0.0000000001 );
5397 setPreferenceProperty( zTol, "max", 1000000.0 );
5398 setPreferenceProperty( zTol, "step", 1. );
5399 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
5401 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
5402 setPreferenceProperty( computeGroup, "columns", 2 );
5403 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
5405 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5406 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5407 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5409 indices.append( 0 );
5410 indices.append( 1 );
5411 indices.append( 2 );
5412 setPreferenceProperty( notifyMode, "strings", modes );
5413 setPreferenceProperty( notifyMode, "indexes", indices );
5415 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5416 setPreferenceProperty( infoGroup, "columns", 2 );
5417 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5419 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5420 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5422 indices.append( 0 );
5423 indices.append( 1 );
5424 setPreferenceProperty( elemInfo, "strings", modes );
5425 setPreferenceProperty( elemInfo, "indexes", indices );
5426 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5427 setPreferenceProperty( nodesLim, "min", 0 );
5428 setPreferenceProperty( nodesLim, "max", 10000000 );
5429 setPreferenceProperty( nodesLim, "step", 10000 );
5430 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5431 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5432 setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5433 setPreferenceProperty( ctrlLim, "min", 0 );
5434 setPreferenceProperty( ctrlLim, "max", 10000000 );
5435 setPreferenceProperty( ctrlLim, "step", 1000 );
5436 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5437 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5438 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5439 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5440 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5442 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5443 setPreferenceProperty( segGroup, "columns", 2 );
5444 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5445 "SMESH", "segmentation" );
5446 setPreferenceProperty( segLen, "min", 1 );
5447 setPreferenceProperty( segLen, "max", 10000000 );
5448 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5449 "SMESH", "nb_segments_per_edge" );
5450 setPreferenceProperty( nbSeg, "min", 1 );
5451 setPreferenceProperty( nbSeg, "max", 10000000 );
5452 addPreference( tr( "PREF_USE_MESHGEMS_HYPOSET" ), segGroup, LightApp_Preferences::Bool, "SMESH", "use-meshgems-hypo-sets" );
5454 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5455 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5456 "SMESH", "forget_mesh_on_hyp_modif" );
5459 // Quantities with individual precision settings
5460 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5461 setPreferenceProperty( precGroup, "columns", 2 );
5463 const int nbQuantities = 6;
5464 int precs[nbQuantities], ii = 0;
5465 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5466 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5467 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5468 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5469 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5470 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5471 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5472 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5473 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5474 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5475 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5476 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5478 // Set property for precision value for spinboxes
5479 for ( ii = 0; ii < nbQuantities; ii++ ){
5480 setPreferenceProperty( precs[ii], "min", -14 );
5481 setPreferenceProperty( precs[ii], "max", 14 );
5482 setPreferenceProperty( precs[ii], "precision", 2 );
5485 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5486 setPreferenceProperty( previewGroup, "columns", 2 );
5487 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5488 setPreferenceProperty( chunkSize, "min", 1 );
5489 setPreferenceProperty( chunkSize, "max", 1000 );
5490 setPreferenceProperty( chunkSize, "step", 50 );
5492 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5493 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5495 // Mesh tab ------------------------------------------------------------------------
5496 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5497 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5498 setPreferenceProperty( nodeGroup, "columns", 3 );
5500 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5502 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5504 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5505 QList<QVariant> aMarkerTypeIndicesList;
5506 QList<QVariant> aMarkerTypeIconsList;
5507 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5508 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5509 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5510 aMarkerTypeIndicesList << i;
5511 aMarkerTypeIconsList << pixmap;
5513 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5514 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
5516 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5518 QList<QVariant> aMarkerScaleIndicesList;
5519 QStringList aMarkerScaleValuesList;
5520 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5521 aMarkerScaleIndicesList << i;
5522 //aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5523 aMarkerScaleValuesList << QString::number( i );
5525 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5526 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5528 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5529 //setPreferenceProperty( elemGroup, "columns", 2 );
5531 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5532 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5533 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5534 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5535 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5536 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5537 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5538 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5539 addPreference( tr( "PREF_PREVIEW_COLOR" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5542 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5543 setPreferenceProperty( grpGroup, "columns", 2 );
5545 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5546 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5548 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5549 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5550 /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5551 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5552 double ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5553 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5554 double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5555 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5556 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
5557 LightApp_Preferences::IntSpin, "SMESH", "element_width");
5558 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5559 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5560 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5561 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5563 setPreferenceProperty( size0d, "min", 1 );
5564 setPreferenceProperty( size0d, "max", 10 );
5566 // setPreferenceProperty( ballSize, "min", 1 );
5567 // setPreferenceProperty( ballSize, "max", 10 );
5569 setPreferenceProperty( ballDiameter, "min", 1e-7 );
5570 setPreferenceProperty( ballDiameter, "max", 1e9 );
5571 setPreferenceProperty( ballDiameter, "step", 0.1 );
5573 setPreferenceProperty( ballScale, "min", 1e-2 );
5574 setPreferenceProperty( ballScale, "max", 1e7 );
5575 setPreferenceProperty( ballScale, "step", 0.5 );
5577 setPreferenceProperty( elemW, "min", 1 );
5578 setPreferenceProperty( elemW, "max", 5 );
5580 setPreferenceProperty( outW, "min", 1 );
5581 setPreferenceProperty( outW, "max", 5 );
5583 setPreferenceProperty( shrink, "min", 0 );
5584 setPreferenceProperty( shrink, "max", 100 );
5586 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5587 setPreferenceProperty( numGroup, "columns", 2 );
5589 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5590 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5592 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5593 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5595 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5596 setPreferenceProperty( orientGroup, "columns", 1 );
5598 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5599 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5601 setPreferenceProperty( orientScale, "min", 0.05 );
5602 setPreferenceProperty( orientScale, "max", 0.5 );
5603 setPreferenceProperty( orientScale, "step", 0.05 );
5605 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5607 // Selection tab ------------------------------------------------------------------------
5608 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5610 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5611 setPreferenceProperty( selGroup, "columns", 2 );
5613 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5614 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5616 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5617 setPreferenceProperty( preGroup, "columns", 2 );
5619 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5621 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5622 setPreferenceProperty( precSelGroup, "columns", 2 );
5624 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5625 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5626 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5628 int sinc = addPreference(tr("PREF_SELECTION_INCREMENT"), selTab, LightApp_Preferences::IntSpin, "SMESH", "selection_increment");
5629 setPreferenceProperty( sinc, "min", 0 );
5630 setPreferenceProperty( sinc, "max", 5 );
5632 // Scalar Bar tab ------------------------------------------------------------------------
5633 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5634 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5635 setPreferenceProperty( fontGr, "columns", 2 );
5637 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5638 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5640 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5641 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5643 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5644 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5646 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5647 setPreferenceProperty( numcol, "min", 2 );
5648 setPreferenceProperty( numcol, "max", 256 );
5650 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5651 setPreferenceProperty( numlab, "min", 2 );
5652 setPreferenceProperty( numlab, "max", 65 );
5654 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5655 setPreferenceProperty( orientGr, "columns", 2 );
5656 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5657 QStringList orients;
5658 orients.append( tr( "SMESH_VERTICAL" ) );
5659 orients.append( tr( "SMESH_HORIZONTAL" ) );
5660 indices.clear(); indices.append( 0 ); indices.append( 1 );
5661 setPreferenceProperty( orient, "strings", orients );
5662 setPreferenceProperty( orient, "indexes", indices );
5664 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5665 setPreferenceProperty( posVSizeGr, "columns", 2 );
5666 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5667 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5668 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5669 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5670 setPreferenceProperty( xv, "step", 0.1 );
5671 setPreferenceProperty( xv, "min", 0.0 );
5672 setPreferenceProperty( xv, "max", 1.0 );
5673 setPreferenceProperty( yv, "step", 0.1 );
5674 setPreferenceProperty( yv, "min", 0.0 );
5675 setPreferenceProperty( yv, "max", 1.0 );
5676 setPreferenceProperty( wv, "step", 0.1 );
5677 setPreferenceProperty( wv, "min", 0.0 );
5678 setPreferenceProperty( wv, "max", 1.0 );
5679 setPreferenceProperty( hv, "min", 0.0 );
5680 setPreferenceProperty( hv, "max", 1.0 );
5681 setPreferenceProperty( hv, "step", 0.1 );
5683 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5684 setPreferenceProperty( posHSizeGr, "columns", 2 );
5685 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5686 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5687 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5688 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5689 setPreferenceProperty( xv, "min", 0.0 );
5690 setPreferenceProperty( xv, "max", 1.0 );
5691 setPreferenceProperty( xv, "step", 0.1 );
5692 setPreferenceProperty( xh, "min", 0.0 );
5693 setPreferenceProperty( xh, "max", 1.0 );
5694 setPreferenceProperty( xh, "step", 0.1 );
5695 setPreferenceProperty( yh, "min", 0.0 );
5696 setPreferenceProperty( yh, "max", 1.0 );
5697 setPreferenceProperty( yh, "step", 0.1 );
5698 setPreferenceProperty( wh, "min", 0.0 );
5699 setPreferenceProperty( wh, "max", 1.0 );
5700 setPreferenceProperty( wh, "step", 0.1 );
5701 setPreferenceProperty( hh, "min", 0.0 );
5702 setPreferenceProperty( hh, "max", 1.0 );
5703 setPreferenceProperty( hh, "step", 0.1 );
5705 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5706 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5707 setPreferenceProperty( distributionGr, "columns", 3 );
5709 types.append( tr( "SMESH_MONOCOLOR" ) );
5710 types.append( tr( "SMESH_MULTICOLOR" ) );
5711 indices.clear(); indices.append( 0 ); indices.append( 1 );
5712 setPreferenceProperty( coloringType, "strings", types );
5713 setPreferenceProperty( coloringType, "indexes", indices );
5714 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5718 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5720 if ( sect=="SMESH" ) {
5721 float sbX1 = 0.01, sbY1 = 0.01, sbW = 0.08, sbH = 0.08;
5722 float aTol = 1.00000009999999;
5723 std::string aWarning;
5724 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5726 if ( name == "selection_object_color" ||
5727 name == "selection_element_color" ||
5728 name == "highlight_color" ||
5729 name == "selection_precision_node" ||
5730 name == "selection_precision_element" ||
5731 name == "selection_precision_object" ||
5732 name == "selection_increment")
5734 SMESH::UpdateSelectionProp( this );
5736 else if (name == "scalar_bar_vertical_x" || name == "scalar_bar_vertical_width")
5738 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5739 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5740 if ( sbX1+sbW > aTol ) {
5741 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5744 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5745 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5748 else if (name == "scalar_bar_vertical_y" || name == "scalar_bar_vertical_height" )
5750 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5751 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5752 if ( sbY1 + sbH > aTol ) {
5753 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5754 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5755 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5758 else if (name == "scalar_bar_horizontal_x" || name == "scalar_bar_horizontal_width")
5760 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5761 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5762 if ( sbX1 + sbW > aTol ) {
5763 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5766 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5767 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5770 else if (name == "scalar_bar_horizontal_y" || name == "scalar_bar_horizontal_height")
5772 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5773 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5774 if ( sbY1 + sbH > aTol ) {
5775 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5778 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5779 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5782 else if ( name == "segmentation" )
5784 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5785 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5787 else if ( name == "nb_segments_per_edge" )
5789 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5790 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5792 else if ( name == "historical_python_dump" || name == "forget_mesh_on_hyp_modif" || name == "default_grp_color" )
5794 QString val = aResourceMgr->stringValue( "SMESH", name );
5795 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5797 else if ( name == "numbering_node_color" || name == "numbering_node_font" )
5799 SMESH::UpdateFontProp( this );
5801 else if ( name == "numbering_elem_color" || name == "numbering_elem_font" )
5803 SMESH::UpdateFontProp( this );
5806 if ( aWarning.size() != 0 ) {
5807 aWarning += "The default values are applied instead.";
5808 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5809 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5810 QObject::tr(aWarning.c_str()));
5815 //================================================================================
5817 * \brief Update something in accordance with update flags
5818 * \param theFlags - update flags
5820 * Update viewer or/and object browser etc. in accordance with update flags ( see
5821 * LightApp_UpdateFlags enumeration ).
5823 //================================================================================
5824 void SMESHGUI::update( const int flags )
5826 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5827 SMESH::UpdateView();
5829 SalomeApp_Module::update( flags );
5832 //================================================================================
5834 * \brief Set default selection mode
5836 * SLOT called when operation committed. Sets default selection mode
5838 //================================================================================
5839 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5841 SVTK_ViewWindow* vtkWnd =
5842 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5844 vtkWnd->SetSelectionMode( ActorSelection );
5847 //================================================================================
5849 * \brief Set default selection mode
5851 * SLOT called when operation aborted. Sets default selection mode
5853 //================================================================================
5854 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5856 SVTK_ViewWindow* vtkWnd =
5857 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5859 vtkWnd->SetSelectionMode( ActorSelection );
5862 //================================================================================
5864 * \brief Creates operation with given identifier
5865 * \param id - identifier of operation to be started
5866 * \return Pointer on created operation or NULL if operation is not created
5868 * Virtual method redefined from the base class creates operation with given id.
5869 * It is called called automatically from startOperation method of base class.
5871 //================================================================================
5872 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5874 LightApp_Operation* op = 0;
5875 // to do : create operation here
5878 case SMESHOp::OpSplitBiQuadratic:
5879 op = new SMESHGUI_SplitBiQuadOp();
5881 case SMESHOp::OpUniformRefinement:
5883 case SMESHOp::OpHONewCase:
5885 case SMESHOp::OpHOCaseFollow:
5887 case SMESHOp::OpHONewIter:
5889 case SMESHOp::OpHOIterCompute:
5891 case SMESHOp::OpHOIterComputePublish:
5893 case SMESHOp::OpHOEdit:
5895 case SMESHOp::OpHODelete:
5897 case SMESHOp::OpMGAdapt:
5899 case SMESHOp::OpConvertMeshToQuadratic:
5900 op = new SMESHGUI_ConvToQuadOp();
5902 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5903 op = new SMESHGUI_Make2DFrom3DOp();
5905 case SMESHOp::OpReorientFaces:
5906 op = new SMESHGUI_ReorientFacesOp();
5908 case SMESHOp::OpCreateMesh:
5909 op = new SMESHGUI_MeshOp( true, true );
5911 case SMESHOp::OpCreateSubMesh:
5912 op = new SMESHGUI_MeshOp( true, false );
5914 case SMESHOp::OpEditMeshOrSubMesh:
5915 case SMESHOp::OpEditMesh:
5916 case SMESHOp::OpEditSubMesh:
5917 op = new SMESHGUI_MeshOp( false );
5919 case SMESHOp::OpCompute:
5920 case SMESHOp::OpComputeSubMesh:
5921 op = new SMESHGUI_ComputeOp();
5923 case SMESHOp::OpPreCompute:
5924 op = new SMESHGUI_PrecomputeOp();
5926 case SMESHOp::OpEvaluate:
5927 op = new SMESHGUI_EvaluateOp();
5929 case SMESHOp::OpMeshOrder:
5930 op = new SMESHGUI_MeshOrderOp();
5932 case SMESHOp::OpCreateGeometryGroup:
5933 op = new SMESHGUI_GroupOnShapeOp();
5935 case SMESHOp::OpFindElementByPoint:
5936 op = new SMESHGUI_FindElemByPointOp();
5938 case SMESHOp::OpMoveNode: // Make mesh pass through point
5939 op = new SMESHGUI_MakeNodeAtPointOp();
5941 case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
5942 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5949 op = SalomeApp_Module::createOperation( id );
5953 //================================================================================
5955 * \brief Stops current operations and starts a given one
5956 * \param id - The id of the operation to start
5958 //================================================================================
5960 void SMESHGUI::switchToOperation(int id)
5962 activeStudy()->abortAllOperations();
5963 startOperation( id );
5966 LightApp_Displayer* SMESHGUI::displayer()
5969 myDisplayer = new SMESHGUI_Displayer( getApp() );
5973 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5976 int aTolerance = 64;
5977 int anIterations = 0;
5983 if( anIterations % aPeriod == 0 )
5986 if( aTolerance < 1 )
5990 aHue = (int)( 360.0 * rand() / RAND_MAX );
5993 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5994 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5995 for( ; it != itEnd; ++it )
5997 SALOMEDS::Color anAutoColor = *it;
5998 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
6001 aQColor.getHsv( &h, &s, &v );
6002 if( abs( h - aHue ) < aTolerance )
6014 aColor.setHsv( aHue, 255, 255 );
6016 SALOMEDS::Color aSColor;
6017 aSColor.R = aColor.redF();
6018 aSColor.G = aColor.greenF();
6019 aSColor.B = aColor.blueF();
6024 const char* gSeparator = "_"; // character used to separate parameter names
6025 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
6026 const char* gPathSep = "|"; // character used to separate paths
6029 * \brief Store visual parameters
6031 * This method is called just before the study document is saved.
6032 * Store visual parameters in AttributeParameter attribute(s)
6034 void SMESHGUI::storeVisualParameters (int savePoint)
6037 Kernel_Utils::Localizer loc;
6039 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6040 if (!appStudy || !appStudy->studyDS())
6042 _PTR(Study) studyDS = appStudy->studyDS();
6044 // componentName is used for encoding of entries when storing them in IParameters
6045 std::string componentName = myComponentSMESH->ComponentDataType();
6046 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
6047 //if (!aSComponent) return;
6050 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6051 componentName.c_str(),
6053 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6055 // store custom markers
6056 if( !myMarkerMap.empty() )
6058 VTK::MarkerMap::const_iterator anIter = myMarkerMap.begin();
6059 for( ; anIter != myMarkerMap.end(); anIter++ )
6061 int anId = anIter->first;
6062 VTK::MarkerData aMarkerData = anIter->second;
6063 std::string aMarkerFileName = aMarkerData.first;
6064 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
6065 if( aMarkerTexture.size() < 3 )
6066 continue; // should contain at least width, height and the first value
6068 QString aPropertyName( "texture" );
6069 aPropertyName += gSeparator;
6070 aPropertyName += QString::number( anId );
6072 QString aPropertyValue = aMarkerFileName.c_str();
6073 aPropertyValue += gPathSep;
6075 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
6076 ushort aWidth = *aTextureIter++;
6077 ushort aHeight = *aTextureIter++;
6078 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
6079 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
6080 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
6081 aPropertyValue += QString::number( *aTextureIter );
6083 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
6087 // viewers counters are used for storing view_numbers in IParameters
6090 // main cycle to store parameters of displayed objects
6091 QList<SUIT_ViewManager*> lst;
6092 QList<SUIT_ViewManager*>::Iterator it;
6093 getApp()->viewManagers(lst);
6094 for (it = lst.begin(); it != lst.end(); it++)
6096 SUIT_ViewManager* vman = *it;
6097 QString vType = vman->getType();
6099 // saving VTK actors properties
6100 if (vType == SVTK_Viewer::Type())
6102 // store the clipping planes attached to the view manager
6103 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
6104 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
6105 if( anIter != myClippingPlaneInfoMap.end() )
6106 aClippingPlaneInfoList = anIter->second;
6108 if( !aClippingPlaneInfoList.empty() ) {
6109 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
6110 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
6112 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
6113 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
6115 QString aPropertyName( "ClippingPlane" );
6116 aPropertyName += gSeparator;
6117 aPropertyName += QString::number( vtkViewers );
6118 aPropertyName += gSeparator;
6119 aPropertyName += QString::number( anId );
6121 QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
6122 aPropertyValue += gDigitsSep;
6123 aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
6124 aPropertyValue += gDigitsSep;
6125 if ( aPlane->PlaneMode == SMESH::Absolute ) {
6126 aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
6127 aPropertyValue += gDigitsSep;
6128 aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
6129 aPropertyValue += gDigitsSep;
6130 aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
6131 aPropertyValue += gDigitsSep;
6132 aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
6133 aPropertyValue += gDigitsSep;
6134 aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
6135 aPropertyValue += gDigitsSep;
6136 aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
6137 aPropertyValue += gDigitsSep;
6138 aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
6140 else if ( aPlane->PlaneMode == SMESH::Relative ) {
6141 aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
6142 aPropertyValue += gDigitsSep;
6143 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
6144 aPropertyValue += gDigitsSep;
6145 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
6146 aPropertyValue += gDigitsSep;
6147 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
6150 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
6154 QVector<SUIT_ViewWindow*> views = vman->getViews();
6155 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
6157 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
6159 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
6160 vtkActorCollection* allActors = aCopy.GetActors();
6161 allActors->InitTraversal();
6162 while (vtkActor* actor = allActors->GetNextActor())
6164 if (actor->GetVisibility()) // store only visible actors
6166 SMESH_Actor* aSmeshActor = 0;
6167 if (actor->IsA("SMESH_Actor"))
6168 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
6169 if (aSmeshActor && aSmeshActor->hasIO())
6171 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
6174 // entry is "encoded" = it does NOT contain component address,
6175 // since it is a subject to change on next component loading
6176 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
6178 std::string param, vtkParam = vType.toLatin1().data();
6179 vtkParam += gSeparator;
6180 vtkParam += QString::number(vtkViewers).toLatin1().data();
6181 vtkParam += gSeparator;
6184 param = vtkParam + "Visibility";
6185 ip->setParameter(entry, param, "On");
6188 param = vtkParam + "Representation";
6189 ip->setParameter(entry, param, QString::number
6190 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
6193 param = vtkParam + "IsShrunk";
6194 ip->setParameter(entry, param, QString::number
6195 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
6197 // Displayed entities
6198 unsigned int aMode = aSmeshActor->GetEntityMode();
6199 bool isE = aMode & SMESH_Actor::eEdges;
6200 bool isF = aMode & SMESH_Actor::eFaces;
6201 bool isV = aMode & SMESH_Actor::eVolumes;
6202 bool is0d = aMode & SMESH_Actor::e0DElements;
6203 bool isB = aMode & SMESH_Actor::eBallElem;
6205 QString modeStr ("e");
6206 modeStr += gDigitsSep; modeStr += QString::number(isE);
6207 modeStr += gDigitsSep; modeStr += "f";
6208 modeStr += gDigitsSep; modeStr += QString::number(isF);
6209 modeStr += gDigitsSep; modeStr += "v";
6210 modeStr += gDigitsSep; modeStr += QString::number(isV);
6211 modeStr += gDigitsSep; modeStr += "0d";
6212 modeStr += gDigitsSep; modeStr += QString::number(is0d);
6213 modeStr += gDigitsSep; modeStr += "b";
6214 modeStr += gDigitsSep; modeStr += QString::number(isB);
6216 param = vtkParam + "Entities";
6217 ip->setParameter(entry, param, modeStr.toLatin1().data());
6223 aSmeshActor->GetSufaceColor(r, g, b, delta);
6224 QStringList colorStr;
6225 colorStr << "surface";
6226 colorStr << QString::number(r);
6227 colorStr << QString::number(g);
6228 colorStr << QString::number(b);
6230 colorStr << "backsurface";
6231 colorStr << QString::number(delta);
6233 aSmeshActor->GetVolumeColor(r, g, b, delta);
6234 colorStr << "volume";
6235 colorStr << QString::number(r);
6236 colorStr << QString::number(g);
6237 colorStr << QString::number(b);
6238 colorStr << QString::number(delta);
6240 aSmeshActor->GetEdgeColor(r, g, b);
6242 colorStr << QString::number(r);
6243 colorStr << QString::number(g);
6244 colorStr << QString::number(b);
6246 aSmeshActor->GetNodeColor(r, g, b);
6248 colorStr << QString::number(r);
6249 colorStr << QString::number(g);
6250 colorStr << QString::number(b);
6252 aSmeshActor->GetOutlineColor(r, g, b);
6253 colorStr << "outline";
6254 colorStr << QString::number(r);
6255 colorStr << QString::number(g);
6256 colorStr << QString::number(b);
6258 aSmeshActor->Get0DColor(r, g, b);
6259 colorStr << "elem0d";
6260 colorStr << QString::number(r);
6261 colorStr << QString::number(g);
6262 colorStr << QString::number(b);
6264 aSmeshActor->GetBallColor(r, g, b);
6266 colorStr << QString::number(r);
6267 colorStr << QString::number(g);
6268 colorStr << QString::number(b);
6270 aSmeshActor->GetFacesOrientationColor(r, g, b);
6271 colorStr << "orientation";
6272 colorStr << QString::number(r);
6273 colorStr << QString::number(g);
6274 colorStr << QString::number(b);
6276 param = vtkParam + "Colors";
6277 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
6280 QStringList sizeStr;
6282 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
6283 sizeStr << "outline";
6284 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
6285 sizeStr << "elem0d";
6286 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
6288 //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
6289 sizeStr << QString::number((double)aSmeshActor->GetBallSize());
6290 sizeStr << QString::number((double)aSmeshActor->GetBallScale());
6291 sizeStr << "shrink";
6292 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
6293 sizeStr << "orientation";
6294 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
6295 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
6297 param = vtkParam + "Sizes";
6298 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
6303 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
6304 if( aMarkerType == VTK::MT_USER ) {
6305 markerStr += "custom";
6306 markerStr += gDigitsSep;
6307 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
6311 markerStr += gDigitsSep;
6312 markerStr += QString::number( (int)aMarkerType );
6313 markerStr += gDigitsSep;
6314 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
6317 param = vtkParam + "PointMarker";
6318 ip->setParameter(entry, param, markerStr.toLatin1().data());
6321 param = vtkParam + "Opacity";
6322 ip->setParameter(entry, param,
6323 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
6326 param = vtkParam + "ClippingPlane";
6328 if( !aClippingPlaneInfoList.empty() ) {
6329 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
6330 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
6332 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
6333 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
6334 SMESH::TActorList::iterator anIter2 = anActorList.begin();
6335 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
6336 if( aSmeshActor == *anIter2 ) {
6337 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
6338 QString::number( anId ).toLatin1().constData() );
6345 ip->setParameter( entry, param, "Off" );
6346 } // if (io->hasEntry())
6347 } // SMESH_Actor && hasIO
6349 } // while.. actors traversal
6353 } // if (SVTK view model)
6354 } // for (viewManagers)
6357 // data structures for clipping planes processing
6361 bool isOpenGLClipping;
6362 vtkIdType RelativeOrientation;
6365 int AbsoluteOrientation;
6366 double X, Y, Z, Dx, Dy, Dz;
6368 typedef std::list<TPlaneData> TPlaneDataList;
6369 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
6371 typedef std::list<vtkActor*> TActorList;
6374 TActorList ActorList;
6375 SUIT_ViewManager* ViewManager;
6377 typedef std::list<TPlaneInfo> TPlaneInfoList;
6378 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
6381 * \brief Restore visual parameters
6383 * This method is called after the study document is opened.
6384 * Restore visual parameters from AttributeParameter attribute(s)
6386 void SMESHGUI::restoreVisualParameters (int savePoint)
6389 Kernel_Utils::Localizer loc;
6391 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6392 if (!appStudy || !appStudy->studyDS())
6394 _PTR(Study) studyDS = appStudy->studyDS();
6396 // componentName is used for encoding of entries when storing them in IParameters
6397 std::string componentName = myComponentSMESH->ComponentDataType();
6400 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6401 componentName.c_str(),
6403 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6405 // restore custom markers and map of clipping planes
6406 TPlaneDataMap aPlaneDataMap;
6408 std::vector<std::string> properties = ip->getProperties();
6409 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
6411 std::string property = *propIt;
6412 QString aPropertyName( property.c_str() );
6413 QString aPropertyValue( ip->getProperty( property ).c_str() );
6415 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
6416 if( aPropertyNameList.isEmpty() )
6419 QString aPropertyType = aPropertyNameList[0];
6420 if( aPropertyType == "texture" )
6422 if( aPropertyNameList.size() != 2 )
6426 int anId = aPropertyNameList[1].toInt( &ok );
6427 if( !ok || anId < 1 )
6430 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
6431 if( aPropertyValueList.size() != 2 )
6434 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
6435 QString aMarkerTextureString = aPropertyValueList[1];
6436 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
6437 if( aMarkerTextureStringList.size() != 3 )
6441 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6446 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6450 VTK::MarkerTexture aMarkerTexture;
6451 aMarkerTexture.push_back( aWidth );
6452 aMarkerTexture.push_back( aHeight );
6454 QString aMarkerTextureData = aMarkerTextureStringList[2];
6455 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6457 QChar aChar = aMarkerTextureData.at( i );
6458 if( aChar.isDigit() )
6459 aMarkerTexture.push_back( aChar.digitValue() );
6462 myMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6464 else if( aPropertyType == "ClippingPlane" )
6466 if( aPropertyNameList.size() != 3 )
6470 int aViewId = aPropertyNameList[1].toInt( &ok );
6471 if( !ok || aViewId < 0 )
6475 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6476 if( !ok || aClippingPlaneId < 0 )
6479 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6480 if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6483 TPlaneData aPlaneData;
6484 aPlaneData.AbsoluteOrientation = false;
6485 aPlaneData.RelativeOrientation = 0;
6486 aPlaneData.Distance = aPlaneData.Angle[0] = aPlaneData.Angle[1] = 0;
6487 aPlaneData.X = aPlaneData.Y = aPlaneData.Z = 0;
6488 aPlaneData.Dx = aPlaneData.Dy = aPlaneData.Dz = 0;
6490 aPlaneData.Id = aClippingPlaneId;
6493 aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6498 aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6502 if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6505 aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6510 aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6515 aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6520 aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6525 aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6530 aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6535 aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6539 else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6541 aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6546 aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6551 aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6556 aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6561 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6562 aPlaneDataList.push_back( aPlaneData );
6566 TPlaneInfoMap aPlaneInfoMap;
6568 std::vector<std::string> entries = ip->getEntries();
6570 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6572 // entry is a normal entry - it should be "decoded" (setting base address of component)
6573 QString entry (ip->decodeEntry(*entIt).c_str());
6575 // Check that the entry corresponds to a real object in the Study
6576 // as the object may be deleted or modified after the visual state is saved.
6577 _PTR(SObject) so = studyDS->FindObjectID(entry.toUtf8().data());
6578 if (!so) continue; //Skip the not existent entry
6580 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6581 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6583 std::vector<std::string>::iterator namesIt = paramNames.begin();
6584 std::vector<std::string>::iterator valuesIt = paramValues.begin();
6586 // actors are stored in a map after displaying of them for
6587 // quicker access in the future: map < viewID to actor >
6588 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6590 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6592 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6593 // '_' is used as separator and should not be used in viewer type or parameter names.
6594 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6595 if (lst.size() != 3)
6598 QString viewerTypStr = lst[0];
6599 QString viewIndexStr = lst[1];
6600 QString paramNameStr = lst[2];
6603 int viewIndex = viewIndexStr.toUInt(&ok);
6604 if (!ok) // bad conversion of view index to integer
6608 if (viewerTypStr == SVTK_Viewer::Type())
6610 SMESH_Actor* aSmeshActor = 0;
6611 if (vtkActors.IsBound(viewIndex))
6612 aSmeshActor = vtkActors.Find(viewIndex);
6614 QList<SUIT_ViewManager*> lst;
6615 getApp()->viewManagers(viewerTypStr, lst);
6617 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6618 SUIT_ViewManager* vman = NULL;
6619 if (viewIndex >= 0 && viewIndex < lst.count())
6620 vman = lst.at(viewIndex);
6622 if (paramNameStr == "Visibility")
6624 if (!aSmeshActor && displayer() && vman)
6626 SUIT_ViewModel* vmodel = vman->getViewModel();
6627 // SVTK view model can be casted to SALOME_View
6628 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6630 // store displayed actor in a temporary map for quicker
6631 // access later when restoring other parameters
6632 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6633 vtkRenderer* Renderer = vtkView->getRenderer();
6634 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6635 vtkActorCollection* theActors = aCopy.GetActors();
6636 theActors->InitTraversal();
6637 bool isFound = false;
6638 vtkActor *ac = theActors->GetNextActor();
6639 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6640 if (ac->IsA("SMESH_Actor")) {
6641 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6642 if (aGeomAc->hasIO()) {
6643 Handle(SALOME_InteractiveObject) io = aGeomAc->getIO();
6644 if (io->hasEntry() && strcmp(io->getEntry(), entry.toUtf8().data()) == 0) {
6646 vtkActors.Bind(viewIndex, aGeomAc);
6652 } // if (paramNameStr == "Visibility")
6655 // the rest properties "work" with SMESH_Actor
6658 QString val ((*valuesIt).c_str());
6661 if (paramNameStr == "Representation") {
6662 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6665 else if (paramNameStr == "IsShrunk") {
6667 if (!aSmeshActor->IsShrunk())
6668 aSmeshActor->SetShrink();
6671 if (aSmeshActor->IsShrunk())
6672 aSmeshActor->UnShrink();
6675 // Displayed entities
6676 else if (paramNameStr == "Entities") {
6677 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6678 int aEntityMode = SMESH_Actor::eAllEntity;
6679 for ( int i = 0; i < mode.count(); i+=2 ) {
6680 if ( i < mode.count()-1 ) {
6681 QString type = mode[i];
6682 bool val = mode[i+1].toInt();
6683 if ( type == "e" && !val )
6684 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6685 else if ( type == "f" && !val )
6686 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6687 else if ( type == "v" && !val )
6688 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6689 else if ( type == "0d" && !val )
6690 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6691 else if ( type == "b" && !val )
6692 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6695 aSmeshActor->SetEntityMode( aEntityMode );
6698 else if (paramNameStr == "Colors") {
6699 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6706 QColor outlineColor;
6707 QColor orientationColor;
6713 // below lines are required to get default values for delta coefficients
6714 // of backface color for faces and color of reversed volumes
6715 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
6716 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6717 for ( int i = 0; i < colors.count(); i++ ) {
6718 QString type = colors[i];
6719 if ( type == "surface" ) {
6720 // face color is set by 3 values r:g:b, where
6721 // - r,g,b - is rgb color components
6722 if ( i+1 >= colors.count() ) break; // format error
6723 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6724 if ( i+2 >= colors.count() ) break; // format error
6725 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6726 if ( i+3 >= colors.count() ) break; // format error
6727 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6728 faceColor.setRgbF( r, g, b );
6731 else if ( type == "backsurface" ) {
6732 // backface color can be defined in several ways
6733 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6734 // - in latest versions, it is set as delta coefficient
6735 bool rgbOk = false, deltaOk;
6736 if ( i+1 >= colors.count() ) break; // format error
6737 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6738 int delta = colors[i+1].toInt( &deltaOk );
6740 if ( i+1 < colors.count() ) // index is shifted to 1
6741 g = colors[i+1].toDouble( &rgbOk );
6742 if ( rgbOk ) i++; // shift index
6743 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6744 b = colors[i+1].toDouble( &rgbOk );
6746 // - as currently there's no way to set directly backsurface color as it was before,
6747 // we ignore old dump where r,g,b triple was set
6748 // - also we check that delta parameter is set properly
6749 if ( !rgbOk && deltaOk )
6752 else if ( type == "volume" ) {
6753 // volume color is set by 4 values r:g:b:delta, where
6754 // - r,g,b - is a normal volume rgb color components
6755 // - delta - is a reversed volume color delta coefficient
6756 if ( i+1 >= colors.count() ) break; // format error
6757 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6758 if ( i+2 >= colors.count() ) break; // format error
6759 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6760 if ( i+3 >= colors.count() ) break; // format error
6761 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6762 if ( i+4 >= colors.count() ) break; // format error
6763 int delta = colors[i+4].toInt( &bOk );
6764 if ( !bOk ) break; // format error
6765 volumeColor.setRgbF( r, g, b );
6769 else if ( type == "edge" ) {
6770 // edge color is set by 3 values r:g:b, where
6771 // - r,g,b - is rgb color components
6772 if ( i+1 >= colors.count() ) break; // format error
6773 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6774 if ( i+2 >= colors.count() ) break; // format error
6775 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6776 if ( i+3 >= colors.count() ) break; // format error
6777 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6778 edgeColor.setRgbF( r, g, b );
6781 else if ( type == "node" ) {
6782 // node color is set by 3 values r:g:b, where
6783 // - r,g,b - is rgb color components
6784 if ( i+1 >= colors.count() ) break; // format error
6785 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6786 if ( i+2 >= colors.count() ) break; // format error
6787 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6788 if ( i+3 >= colors.count() ) break; // format error
6789 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6790 nodeColor.setRgbF( r, g, b );
6793 else if ( type == "elem0d" ) {
6794 // 0d element color is set by 3 values r:g:b, where
6795 // - r,g,b - is rgb color components
6796 if ( i+1 >= colors.count() ) break; // format error
6797 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6798 if ( i+2 >= colors.count() ) break; // format error
6799 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6800 if ( i+3 >= colors.count() ) break; // format error
6801 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6802 elem0dColor.setRgbF( r, g, b );
6805 else if ( type == "ball" ) {
6806 // ball color is set by 3 values r:g:b, where
6807 // - r,g,b - is rgb color components
6808 if ( i+1 >= colors.count() ) break; // format error
6809 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6810 if ( i+2 >= colors.count() ) break; // format error
6811 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6812 if ( i+3 >= colors.count() ) break; // format error
6813 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6814 ballColor.setRgbF( r, g, b );
6817 else if ( type == "outline" ) {
6818 // outline color is set by 3 values r:g:b, where
6819 // - r,g,b - is rgb color components
6820 if ( i+1 >= colors.count() ) break; // format error
6821 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6822 if ( i+2 >= colors.count() ) break; // format error
6823 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6824 if ( i+3 >= colors.count() ) break; // format error
6825 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6826 outlineColor.setRgbF( r, g, b );
6829 else if ( type == "orientation" ) {
6830 // orientation color is set by 3 values r:g:b, where
6831 // - r,g,b - is rgb color components
6832 if ( i+1 >= colors.count() ) break; // format error
6833 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6834 if ( i+2 >= colors.count() ) break; // format error
6835 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6836 if ( i+3 >= colors.count() ) break; // format error
6837 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6838 orientationColor.setRgbF( r, g, b );
6843 if ( nodeColor.isValid() )
6844 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6846 if ( edgeColor.isValid() )
6847 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6849 if ( faceColor.isValid() )
6850 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6852 if ( volumeColor.isValid() )
6853 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6854 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6855 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6857 if ( elem0dColor.isValid() )
6858 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6860 if ( ballColor.isValid() )
6861 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6863 if ( outlineColor.isValid() )
6864 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6865 // orientation color
6866 if ( orientationColor.isValid() )
6867 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6870 else if (paramNameStr == "Sizes") {
6871 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6874 int outlineWidth = -1;
6875 int elem0dSize = -1;
6876 //int ballSize = -1;
6877 double ballDiameter = -1.0;
6878 double ballScale = -1.0;
6879 double shrinkSize = -1;
6880 double orientationSize = -1;
6881 bool orientation3d = false;
6882 for ( int i = 0; i < sizes.count(); i++ ) {
6883 QString type = sizes[i];
6884 if ( type == "line" ) {
6885 // line (wireframe) width is given as single integer value
6886 if ( i+1 >= sizes.count() ) break; // format error
6887 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6891 if ( type == "outline" ) {
6892 // outline width is given as single integer value
6893 if ( i+1 >= sizes.count() ) break; // format error
6894 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6898 else if ( type == "elem0d" ) {
6899 // 0d element size is given as single integer value
6900 if ( i+1 >= sizes.count() ) break; // format error
6901 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6905 else if ( type == "ball" ) {
6906 // balls are specified by two values: size:scale, where
6907 // - size - is a integer value specifying size
6908 // - scale - is a double value specifying scale factor
6909 if ( i+1 >= sizes.count() ) break; // format error
6910 //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6911 double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6912 if ( i+2 >= sizes.count() ) break; // format error
6913 double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6919 else if ( type == "shrink" ) {
6920 // shrink factor is given as single floating point value
6921 if ( i+1 >= sizes.count() ) break; // format error
6922 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6926 else if ( type == "orientation" ) {
6927 // orientation vectors are specified by two values size:3d, where
6928 // - size - is a floating point value specifying scale factor
6929 // - 3d - is a boolean
6930 if ( i+1 >= sizes.count() ) break; // format error
6931 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6932 if ( i+2 >= sizes.count() ) break; // format error
6933 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6934 orientationSize = v1;
6935 orientation3d = (bool)v2;
6939 // line (wireframe) width
6940 if ( lineWidth > 0 )
6941 aSmeshActor->SetLineWidth( lineWidth );
6943 if ( outlineWidth > 0 )
6944 aSmeshActor->SetOutlineWidth( outlineWidth );
6945 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6946 aSmeshActor->SetOutlineWidth( lineWidth );
6948 if ( elem0dSize > 0 )
6949 aSmeshActor->Set0DSize( elem0dSize );
6951 /*if ( ballSize > 0 )
6952 aSmeshActor->SetBallSize( ballSize );*/
6954 if ( ballDiameter > 0 )
6955 aSmeshActor->SetBallSize( ballDiameter );
6957 if ( ballScale > 0.0 )
6958 aSmeshActor->SetBallScale( ballScale );
6960 if ( shrinkSize > 0 )
6961 aSmeshActor->SetShrinkFactor( shrinkSize );
6962 // orientation vectors
6963 if ( orientationSize > 0 ) {
6964 aSmeshActor->SetFacesOrientationScale( orientationSize );
6965 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6969 else if (paramNameStr == "PointMarker") {
6970 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6971 if( data.count() >= 2 ) {
6973 int aParam1 = data[1].toInt( &ok );
6975 if( data[0] == "std" && data.count() == 3 ) {
6976 int aParam2 = data[2].toInt( &ok );
6977 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6979 else if( data[0] == "custom" ) {
6980 VTK::MarkerMap::const_iterator markerIt = myMarkerMap.find( aParam1 );
6981 if( markerIt != myMarkerMap.end() ) {
6982 VTK::MarkerData aMarkerData = markerIt->second;
6983 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6990 else if (paramNameStr == "Opacity") {
6991 aSmeshActor->SetOpacity(val.toFloat());
6994 else if (paramNameStr.startsWith("ClippingPlane")) {
6995 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6996 // old format - val looks like "Off" or "1:0:0:0.5:0:0"
6997 // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
6998 // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
6999 // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
7000 // new format - val looks like "Off" or "0" (plane id)
7001 // (note: in new format "Off" value is used only for consistency,
7002 // so it is processed together with values in old format)
7003 bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
7004 if( anIsOldFormat ) {
7005 if (paramNameStr == "ClippingPlane1" || val == "Off")
7006 aSmeshActor->RemoveAllClippingPlanes();
7008 QList<SUIT_ViewManager*> lst;
7009 getApp()->viewManagers(viewerTypStr, lst);
7010 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
7011 if (viewIndex >= 0 && viewIndex < lst.count()) {
7012 SUIT_ViewManager* vman = lst.at(viewIndex);
7013 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
7015 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
7017 SMESH::TActorList anActorList;
7018 anActorList.push_back( aSmeshActor );
7019 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
7020 aPlane->myViewWindow = vtkView;
7021 SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
7022 aPlane->PlaneMode = aMode;
7023 bool isOpenGLClipping = ( bool )vals[1].toInt();
7024 aPlane->IsOpenGLClipping = isOpenGLClipping;
7025 if ( aMode == SMESH::Absolute ) {
7026 aPlane->myAbsoluteOrientation = vals[2].toInt();
7027 aPlane->X = vals[3].toFloat();
7028 aPlane->Y = vals[4].toFloat();
7029 aPlane->Z = vals[5].toFloat();
7030 aPlane->Dx = vals[6].toFloat();
7031 aPlane->Dy = vals[7].toFloat();
7032 aPlane->Dz = vals[8].toFloat();
7034 else if ( aMode == SMESH::Relative ) {
7035 aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
7036 aPlane->myDistance = vals[3].toFloat();
7037 aPlane->myAngle[0] = vals[4].toFloat();
7038 aPlane->myAngle[1] = vals[5].toFloat();
7042 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
7043 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
7044 aClippingPlaneInfo.Plane = aPlane;
7045 aClippingPlaneInfo.ActorList = anActorList;
7046 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
7054 int aPlaneId = val.toInt( &ok );
7055 if( ok && aPlaneId >= 0 ) {
7056 bool anIsDefinedPlane = false;
7057 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
7058 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
7059 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
7060 TPlaneInfo& aPlaneInfo = *anIter;
7061 if( aPlaneInfo.PlaneId == aPlaneId ) {
7062 aPlaneInfo.ActorList.push_back( aSmeshActor );
7063 anIsDefinedPlane = true;
7067 if( !anIsDefinedPlane ) {
7068 TPlaneInfo aPlaneInfo;
7069 aPlaneInfo.PlaneId = aPlaneId;
7070 aPlaneInfo.ActorList.push_back( aSmeshActor );
7071 aPlaneInfo.ViewManager = vman;
7073 // to make the list sorted by plane id
7074 anIter = aPlaneInfoList.begin();
7075 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
7076 const TPlaneInfo& aPlaneInfoRef = *anIter;
7077 if( aPlaneInfoRef.PlaneId > aPlaneId )
7080 aPlaneInfoList.insert( anIter, aPlaneInfo );
7085 } // if (aSmeshActor)
7086 } // other parameters than Visibility
7088 } // for names/parameters iterator
7089 } // for entries iterator
7091 // take into account planes with empty list of actors referred to them
7092 QList<SUIT_ViewManager*> aVMList;
7093 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
7095 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
7096 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
7097 int aViewId = aPlaneDataIter->first;
7098 if( aViewId >= 0 && aViewId < aVMList.count() ) {
7099 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
7101 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
7103 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
7104 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
7105 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
7106 const TPlaneData& aPlaneData = *anIter2;
7107 int aPlaneId = aPlaneData.Id;
7109 bool anIsFound = false;
7110 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
7111 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
7112 const TPlaneInfo& aPlaneInfo = *anIter3;
7113 if( aPlaneInfo.PlaneId == aPlaneId ) {
7120 TPlaneInfo aPlaneInfo; // ActorList field is empty
7121 aPlaneInfo.PlaneId = aPlaneId;
7122 aPlaneInfo.ViewManager = aViewManager;
7124 // to make the list sorted by plane id
7125 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
7126 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
7127 const TPlaneInfo& aPlaneInfoRef = *anIter4;
7128 if( aPlaneInfoRef.PlaneId > aPlaneId )
7131 aPlaneInfoList.insert( anIter4, aPlaneInfo );
7137 // add clipping planes to actors according to the restored parameters
7138 // and update the clipping plane map
7139 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
7140 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
7141 int aViewId = anIter1->first;
7142 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
7144 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
7145 if( anIter2 == aPlaneDataMap.end() )
7147 const TPlaneDataList& aPlaneDataList = anIter2->second;
7149 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
7150 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
7151 const TPlaneInfo& aPlaneInfo = *anIter3;
7152 int aPlaneId = aPlaneInfo.PlaneId;
7153 const TActorList& anActorList = aPlaneInfo.ActorList;
7154 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
7158 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
7162 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
7164 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
7165 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
7166 const TPlaneData& aPlaneData = *anIter4;
7167 if( aPlaneData.Id == aPlaneId ) {
7168 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
7169 aPlane->myViewWindow = aViewWindow;
7170 aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
7171 aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
7172 if ( aPlane->PlaneMode == SMESH::Absolute ) {
7173 aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
7174 aPlane->X = aPlaneData.X;
7175 aPlane->Y = aPlaneData.Y;
7176 aPlane->Z = aPlaneData.Z;
7177 aPlane->Dx = aPlaneData.Dx;
7178 aPlane->Dy = aPlaneData.Dy;
7179 aPlane->Dz = aPlaneData.Dz;
7181 else if ( aPlane->PlaneMode == SMESH::Relative ) {
7182 aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
7183 aPlane->myDistance = aPlaneData.Distance;
7184 aPlane->myAngle[0] = aPlaneData.Angle[0];
7185 aPlane->myAngle[1] = aPlaneData.Angle[1];
7188 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
7189 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
7190 aClippingPlaneInfo.Plane = aPlane;
7191 aClippingPlaneInfo.ActorList = anActorList;
7192 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
7203 // update all VTK views
7204 QList<SUIT_ViewManager*> lst;
7205 getApp()->viewManagers(lst);
7206 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
7207 SUIT_ViewModel* vmodel = (*it)->getViewModel();
7208 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
7209 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
7210 // set OpenGL clipping planes
7211 VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
7212 vtkActorCollection* anAllActors = aCopy.GetActors();
7213 anAllActors->InitTraversal();
7214 while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
7215 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
7216 anActor->SetOpenGLClippingPlane();
7218 vtkView->getRenderer()->ResetCameraClippingRange();
7225 \brief Adds preferences for dfont of VTK viewer
7227 \param pIf group identifier
7228 \param param parameter
7229 \return identifier of preferences
7231 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
7233 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
7235 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
7238 fam.append( tr( "SMESH_FONT_ARIAL" ) );
7239 fam.append( tr( "SMESH_FONT_COURIER" ) );
7240 fam.append( tr( "SMESH_FONT_TIMES" ) );
7242 setPreferenceProperty( tfont, "fonts", fam );
7244 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
7245 if ( needSize ) f = f | QtxFontEdit::Size;
7246 setPreferenceProperty( tfont, "features", f );
7252 \brief Actions after hypothesis edition
7253 Updates object browser after hypothesis edition
7255 void SMESHGUI::onHypothesisEdit( int result )
7258 SMESHGUI::Modified();
7259 updateObjBrowser( true );
7263 \brief Actions after choosing menu of control modes
7264 Updates control mode actions according to current selection
7266 void SMESHGUI::onUpdateControlActions()
7268 SALOME_ListIO selected;
7269 if ( LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr() )
7270 aSel->selectedObjects( selected );
7272 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
7273 if ( selected.Extent() ) {
7274 if ( selected.First()->hasEntry() ) {
7275 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( selected.First()->getEntry() )) {
7276 aControl = anActor->GetControlMode();
7277 SALOME_ListIteratorOfListIO it(selected);
7278 for ( it.Next(); it.More(); it.Next() ) {
7279 Handle(SALOME_InteractiveObject) anIO = it.Value();
7280 if ( anIO->hasEntry() ) {
7281 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
7282 if ( aControl != anActor->GetControlMode() ) {
7283 aControl = SMESH_Actor::eNone;
7293 int anAction = ActionToControl( aControl, true );
7295 action( anAction )->setChecked( true );
7297 QMenu* send = (QMenu*)sender();
7298 QList<QAction*> actions = send->actions();
7299 for ( int i = 0; i < actions.size(); i++ )
7300 actions[i]->setChecked( false );
7306 \brief Signal handler closing(SUIT_ViewWindow*) of a view
7307 \param pview view being closed
7309 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
7310 #ifndef DISABLE_PLOT2DVIEWER
7311 //Crear all Plot2d Viewers if need.
7312 SMESH::ClearPlot2Viewers(pview);
7314 EmitSignalCloseView();
7317 void SMESHGUI::message( const QString& msg )
7320 QStringList data = msg.split("/");
7321 if ( data.count() > 0 ) {
7322 if ( data.first() == "mesh_loading" ) {
7324 QString entry = data.count() > 1 ? data[1] : QString();
7325 if ( entry.isEmpty() )
7328 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
7330 _PTR(SObject) obj = study->FindObjectID( entry.toUtf8().constData() );
7333 name = SMESH::fromUtf8(obj->GetName());
7334 if ( name.isEmpty() )
7337 if ( data.last() == "stop" )
7338 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
7340 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
7341 QApplication::processEvents();
7347 \brief Connects or disconnects signals about activating and cloning view on the module slots
7348 \param pview view which is connected/disconnected
7350 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
7354 SUIT_ViewManager* viewMgr = pview->getViewManager();
7356 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7357 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7359 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7360 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7365 \brief Return \c true if object can be renamed
7367 bool SMESHGUI::renameAllowed( const QString& entry) const {
7368 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7372 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7376 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
7381 if(appStudy->isComponent(entry) || obj->isReference())
7384 // check type to prevent renaming of inappropriate objects
7385 int aType = SMESHGUI_Selection::type(qPrintable(entry));
7386 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7387 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7388 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7389 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7390 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
7397 Rename object by entry.
7398 \param entry entry of the object
7399 \param name new name of the object
7400 \brief Return \c true if rename operation finished successfully, \c false otherwise.
7402 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
7404 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7408 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7413 _PTR(Study) aStudy = appStudy->studyDS();
7418 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
7420 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
7425 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
7426 _PTR(GenericAttribute) anAttr;
7427 _PTR(AttributeName) aName;
7429 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
7431 // check type to prevent renaming of inappropriate objects
7432 int aType = SMESHGUI_Selection::type( qPrintable(entry));
7433 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7434 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7435 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7436 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7437 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
7438 if ( !name.isEmpty() ) {
7439 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qUtf8Printable(name) );
7441 // update name of group object and its actor
7442 Handle(SALOME_InteractiveObject) IObject =
7443 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
7445 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
7446 if( !aGroupObject->_is_nil() ) {
7447 aGroupObject->SetName( qUtf8Printable(name) );
7448 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
7449 anActor->setName( qUtf8Printable(name) );
7459 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
7461 static QList<QColor> colors;
7463 if ( colors.isEmpty() ) {
7465 for (int s = 0; s < 2 ; s++)
7467 for (int v = 100; v >= 40; v = v - 20)
7469 for (int h = 0; h < 359 ; h = h + 60)
7471 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
7476 static int currentColor = randomize( colors.size() );
7478 SALOMEDS::Color color;
7479 color.R = (double)colors[currentColor].red() / 255.0;
7480 color.G = (double)colors[currentColor].green() / 255.0;
7481 color.B = (double)colors[currentColor].blue() / 255.0;
7483 currentColor = (currentColor+1) % colors.count();