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 case SMESHOp::OpShowErrors:
2874 startOperation( theCommandID );
2876 case SMESHOp::OpRecompute:
2878 if ( isStudyLocked() )
2880 SALOME_ListIO selected;
2881 if ( LightApp_SelectionMgr *sel = selectionMgr() )
2882 sel->selectedObjects( selected );
2883 if ( selected.Extent() == 1 ) {
2884 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO( selected.First() );
2885 if ( !aMesh->_is_nil() )
2887 startOperation( SMESHOp::OpCompute );
2891 case SMESHOp::OpCopyMesh:
2893 if (isStudyLocked()) break;
2894 EmitSignalDeactivateDialog();
2895 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2898 case SMESHOp::OpBuildCompoundMesh:
2900 if (isStudyLocked()) break;
2901 EmitSignalDeactivateDialog();
2902 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2906 case SMESHOp::OpDiagonalInversion:
2907 case SMESHOp::OpUnionOfTwoTriangle:
2911 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2915 if ( isStudyLocked() )
2917 if ( warnOnGeomModif() )
2918 break; // action forbiden as geometry modified
2920 /*Standard_Boolean aRes;
2921 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2922 if ( aMesh->_is_nil() )
2924 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2925 tr( "SMESH_BAD_SELECTION" ) );
2929 EmitSignalDeactivateDialog();
2930 if ( theCommandID == SMESHOp::OpDiagonalInversion )
2931 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2933 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2936 case SMESHOp::OpOrientation:
2937 case SMESHOp::OpUnionOfTriangles:
2938 case SMESHOp::OpCuttingOfQuadrangles:
2939 case SMESHOp::OpSplitVolumes:
2943 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2947 if ( isStudyLocked() )
2949 if ( warnOnGeomModif() )
2950 break; // action forbiden as geometry modified
2952 EmitSignalDeactivateDialog();
2953 SMESHGUI_MultiEditDlg* aDlg = NULL;
2954 if ( theCommandID == SMESHOp::OpOrientation )
2955 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2956 else if ( theCommandID == SMESHOp::OpUnionOfTriangles )
2957 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2958 else if ( theCommandID == SMESHOp::OpSplitVolumes )
2959 aDlg = new SMESHGUI_SplitVolumesDlg(this);
2961 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2966 case SMESHOp::OpSmoothing:
2968 if(isStudyLocked()) break;
2969 if ( warnOnGeomModif() )
2970 break; // action forbiden as geometry modified
2972 EmitSignalDeactivateDialog();
2973 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2976 SUIT_MessageBox::warning(desktop(), tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2980 case SMESHOp::OpExtrusion:
2982 if (isStudyLocked()) break;
2983 if ( warnOnGeomModif() )
2984 break; // action forbiden as geometry modified
2986 EmitSignalDeactivateDialog();
2987 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2989 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2993 case SMESHOp::OpExtrusionAlongAPath:
2995 if (isStudyLocked()) break;
2996 if ( warnOnGeomModif() )
2997 break; // action forbiden as geometry modified
2999 EmitSignalDeactivateDialog();
3000 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
3002 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3006 case SMESHOp::OpRevolution:
3008 if(isStudyLocked()) break;
3009 if ( warnOnGeomModif() )
3010 break; // action forbiden as geometry modified
3012 EmitSignalDeactivateDialog();
3013 ( new SMESHGUI_RevolutionDlg( this ) )->show();
3016 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3020 case SMESHOp::OpPatternMapping:
3022 if ( isStudyLocked() )
3024 if ( warnOnGeomModif() )
3025 break; // action forbiden as geometry modified
3028 EmitSignalDeactivateDialog();
3029 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
3032 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3036 case SMESHOp::OpSplitBiQuadratic:
3037 case SMESHOp::OpConvertMeshToQuadratic:
3038 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
3039 case SMESHOp::OpReorientFaces:
3040 case SMESHOp::OpCreateGeometryGroup:
3042 if ( warnOnGeomModif() )
3043 break; // action forbiden as geometry modified
3044 startOperation( theCommandID );
3047 case SMESHOp::OpCreateGroup:
3051 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3055 if(isStudyLocked()) break;
3056 if ( warnOnGeomModif() )
3057 break; // action forbiden as geometry modified
3058 EmitSignalDeactivateDialog();
3059 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
3061 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3062 SALOME_ListIO selected;
3064 aSel->selectedObjects( selected );
3066 int nbSel = selected.Extent();
3068 // check if mesh is selected
3069 aMesh = SMESH::GetMeshByIO( selected.First() );
3071 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
3076 case SMESHOp::OpConstructGroup:
3080 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3084 if(isStudyLocked()) break;
3085 if ( warnOnGeomModif() )
3086 break; // action forbiden as geometry modified
3087 EmitSignalDeactivateDialog();
3089 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3090 SALOME_ListIO selected;
3092 aSel->selectedObjects( selected );
3094 int nbSel = selected.Extent();
3096 // check if submesh is selected
3097 Handle(SALOME_InteractiveObject) IObject = selected.First();
3098 if (IObject->hasEntry()) {
3099 _PTR(SObject) aSObj = SMESH::getStudy()->FindObjectID(IObject->getEntry());
3101 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
3102 if (!aSubMesh->_is_nil()) {
3104 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
3105 // get submesh elements list by types
3106 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
3107 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
3108 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
3109 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
3110 // create group for each type o elements
3111 QString aName = IObject->getName();
3112 QStringList anEntryList;
3113 if (aNodes->length() > 0) {
3114 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
3115 aGroup->Add(aNodes.inout());
3116 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3117 anEntryList.append( aSObject->GetID().c_str() );
3119 if (aEdges->length() > 0) {
3120 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
3121 aGroup->Add(aEdges.inout());
3122 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3123 anEntryList.append( aSObject->GetID().c_str() );
3125 if (aFaces->length() > 0) {
3126 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
3127 aGroup->Add(aFaces.inout());
3128 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3129 anEntryList.append( aSObject->GetID().c_str() );
3131 if (aVolumes->length() > 0) {
3132 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
3133 aGroup->Add(aVolumes.inout());
3134 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3135 anEntryList.append( aSObject->GetID().c_str() );
3138 anApp->browseObjects( anEntryList );
3140 catch(const SALOME::SALOME_Exception & S_ex){
3141 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3148 SUIT_MessageBox::warning(desktop(),
3149 tr("SMESH_WRN_WARNING"),
3150 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
3155 case SMESHOp::OpEditGroup:
3159 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3163 if(isStudyLocked()) break;
3164 if ( warnOnGeomModif() )
3165 break; // action forbiden as geometry modified
3166 EmitSignalDeactivateDialog();
3168 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3169 SALOME_ListIO selected;
3171 aSel->selectedObjects( selected );
3173 SALOME_ListIteratorOfListIO It (selected);
3174 int nbSelectedGroups = 0;
3175 for ( ; It.More(); It.Next() )
3177 SMESH::SMESH_GroupBase_var aGroup =
3178 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
3179 if (!aGroup->_is_nil()) {
3181 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
3185 if (nbSelectedGroups == 0)
3187 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
3193 case SMESHOp::OpAddElemGroupPopup: // Add elements to group
3195 if(isStudyLocked()) break;
3196 if (myState == 800) {
3197 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3198 if (aDlg) aDlg->onAdd();
3203 case SMESHOp::OpRemoveElemGroupPopup: // Remove elements from group
3205 if(isStudyLocked()) break;
3206 if (myState == 800) {
3207 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3208 if (aDlg) aDlg->onRemove();
3213 case SMESHOp::OpEditGeomGroupAsGroup:
3217 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3221 if(isStudyLocked()) break;
3222 EmitSignalDeactivateDialog();
3224 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3225 SALOME_ListIO selected;
3227 aSel->selectedObjects( selected );
3229 SALOME_ListIteratorOfListIO It (selected);
3230 for ( ; It.More(); It.Next() )
3232 SMESH::SMESH_GroupOnGeom_var aGroup =
3233 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
3234 if (!aGroup->_is_nil()) {
3235 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3240 SMESH::SMESH_GroupOnFilter_var aGroup =
3241 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
3242 if (!aGroup->_is_nil()) {
3243 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3251 case SMESHOp::OpUnionGroups:
3252 case SMESHOp::OpIntersectGroups:
3253 case SMESHOp::OpCutGroups:
3257 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3261 if ( isStudyLocked() )
3263 if ( warnOnGeomModif() )
3264 break; // action forbiden as geometry modified
3266 EmitSignalDeactivateDialog();
3268 SMESHGUI_GroupOpDlg* aDlg = 0;
3269 if ( theCommandID == SMESHOp::OpUnionGroups )
3270 aDlg = new SMESHGUI_UnionGroupsDlg( this );
3271 else if ( theCommandID == SMESHOp::OpIntersectGroups )
3272 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3274 aDlg = new SMESHGUI_CutGroupsDlg( this );
3281 case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
3283 if ( isStudyLocked() )
3285 if ( warnOnGeomModif() )
3286 break; // action forbiden as geometry modified
3288 EmitSignalDeactivateDialog();
3289 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3295 case SMESHOp::OpFaceGroupsByEdges: // Create face groups separated by sharp edges
3297 if ( isStudyLocked() )
3299 if ( warnOnGeomModif() )
3300 break; // action forbiden as geometry modified
3302 EmitSignalDeactivateDialog();
3303 SMESHGUI_FaceGroupsSeparatedByEdgesDlg* aDlg = new SMESHGUI_FaceGroupsSeparatedByEdgesDlg( this );
3309 case SMESHOp::OpDeleteGroup: // Delete groups with their contents
3313 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3317 if ( isStudyLocked() )
3320 EmitSignalDeactivateDialog();
3322 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3326 case SMESHOp::OpMeshInformation:
3327 case SMESHOp::OpWhatIs:
3329 int page = theCommandID == SMESHOp::OpMeshInformation ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3330 EmitSignalDeactivateDialog();
3331 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3332 SALOME_ListIO selected;
3334 aSel->selectedObjects( selected );
3336 if ( selected.Extent() > 1 ) { // a dlg for each IO
3337 SALOME_ListIteratorOfListIO It( selected );
3338 for ( ; It.More(); It.Next() ) {
3339 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3340 dlg->showInfo( It.Value() );
3345 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3351 case SMESHOp::OpFindElementByPoint:
3353 startOperation( theCommandID );
3357 case SMESHOp::OpEditHypothesis:
3359 if(isStudyLocked()) break;
3360 if ( warnOnGeomModif() )
3361 break; // action forbiden as geometry modified
3363 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3364 SALOME_ListIO selected;
3366 aSel->selectedObjects( selected );
3368 int nbSel = selected.Extent();
3371 Handle(SALOME_InteractiveObject) anIObject = selected.First();
3372 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3374 if ( !aHypothesis->_is_nil() )
3376 SMESHGUI_GenericHypothesisCreator* aCreator =
3377 SMESH::GetHypothesisCreator( SMESH::toQStr( aHypothesis->GetName() ));
3380 // set geometry of mesh and sub-mesh to aCreator
3381 aSel->selectedObjects( selected, "", /*convertReferences=*/false);
3382 if ( selected.Extent() == 1 )
3384 QString subGeomID, meshGeomID;
3385 Handle(SALOME_InteractiveObject) hypIO = selected.First();
3386 if ( SMESH::GetGeomEntries( hypIO, subGeomID, meshGeomID ))
3388 if ( subGeomID.isEmpty() ) subGeomID = meshGeomID;
3389 aCreator->setShapeEntry( subGeomID );
3390 aCreator->setMainShapeEntry( meshGeomID );
3394 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3404 case SMESHOp::OpUnassign: // REMOVE HYPOTHESIS / ALGORITHMS
3406 if(isStudyLocked()) break;
3407 if ( warnOnGeomModif() )
3408 break; // action forbiden as geometry modified
3409 SUIT_OverrideCursor wc;
3411 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3412 SALOME_ListIO selected;
3414 aSel->selectedObjects( selected, QString::null, false );
3416 SALOME_ListIteratorOfListIO It(selected);
3417 for (int i = 0; It.More(); It.Next(), i++) {
3418 Handle(SALOME_InteractiveObject) IObject = It.Value();
3419 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3422 aSel->setSelectedObjects( l1 );
3427 case SMESHOp::OpElem0D:
3428 case SMESHOp::OpBall:
3429 case SMESHOp::OpEdge:
3430 case SMESHOp::OpTriangle:
3431 case SMESHOp::OpQuadrangle:
3432 case SMESHOp::OpPolygon:
3433 case SMESHOp::OpTetrahedron:
3434 case SMESHOp::OpHexahedron:
3435 case SMESHOp::OpPentahedron:
3436 case SMESHOp::OpPyramid:
3437 case SMESHOp::OpHexagonalPrism:
3439 if(isStudyLocked()) break;
3440 if ( warnOnGeomModif() )
3441 break; // action forbiden as geometry modified
3443 EmitSignalDeactivateDialog();
3444 SMDSAbs_EntityType type = SMDSEntity_Edge;
3445 switch (theCommandID) {
3446 case SMESHOp::OpElem0D: type = SMDSEntity_0D; break;
3447 case SMESHOp::OpBall: type = SMDSEntity_Ball; break;
3448 case SMESHOp::OpTriangle: type = SMDSEntity_Triangle; break;
3449 case SMESHOp::OpQuadrangle: type = SMDSEntity_Quadrangle; break;
3450 case SMESHOp::OpTetrahedron: type = SMDSEntity_Tetra; break;
3451 case SMESHOp::OpPolygon: type = SMDSEntity_Polygon; break;
3452 case SMESHOp::OpHexahedron: type = SMDSEntity_Hexa; break;
3453 case SMESHOp::OpPentahedron: type = SMDSEntity_Penta; break;
3454 case SMESHOp::OpPyramid: type = SMDSEntity_Pyramid; break;
3455 case SMESHOp::OpHexagonalPrism: type = SMDSEntity_Hexagonal_Prism; break;
3458 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3461 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3465 case SMESHOp::OpPolyhedron:
3467 if(isStudyLocked()) break;
3468 if ( warnOnGeomModif() )
3469 break; // action forbiden as geometry modified
3471 EmitSignalDeactivateDialog();
3472 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3475 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3479 case SMESHOp::OpQuadraticEdge:
3480 case SMESHOp::OpQuadraticTriangle:
3481 case SMESHOp::OpBiQuadraticTriangle:
3482 case SMESHOp::OpQuadraticQuadrangle:
3483 case SMESHOp::OpBiQuadraticQuadrangle:
3484 case SMESHOp::OpQuadraticPolygon:
3485 case SMESHOp::OpQuadraticTetrahedron:
3486 case SMESHOp::OpQuadraticPyramid:
3487 case SMESHOp::OpQuadraticPentahedron:
3488 case SMESHOp::OpBiQuadraticPentahedron:
3489 case SMESHOp::OpQuadraticHexahedron:
3490 case SMESHOp::OpTriQuadraticHexahedron:
3492 if(isStudyLocked()) break;
3493 if ( warnOnGeomModif() )
3494 break; // action forbiden as geometry modified
3496 EmitSignalDeactivateDialog();
3497 SMDSAbs_EntityType type = SMDSEntity_Last;
3499 switch (theCommandID) {
3500 case SMESHOp::OpQuadraticEdge: type = SMDSEntity_Quad_Edge; break;
3501 case SMESHOp::OpQuadraticTriangle: type = SMDSEntity_Quad_Triangle; break;
3502 case SMESHOp::OpBiQuadraticTriangle: type = SMDSEntity_BiQuad_Triangle; break;
3503 case SMESHOp::OpQuadraticQuadrangle: type = SMDSEntity_Quad_Quadrangle; break;
3504 case SMESHOp::OpBiQuadraticQuadrangle: type = SMDSEntity_BiQuad_Quadrangle; break;
3505 case SMESHOp::OpQuadraticPolygon: type = SMDSEntity_Quad_Polygon; break;
3506 case SMESHOp::OpQuadraticTetrahedron: type = SMDSEntity_Quad_Tetra; break;
3507 case SMESHOp::OpQuadraticPyramid: type = SMDSEntity_Quad_Pyramid; break;
3508 case SMESHOp::OpQuadraticPentahedron: type = SMDSEntity_Quad_Penta; break;
3509 case SMESHOp::OpBiQuadraticPentahedron: type = SMDSEntity_BiQuad_Penta; break;
3510 case SMESHOp::OpQuadraticHexahedron: type = SMDSEntity_Quad_Hexa; break;
3511 case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
3514 if ( type != SMDSEntity_Last )
3515 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3518 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3519 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3523 case SMESHOp::OpRemoveNodes:
3525 if(isStudyLocked()) break;
3526 if ( warnOnGeomModif() )
3527 break; // action forbiden as geometry modified
3529 EmitSignalDeactivateDialog();
3530 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3533 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3534 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3538 case SMESHOp::OpRemoveElements: // REMOVES ELEMENTS
3540 if(isStudyLocked()) break;
3541 if ( warnOnGeomModif() )
3542 break; // action forbiden as geometry modified
3544 EmitSignalDeactivateDialog();
3545 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3549 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3550 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3554 case SMESHOp::OpClearMesh: {
3556 if(isStudyLocked()) break;
3557 if ( warnOnGeomModif() )
3558 break; // action forbiden as geometry modified
3560 SALOME_ListIO selected;
3561 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3562 aSel->selectedObjects( selected );
3564 SUIT_OverrideCursor wc;
3565 SALOME_ListIteratorOfListIO It (selected);
3566 for ( ; It.More(); It.Next() )
3568 Handle(SALOME_InteractiveObject) IOS = It.Value();
3569 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3570 if ( aMesh->_is_nil()) continue;
3573 if ( aMesh->NbNodes() == 0 ) // imported mesh is not empty
3574 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3575 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3576 // hide groups and submeshes
3577 _PTR(ChildIterator) anIter =
3578 SMESH::getStudy()->NewChildIterator( aMeshSObj );
3579 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3581 _PTR(SObject) so = anIter->Value();
3582 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3585 catch (const SALOME::SALOME_Exception& S_ex){
3587 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3591 SMESH::UpdateView();
3595 case SMESHOp::OpRemoveOrphanNodes:
3597 if(isStudyLocked()) break;
3598 if ( warnOnGeomModif() )
3599 break; // action forbiden as geometry modified
3600 SALOME_ListIO selected;
3601 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3602 aSel->selectedObjects( selected );
3603 if ( selected.Extent() == 1 ) {
3604 Handle(SALOME_InteractiveObject) anIO = selected.First();
3605 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3606 if ( !aMesh->_is_nil() ) {
3607 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3608 tr( "SMESH_WARNING" ),
3609 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3610 SUIT_MessageBox::Yes |
3611 SUIT_MessageBox::No,
3612 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3615 SUIT_OverrideCursor wc;
3616 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3617 int removed = aMeshEditor->RemoveOrphanNodes();
3618 SUIT_MessageBox::information(SMESHGUI::desktop(),
3619 tr("SMESH_INFORMATION"),
3620 tr("NB_NODES_REMOVED").arg(removed));
3621 if ( removed > 0 ) {
3622 SMESH::UpdateView();
3623 SMESHGUI::Modified();
3626 catch (const SALOME::SALOME_Exception& S_ex) {
3627 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3636 case SMESHOp::OpRenumberingNodes:
3638 if(isStudyLocked()) break;
3639 if ( warnOnGeomModif() )
3640 break; // action forbiden as geometry modified
3642 EmitSignalDeactivateDialog();
3643 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3647 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3648 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3652 case SMESHOp::OpRenumberingElements:
3654 if(isStudyLocked()) break;
3655 if ( warnOnGeomModif() )
3656 break; // action forbiden as geometry modified
3658 EmitSignalDeactivateDialog();
3659 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3663 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3664 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3668 case SMESHOp::OpTranslation:
3670 if(isStudyLocked()) break;
3671 if ( warnOnGeomModif() )
3672 break; // action forbiden as geometry modified
3674 EmitSignalDeactivateDialog();
3675 ( new SMESHGUI_TranslationDlg( this ) )->show();
3678 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3679 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3683 case SMESHOp::OpRotation:
3685 if(isStudyLocked()) break;
3686 if ( warnOnGeomModif() )
3687 break; // action forbiden as geometry modified
3689 EmitSignalDeactivateDialog();
3690 ( new SMESHGUI_RotationDlg( this ) )->show();
3693 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3694 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3698 case SMESHOp::OpSymmetry:
3700 if(isStudyLocked()) break;
3701 if ( warnOnGeomModif() )
3702 break; // action forbiden as geometry modified
3704 EmitSignalDeactivateDialog();
3705 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3708 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3709 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3713 case SMESHOp::OpScale:
3715 if(isStudyLocked()) break;
3716 if ( warnOnGeomModif() )
3717 break; // action forbiden as geometry modified
3719 EmitSignalDeactivateDialog();
3720 ( new SMESHGUI_ScaleDlg( this ) )->show();
3723 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3724 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3729 case SMESHOp::OpOffset:
3731 if(isStudyLocked()) break;
3732 if ( warnOnGeomModif() )
3733 break; // action forbiden as geometry modified
3735 EmitSignalDeactivateDialog();
3736 ( new SMESHGUI_OffsetDlg( this ) )->show();
3739 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3740 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3745 case SMESHOp::OpSewing:
3747 if(isStudyLocked()) break;
3748 if ( warnOnGeomModif() )
3749 break; // action forbiden as geometry modified
3751 EmitSignalDeactivateDialog();
3752 ( new SMESHGUI_SewingDlg( this ) )->show();
3755 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3756 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3760 case SMESHOp::OpMergeNodes:
3762 if(isStudyLocked()) break;
3763 if ( warnOnGeomModif() )
3764 break; // action forbiden as geometry modified
3766 EmitSignalDeactivateDialog();
3767 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3770 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3771 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3775 case SMESHOp::OpMergeElements:
3777 if (isStudyLocked()) break;
3778 if ( warnOnGeomModif() )
3779 break; // action forbiden as geometry modified
3781 EmitSignalDeactivateDialog();
3782 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3784 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3785 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3790 case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
3791 if ( warnOnGeomModif() )
3792 break; // action forbiden as geometry modified
3793 startOperation( SMESHOp::OpMoveNode );
3796 case SMESHOp::OpDuplicateNodes:
3798 if(isStudyLocked()) break;
3799 if ( warnOnGeomModif() )
3800 break; // action forbiden as geometry modified
3802 EmitSignalDeactivateDialog();
3803 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3806 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3807 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3812 case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
3813 if ( warnOnGeomModif() )
3814 break; // action forbiden as geometry modified
3815 startOperation( SMESHOp::OpElem0DOnElemNodes );
3818 case SMESHOp::OpSelectFiltersLibrary: // Library of selection filters
3820 static QList<int> aTypes;
3821 if ( aTypes.isEmpty() )
3823 aTypes.append( SMESH::NODE );
3824 aTypes.append( SMESH::EDGE );
3825 aTypes.append( SMESH::FACE );
3826 aTypes.append( SMESH::VOLUME );
3828 if (!myFilterLibraryDlg)
3829 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3830 else if (myFilterLibraryDlg->isHidden())
3831 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3832 myFilterLibraryDlg->raise();
3836 case SMESHOp::OpFreeNode:
3837 case SMESHOp::OpEqualNode:
3838 case SMESHOp::OpNodeConnectivityNb:
3839 case SMESHOp::OpFreeEdge:
3840 case SMESHOp::OpFreeBorder:
3841 case SMESHOp::OpLength:
3842 case SMESHOp::OpConnection:
3843 case SMESHOp::OpEqualEdge:
3844 case SMESHOp::OpFreeFace:
3845 case SMESHOp::OpBareBorderFace:
3846 case SMESHOp::OpOverConstrainedFace:
3847 case SMESHOp::OpLength2D:
3848 case SMESHOp::OpDeflection2D:
3849 case SMESHOp::OpConnection2D:
3850 case SMESHOp::OpArea:
3851 case SMESHOp::OpTaper:
3852 case SMESHOp::OpAspectRatio:
3853 case SMESHOp::OpMinimumAngle:
3854 case SMESHOp::OpWarpingAngle:
3855 case SMESHOp::OpSkew:
3856 case SMESHOp::OpMaxElementLength2D:
3857 case SMESHOp::OpEqualFace:
3858 case SMESHOp::OpAspectRatio3D:
3859 case SMESHOp::OpVolume:
3860 case SMESHOp::OpMaxElementLength3D:
3861 case SMESHOp::OpBareBorderVolume:
3862 case SMESHOp::OpOverConstrainedVolume:
3863 case SMESHOp::OpEqualVolume:
3866 LightApp_SelectionMgr* mgr = selectionMgr();
3867 SALOME_ListIO selected; mgr->selectedObjects( selected );
3869 if( !selected.IsEmpty() ) {
3870 SUIT_OverrideCursor wc;
3871 ::Control( theCommandID );
3874 SUIT_MessageBox::warning(desktop(),
3875 tr( "SMESH_WRN_WARNING" ),
3876 tr( "SMESH_BAD_SELECTION" ) );
3880 SUIT_MessageBox::warning(desktop(),
3881 tr( "SMESH_WRN_WARNING" ),
3882 tr( "NOT_A_VTK_VIEWER" ) );
3885 case SMESHOp::OpOverallMeshQuality:
3886 OverallMeshQuality();
3888 case SMESHOp::OpNumberingNodes:
3890 SUIT_OverrideCursor wc;
3891 LightApp_SelectionMgr* mgr = selectionMgr();
3892 SALOME_ListIO selected; mgr->selectedObjects( selected );
3894 SALOME_ListIteratorOfListIO it(selected);
3895 for( ; it.More(); it.Next()) {
3896 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3897 if(anIObject->hasEntry()) {
3898 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3899 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3905 case SMESHOp::OpNumberingElements:
3907 SUIT_OverrideCursor wc;
3908 LightApp_SelectionMgr* mgr = selectionMgr();
3909 SALOME_ListIO selected; mgr->selectedObjects( selected );
3911 SALOME_ListIteratorOfListIO it(selected);
3912 for( ; it.More(); it.Next()) {
3913 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3914 if(anIObject->hasEntry())
3915 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3916 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3921 case SMESHOp::OpPropertiesLength:
3922 case SMESHOp::OpPropertiesArea:
3923 case SMESHOp::OpPropertiesVolume:
3924 case SMESHOp::OpMinimumDistance:
3925 case SMESHOp::OpBoundingBox:
3926 case SMESHOp::OpAngle:
3928 int page = SMESHGUI_MeasureDlg::MinDistance;
3929 if ( theCommandID == SMESHOp::OpBoundingBox )
3930 page = SMESHGUI_MeasureDlg::BoundingBox;
3931 else if ( theCommandID == SMESHOp::OpPropertiesLength )
3932 page = SMESHGUI_MeasureDlg::Length;
3933 else if ( theCommandID == SMESHOp::OpPropertiesArea )
3934 page = SMESHGUI_MeasureDlg::Area;
3935 else if ( theCommandID == SMESHOp::OpPropertiesVolume )
3936 page = SMESHGUI_MeasureDlg::Volume;
3937 else if ( theCommandID == SMESHOp::OpAngle )
3938 page = SMESHGUI_MeasureDlg::Angle;
3940 EmitSignalDeactivateDialog();
3941 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3945 case SMESHOp::OpSortChild:
3948 case SMESHOp::OpBreakLink:
3949 ::breakShaperLink();
3954 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3955 //updateObjBrowser();
3959 //=============================================================================
3963 //=============================================================================
3964 bool SMESHGUI::OnMousePress( QMouseEvent * /*pe*/, SUIT_ViewWindow * /*wnd*/ )
3969 //=============================================================================
3973 //=============================================================================
3974 bool SMESHGUI::OnMouseMove( QMouseEvent * /*pe*/, SUIT_ViewWindow * /*wnd*/ )
3979 //=============================================================================
3983 //=============================================================================
3984 bool SMESHGUI::OnKeyPress( QKeyEvent * /*pe*/, SUIT_ViewWindow * /*wnd*/ )
3989 //=============================================================================
3990 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3991 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3993 //=============================================================================
3994 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3995 SUIT_ViewWindow* wnd )
3997 if(theIO->hasEntry()){
3998 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3999 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
4003 //=======================================================================
4004 // function : createSMESHAction
4006 //=======================================================================
4007 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
4008 const int key, const bool toggle, const QString& shortcutAction )
4011 QWidget* parent = application()->desktop();
4012 SUIT_ResourceMgr* resMgr = resourceMgr();
4014 if ( !icon_id.isEmpty() )
4015 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
4017 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICON_%1" ).arg( po_id ).toLatin1().data() ), false );
4018 if ( !pix.isNull() )
4019 icon = QIcon( pix );
4021 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
4022 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
4023 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
4025 createAction( id, tooltip, icon, menu, status_bar, key, parent,
4026 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
4029 //=======================================================================
4030 // function : createPopupItem
4032 //=======================================================================
4033 void SMESHGUI::createPopupItem( const int id,
4034 const QString& clients,
4035 const QString& types,
4036 const QString& theRule,
4039 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
4040 popupMgr()->insert( action( id ), pId, 0 );
4042 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4043 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4044 QString rule = "(%1) and (%2) and (%3)";
4045 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
4046 if( clients.isEmpty() )
4047 rule = rule.arg( QString( "true" ) );
4049 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
4050 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
4053 bool cont = myRules.contains( id );
4055 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
4057 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
4058 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
4061 //=======================================================================
4062 // function : initialize
4064 //=======================================================================
4065 void SMESHGUI::initialize( CAM_Application* app )
4067 SalomeApp_Module::initialize( app );
4069 // SUIT_ResourceMgr* mgr = app->resourceMgr();
4071 /* Automatic Update flag */
4072 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
4074 // ----- create actions --------------
4076 //createSMESHAction( SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
4077 createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_I) );
4078 createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
4079 createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL" );
4081 createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
4083 createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
4084 createSMESHAction( SMESHOp::OpImportGMF, "IMPORT_GMF" );
4085 createSMESHAction( SMESHOp::OpPopupImportUNV, "IMPORT_UNV");
4086 createSMESHAction( SMESHOp::OpPopupImportMED, "IMPORT_MED");
4087 createSMESHAction( SMESHOp::OpPopupImportSTL, "IMPORT_STL" );
4089 createSMESHAction( SMESHOp::OpPopupImportCGNS, "IMPORT_CGNS" );
4091 createSMESHAction( SMESHOp::OpPopupImportSAUV, "IMPORT_SAUV" );
4092 createSMESHAction( SMESHOp::OpPopupImportGMF, "IMPORT_GMF" );
4094 createSMESHAction( SMESHOp::OpExportDAT, "DAT" );
4095 createSMESHAction( SMESHOp::OpExportMED, "MED" );
4096 createSMESHAction( SMESHOp::OpExportUNV, "UNV" );
4097 createSMESHAction( SMESHOp::OpExportSTL, "STL" );
4099 createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
4101 createSMESHAction( SMESHOp::OpExportSAUV, "SAUV");
4102 createSMESHAction( SMESHOp::OpExportGMF, "GMF" );
4103 createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
4104 createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
4105 createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
4106 createSMESHAction( SMESHOp::OpPopupExportSTL, "STL" );
4108 createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
4110 createSMESHAction( SMESHOp::OpPopupExportSAUV, "SAUV");
4111 createSMESHAction( SMESHOp::OpPopupExportGMF, "GMF" );
4112 createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
4113 createSMESHAction( SMESHOp::OpDelete, "DELETE", "ICON_DELETE", Qt::Key_Delete );
4114 createSMESHAction( SMESHOp::OpSelectFiltersLibrary, "SEL_FILTER_LIB" );
4115 createSMESHAction( SMESHOp::OpCreateMesh, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
4116 createSMESHAction( SMESHOp::OpCreateSubMesh, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
4117 createSMESHAction( SMESHOp::OpEditMeshOrSubMesh, "EDIT_MESHSUBMESH", "ICON_DLG_EDIT_MESH" );
4118 createSMESHAction( SMESHOp::OpEditMesh, "EDIT_MESH", "ICON_DLG_EDIT_MESH" );
4119 createSMESHAction( SMESHOp::OpEditSubMesh, "EDIT_SUBMESH", "ICON_DLG_EDIT_MESH" );
4120 createSMESHAction( SMESHOp::OpBuildCompoundMesh, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
4121 createSMESHAction( SMESHOp::OpCopyMesh, "COPY_MESH", "ICON_COPY_MESH" );
4122 createSMESHAction( SMESHOp::OpCompute, "COMPUTE", "ICON_COMPUTE" );
4123 createSMESHAction( SMESHOp::OpComputeSubMesh, "COMPUTE_SUBMESH", "ICON_COMPUTE" );
4124 createSMESHAction( SMESHOp::OpRecompute, "RE_COMPUTE", "ICON_COMPUTE" );
4125 createSMESHAction( SMESHOp::OpPreCompute, "PRECOMPUTE", "ICON_PRECOMPUTE" );
4126 createSMESHAction( SMESHOp::OpShowErrors, "SHOW_ERRORS", "ICON_SHOW_ERRORS" );
4127 createSMESHAction( SMESHOp::OpEvaluate, "EVALUATE", "ICON_EVALUATE" );
4128 createSMESHAction( SMESHOp::OpMeshOrder, "MESH_ORDER", "ICON_MESH_ORDER");
4129 createSMESHAction( SMESHOp::OpCreateGroup, "CREATE_GROUP", "ICON_CREATE_GROUP" );
4130 createSMESHAction( SMESHOp::OpCreateGeometryGroup, "CREATE_GEO_GROUP", "ICON_CREATE_GEO_GROUP" );
4131 createSMESHAction( SMESHOp::OpConstructGroup, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
4132 createSMESHAction( SMESHOp::OpEditGroup, "EDIT_GROUP", "ICON_EDIT_GROUP" );
4133 createSMESHAction( SMESHOp::OpEditGeomGroupAsGroup, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
4134 createSMESHAction( SMESHOp::OpUnionGroups, "UN_GROUP", "ICON_UNION" );
4135 createSMESHAction( SMESHOp::OpIntersectGroups, "INT_GROUP", "ICON_INTERSECT" );
4136 createSMESHAction( SMESHOp::OpCutGroups, "CUT_GROUP", "ICON_CUT" );
4137 createSMESHAction( SMESHOp::OpGroupUnderlyingElem, "UNDERLYING_ELEMS", "ICON_UNDERLYING_ELEMS" );
4138 createSMESHAction( SMESHOp::OpFaceGroupsByEdges, "FACE_GROUPS_BY_EDGES", "ICON_FACE_GROUPS_BY_EDGES" );
4139 createSMESHAction( SMESHOp::OpAddElemGroupPopup, "ADD_TO_GROUP" );
4140 createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE_FROM_GROUP" );
4141 createSMESHAction( SMESHOp::OpDeleteGroup, "DEL_GROUP", "ICON_DEL_GROUP" );
4142 createSMESHAction( SMESHOp::OpMeshInformation , "ADV_INFO", "ICON_ADV_INFO" );
4143 //createSMESHAction( SMESHOp::OpStdInfo, "STD_INFO", "ICON_STD_INFO" );
4144 //createSMESHAction( SMESHOp::OpWhatIs, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4145 createSMESHAction( SMESHOp::OpFindElementByPoint, "FIND_ELEM", "ICON_FIND_ELEM" );
4147 createSMESHAction( SMESHOp::OpFreeNode, "FREE_NODE", "ICON_FREE_NODE", 0, true );
4148 createSMESHAction( SMESHOp::OpEqualNode, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
4149 createSMESHAction( SMESHOp::OpNodeConnectivityNb, "NODE_CONNECTIVITY_NB", "ICON_NODE_CONN_NB", 0, true );
4150 createSMESHAction( SMESHOp::OpFreeEdge, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
4151 createSMESHAction( SMESHOp::OpFreeBorder, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
4152 createSMESHAction( SMESHOp::OpLength, "LENGTH", "ICON_LENGTH", 0, true );
4153 createSMESHAction( SMESHOp::OpConnection, "CONNECTION", "ICON_CONNECTION", 0, true );
4154 createSMESHAction( SMESHOp::OpEqualEdge, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
4155 createSMESHAction( SMESHOp::OpFreeFace, "FREE_FACES", "ICON_FREE_FACES", 0, true );
4156 createSMESHAction( SMESHOp::OpBareBorderFace, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
4157 createSMESHAction( SMESHOp::OpOverConstrainedFace, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
4158 createSMESHAction( SMESHOp::OpLength2D, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
4159 createSMESHAction( SMESHOp::OpDeflection2D, "DEFLECTION_2D", "ICON_DEFLECTION_2D", 0, true );
4160 createSMESHAction( SMESHOp::OpConnection2D, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
4161 createSMESHAction( SMESHOp::OpArea, "AREA", "ICON_AREA", 0, true );
4162 createSMESHAction( SMESHOp::OpTaper, "TAPER", "ICON_TAPER", 0, true );
4163 createSMESHAction( SMESHOp::OpAspectRatio, "ASPECT", "ICON_ASPECT", 0, true );
4164 createSMESHAction( SMESHOp::OpMinimumAngle, "MIN_ANG", "ICON_ANGLE", 0, true );
4165 createSMESHAction( SMESHOp::OpWarpingAngle, "WARP", "ICON_WARP", 0, true );
4166 createSMESHAction( SMESHOp::OpSkew, "SKEW", "ICON_SKEW", 0, true );
4167 createSMESHAction( SMESHOp::OpMaxElementLength2D, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
4168 createSMESHAction( SMESHOp::OpEqualFace, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
4169 createSMESHAction( SMESHOp::OpAspectRatio3D, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
4170 createSMESHAction( SMESHOp::OpVolume, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
4171 createSMESHAction( SMESHOp::OpMaxElementLength3D, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
4172 createSMESHAction( SMESHOp::OpBareBorderVolume, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
4173 createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
4174 createSMESHAction( SMESHOp::OpEqualVolume, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
4175 createSMESHAction( SMESHOp::OpOverallMeshQuality, "OVERALL_MESH_QUALITY", "ICON_OVL_MESH_QUALITY" );
4177 createSMESHAction( SMESHOp::OpNode, "NODE", "ICON_DLG_NODE" );
4178 createSMESHAction( SMESHOp::OpElem0D, "ELEM0D", "ICON_DLG_ELEM0D" );
4179 createSMESHAction( SMESHOp::OpElem0DOnElemNodes, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
4180 createSMESHAction( SMESHOp::OpBall, "BALL", "ICON_DLG_BALL" );
4181 createSMESHAction( SMESHOp::OpEdge, "EDGE", "ICON_DLG_EDGE" );
4182 createSMESHAction( SMESHOp::OpTriangle, "TRIANGLE", "ICON_DLG_TRIANGLE" );
4183 createSMESHAction( SMESHOp::OpQuadrangle, "QUAD", "ICON_DLG_QUADRANGLE" );
4184 createSMESHAction( SMESHOp::OpPolygon, "POLYGON", "ICON_DLG_POLYGON" );
4185 createSMESHAction( SMESHOp::OpTetrahedron, "TETRA", "ICON_DLG_TETRAS" );
4186 createSMESHAction( SMESHOp::OpHexahedron, "HEXA", "ICON_DLG_HEXAS" );
4187 createSMESHAction( SMESHOp::OpPentahedron, "PENTA", "ICON_DLG_PENTA" );
4188 createSMESHAction( SMESHOp::OpPyramid , "PYRAMID", "ICON_DLG_PYRAMID" );
4189 createSMESHAction( SMESHOp::OpHexagonalPrism, "OCTA", "ICON_DLG_OCTA" );
4190 createSMESHAction( SMESHOp::OpPolyhedron, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
4191 createSMESHAction( SMESHOp::OpQuadraticEdge, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
4192 createSMESHAction( SMESHOp::OpQuadraticTriangle, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
4193 createSMESHAction( SMESHOp::OpBiQuadraticTriangle, "BIQUADRATIC_TRIANGLE", "ICON_DLG_BIQUADRATIC_TRIANGLE" );
4194 createSMESHAction( SMESHOp::OpQuadraticQuadrangle, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
4195 createSMESHAction( SMESHOp::OpBiQuadraticQuadrangle, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
4196 createSMESHAction( SMESHOp::OpQuadraticPolygon, "QUADRATIC_POLYGON", "ICON_DLG_QUADRATIC_POLYGON" );
4197 createSMESHAction( SMESHOp::OpQuadraticTetrahedron, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
4198 createSMESHAction( SMESHOp::OpQuadraticPyramid, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
4199 createSMESHAction( SMESHOp::OpQuadraticPentahedron, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
4200 createSMESHAction( SMESHOp::OpBiQuadraticPentahedron, "BIQUADRATIC_PENTAHEDRON", "ICON_DLG_BIQUADRATIC_PENTAHEDRON" );
4201 createSMESHAction( SMESHOp::OpQuadraticHexahedron, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
4202 createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
4204 createSMESHAction( SMESHOp::OpRemoveNodes, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
4205 createSMESHAction( SMESHOp::OpRemoveElements, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
4206 createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
4207 createSMESHAction( SMESHOp::OpClearMesh, "CLEAR_MESH", "ICON_CLEAR_MESH" );
4209 //createSMESHAction( SMESHOp::OpRenumberingNodes, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
4210 //createSMESHAction( SMESHOp::OpRenumberingElements, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
4212 createSMESHAction( SMESHOp::OpTranslation, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
4213 createSMESHAction( SMESHOp::OpRotation, "ROT", "ICON_DLG_MESH_ROTATION" );
4214 createSMESHAction( SMESHOp::OpSymmetry, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
4215 createSMESHAction( SMESHOp::OpScale, "SCALE", "ICON_DLG_MESH_SCALE" );
4216 createSMESHAction( SMESHOp::OpOffset, "OFFSET", "ICON_DLG_MESH_OFFSET" );
4217 createSMESHAction( SMESHOp::OpSewing, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
4218 createSMESHAction( SMESHOp::OpMergeNodes, "MERGE", "ICON_SMESH_MERGE_NODES" );
4219 createSMESHAction( SMESHOp::OpMergeElements, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
4220 createSMESHAction( SMESHOp::OpMoveNode, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
4221 createSMESHAction( SMESHOp::OpDuplicateNodes, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
4222 createSMESHAction( SMESHOp::OpDiagonalInversion, "INV", "ICON_DLG_MESH_DIAGONAL" );
4223 createSMESHAction( SMESHOp::OpUnionOfTwoTriangle, "UNION2", "ICON_UNION2TRI" );
4224 createSMESHAction( SMESHOp::OpOrientation, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
4225 createSMESHAction( SMESHOp::OpReorientFaces, "REORIENT_2D", "ICON_REORIENT_2D" );
4226 createSMESHAction( SMESHOp::OpUnionOfTriangles, "UNION", "ICON_UNIONTRI" );
4227 createSMESHAction( SMESHOp::OpCuttingOfQuadrangles, "CUT", "ICON_CUTQUAD" );
4228 createSMESHAction( SMESHOp::OpSplitVolumes, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
4229 createSMESHAction( SMESHOp::OpSplitBiQuadratic, "SPLIT_BIQUAD", "ICON_SPLIT_BIQUAD" );
4230 createSMESHAction( SMESHOp::OpSmoothing, "SMOOTH", "ICON_DLG_SMOOTHING" );
4231 createSMESHAction( SMESHOp::OpExtrusion, "EXTRUSION", "ICON_EXTRUSION" );
4232 createSMESHAction( SMESHOp::OpExtrusionAlongAPath, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
4233 createSMESHAction( SMESHOp::OpRevolution, "REVOLUTION", "ICON_REVOLUTION" );
4234 createSMESHAction( SMESHOp::OpPatternMapping, "MAP", "ICON_MAP" );
4235 createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
4236 createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D", "ICON_2D_FROM_3D" );
4238 createSMESHAction( SMESHOp::OpReset, "RESET" );
4239 createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
4240 createSMESHAction( SMESHOp::OpShowScalarBar, "SHOW_SCALAR_BAR","",0, true );
4241 createSMESHAction( SMESHOp::OpSaveDistribution, "SAVE_DISTRIBUTION" );
4242 createSMESHAction( SMESHOp::OpShowDistribution, "SHOW_DISTRIBUTION","",0, true );
4243 #ifndef DISABLE_PLOT2DVIEWER
4244 createSMESHAction( SMESHOp::OpPlotDistribution, "PLOT_DISTRIBUTION" );
4246 createSMESHAction( SMESHOp::OpDMWireframe, "WIRE", "ICON_WIRE", 0, true );
4247 createSMESHAction( SMESHOp::OpDMShading, "SHADE", "ICON_SHADE", 0, true );
4248 createSMESHAction( SMESHOp::OpDMNodes, "NODES", "ICON_POINTS", 0, true );
4249 createSMESHAction( SMESHOp::OpDMShrink, "SHRINK", "ICON_SHRINK", 0, true );
4250 createSMESHAction( SMESHOp::OpUpdate, "UPDATE", "ICON_UPDATE" );
4251 createSMESHAction( SMESHOp::OpDE0DElements, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
4252 createSMESHAction( SMESHOp::OpDEEdges, "EDGES", "ICON_DLG_EDGE", 0, true );
4253 createSMESHAction( SMESHOp::OpDEFaces, "FACES", "ICON_DLG_TRIANGLE", 0, true );
4254 createSMESHAction( SMESHOp::OpDEVolumes, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
4255 createSMESHAction( SMESHOp::OpDEBalls, "BALLS", "ICON_DLG_BALL", 0, true );
4256 createSMESHAction( SMESHOp::OpDEChoose, "CHOOSE", "ICON_DLG_CHOOSE", 0, false );
4257 createSMESHAction( SMESHOp::OpDEAllEntity, "ALL", "ICON_DLG_CHOOSE_ALL", 0, false );
4258 createSMESHAction( SMESHOp::OpOrientationOnFaces, "FACE_ORIENTATION", "", 0, true );
4260 createSMESHAction( SMESHOp::OpRepresentationLines, "LINE_REPRESENTATION", "", 0, true );
4261 createSMESHAction( SMESHOp::OpRepresentationArcs, "ARC_REPRESENTATION", "", 0, true );
4263 createSMESHAction( SMESHOp::OpEditHypothesis, "EDIT_HYPO" );
4264 createSMESHAction( SMESHOp::OpUnassign, "UNASSIGN" );
4265 createSMESHAction( SMESHOp::OpNumberingNodes, "NUM_NODES", "", 0, true );
4266 createSMESHAction( SMESHOp::OpNumberingElements, "NUM_ELEMENTS", "", 0, true );
4267 createSMESHAction( SMESHOp::OpProperties, "COLORS" );
4268 createSMESHAction( SMESHOp::OpTransparency, "TRANSP" );
4269 createSMESHAction( SMESHOp::OpClipping, "CLIP" );
4270 createSMESHAction( SMESHOp::OpAutoColor, "AUTO_COLOR" );
4271 createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
4273 createSMESHAction( SMESHOp::OpMinimumDistance, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
4274 createSMESHAction( SMESHOp::OpBoundingBox, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
4275 createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH", "ICON_MEASURE_LENGTH" );
4276 createSMESHAction( SMESHOp::OpPropertiesArea, "MEASURE_AREA", "ICON_MEASURE_AREA" );
4277 createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME", "ICON_MEASURE_VOLUME" );
4278 createSMESHAction( SMESHOp::OpAngle, "MEASURE_ANGLE", "ICON_MEASURE_ANGLE" );
4280 createSMESHAction( SMESHOp::OpHide, "HIDE", "ICON_HIDE" );
4281 createSMESHAction( SMESHOp::OpShow, "SHOW", "ICON_SHOW" );
4282 createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
4284 createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
4286 createSMESHAction( SMESHOp::OpBreakLink, "BREAK_SHAPER_LINK" );
4288 QList<int> aCtrlActions;
4289 aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode
4290 << SMESHOp::OpNodeConnectivityNb // node controls
4291 << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
4292 << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge // edge controls
4293 << SMESHOp::OpDeflection2D
4294 << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
4295 << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
4296 << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
4297 << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
4298 << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace // face controls
4299 << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
4300 << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
4301 << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume; // volume controls
4302 QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
4303 aCtrlGroup->setExclusive( true );
4304 for( int i = 0; i < aCtrlActions.size(); i++ )
4305 aCtrlGroup->addAction( action( aCtrlActions[i] ) );
4307 // ----- create menu --------------
4308 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
4309 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
4310 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
4311 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
4312 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
4313 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
4314 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
4315 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
4317 createMenu( separator(), fileId );
4319 QMenu* nodeMenu = new QMenu(); QMenu* edgeMenu = new QMenu();
4320 QMenu* faceMenu = new QMenu(); QMenu* volumeMenu = new QMenu();
4321 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
4322 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
4323 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10, -1, nodeMenu ),
4324 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10, -1, edgeMenu ),
4325 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10, -1, faceMenu ),
4326 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10, -1, volumeMenu ),
4327 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
4328 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
4329 //renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
4330 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
4331 basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
4333 //createMenu( SMESHOp::OpImportDAT, importId, -1 );
4334 createMenu( SMESHOp::OpImportUNV, importId, -1 );
4335 createMenu( SMESHOp::OpImportMED, importId, -1 );
4336 createMenu( SMESHOp::OpImportSTL, importId, -1 );
4338 createMenu( SMESHOp::OpImportCGNS, importId, -1 );
4340 createMenu( SMESHOp::OpImportSAUV, importId, -1 );
4341 createMenu( SMESHOp::OpImportGMF, importId, -1 );
4342 createMenu( SMESHOp::OpExportDAT, exportId, -1 );
4343 createMenu( SMESHOp::OpExportMED, exportId, -1 );
4344 createMenu( SMESHOp::OpExportUNV, exportId, -1 );
4345 createMenu( SMESHOp::OpExportSTL, exportId, -1 );
4347 createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
4349 createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
4350 createMenu( SMESHOp::OpExportGMF, exportId, -1 );
4351 createMenu( separator(), fileId, 10 );
4353 createMenu( SMESHOp::OpDelete, editId, -1 );
4355 createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
4357 createMenu( SMESHOp::OpCreateMesh, meshId, -1 ); // "Mesh" menu
4358 createMenu( SMESHOp::OpCreateSubMesh, meshId, -1 );
4359 createMenu( SMESHOp::OpEditMeshOrSubMesh, meshId, -1 );
4360 createMenu( SMESHOp::OpBuildCompoundMesh, meshId, -1 );
4361 createMenu( SMESHOp::OpCopyMesh, meshId, -1 );
4362 createMenu( separator(), meshId, -1 );
4363 createMenu( SMESHOp::OpCompute, meshId, -1 );
4364 createMenu( SMESHOp::OpPreCompute, meshId, -1 );
4365 createMenu( SMESHOp::OpEvaluate, meshId, -1 );
4366 createMenu( SMESHOp::OpMeshOrder, meshId, -1 );
4367 createMenu( separator(), meshId, -1 );
4368 createMenu( SMESHOp::OpCreateGroup, meshId, -1 );
4369 createMenu( SMESHOp::OpCreateGeometryGroup, meshId, -1 );
4370 createMenu( SMESHOp::OpConstructGroup, meshId, -1 );
4371 createMenu( SMESHOp::OpEditGroup, meshId, -1 );
4372 createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4373 createMenu( separator(), meshId, -1 );
4374 createMenu( SMESHOp::OpUnionGroups, meshId, -1 );
4375 createMenu( SMESHOp::OpIntersectGroups, meshId, -1 );
4376 createMenu( SMESHOp::OpCutGroups, meshId, -1 );
4377 createMenu( separator(), meshId, -1 );
4378 createMenu( SMESHOp::OpGroupUnderlyingElem, meshId, -1 );
4379 createMenu( SMESHOp::OpFaceGroupsByEdges, meshId, -1 );
4380 createMenu( separator(), meshId, -1 );
4381 createMenu( SMESHOp::OpMeshInformation, meshId, -1 );
4382 //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4383 //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4384 createMenu( SMESHOp::OpFindElementByPoint, meshId, -1 );
4385 createMenu( separator(), meshId, -1 );
4387 createMenu( SMESHOp::OpFreeNode, nodeId, -1 );
4388 createMenu( SMESHOp::OpEqualNode, nodeId, -1 );
4389 //createMenu( SMESHOp::OpNodeConnectivityNb, nodeId, -1 );
4390 createMenu( SMESHOp::OpFreeBorder, edgeId, -1 );
4391 createMenu( SMESHOp::OpLength, edgeId, -1 );
4392 createMenu( SMESHOp::OpConnection, edgeId, -1 );
4393 createMenu( SMESHOp::OpEqualEdge, edgeId, -1 );
4394 createMenu( SMESHOp::OpFreeEdge, faceId, -1 );
4395 createMenu( SMESHOp::OpFreeFace, faceId, -1 );
4396 createMenu( SMESHOp::OpBareBorderFace, faceId, -1 );
4397 createMenu( SMESHOp::OpOverConstrainedFace, faceId, -1 );
4398 createMenu( SMESHOp::OpLength2D, faceId, -1 );
4399 createMenu( SMESHOp::OpConnection2D, faceId, -1 );
4400 createMenu( SMESHOp::OpArea, faceId, -1 );
4401 createMenu( SMESHOp::OpTaper, faceId, -1 );
4402 createMenu( SMESHOp::OpAspectRatio, faceId, -1 );
4403 createMenu( SMESHOp::OpMinimumAngle, faceId, -1 );
4404 createMenu( SMESHOp::OpWarpingAngle, faceId, -1 );
4405 createMenu( SMESHOp::OpSkew, faceId, -1 );
4406 createMenu( SMESHOp::OpMaxElementLength2D, faceId, -1 );
4407 createMenu( SMESHOp::OpEqualFace, faceId, -1 );
4408 createMenu( SMESHOp::OpDeflection2D, faceId, -1 );
4409 createMenu( SMESHOp::OpAspectRatio3D, volumeId, -1 );
4410 createMenu( SMESHOp::OpVolume, volumeId, -1 );
4411 createMenu( SMESHOp::OpMaxElementLength3D, volumeId, -1 );
4412 createMenu( SMESHOp::OpBareBorderVolume, volumeId, -1 );
4413 createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4414 createMenu( SMESHOp::OpEqualVolume, volumeId, -1 );
4415 createMenu( separator(), ctrlId, -1 );
4416 createMenu( SMESHOp::OpReset, ctrlId, -1 );
4417 createMenu( separator(), ctrlId, -1 );
4418 createMenu( SMESHOp::OpOverallMeshQuality, ctrlId, -1 );
4420 createMenu( SMESHOp::OpNode, addId, -1 );
4421 createMenu( SMESHOp::OpElem0D, addId, -1 );
4422 createMenu( SMESHOp::OpElem0DOnElemNodes, addId, -1 );
4423 createMenu( SMESHOp::OpBall, addId, -1 );
4424 createMenu( SMESHOp::OpEdge, addId, -1 );
4425 createMenu( SMESHOp::OpTriangle, addId, -1 );
4426 createMenu( SMESHOp::OpQuadrangle, addId, -1 );
4427 createMenu( SMESHOp::OpPolygon, addId, -1 );
4428 createMenu( SMESHOp::OpTetrahedron, addId, -1 );
4429 createMenu( SMESHOp::OpHexahedron, addId, -1 );
4430 createMenu( SMESHOp::OpPentahedron, addId, -1 );
4431 createMenu( SMESHOp::OpPyramid, addId, -1 );
4432 createMenu( SMESHOp::OpHexagonalPrism, addId, -1 );
4433 createMenu( SMESHOp::OpPolyhedron, addId, -1 );
4434 createMenu( separator(), addId, -1 );
4435 createMenu( SMESHOp::OpQuadraticEdge, addId, -1 );
4436 createMenu( SMESHOp::OpQuadraticTriangle, addId, -1 );
4437 createMenu( SMESHOp::OpBiQuadraticTriangle , addId, -1 );
4438 createMenu( SMESHOp::OpQuadraticQuadrangle, addId, -1 );
4439 createMenu( SMESHOp::OpBiQuadraticQuadrangle, addId, -1 );
4440 createMenu( SMESHOp::OpQuadraticPolygon, addId, -1 );
4441 createMenu( SMESHOp::OpQuadraticTetrahedron, addId, -1 );
4442 createMenu( SMESHOp::OpQuadraticPyramid, addId, -1 );
4443 createMenu( SMESHOp::OpQuadraticPentahedron, addId, -1 );
4444 createMenu( SMESHOp::OpBiQuadraticPentahedron, addId, -1 );
4445 createMenu( SMESHOp::OpQuadraticHexahedron, addId, -1 );
4446 createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4448 createMenu( SMESHOp::OpRemoveNodes, removeId, -1 );
4449 createMenu( SMESHOp::OpRemoveElements, removeId, -1 );
4450 createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4451 createMenu( separator(), removeId, -1 );
4452 createMenu( SMESHOp::OpDeleteGroup, removeId, -1 );
4453 createMenu( separator(), removeId, -1 );
4454 createMenu( SMESHOp::OpClearMesh, removeId, -1 );
4456 //createMenu( SMESHOp::OpRenumberingNodes, renumId, -1 );
4457 //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4459 createMenu( SMESHOp::OpMergeNodes, transfId, -1 );
4460 createMenu( SMESHOp::OpMergeElements, transfId, -1 );
4461 createMenu( SMESHOp::OpTranslation, transfId, -1 );
4462 createMenu( SMESHOp::OpRotation, transfId, -1 );
4463 createMenu( SMESHOp::OpSymmetry, transfId, -1 );
4464 createMenu( SMESHOp::OpScale, transfId, -1 );
4465 createMenu( SMESHOp::OpOffset, transfId, -1 );
4466 createMenu( SMESHOp::OpSewing, transfId, -1 );
4467 createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4469 createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4470 createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4471 createMenu( SMESHOp::OpExtrusion, modifyId, -1 );
4472 createMenu( SMESHOp::OpExtrusionAlongAPath, modifyId, -1 );
4473 createMenu( SMESHOp::OpRevolution, modifyId, -1 );
4474 createMenu( SMESHOp::OpOrientation, modifyId, -1 );
4475 createMenu( SMESHOp::OpReorientFaces, modifyId, -1 );
4476 createMenu( SMESHOp::OpMoveNode, modifyId, -1 );
4477 createMenu( SMESHOp::OpDiagonalInversion, modifyId, -1 );
4478 createMenu( SMESHOp::OpUnionOfTwoTriangle, modifyId, -1 );
4479 createMenu( SMESHOp::OpUnionOfTriangles, modifyId, -1 );
4480 createMenu( SMESHOp::OpCuttingOfQuadrangles, modifyId, -1 );
4481 createMenu( SMESHOp::OpSplitVolumes, modifyId, -1 );
4482 createMenu( SMESHOp::OpSplitBiQuadratic, modifyId, -1 );
4483 createMenu( SMESHOp::OpSmoothing, modifyId, -1 );
4484 createMenu( SMESHOp::OpPatternMapping, modifyId, -1 );
4486 createMenu( SMESHOp::OpMinimumDistance, measureId, -1 );
4487 createMenu( SMESHOp::OpBoundingBox, measureId, -1 );
4488 createMenu( SMESHOp::OpAngle, measureId, -1 );
4489 createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4490 createMenu( SMESHOp::OpPropertiesArea, basicPropId, -1 );
4491 createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4492 createMenu( SMESHOp::OpUpdate, viewId, -1 );
4494 connect( nodeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4495 connect( edgeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4496 connect( faceMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4497 connect( volumeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4499 // ----- create toolbars --------------
4500 int meshTb = createTool( tr( "TB_MESH" ), QString( "SMESHMeshToolbar" ) ),
4501 info = createTool( tr( "TB_INFO" ), QString( "SMESHInformationToolbar" ) ),
4502 groupTb = createTool( tr( "TB_GROUP" ), QString( "SMESHGroupToolbar" ) ),
4503 ctrl0dTb = createTool( tr( "TB_CTRL0D" ), QString( "SMESHNodeControlsToolbar" ) ),
4504 ctrl1dTb = createTool( tr( "TB_CTRL1D" ), QString( "SMESHEdgeControlsToolbar" ) ),
4505 ctrl2dTb = createTool( tr( "TB_CTRL2D" ), QString( "SMESHFaceControlsToolbar" ) ),
4506 ctrl3dTb = createTool( tr( "TB_CTRL3D" ), QString( "SMESHVolumeControlsToolbar" ) ),
4507 addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ),
4508 addNonElemTb = createTool( tr( "TB_ADDNON" ), QString( "SMESHAddElementToolbar" ) ),
4509 remTb = createTool( tr( "TB_REM" ), QString( "SMESHRemoveToolbar" ) ),
4510 //renumbTb = createTool( tr( "TB_RENUMBER" ), QString( "SMESHRenumberingToolbar" ) ),
4511 transformTb = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ),
4512 modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ),
4513 measuremTb = createTool( tr( "TB_MEASUREM" ), QString( "SMESHMeasurementsToolbar" ) ),
4514 dispModeTb = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4516 createTool( SMESHOp::OpCreateMesh, meshTb );
4517 createTool( SMESHOp::OpCreateSubMesh, meshTb );
4518 createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4519 createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4520 createTool( SMESHOp::OpCopyMesh, meshTb );
4521 createTool( separator(), meshTb );
4522 createTool( SMESHOp::OpCompute, meshTb );
4523 createTool( SMESHOp::OpPreCompute, meshTb );
4524 createTool( SMESHOp::OpEvaluate, meshTb );
4525 createTool( SMESHOp::OpMeshOrder, meshTb );
4527 createTool( SMESHOp::OpCreateGroup, groupTb );
4528 createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4529 createTool( SMESHOp::OpConstructGroup, groupTb );
4530 createTool( SMESHOp::OpEditGroup, groupTb );
4532 createTool( SMESHOp::OpMeshInformation, info );
4533 //createTool( SMESHOp::OpStdInfo, meshTb );
4534 //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4535 createTool( SMESHOp::OpFindElementByPoint, info );
4537 createTool( SMESHOp::OpFreeNode, ctrl0dTb );
4538 createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4539 //createTool( SMESHOp::OpNodeConnectivityNb, ctrl0dTb );
4541 createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4542 createTool( SMESHOp::OpLength, ctrl1dTb );
4543 createTool( SMESHOp::OpConnection, ctrl1dTb );
4544 createTool( SMESHOp::OpEqualEdge, ctrl1dTb );
4546 createTool( SMESHOp::OpFreeEdge, ctrl2dTb );
4547 createTool( SMESHOp::OpFreeFace, ctrl2dTb );
4548 createTool( SMESHOp::OpBareBorderFace, ctrl2dTb );
4549 createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4550 createTool( SMESHOp::OpLength2D, ctrl2dTb );
4551 createTool( SMESHOp::OpConnection2D, ctrl2dTb );
4552 createTool( SMESHOp::OpArea, ctrl2dTb );
4553 createTool( SMESHOp::OpTaper, ctrl2dTb );
4554 createTool( SMESHOp::OpAspectRatio, ctrl2dTb );
4555 createTool( SMESHOp::OpMinimumAngle, ctrl2dTb );
4556 createTool( SMESHOp::OpWarpingAngle, ctrl2dTb );
4557 createTool( SMESHOp::OpSkew, ctrl2dTb );
4558 createTool( SMESHOp::OpMaxElementLength2D, ctrl2dTb );
4559 createTool( SMESHOp::OpEqualFace, ctrl2dTb );
4560 createTool( SMESHOp::OpDeflection2D, ctrl2dTb );
4562 createTool( SMESHOp::OpAspectRatio3D, ctrl3dTb );
4563 createTool( SMESHOp::OpVolume, ctrl3dTb );
4564 createTool( SMESHOp::OpMaxElementLength3D, ctrl3dTb );
4565 createTool( SMESHOp::OpBareBorderVolume, ctrl3dTb );
4566 createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
4567 createTool( SMESHOp::OpEqualVolume, ctrl3dTb );
4569 createTool( SMESHOp::OpNode, addElemTb );
4570 createTool( SMESHOp::OpElem0D, addElemTb );
4571 createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4572 createTool( SMESHOp::OpBall, addElemTb );
4573 createTool( SMESHOp::OpEdge, addElemTb );
4574 createTool( SMESHOp::OpTriangle, addElemTb );
4575 createTool( SMESHOp::OpQuadrangle, addElemTb );
4576 createTool( SMESHOp::OpPolygon, addElemTb );
4577 createTool( SMESHOp::OpTetrahedron, addElemTb );
4578 createTool( SMESHOp::OpHexahedron, addElemTb );
4579 createTool( SMESHOp::OpPentahedron, addElemTb );
4580 createTool( SMESHOp::OpPyramid, addElemTb );
4581 createTool( SMESHOp::OpHexagonalPrism, addElemTb );
4582 createTool( SMESHOp::OpPolyhedron, addElemTb );
4584 createTool( SMESHOp::OpQuadraticEdge, addNonElemTb );
4585 createTool( SMESHOp::OpQuadraticTriangle, addNonElemTb );
4586 createTool( SMESHOp::OpBiQuadraticTriangle, addNonElemTb );
4587 createTool( SMESHOp::OpQuadraticQuadrangle, addNonElemTb );
4588 createTool( SMESHOp::OpBiQuadraticQuadrangle, addNonElemTb );
4589 createTool( SMESHOp::OpQuadraticPolygon, addNonElemTb );
4590 createTool( SMESHOp::OpQuadraticTetrahedron, addNonElemTb );
4591 createTool( SMESHOp::OpQuadraticPyramid, addNonElemTb );
4592 createTool( SMESHOp::OpQuadraticPentahedron, addNonElemTb );
4593 createTool( SMESHOp::OpBiQuadraticPentahedron, addNonElemTb );
4594 createTool( SMESHOp::OpQuadraticHexahedron, addNonElemTb );
4595 createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4597 createTool( SMESHOp::OpRemoveNodes, remTb );
4598 createTool( SMESHOp::OpRemoveElements, remTb );
4599 createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4600 createTool( SMESHOp::OpClearMesh, remTb );
4602 //createTool( SMESHOp::OpRenumberingNodes, renumbTb );
4603 //createTool( SMESHOp::OpRenumberingElements, renumbTb );
4605 createTool( SMESHOp::OpMergeNodes, transformTb );
4606 createTool( SMESHOp::OpMergeElements, transformTb );
4607 createTool( SMESHOp::OpTranslation, transformTb );
4608 createTool( SMESHOp::OpRotation, transformTb );
4609 createTool( SMESHOp::OpSymmetry, transformTb );
4610 createTool( SMESHOp::OpScale, transformTb );
4611 createTool( SMESHOp::OpOffset, transformTb );
4612 createTool( SMESHOp::OpSewing, transformTb );
4613 createTool( SMESHOp::OpDuplicateNodes, transformTb );
4615 createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4616 createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4617 createTool( SMESHOp::OpExtrusion, modifyTb );
4618 createTool( SMESHOp::OpExtrusionAlongAPath, modifyTb );
4619 createTool( SMESHOp::OpRevolution, modifyTb );
4620 createTool( SMESHOp::OpOrientation, modifyTb );
4621 createTool( SMESHOp::OpReorientFaces, modifyTb );
4622 createTool( SMESHOp::OpMoveNode, modifyTb );
4623 createTool( SMESHOp::OpDiagonalInversion, modifyTb );
4624 createTool( SMESHOp::OpUnionOfTwoTriangle, modifyTb );
4625 createTool( SMESHOp::OpUnionOfTriangles, modifyTb );
4626 createTool( SMESHOp::OpCuttingOfQuadrangles, modifyTb );
4627 createTool( SMESHOp::OpSplitVolumes, modifyTb );
4628 createTool( SMESHOp::OpSplitBiQuadratic, modifyTb );
4629 createTool( SMESHOp::OpSmoothing, modifyTb );
4630 createTool( SMESHOp::OpPatternMapping, modifyTb );
4632 createTool( SMESHOp::OpMinimumDistance, measuremTb );
4634 createTool( SMESHOp::OpUpdate, dispModeTb );
4636 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4637 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4641 OB = "'ObjectBrowser'",
4642 View = "'" + SVTK_Viewer::Type() + "'",
4644 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4645 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4646 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4647 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4648 smesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::COMPONENT ) ),
4649 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4650 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4651 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4652 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4653 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4654 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4655 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4657 mesh_part = mesh + " " + subMesh + " " + group,
4658 mesh_group = mesh + " " + group,
4659 mesh_submesh = mesh + " " + subMesh,
4660 hyp_alg = hypo + " " + algo;
4662 // popup for object browser
4664 isInvisible("not( isVisible )"),
4665 isEmpty("numberOfNodes = 0"),
4666 isNotEmpty("numberOfNodes <> 0"),
4668 // has nodes, edges, etc in VISIBLE! actor
4669 hasNodes("(numberOfNodes > 0 ) && hasActor"),
4670 hasElems("(count( elemTypes ) > 0)"),
4671 hasDifferentElems("(count( elemTypes ) > 1)"),
4672 hasDifferentObjElems("(count( objElemTypes ) > 1)"),
4673 hasBalls("({'BallElem'} in elemTypes)"),
4674 hasElems0d("({'Elem0d'} in elemTypes)"),
4675 hasEdges("({'Edge'} in elemTypes)"),
4676 hasFaces("({'Face'} in elemTypes)"),
4677 hasVolumes("({'Volume'} in elemTypes)"),
4678 hasFacesOrVolumes("(({'Face'} in elemTypes) || ({'Volume'} in elemTypes)) ");
4680 createPopupItem( SMESHOp::OpEditMesh, OB, mesh, "&& selcount=1" );
4681 createPopupItem( SMESHOp::OpCreateSubMesh, OB, mesh, "&& hasGeomReference");
4682 createPopupItem( SMESHOp::OpMeshOrder, OB, mesh, "&& selcount=1 && hasAlgo && hasGeomReference" );
4683 createPopupItem( SMESHOp::OpEditSubMesh, OB, subMesh, "&& selcount=1 && hasGeomReference" );
4684 createPopupItem( SMESHOp::OpEditGroup, OB, group );
4685 createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4687 popupMgr()->insert( separator(), -1, 0 );
4688 createPopupItem( SMESHOp::OpCompute, OB, mesh, "&& selcount=1 && hasAlgo && isComputable" );
4689 createPopupItem( SMESHOp::OpRecompute, OB, mesh, "&& selcount=1 && hasAlgo && (" + isNotEmpty + " || hasErrors )");
4690 createPopupItem( SMESHOp::OpShowErrors, OB, mesh, "&& selcount=1 && hasErrors" );
4691 createPopupItem( SMESHOp::OpComputeSubMesh, OB, subMesh, "&& selcount=1 && hasAlgo && isComputable" );
4692 createPopupItem( SMESHOp::OpPreCompute, OB, mesh, "&& selcount=1 && hasAlgo && isPreComputable" );
4693 createPopupItem( SMESHOp::OpEvaluate, OB, mesh, "&& selcount=1 && hasAlgo && isComputable" );
4694 popupMgr()->insert( separator(), -1, 0 );
4695 createPopupItem( SMESHOp::OpFileInformation, OB, mesh, "&& selcount=1 && isImported" );
4696 createPopupItem( SMESHOp::OpMeshInformation, OB, mesh_part );
4697 createPopupItem( SMESHOp::OpFindElementByPoint,OB, mesh_group, "&& selcount=1 && " + hasElems );
4698 createPopupItem( SMESHOp::OpOverallMeshQuality,OB, mesh_part );
4699 popupMgr()->insert( separator(), -1, 0 );
4700 createPopupItem( SMESHOp::OpCreateGroup, OB, mesh, "&& selcount=1" );
4701 createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh, "&& selcount=1 && hasGeomReference" );
4702 createPopupItem( SMESHOp::OpConstructGroup, OB, subMesh );
4703 popupMgr()->insert( separator(), -1, 0 );
4704 createPopupItem( SMESHOp::OpEditHypothesis, OB, hypo, "&& isEditableHyp");
4705 createPopupItem( SMESHOp::OpUnassign, OB, hyp_alg );
4706 popupMgr()->insert( separator(), -1, 0 );
4707 createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh_submesh, "&& " + hasElems );
4708 createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh_group, "&& selcount=1 && dim>=2");
4709 //popupMgr()->insert( separator(), -1, 0 );
4711 //popupMgr()->insert( separator(), -1, 0 );
4713 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4714 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4715 QString only_one_2D = only_one_non_empty + " && dim>1";
4717 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4718 popupMgr()->findMenu( anId )->menuAction()->setIcon( resourceMgr()->loadPixmap( "SMESH", tr( "ICON_EXPORT" )));
4719 createPopupItem( SMESHOp::OpPopupExportMED, OB, mesh_group, multiple_non_empty, anId );
4720 createPopupItem( SMESHOp::OpPopupExportUNV, OB, mesh_group, only_one_non_empty, anId );
4721 createPopupItem( SMESHOp::OpPopupExportSTL, OB, mesh_group, only_one_2D, anId );
4723 createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4725 createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, only_one_non_empty, anId );
4726 createPopupItem( SMESHOp::OpPopupExportGMF, OB, mesh_group, only_one_non_empty, anId );
4727 createPopupItem( SMESHOp::OpPopupExportDAT, OB, mesh_group, only_one_non_empty, anId );
4729 anId = popupMgr()->insert( tr( "MEN_IMPORT" ), -1, -1 ); // IMPORT submenu
4730 createPopupItem( SMESHOp::OpPopupImportMED, OB, smesh, "", anId );
4731 createPopupItem( SMESHOp::OpPopupImportUNV, OB, smesh, "", anId );
4732 createPopupItem( SMESHOp::OpPopupImportSTL, OB, smesh, "", anId );
4734 createPopupItem( SMESHOp::OpPopupImportCGNS, OB, smesh, "", anId );
4736 createPopupItem( SMESHOp::OpPopupImportSAUV, OB, smesh, "", anId );
4737 createPopupItem( SMESHOp::OpPopupImportGMF, OB, smesh, "", anId );
4738 createPopupItem( SMESHOp::OpPopupImportDAT, OB, smesh, "", anId );
4739 popupMgr()->insert( separator(), -1, 0 );
4741 createPopupItem( SMESHOp::OpClearMesh, OB, mesh );
4742 createPopupItem( SMESHOp::OpDelete, OB, mesh_part + " " + hyp_alg );
4743 createPopupItem( SMESHOp::OpDeleteGroup, OB, group );
4746 createPopupItem( SMESHOp::OpEditGroup, View, group );
4747 createPopupItem( SMESHOp::OpAddElemGroupPopup, View, elems, "&& guiState = 800" );
4748 createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems, "&& guiState = 800" );
4750 popupMgr()->insert( separator(), -1, 0 );
4751 createPopupItem( SMESHOp::OpMeshInformation, View, mesh_part );
4752 createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4753 createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh, "&& " + hasElems);
4754 popupMgr()->insert( separator(), -1, 0 );
4756 createPopupItem( SMESHOp::OpUpdate, OB + " " + View, mesh_part );
4757 createPopupItem( SMESHOp::OpAutoColor, OB + " " + View, mesh, "&& (not isAutoColor)" );
4758 createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4759 popupMgr()->insert( separator(), -1, 0 );
4761 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4762 QString aType = QString( "%1type in {%2}" ).arg( lc );
4763 aType = aType.arg( mesh_part );
4764 QString aMeshInVTK = aClient + "&&" + aType;
4766 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4767 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4768 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4770 //-------------------------------------------------
4772 //-------------------------------------------------
4773 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4775 popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4776 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4777 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4779 popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4780 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4781 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4783 popupMgr()->insert( separator(), -1, -1 );
4785 //-------------------------------------------------
4787 //-------------------------------------------------
4788 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4790 popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4791 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4792 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4794 popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4795 popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4796 popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4798 popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4799 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4800 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4802 popupMgr()->insert( separator(), anId, -1 );
4804 popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4805 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4806 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4808 //-------------------------------------------------
4810 //-------------------------------------------------
4811 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4813 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4815 popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4816 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4817 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4819 popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4820 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4821 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4823 popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4824 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4825 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4827 popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4828 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4829 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4831 popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4832 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4833 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4835 popupMgr()->insert( separator(), anId, -1 );
4837 popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4838 popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&& $type in {" + mesh + "} &&" + hasDifferentObjElems, QtxPopupMgr::VisibleRule );
4840 popupMgr()->insert( separator(), anId, -1 );
4842 popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4843 popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4846 //-------------------------------------------------
4847 // Representation of the 2D Quadratic elements
4848 //-------------------------------------------------
4849 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4850 popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4851 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "&& isVisible && isQuadratic",QtxPopupMgr::VisibleRule );
4852 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4854 popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4855 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "&& isVisible && isQuadratic", QtxPopupMgr::VisibleRule );
4856 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4858 //-------------------------------------------------
4859 // Orientation of faces
4860 //-------------------------------------------------
4861 popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4862 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4863 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4865 //-------------------------------------------------
4867 //-------------------------------------------------
4868 popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4869 popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4871 //-------------------------------------------------
4873 //-------------------------------------------------
4874 popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4875 popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4877 //-------------------------------------------------
4879 //-------------------------------------------------
4881 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4882 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4883 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4884 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4886 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4888 popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4889 popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4891 popupMgr()->insert( separator(), anId, -1 );
4893 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4895 popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4896 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4897 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4899 popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4900 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4901 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4903 // popupMgr()->insert( action( SMESHOp::OpNodeConnectivityNb ), aSubId, -1 );
4904 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4905 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), "controlMode = 'eNodeConnectivityNb'", QtxPopupMgr::ToggleRule );
4907 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4909 popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4910 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVTK + "&&" + hasEdges + "&&" + hasFacesOrVolumes, QtxPopupMgr::VisibleRule );
4911 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4913 popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4914 popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4915 popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4917 popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4918 popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4919 popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4920 popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4921 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4922 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4924 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4926 popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4927 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4928 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4930 popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4931 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4932 QtxPopupMgr::VisibleRule );
4933 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4935 popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4936 popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4937 popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4939 popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4940 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4941 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4943 popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
4944 popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4945 popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4947 popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
4948 popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4949 popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4951 popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
4952 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4953 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4955 popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
4956 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4957 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4959 popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
4960 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4961 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4963 popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
4964 popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4965 popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4967 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
4968 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4969 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4971 popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
4972 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4973 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4975 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
4976 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4977 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4979 popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
4980 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4981 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4983 popupMgr()->insert ( action( SMESHOp::OpDeflection2D ), aSubId, -1 );
4984 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), aMeshInVtkHasFaces + " && hasGeomReference", QtxPopupMgr::VisibleRule );
4985 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), "controlMode = 'eDeflection2D'", QtxPopupMgr::ToggleRule );
4987 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4989 popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D ), aSubId, -1 );
4990 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4991 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4993 popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
4994 popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4995 popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4997 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
4998 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4999 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
5001 popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
5002 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5003 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
5005 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
5006 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5007 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
5009 popupMgr()->insert ( action( SMESHOp::OpEqualVolume ), aSubId, -1 );
5010 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
5011 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
5013 popupMgr()->insert( separator(), anId, -1 );
5015 popupMgr()->insert( action( SMESHOp::OpShowScalarBar ), anId, -1 );
5016 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
5017 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone' && isScalarBarVisible", QtxPopupMgr::ToggleRule );
5018 popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
5019 popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
5021 popupMgr()->insert( separator(), anId, -1 );
5023 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
5025 popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
5026 popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
5028 popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
5029 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
5030 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isScalarBarVisible && isDistributionVisible", QtxPopupMgr::ToggleRule);
5032 #ifndef DISABLE_PLOT2DVIEWER
5033 popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
5034 popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
5037 //-------------------------------------------------
5039 //-------------------------------------------------
5040 popupMgr()->insert( separator(), -1, -1 );
5041 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
5042 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
5043 popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
5044 popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
5046 popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
5047 popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
5049 popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
5050 popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
5052 popupMgr()->insert( separator(), -1, -1 );
5054 //-------------------------------------------------
5056 //-------------------------------------------------
5057 popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
5058 popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
5060 popupMgr()->insert( separator(), -1, -1 );
5062 popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
5063 popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
5064 popupMgr()->insert( separator(), -1, -1 );
5066 popupMgr()->insert( action( SMESHOp::OpBreakLink), -1, -1 );
5067 popupMgr()->setRule( action( SMESHOp::OpBreakLink), "$component={'SHAPERSTUDY'} and client='ObjectBrowser' and canBreakLink", QtxPopupMgr::VisibleRule );
5069 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
5070 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
5072 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
5073 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
5076 //================================================================================
5078 * \brief Return true if SMESH or GEOM objects are selected.
5079 * Is called form LightApp_Module::activateModule() which clear selection if
5080 * not isSelectionCompatible()
5082 //================================================================================
5084 bool SMESHGUI::isSelectionCompatible()
5086 bool isCompatible = true;
5087 SALOME_ListIO selected;
5088 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
5089 Sel->selectedObjects( selected );
5091 SALOME_ListIteratorOfListIO It( selected );
5092 for ( ; isCompatible && It.More(); It.Next())
5094 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
5095 ( strcmp("SHAPERSTUDY", It.Value()->getComponentDataType()) == 0 ) ||
5096 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
5098 return isCompatible;
5102 bool SMESHGUI::reusableOperation( const int id )
5104 // compute, evaluate and precompute are not reusable operations
5105 return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate || id == SMESHOp::OpRecompute ) ? false : SalomeApp_Module::reusableOperation( id );
5108 bool SMESHGUI::activateModule( SUIT_Study* study )
5110 bool res = SalomeApp_Module::activateModule( study );
5112 setMenuShown( true );
5113 setToolShown( true );
5115 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
5116 PyGILState_STATE gstate = PyGILState_Ensure();
5117 PyObject* pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
5118 if ( !pluginsmanager ) {
5122 PyObject* result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toUtf8().data(),tr("SMESH_PLUGINS_OTHER").toUtf8().data());
5127 PyGILState_Release(gstate);
5128 // end of SMESH plugins loading
5130 // Reset actions accelerator keys
5131 action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
5133 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
5134 GetSMESHGen()->UpdateStudy();
5136 // get all view currently opened in the study and connect their signals to
5137 // the corresponding slots of the class.
5138 SUIT_Desktop* aDesk = study->application()->desktop();
5140 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
5141 SUIT_ViewWindow* wnd;
5142 foreach ( wnd, wndList )
5146 // remove actors whose objects are removed in GetSMESHGen()->UpdateStudy()
5147 SMESH::UpdateActorsAfterUpdateStudy(wnd);
5153 Py_XDECREF(pluginsmanager);
5157 bool SMESHGUI::deactivateModule( SUIT_Study* study )
5159 setMenuShown( false );
5160 setToolShown( false );
5162 EmitSignalCloseAllDialogs();
5164 // Unset actions accelerator keys
5165 action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
5167 return SalomeApp_Module::deactivateModule( study );
5170 void SMESHGUI::studyClosed( SUIT_Study* s )
5174 SMESH::RemoveVisuData();
5175 SalomeApp_Module::studyClosed( s );
5178 void SMESHGUI::OnGUIEvent()
5180 const QObject* obj = sender();
5181 if ( !obj || !obj->inherits( "QAction" ) )
5183 int id = actionId((QAction*)obj);
5188 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
5190 if ( CORBA::is_nil( myComponentSMESH ) )
5192 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
5193 return aGUI.myComponentSMESH;
5195 return myComponentSMESH;
5198 QString SMESHGUI::engineIOR() const
5200 CORBA::ORB_var anORB = getApp()->orb();
5201 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
5202 return QString( anIOR.in() );
5205 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
5207 SalomeApp_Module::contextMenuPopup( client, menu, title );
5209 selectionMgr()->selectedObjects( lst );
5210 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
5211 Handle(SALOME_InteractiveObject) io = lst.First();
5212 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
5213 _PTR(Study) study = appStudy->studyDS();
5214 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
5216 QString aName = SMESH::fromUtf8( obj->GetName());
5217 while ( !aName.isEmpty() && aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
5218 aName.remove(( aName.length() - 1 ), 1 );
5224 LightApp_Selection* SMESHGUI::createSelection() const
5226 return new SMESHGUI_Selection();
5229 void SMESHGUI::windows( QMap<int, int>& aMap ) const
5231 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
5232 aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
5233 #ifndef DISABLE_PYCONSOLE
5234 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
5238 void SMESHGUI::viewManagers( QStringList& list ) const
5240 list.append( SVTK_Viewer::Type() );
5243 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
5245 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
5246 SMESH::UpdateSelectionProp( this );
5248 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
5249 for(int i = 0; i < aViews.count() ; i++){
5250 SUIT_ViewWindow *sf = aViews[i];
5253 EmitSignalActivatedViewManager();
5257 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
5259 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
5260 myClippingPlaneInfoMap.erase( theViewManager );
5263 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
5265 theActor->AddObserver( SMESH::DeleteActorEvent,
5266 myEventCallbackCommand.GetPointer(),
5270 void SMESHGUI::ProcessEvents( vtkObject* theObject,
5271 unsigned long theEvent,
5272 void* theClientData,
5273 void* /*theCallData*/ )
5275 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
5276 if( theObject && (int) theEvent == SMESH::DeleteActorEvent ) {
5277 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
5278 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
5279 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
5280 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
5281 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
5282 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
5283 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
5284 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
5285 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
5286 SMESH::TActorList::iterator anIter3 = anActorList.begin();
5287 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
5288 if( anActor == *anIter3 ) {
5289 anActorList.erase( anIter3 );
5300 void SMESHGUI::createPreferences()
5302 // General tab ------------------------------------------------------------------------
5303 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
5305 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
5306 setPreferenceProperty( autoUpdate, "columns", 2 );
5307 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
5308 setPreferenceProperty( lim, "min", 0 );
5309 setPreferenceProperty( lim, "max", 100000000 );
5310 setPreferenceProperty( lim, "step", 1000 );
5311 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5312 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
5314 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
5315 setPreferenceProperty( dispgroup, "columns", 2 );
5317 addPreference( tr( "PREF_FITALL_ON_DISPLAYONLY" ), dispgroup, LightApp_Preferences::Bool, "SMESH", "fitall_on_displayonly" );
5319 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
5321 modes.append( tr("MEN_WIRE") );
5322 modes.append( tr("MEN_SHADE") );
5323 modes.append( tr("MEN_NODES") );
5324 modes.append( tr("MEN_SHRINK") );
5325 QList<QVariant> indices;
5326 indices.append( 0 );
5327 indices.append( 1 );
5328 indices.append( 2 );
5329 indices.append( 3 );
5330 setPreferenceProperty( dispmode, "strings", modes );
5331 setPreferenceProperty( dispmode, "indexes", indices );
5333 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
5334 setPreferenceProperty( arcgroup, "columns", 2 );
5335 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
5336 QStringList quadraticModes;
5337 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
5338 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
5340 indices.append( 0 );
5341 indices.append( 1 );
5342 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
5343 setPreferenceProperty( quadraticmode, "indexes", indices );
5345 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
5346 "SMESH", "max_angle" );
5347 setPreferenceProperty( maxAngle, "min", 1 );
5348 setPreferenceProperty( maxAngle, "max", 90 );
5350 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
5351 setPreferenceProperty( qaGroup, "columns", 2 );
5352 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
5353 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
5354 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
5355 setPreferenceProperty( prec, "min", 0 );
5356 setPreferenceProperty( prec, "max", 100 );
5357 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
5358 setPreferenceProperty( doubleNodesTol, "precision", 10 );
5359 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
5360 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
5361 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
5364 int cinc = addPreference(tr("PREF_CONTROLS_INCREMENT"), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_increment");
5365 setPreferenceProperty( cinc, "min", 0 );
5366 setPreferenceProperty( cinc, "max", 5 );
5369 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
5370 setPreferenceProperty( exportgroup, "columns", 2 );
5371 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
5372 addPreference( tr( "PREF_SHOW_WARN" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "show_warning" );
5373 int zTol = addPreference( tr( "PREF_ZTOLERANCE" ), exportgroup, LightApp_Preferences::DblSpin, "SMESH", "med_ztolerance" );
5374 setPreferenceProperty( zTol, "precision", 10 );
5375 setPreferenceProperty( zTol, "min", 0.0000000001 );
5376 setPreferenceProperty( zTol, "max", 1000000.0 );
5377 setPreferenceProperty( zTol, "step", 1. );
5378 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
5380 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
5381 setPreferenceProperty( computeGroup, "columns", 2 );
5382 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
5384 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5385 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5386 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5388 indices.append( 0 );
5389 indices.append( 1 );
5390 indices.append( 2 );
5391 setPreferenceProperty( notifyMode, "strings", modes );
5392 setPreferenceProperty( notifyMode, "indexes", indices );
5394 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5395 setPreferenceProperty( infoGroup, "columns", 2 );
5396 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5398 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5399 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5401 indices.append( 0 );
5402 indices.append( 1 );
5403 setPreferenceProperty( elemInfo, "strings", modes );
5404 setPreferenceProperty( elemInfo, "indexes", indices );
5405 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5406 setPreferenceProperty( nodesLim, "min", 0 );
5407 setPreferenceProperty( nodesLim, "max", 10000000 );
5408 setPreferenceProperty( nodesLim, "step", 10000 );
5409 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5410 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5411 setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5412 setPreferenceProperty( ctrlLim, "min", 0 );
5413 setPreferenceProperty( ctrlLim, "max", 10000000 );
5414 setPreferenceProperty( ctrlLim, "step", 1000 );
5415 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5416 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5417 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5418 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5419 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5421 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5422 setPreferenceProperty( segGroup, "columns", 2 );
5423 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5424 "SMESH", "segmentation" );
5425 setPreferenceProperty( segLen, "min", 1 );
5426 setPreferenceProperty( segLen, "max", 10000000 );
5427 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5428 "SMESH", "nb_segments_per_edge" );
5429 setPreferenceProperty( nbSeg, "min", 1 );
5430 setPreferenceProperty( nbSeg, "max", 10000000 );
5431 addPreference( tr( "PREF_USE_MESHGEMS_HYPOSET" ), segGroup, LightApp_Preferences::Bool, "SMESH", "use-meshgems-hypo-sets" );
5433 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5434 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5435 "SMESH", "forget_mesh_on_hyp_modif" );
5438 // Quantities with individual precision settings
5439 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5440 setPreferenceProperty( precGroup, "columns", 2 );
5442 const int nbQuantities = 6;
5443 int precs[nbQuantities], ii = 0;
5444 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5445 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5446 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5447 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5448 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5449 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5450 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5451 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5452 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5453 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5454 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5455 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5457 // Set property for precision value for spinboxes
5458 for ( ii = 0; ii < nbQuantities; ii++ ){
5459 setPreferenceProperty( precs[ii], "min", -14 );
5460 setPreferenceProperty( precs[ii], "max", 14 );
5461 setPreferenceProperty( precs[ii], "precision", 2 );
5464 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5465 setPreferenceProperty( previewGroup, "columns", 2 );
5466 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5467 setPreferenceProperty( chunkSize, "min", 1 );
5468 setPreferenceProperty( chunkSize, "max", 1000 );
5469 setPreferenceProperty( chunkSize, "step", 50 );
5471 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5472 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5474 // Mesh tab ------------------------------------------------------------------------
5475 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5476 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5477 setPreferenceProperty( nodeGroup, "columns", 3 );
5479 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5481 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5483 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5484 QList<QVariant> aMarkerTypeIndicesList;
5485 QList<QVariant> aMarkerTypeIconsList;
5486 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5487 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5488 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5489 aMarkerTypeIndicesList << i;
5490 aMarkerTypeIconsList << pixmap;
5492 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5493 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
5495 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5497 QList<QVariant> aMarkerScaleIndicesList;
5498 QStringList aMarkerScaleValuesList;
5499 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5500 aMarkerScaleIndicesList << i;
5501 //aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5502 aMarkerScaleValuesList << QString::number( i );
5504 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5505 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5507 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5508 //setPreferenceProperty( elemGroup, "columns", 2 );
5510 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5511 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5512 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5513 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5514 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5515 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5516 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5517 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5518 addPreference( tr( "PREF_PREVIEW_COLOR" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5521 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5522 setPreferenceProperty( grpGroup, "columns", 2 );
5524 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5525 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5527 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5528 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5529 /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5530 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5531 double ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5532 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5533 double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5534 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5535 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
5536 LightApp_Preferences::IntSpin, "SMESH", "element_width");
5537 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5538 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5539 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5540 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5542 setPreferenceProperty( size0d, "min", 1 );
5543 setPreferenceProperty( size0d, "max", 10 );
5545 // setPreferenceProperty( ballSize, "min", 1 );
5546 // setPreferenceProperty( ballSize, "max", 10 );
5548 setPreferenceProperty( ballDiameter, "min", 1e-7 );
5549 setPreferenceProperty( ballDiameter, "max", 1e9 );
5550 setPreferenceProperty( ballDiameter, "step", 0.1 );
5552 setPreferenceProperty( ballScale, "min", 1e-2 );
5553 setPreferenceProperty( ballScale, "max", 1e7 );
5554 setPreferenceProperty( ballScale, "step", 0.5 );
5556 setPreferenceProperty( elemW, "min", 1 );
5557 setPreferenceProperty( elemW, "max", 5 );
5559 setPreferenceProperty( outW, "min", 1 );
5560 setPreferenceProperty( outW, "max", 5 );
5562 setPreferenceProperty( shrink, "min", 0 );
5563 setPreferenceProperty( shrink, "max", 100 );
5565 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5566 setPreferenceProperty( numGroup, "columns", 2 );
5568 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5569 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5571 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5572 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5574 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5575 setPreferenceProperty( orientGroup, "columns", 1 );
5577 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5578 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5580 setPreferenceProperty( orientScale, "min", 0.05 );
5581 setPreferenceProperty( orientScale, "max", 0.5 );
5582 setPreferenceProperty( orientScale, "step", 0.05 );
5584 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5586 // Selection tab ------------------------------------------------------------------------
5587 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5589 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5590 setPreferenceProperty( selGroup, "columns", 2 );
5592 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5593 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5595 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5596 setPreferenceProperty( preGroup, "columns", 2 );
5598 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5600 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5601 setPreferenceProperty( precSelGroup, "columns", 2 );
5603 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5604 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5605 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5607 int sinc = addPreference(tr("PREF_SELECTION_INCREMENT"), selTab, LightApp_Preferences::IntSpin, "SMESH", "selection_increment");
5608 setPreferenceProperty( sinc, "min", 0 );
5609 setPreferenceProperty( sinc, "max", 5 );
5611 // Scalar Bar tab ------------------------------------------------------------------------
5612 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5613 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5614 setPreferenceProperty( fontGr, "columns", 2 );
5616 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5617 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5619 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5620 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5622 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5623 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5625 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5626 setPreferenceProperty( numcol, "min", 2 );
5627 setPreferenceProperty( numcol, "max", 256 );
5629 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5630 setPreferenceProperty( numlab, "min", 2 );
5631 setPreferenceProperty( numlab, "max", 65 );
5633 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5634 setPreferenceProperty( orientGr, "columns", 2 );
5635 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5636 QStringList orients;
5637 orients.append( tr( "SMESH_VERTICAL" ) );
5638 orients.append( tr( "SMESH_HORIZONTAL" ) );
5639 indices.clear(); indices.append( 0 ); indices.append( 1 );
5640 setPreferenceProperty( orient, "strings", orients );
5641 setPreferenceProperty( orient, "indexes", indices );
5643 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5644 setPreferenceProperty( posVSizeGr, "columns", 2 );
5645 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5646 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5647 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5648 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5649 setPreferenceProperty( xv, "step", 0.1 );
5650 setPreferenceProperty( xv, "min", 0.0 );
5651 setPreferenceProperty( xv, "max", 1.0 );
5652 setPreferenceProperty( yv, "step", 0.1 );
5653 setPreferenceProperty( yv, "min", 0.0 );
5654 setPreferenceProperty( yv, "max", 1.0 );
5655 setPreferenceProperty( wv, "step", 0.1 );
5656 setPreferenceProperty( wv, "min", 0.0 );
5657 setPreferenceProperty( wv, "max", 1.0 );
5658 setPreferenceProperty( hv, "min", 0.0 );
5659 setPreferenceProperty( hv, "max", 1.0 );
5660 setPreferenceProperty( hv, "step", 0.1 );
5662 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5663 setPreferenceProperty( posHSizeGr, "columns", 2 );
5664 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5665 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5666 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5667 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5668 setPreferenceProperty( xv, "min", 0.0 );
5669 setPreferenceProperty( xv, "max", 1.0 );
5670 setPreferenceProperty( xv, "step", 0.1 );
5671 setPreferenceProperty( xh, "min", 0.0 );
5672 setPreferenceProperty( xh, "max", 1.0 );
5673 setPreferenceProperty( xh, "step", 0.1 );
5674 setPreferenceProperty( yh, "min", 0.0 );
5675 setPreferenceProperty( yh, "max", 1.0 );
5676 setPreferenceProperty( yh, "step", 0.1 );
5677 setPreferenceProperty( wh, "min", 0.0 );
5678 setPreferenceProperty( wh, "max", 1.0 );
5679 setPreferenceProperty( wh, "step", 0.1 );
5680 setPreferenceProperty( hh, "min", 0.0 );
5681 setPreferenceProperty( hh, "max", 1.0 );
5682 setPreferenceProperty( hh, "step", 0.1 );
5684 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5685 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5686 setPreferenceProperty( distributionGr, "columns", 3 );
5688 types.append( tr( "SMESH_MONOCOLOR" ) );
5689 types.append( tr( "SMESH_MULTICOLOR" ) );
5690 indices.clear(); indices.append( 0 ); indices.append( 1 );
5691 setPreferenceProperty( coloringType, "strings", types );
5692 setPreferenceProperty( coloringType, "indexes", indices );
5693 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5697 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5699 if ( sect=="SMESH" ) {
5700 float sbX1 = 0.01, sbY1 = 0.01, sbW = 0.08, sbH = 0.08;
5701 float aTol = 1.00000009999999;
5702 std::string aWarning;
5703 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5705 if ( name == "selection_object_color" ||
5706 name == "selection_element_color" ||
5707 name == "highlight_color" ||
5708 name == "selection_precision_node" ||
5709 name == "selection_precision_element" ||
5710 name == "selection_precision_object" ||
5711 name == "selection_increment")
5713 SMESH::UpdateSelectionProp( this );
5715 else if (name == "scalar_bar_vertical_x" || name == "scalar_bar_vertical_width")
5717 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5718 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5719 if ( sbX1+sbW > aTol ) {
5720 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5723 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5724 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5727 else if (name == "scalar_bar_vertical_y" || name == "scalar_bar_vertical_height" )
5729 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5730 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5731 if ( sbY1 + sbH > aTol ) {
5732 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5733 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5734 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5737 else if (name == "scalar_bar_horizontal_x" || name == "scalar_bar_horizontal_width")
5739 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5740 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5741 if ( sbX1 + sbW > aTol ) {
5742 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5745 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5746 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5749 else if (name == "scalar_bar_horizontal_y" || name == "scalar_bar_horizontal_height")
5751 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5752 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5753 if ( sbY1 + sbH > aTol ) {
5754 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5757 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5758 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5761 else if ( name == "segmentation" )
5763 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5764 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5766 else if ( name == "nb_segments_per_edge" )
5768 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5769 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5771 else if ( name == "historical_python_dump" || name == "forget_mesh_on_hyp_modif" || name == "default_grp_color" )
5773 QString val = aResourceMgr->stringValue( "SMESH", name );
5774 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5776 else if ( name == "numbering_node_color" || name == "numbering_node_font" )
5778 SMESH::UpdateFontProp( this );
5780 else if ( name == "numbering_elem_color" || name == "numbering_elem_font" )
5782 SMESH::UpdateFontProp( this );
5785 if ( aWarning.size() != 0 ) {
5786 aWarning += "The default values are applied instead.";
5787 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5788 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5789 QObject::tr(aWarning.c_str()));
5794 //================================================================================
5796 * \brief Update something in accordance with update flags
5797 * \param theFlags - update flags
5799 * Update viewer or/and object browser etc. in accordance with update flags ( see
5800 * LightApp_UpdateFlags enumeration ).
5802 //================================================================================
5803 void SMESHGUI::update( const int flags )
5805 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5806 SMESH::UpdateView();
5808 SalomeApp_Module::update( flags );
5811 //================================================================================
5813 * \brief Set default selection mode
5815 * SLOT called when operation committed. Sets default selection mode
5817 //================================================================================
5818 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5820 SVTK_ViewWindow* vtkWnd =
5821 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5823 vtkWnd->SetSelectionMode( ActorSelection );
5826 //================================================================================
5828 * \brief Set default selection mode
5830 * SLOT called when operation aborted. Sets default selection mode
5832 //================================================================================
5833 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5835 SVTK_ViewWindow* vtkWnd =
5836 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5838 vtkWnd->SetSelectionMode( ActorSelection );
5841 //================================================================================
5843 * \brief Creates operation with given identifier
5844 * \param id - identifier of operation to be started
5845 * \return Pointer on created operation or NULL if operation is not created
5847 * Virtual method redefined from the base class creates operation with given id.
5848 * It is called called automatically from startOperation method of base class.
5850 //================================================================================
5851 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5853 LightApp_Operation* op = 0;
5854 // to do : create operation here
5857 case SMESHOp::OpSplitBiQuadratic:
5858 op = new SMESHGUI_SplitBiQuadOp();
5860 case SMESHOp::OpConvertMeshToQuadratic:
5861 op = new SMESHGUI_ConvToQuadOp();
5863 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5864 op = new SMESHGUI_Make2DFrom3DOp();
5866 case SMESHOp::OpReorientFaces:
5867 op = new SMESHGUI_ReorientFacesOp();
5869 case SMESHOp::OpCreateMesh:
5870 op = new SMESHGUI_MeshOp( true, true );
5872 case SMESHOp::OpCreateSubMesh:
5873 op = new SMESHGUI_MeshOp( true, false );
5875 case SMESHOp::OpEditMeshOrSubMesh:
5876 case SMESHOp::OpEditMesh:
5877 case SMESHOp::OpEditSubMesh:
5878 op = new SMESHGUI_MeshOp( false );
5880 case SMESHOp::OpCompute:
5881 case SMESHOp::OpComputeSubMesh:
5882 op = new SMESHGUI_ComputeOp();
5884 case SMESHOp::OpShowErrors:
5885 op = new SMESHGUI_ShowErrorsOp();
5887 case SMESHOp::OpPreCompute:
5888 op = new SMESHGUI_PrecomputeOp();
5890 case SMESHOp::OpEvaluate:
5891 op = new SMESHGUI_EvaluateOp();
5893 case SMESHOp::OpMeshOrder:
5894 op = new SMESHGUI_MeshOrderOp();
5896 case SMESHOp::OpCreateGeometryGroup:
5897 op = new SMESHGUI_GroupOnShapeOp();
5899 case SMESHOp::OpFindElementByPoint:
5900 op = new SMESHGUI_FindElemByPointOp();
5902 case SMESHOp::OpMoveNode: // Make mesh pass through point
5903 op = new SMESHGUI_MakeNodeAtPointOp();
5905 case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
5906 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5913 op = SalomeApp_Module::createOperation( id );
5917 //================================================================================
5919 * \brief Stops current operations and starts a given one
5920 * \param id - The id of the operation to start
5922 //================================================================================
5924 void SMESHGUI::switchToOperation(int id)
5926 activeStudy()->abortAllOperations();
5927 startOperation( id );
5930 LightApp_Displayer* SMESHGUI::displayer()
5933 myDisplayer = new SMESHGUI_Displayer( getApp() );
5937 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5940 int aTolerance = 64;
5941 int anIterations = 0;
5947 if( anIterations % aPeriod == 0 )
5950 if( aTolerance < 1 )
5954 aHue = (int)( 360.0 * rand() / RAND_MAX );
5957 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5958 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5959 for( ; it != itEnd; ++it )
5961 SALOMEDS::Color anAutoColor = *it;
5962 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5965 aQColor.getHsv( &h, &s, &v );
5966 if( abs( h - aHue ) < aTolerance )
5978 aColor.setHsv( aHue, 255, 255 );
5980 SALOMEDS::Color aSColor;
5981 aSColor.R = aColor.redF();
5982 aSColor.G = aColor.greenF();
5983 aSColor.B = aColor.blueF();
5988 const char* gSeparator = "_"; // character used to separate parameter names
5989 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5990 const char* gPathSep = "|"; // character used to separate paths
5993 * \brief Store visual parameters
5995 * This method is called just before the study document is saved.
5996 * Store visual parameters in AttributeParameter attribute(s)
5998 void SMESHGUI::storeVisualParameters (int savePoint)
6001 Kernel_Utils::Localizer loc;
6003 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6004 if (!appStudy || !appStudy->studyDS())
6006 _PTR(Study) studyDS = appStudy->studyDS();
6008 // componentName is used for encoding of entries when storing them in IParameters
6009 std::string componentName = myComponentSMESH->ComponentDataType();
6010 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
6011 //if (!aSComponent) return;
6014 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6015 componentName.c_str(),
6017 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6019 // store custom markers
6020 if( !myMarkerMap.empty() )
6022 VTK::MarkerMap::const_iterator anIter = myMarkerMap.begin();
6023 for( ; anIter != myMarkerMap.end(); anIter++ )
6025 int anId = anIter->first;
6026 VTK::MarkerData aMarkerData = anIter->second;
6027 std::string aMarkerFileName = aMarkerData.first;
6028 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
6029 if( aMarkerTexture.size() < 3 )
6030 continue; // should contain at least width, height and the first value
6032 QString aPropertyName( "texture" );
6033 aPropertyName += gSeparator;
6034 aPropertyName += QString::number( anId );
6036 QString aPropertyValue = aMarkerFileName.c_str();
6037 aPropertyValue += gPathSep;
6039 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
6040 ushort aWidth = *aTextureIter++;
6041 ushort aHeight = *aTextureIter++;
6042 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
6043 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
6044 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
6045 aPropertyValue += QString::number( *aTextureIter );
6047 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
6051 // viewers counters are used for storing view_numbers in IParameters
6054 // main cycle to store parameters of displayed objects
6055 QList<SUIT_ViewManager*> lst;
6056 QList<SUIT_ViewManager*>::Iterator it;
6057 getApp()->viewManagers(lst);
6058 for (it = lst.begin(); it != lst.end(); it++)
6060 SUIT_ViewManager* vman = *it;
6061 QString vType = vman->getType();
6063 // saving VTK actors properties
6064 if (vType == SVTK_Viewer::Type())
6066 // store the clipping planes attached to the view manager
6067 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
6068 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
6069 if( anIter != myClippingPlaneInfoMap.end() )
6070 aClippingPlaneInfoList = anIter->second;
6072 if( !aClippingPlaneInfoList.empty() ) {
6073 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
6074 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
6076 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
6077 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
6079 QString aPropertyName( "ClippingPlane" );
6080 aPropertyName += gSeparator;
6081 aPropertyName += QString::number( vtkViewers );
6082 aPropertyName += gSeparator;
6083 aPropertyName += QString::number( anId );
6085 QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
6086 aPropertyValue += gDigitsSep;
6087 aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
6088 aPropertyValue += gDigitsSep;
6089 if ( aPlane->PlaneMode == SMESH::Absolute ) {
6090 aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
6091 aPropertyValue += gDigitsSep;
6092 aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
6093 aPropertyValue += gDigitsSep;
6094 aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
6095 aPropertyValue += gDigitsSep;
6096 aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
6097 aPropertyValue += gDigitsSep;
6098 aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
6099 aPropertyValue += gDigitsSep;
6100 aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
6101 aPropertyValue += gDigitsSep;
6102 aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
6104 else if ( aPlane->PlaneMode == SMESH::Relative ) {
6105 aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
6106 aPropertyValue += gDigitsSep;
6107 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
6108 aPropertyValue += gDigitsSep;
6109 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
6110 aPropertyValue += gDigitsSep;
6111 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
6114 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
6118 QVector<SUIT_ViewWindow*> views = vman->getViews();
6119 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
6121 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
6123 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
6124 vtkActorCollection* allActors = aCopy.GetActors();
6125 allActors->InitTraversal();
6126 while (vtkActor* actor = allActors->GetNextActor())
6128 if (actor->GetVisibility()) // store only visible actors
6130 SMESH_Actor* aSmeshActor = 0;
6131 if (actor->IsA("SMESH_Actor"))
6132 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
6133 if (aSmeshActor && aSmeshActor->hasIO())
6135 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
6138 // entry is "encoded" = it does NOT contain component address,
6139 // since it is a subject to change on next component loading
6140 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
6142 std::string param, vtkParam = vType.toLatin1().data();
6143 vtkParam += gSeparator;
6144 vtkParam += QString::number(vtkViewers).toLatin1().data();
6145 vtkParam += gSeparator;
6148 param = vtkParam + "Visibility";
6149 ip->setParameter(entry, param, "On");
6152 param = vtkParam + "Representation";
6153 ip->setParameter(entry, param, QString::number
6154 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
6157 param = vtkParam + "IsShrunk";
6158 ip->setParameter(entry, param, QString::number
6159 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
6161 // Displayed entities
6162 unsigned int aMode = aSmeshActor->GetEntityMode();
6163 bool isE = aMode & SMESH_Actor::eEdges;
6164 bool isF = aMode & SMESH_Actor::eFaces;
6165 bool isV = aMode & SMESH_Actor::eVolumes;
6166 bool is0d = aMode & SMESH_Actor::e0DElements;
6167 bool isB = aMode & SMESH_Actor::eBallElem;
6169 QString modeStr ("e");
6170 modeStr += gDigitsSep; modeStr += QString::number(isE);
6171 modeStr += gDigitsSep; modeStr += "f";
6172 modeStr += gDigitsSep; modeStr += QString::number(isF);
6173 modeStr += gDigitsSep; modeStr += "v";
6174 modeStr += gDigitsSep; modeStr += QString::number(isV);
6175 modeStr += gDigitsSep; modeStr += "0d";
6176 modeStr += gDigitsSep; modeStr += QString::number(is0d);
6177 modeStr += gDigitsSep; modeStr += "b";
6178 modeStr += gDigitsSep; modeStr += QString::number(isB);
6180 param = vtkParam + "Entities";
6181 ip->setParameter(entry, param, modeStr.toLatin1().data());
6187 aSmeshActor->GetSufaceColor(r, g, b, delta);
6188 QStringList colorStr;
6189 colorStr << "surface";
6190 colorStr << QString::number(r);
6191 colorStr << QString::number(g);
6192 colorStr << QString::number(b);
6194 colorStr << "backsurface";
6195 colorStr << QString::number(delta);
6197 aSmeshActor->GetVolumeColor(r, g, b, delta);
6198 colorStr << "volume";
6199 colorStr << QString::number(r);
6200 colorStr << QString::number(g);
6201 colorStr << QString::number(b);
6202 colorStr << QString::number(delta);
6204 aSmeshActor->GetEdgeColor(r, g, b);
6206 colorStr << QString::number(r);
6207 colorStr << QString::number(g);
6208 colorStr << QString::number(b);
6210 aSmeshActor->GetNodeColor(r, g, b);
6212 colorStr << QString::number(r);
6213 colorStr << QString::number(g);
6214 colorStr << QString::number(b);
6216 aSmeshActor->GetOutlineColor(r, g, b);
6217 colorStr << "outline";
6218 colorStr << QString::number(r);
6219 colorStr << QString::number(g);
6220 colorStr << QString::number(b);
6222 aSmeshActor->Get0DColor(r, g, b);
6223 colorStr << "elem0d";
6224 colorStr << QString::number(r);
6225 colorStr << QString::number(g);
6226 colorStr << QString::number(b);
6228 aSmeshActor->GetBallColor(r, g, b);
6230 colorStr << QString::number(r);
6231 colorStr << QString::number(g);
6232 colorStr << QString::number(b);
6234 aSmeshActor->GetFacesOrientationColor(r, g, b);
6235 colorStr << "orientation";
6236 colorStr << QString::number(r);
6237 colorStr << QString::number(g);
6238 colorStr << QString::number(b);
6240 param = vtkParam + "Colors";
6241 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
6244 QStringList sizeStr;
6246 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
6247 sizeStr << "outline";
6248 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
6249 sizeStr << "elem0d";
6250 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
6252 //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
6253 sizeStr << QString::number((double)aSmeshActor->GetBallSize());
6254 sizeStr << QString::number((double)aSmeshActor->GetBallScale());
6255 sizeStr << "shrink";
6256 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
6257 sizeStr << "orientation";
6258 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
6259 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
6261 param = vtkParam + "Sizes";
6262 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
6267 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
6268 if( aMarkerType == VTK::MT_USER ) {
6269 markerStr += "custom";
6270 markerStr += gDigitsSep;
6271 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
6275 markerStr += gDigitsSep;
6276 markerStr += QString::number( (int)aMarkerType );
6277 markerStr += gDigitsSep;
6278 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
6281 param = vtkParam + "PointMarker";
6282 ip->setParameter(entry, param, markerStr.toLatin1().data());
6285 param = vtkParam + "Opacity";
6286 ip->setParameter(entry, param,
6287 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
6290 param = vtkParam + "ClippingPlane";
6292 if( !aClippingPlaneInfoList.empty() ) {
6293 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
6294 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
6296 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
6297 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
6298 SMESH::TActorList::iterator anIter2 = anActorList.begin();
6299 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
6300 if( aSmeshActor == *anIter2 ) {
6301 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
6302 QString::number( anId ).toLatin1().constData() );
6309 ip->setParameter( entry, param, "Off" );
6310 } // if (io->hasEntry())
6311 } // SMESH_Actor && hasIO
6313 } // while.. actors traversal
6317 } // if (SVTK view model)
6318 } // for (viewManagers)
6321 // data structures for clipping planes processing
6325 bool isOpenGLClipping;
6326 vtkIdType RelativeOrientation;
6329 int AbsoluteOrientation;
6330 double X, Y, Z, Dx, Dy, Dz;
6332 typedef std::list<TPlaneData> TPlaneDataList;
6333 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
6335 typedef std::list<vtkActor*> TActorList;
6338 TActorList ActorList;
6339 SUIT_ViewManager* ViewManager;
6341 typedef std::list<TPlaneInfo> TPlaneInfoList;
6342 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
6345 * \brief Restore visual parameters
6347 * This method is called after the study document is opened.
6348 * Restore visual parameters from AttributeParameter attribute(s)
6350 void SMESHGUI::restoreVisualParameters (int savePoint)
6353 Kernel_Utils::Localizer loc;
6355 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6356 if (!appStudy || !appStudy->studyDS())
6358 _PTR(Study) studyDS = appStudy->studyDS();
6360 // componentName is used for encoding of entries when storing them in IParameters
6361 std::string componentName = myComponentSMESH->ComponentDataType();
6364 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6365 componentName.c_str(),
6367 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6369 // restore custom markers and map of clipping planes
6370 TPlaneDataMap aPlaneDataMap;
6372 std::vector<std::string> properties = ip->getProperties();
6373 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
6375 std::string property = *propIt;
6376 QString aPropertyName( property.c_str() );
6377 QString aPropertyValue( ip->getProperty( property ).c_str() );
6379 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
6380 if( aPropertyNameList.isEmpty() )
6383 QString aPropertyType = aPropertyNameList[0];
6384 if( aPropertyType == "texture" )
6386 if( aPropertyNameList.size() != 2 )
6390 int anId = aPropertyNameList[1].toInt( &ok );
6391 if( !ok || anId < 1 )
6394 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
6395 if( aPropertyValueList.size() != 2 )
6398 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
6399 QString aMarkerTextureString = aPropertyValueList[1];
6400 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
6401 if( aMarkerTextureStringList.size() != 3 )
6405 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6410 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6414 VTK::MarkerTexture aMarkerTexture;
6415 aMarkerTexture.push_back( aWidth );
6416 aMarkerTexture.push_back( aHeight );
6418 QString aMarkerTextureData = aMarkerTextureStringList[2];
6419 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6421 QChar aChar = aMarkerTextureData.at( i );
6422 if( aChar.isDigit() )
6423 aMarkerTexture.push_back( aChar.digitValue() );
6426 myMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6428 else if( aPropertyType == "ClippingPlane" )
6430 if( aPropertyNameList.size() != 3 )
6434 int aViewId = aPropertyNameList[1].toInt( &ok );
6435 if( !ok || aViewId < 0 )
6439 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6440 if( !ok || aClippingPlaneId < 0 )
6443 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6444 if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6447 TPlaneData aPlaneData;
6448 aPlaneData.AbsoluteOrientation = false;
6449 aPlaneData.RelativeOrientation = 0;
6450 aPlaneData.Distance = aPlaneData.Angle[0] = aPlaneData.Angle[1] = 0;
6451 aPlaneData.X = aPlaneData.Y = aPlaneData.Z = 0;
6452 aPlaneData.Dx = aPlaneData.Dy = aPlaneData.Dz = 0;
6454 aPlaneData.Id = aClippingPlaneId;
6457 aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6462 aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6466 if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6469 aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6474 aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6479 aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6484 aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6489 aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6494 aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6499 aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6503 else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6505 aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6510 aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6515 aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6520 aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6525 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6526 aPlaneDataList.push_back( aPlaneData );
6530 TPlaneInfoMap aPlaneInfoMap;
6532 std::vector<std::string> entries = ip->getEntries();
6534 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6536 // entry is a normal entry - it should be "decoded" (setting base address of component)
6537 QString entry (ip->decodeEntry(*entIt).c_str());
6539 // Check that the entry corresponds to a real object in the Study
6540 // as the object may be deleted or modified after the visual state is saved.
6541 _PTR(SObject) so = studyDS->FindObjectID(entry.toUtf8().data());
6542 if (!so) continue; //Skip the not existent entry
6544 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6545 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6547 std::vector<std::string>::iterator namesIt = paramNames.begin();
6548 std::vector<std::string>::iterator valuesIt = paramValues.begin();
6550 // actors are stored in a map after displaying of them for
6551 // quicker access in the future: map < viewID to actor >
6552 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6554 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6556 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6557 // '_' is used as separator and should not be used in viewer type or parameter names.
6558 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6559 if (lst.size() != 3)
6562 QString viewerTypStr = lst[0];
6563 QString viewIndexStr = lst[1];
6564 QString paramNameStr = lst[2];
6567 int viewIndex = viewIndexStr.toUInt(&ok);
6568 if (!ok) // bad conversion of view index to integer
6572 if (viewerTypStr == SVTK_Viewer::Type())
6574 SMESH_Actor* aSmeshActor = 0;
6575 if (vtkActors.IsBound(viewIndex))
6576 aSmeshActor = vtkActors.Find(viewIndex);
6578 QList<SUIT_ViewManager*> lst;
6579 getApp()->viewManagers(viewerTypStr, lst);
6581 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6582 SUIT_ViewManager* vman = NULL;
6583 if (viewIndex >= 0 && viewIndex < lst.count())
6584 vman = lst.at(viewIndex);
6586 if (paramNameStr == "Visibility")
6588 if (!aSmeshActor && displayer() && vman)
6590 SUIT_ViewModel* vmodel = vman->getViewModel();
6591 // SVTK view model can be casted to SALOME_View
6592 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6594 // store displayed actor in a temporary map for quicker
6595 // access later when restoring other parameters
6596 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6597 vtkRenderer* Renderer = vtkView->getRenderer();
6598 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6599 vtkActorCollection* theActors = aCopy.GetActors();
6600 theActors->InitTraversal();
6601 bool isFound = false;
6602 vtkActor *ac = theActors->GetNextActor();
6603 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6604 if (ac->IsA("SMESH_Actor")) {
6605 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6606 if (aGeomAc->hasIO()) {
6607 Handle(SALOME_InteractiveObject) io = aGeomAc->getIO();
6608 if (io->hasEntry() && strcmp(io->getEntry(), entry.toUtf8().data()) == 0) {
6610 vtkActors.Bind(viewIndex, aGeomAc);
6616 } // if (paramNameStr == "Visibility")
6619 // the rest properties "work" with SMESH_Actor
6622 QString val ((*valuesIt).c_str());
6625 if (paramNameStr == "Representation") {
6626 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6629 else if (paramNameStr == "IsShrunk") {
6631 if (!aSmeshActor->IsShrunk())
6632 aSmeshActor->SetShrink();
6635 if (aSmeshActor->IsShrunk())
6636 aSmeshActor->UnShrink();
6639 // Displayed entities
6640 else if (paramNameStr == "Entities") {
6641 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6642 int aEntityMode = SMESH_Actor::eAllEntity;
6643 for ( int i = 0; i < mode.count(); i+=2 ) {
6644 if ( i < mode.count()-1 ) {
6645 QString type = mode[i];
6646 bool val = mode[i+1].toInt();
6647 if ( type == "e" && !val )
6648 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6649 else if ( type == "f" && !val )
6650 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6651 else if ( type == "v" && !val )
6652 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6653 else if ( type == "0d" && !val )
6654 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6655 else if ( type == "b" && !val )
6656 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6659 aSmeshActor->SetEntityMode( aEntityMode );
6662 else if (paramNameStr == "Colors") {
6663 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6670 QColor outlineColor;
6671 QColor orientationColor;
6677 // below lines are required to get default values for delta coefficients
6678 // of backface color for faces and color of reversed volumes
6679 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
6680 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6681 for ( int i = 0; i < colors.count(); i++ ) {
6682 QString type = colors[i];
6683 if ( type == "surface" ) {
6684 // face color is set by 3 values r:g:b, where
6685 // - r,g,b - is rgb color components
6686 if ( i+1 >= colors.count() ) break; // format error
6687 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6688 if ( i+2 >= colors.count() ) break; // format error
6689 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6690 if ( i+3 >= colors.count() ) break; // format error
6691 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6692 faceColor.setRgbF( r, g, b );
6695 else if ( type == "backsurface" ) {
6696 // backface color can be defined in several ways
6697 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6698 // - in latest versions, it is set as delta coefficient
6699 bool rgbOk = false, deltaOk;
6700 if ( i+1 >= colors.count() ) break; // format error
6701 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6702 int delta = colors[i+1].toInt( &deltaOk );
6704 if ( i+1 < colors.count() ) // index is shifted to 1
6705 g = colors[i+1].toDouble( &rgbOk );
6706 if ( rgbOk ) i++; // shift index
6707 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6708 b = colors[i+1].toDouble( &rgbOk );
6710 // - as currently there's no way to set directly backsurface color as it was before,
6711 // we ignore old dump where r,g,b triple was set
6712 // - also we check that delta parameter is set properly
6713 if ( !rgbOk && deltaOk )
6716 else if ( type == "volume" ) {
6717 // volume color is set by 4 values r:g:b:delta, where
6718 // - r,g,b - is a normal volume rgb color components
6719 // - delta - is a reversed volume color delta coefficient
6720 if ( i+1 >= colors.count() ) break; // format error
6721 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6722 if ( i+2 >= colors.count() ) break; // format error
6723 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6724 if ( i+3 >= colors.count() ) break; // format error
6725 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6726 if ( i+4 >= colors.count() ) break; // format error
6727 int delta = colors[i+4].toInt( &bOk );
6728 if ( !bOk ) break; // format error
6729 volumeColor.setRgbF( r, g, b );
6733 else if ( type == "edge" ) {
6734 // edge color is set by 3 values r:g:b, where
6735 // - r,g,b - is rgb color components
6736 if ( i+1 >= colors.count() ) break; // format error
6737 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6738 if ( i+2 >= colors.count() ) break; // format error
6739 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6740 if ( i+3 >= colors.count() ) break; // format error
6741 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6742 edgeColor.setRgbF( r, g, b );
6745 else if ( type == "node" ) {
6746 // node color is set by 3 values r:g:b, where
6747 // - r,g,b - is rgb color components
6748 if ( i+1 >= colors.count() ) break; // format error
6749 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6750 if ( i+2 >= colors.count() ) break; // format error
6751 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6752 if ( i+3 >= colors.count() ) break; // format error
6753 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6754 nodeColor.setRgbF( r, g, b );
6757 else if ( type == "elem0d" ) {
6758 // 0d element color is set by 3 values r:g:b, where
6759 // - r,g,b - is rgb color components
6760 if ( i+1 >= colors.count() ) break; // format error
6761 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6762 if ( i+2 >= colors.count() ) break; // format error
6763 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6764 if ( i+3 >= colors.count() ) break; // format error
6765 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6766 elem0dColor.setRgbF( r, g, b );
6769 else if ( type == "ball" ) {
6770 // ball 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 ballColor.setRgbF( r, g, b );
6781 else if ( type == "outline" ) {
6782 // outline 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 outlineColor.setRgbF( r, g, b );
6793 else if ( type == "orientation" ) {
6794 // orientation 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 orientationColor.setRgbF( r, g, b );
6807 if ( nodeColor.isValid() )
6808 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6810 if ( edgeColor.isValid() )
6811 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6813 if ( faceColor.isValid() )
6814 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6816 if ( volumeColor.isValid() )
6817 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6818 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6819 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6821 if ( elem0dColor.isValid() )
6822 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6824 if ( ballColor.isValid() )
6825 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6827 if ( outlineColor.isValid() )
6828 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6829 // orientation color
6830 if ( orientationColor.isValid() )
6831 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6834 else if (paramNameStr == "Sizes") {
6835 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6838 int outlineWidth = -1;
6839 int elem0dSize = -1;
6840 //int ballSize = -1;
6841 double ballDiameter = -1.0;
6842 double ballScale = -1.0;
6843 double shrinkSize = -1;
6844 double orientationSize = -1;
6845 bool orientation3d = false;
6846 for ( int i = 0; i < sizes.count(); i++ ) {
6847 QString type = sizes[i];
6848 if ( type == "line" ) {
6849 // line (wireframe) width is given as single integer value
6850 if ( i+1 >= sizes.count() ) break; // format error
6851 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6855 if ( type == "outline" ) {
6856 // outline width is given as single integer value
6857 if ( i+1 >= sizes.count() ) break; // format error
6858 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6862 else if ( type == "elem0d" ) {
6863 // 0d element size is given as single integer value
6864 if ( i+1 >= sizes.count() ) break; // format error
6865 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6869 else if ( type == "ball" ) {
6870 // balls are specified by two values: size:scale, where
6871 // - size - is a integer value specifying size
6872 // - scale - is a double value specifying scale factor
6873 if ( i+1 >= sizes.count() ) break; // format error
6874 //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6875 double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6876 if ( i+2 >= sizes.count() ) break; // format error
6877 double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6883 else if ( type == "shrink" ) {
6884 // shrink factor is given as single floating point value
6885 if ( i+1 >= sizes.count() ) break; // format error
6886 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6890 else if ( type == "orientation" ) {
6891 // orientation vectors are specified by two values size:3d, where
6892 // - size - is a floating point value specifying scale factor
6893 // - 3d - is a boolean
6894 if ( i+1 >= sizes.count() ) break; // format error
6895 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6896 if ( i+2 >= sizes.count() ) break; // format error
6897 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6898 orientationSize = v1;
6899 orientation3d = (bool)v2;
6903 // line (wireframe) width
6904 if ( lineWidth > 0 )
6905 aSmeshActor->SetLineWidth( lineWidth );
6907 if ( outlineWidth > 0 )
6908 aSmeshActor->SetOutlineWidth( outlineWidth );
6909 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6910 aSmeshActor->SetOutlineWidth( lineWidth );
6912 if ( elem0dSize > 0 )
6913 aSmeshActor->Set0DSize( elem0dSize );
6915 /*if ( ballSize > 0 )
6916 aSmeshActor->SetBallSize( ballSize );*/
6918 if ( ballDiameter > 0 )
6919 aSmeshActor->SetBallSize( ballDiameter );
6921 if ( ballScale > 0.0 )
6922 aSmeshActor->SetBallScale( ballScale );
6924 if ( shrinkSize > 0 )
6925 aSmeshActor->SetShrinkFactor( shrinkSize );
6926 // orientation vectors
6927 if ( orientationSize > 0 ) {
6928 aSmeshActor->SetFacesOrientationScale( orientationSize );
6929 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6933 else if (paramNameStr == "PointMarker") {
6934 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6935 if( data.count() >= 2 ) {
6937 int aParam1 = data[1].toInt( &ok );
6939 if( data[0] == "std" && data.count() == 3 ) {
6940 int aParam2 = data[2].toInt( &ok );
6941 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6943 else if( data[0] == "custom" ) {
6944 VTK::MarkerMap::const_iterator markerIt = myMarkerMap.find( aParam1 );
6945 if( markerIt != myMarkerMap.end() ) {
6946 VTK::MarkerData aMarkerData = markerIt->second;
6947 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6954 else if (paramNameStr == "Opacity") {
6955 aSmeshActor->SetOpacity(val.toFloat());
6958 else if (paramNameStr.startsWith("ClippingPlane")) {
6959 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6960 // old format - val looks like "Off" or "1:0:0:0.5:0:0"
6961 // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
6962 // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
6963 // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
6964 // new format - val looks like "Off" or "0" (plane id)
6965 // (note: in new format "Off" value is used only for consistency,
6966 // so it is processed together with values in old format)
6967 bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
6968 if( anIsOldFormat ) {
6969 if (paramNameStr == "ClippingPlane1" || val == "Off")
6970 aSmeshActor->RemoveAllClippingPlanes();
6972 QList<SUIT_ViewManager*> lst;
6973 getApp()->viewManagers(viewerTypStr, lst);
6974 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6975 if (viewIndex >= 0 && viewIndex < lst.count()) {
6976 SUIT_ViewManager* vman = lst.at(viewIndex);
6977 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6979 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6981 SMESH::TActorList anActorList;
6982 anActorList.push_back( aSmeshActor );
6983 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
6984 aPlane->myViewWindow = vtkView;
6985 SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
6986 aPlane->PlaneMode = aMode;
6987 bool isOpenGLClipping = ( bool )vals[1].toInt();
6988 aPlane->IsOpenGLClipping = isOpenGLClipping;
6989 if ( aMode == SMESH::Absolute ) {
6990 aPlane->myAbsoluteOrientation = vals[2].toInt();
6991 aPlane->X = vals[3].toFloat();
6992 aPlane->Y = vals[4].toFloat();
6993 aPlane->Z = vals[5].toFloat();
6994 aPlane->Dx = vals[6].toFloat();
6995 aPlane->Dy = vals[7].toFloat();
6996 aPlane->Dz = vals[8].toFloat();
6998 else if ( aMode == SMESH::Relative ) {
6999 aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
7000 aPlane->myDistance = vals[3].toFloat();
7001 aPlane->myAngle[0] = vals[4].toFloat();
7002 aPlane->myAngle[1] = vals[5].toFloat();
7006 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
7007 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
7008 aClippingPlaneInfo.Plane = aPlane;
7009 aClippingPlaneInfo.ActorList = anActorList;
7010 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
7018 int aPlaneId = val.toInt( &ok );
7019 if( ok && aPlaneId >= 0 ) {
7020 bool anIsDefinedPlane = false;
7021 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
7022 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
7023 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
7024 TPlaneInfo& aPlaneInfo = *anIter;
7025 if( aPlaneInfo.PlaneId == aPlaneId ) {
7026 aPlaneInfo.ActorList.push_back( aSmeshActor );
7027 anIsDefinedPlane = true;
7031 if( !anIsDefinedPlane ) {
7032 TPlaneInfo aPlaneInfo;
7033 aPlaneInfo.PlaneId = aPlaneId;
7034 aPlaneInfo.ActorList.push_back( aSmeshActor );
7035 aPlaneInfo.ViewManager = vman;
7037 // to make the list sorted by plane id
7038 anIter = aPlaneInfoList.begin();
7039 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
7040 const TPlaneInfo& aPlaneInfoRef = *anIter;
7041 if( aPlaneInfoRef.PlaneId > aPlaneId )
7044 aPlaneInfoList.insert( anIter, aPlaneInfo );
7049 } // if (aSmeshActor)
7050 } // other parameters than Visibility
7052 } // for names/parameters iterator
7053 } // for entries iterator
7055 // take into account planes with empty list of actors referred to them
7056 QList<SUIT_ViewManager*> aVMList;
7057 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
7059 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
7060 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
7061 int aViewId = aPlaneDataIter->first;
7062 if( aViewId >= 0 && aViewId < aVMList.count() ) {
7063 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
7065 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
7067 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
7068 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
7069 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
7070 const TPlaneData& aPlaneData = *anIter2;
7071 int aPlaneId = aPlaneData.Id;
7073 bool anIsFound = false;
7074 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
7075 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
7076 const TPlaneInfo& aPlaneInfo = *anIter3;
7077 if( aPlaneInfo.PlaneId == aPlaneId ) {
7084 TPlaneInfo aPlaneInfo; // ActorList field is empty
7085 aPlaneInfo.PlaneId = aPlaneId;
7086 aPlaneInfo.ViewManager = aViewManager;
7088 // to make the list sorted by plane id
7089 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
7090 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
7091 const TPlaneInfo& aPlaneInfoRef = *anIter4;
7092 if( aPlaneInfoRef.PlaneId > aPlaneId )
7095 aPlaneInfoList.insert( anIter4, aPlaneInfo );
7101 // add clipping planes to actors according to the restored parameters
7102 // and update the clipping plane map
7103 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
7104 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
7105 int aViewId = anIter1->first;
7106 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
7108 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
7109 if( anIter2 == aPlaneDataMap.end() )
7111 const TPlaneDataList& aPlaneDataList = anIter2->second;
7113 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
7114 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
7115 const TPlaneInfo& aPlaneInfo = *anIter3;
7116 int aPlaneId = aPlaneInfo.PlaneId;
7117 const TActorList& anActorList = aPlaneInfo.ActorList;
7118 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
7122 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
7126 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
7128 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
7129 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
7130 const TPlaneData& aPlaneData = *anIter4;
7131 if( aPlaneData.Id == aPlaneId ) {
7132 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
7133 aPlane->myViewWindow = aViewWindow;
7134 aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
7135 aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
7136 if ( aPlane->PlaneMode == SMESH::Absolute ) {
7137 aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
7138 aPlane->X = aPlaneData.X;
7139 aPlane->Y = aPlaneData.Y;
7140 aPlane->Z = aPlaneData.Z;
7141 aPlane->Dx = aPlaneData.Dx;
7142 aPlane->Dy = aPlaneData.Dy;
7143 aPlane->Dz = aPlaneData.Dz;
7145 else if ( aPlane->PlaneMode == SMESH::Relative ) {
7146 aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
7147 aPlane->myDistance = aPlaneData.Distance;
7148 aPlane->myAngle[0] = aPlaneData.Angle[0];
7149 aPlane->myAngle[1] = aPlaneData.Angle[1];
7152 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
7153 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
7154 aClippingPlaneInfo.Plane = aPlane;
7155 aClippingPlaneInfo.ActorList = anActorList;
7156 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
7167 // update all VTK views
7168 QList<SUIT_ViewManager*> lst;
7169 getApp()->viewManagers(lst);
7170 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
7171 SUIT_ViewModel* vmodel = (*it)->getViewModel();
7172 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
7173 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
7174 // set OpenGL clipping planes
7175 VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
7176 vtkActorCollection* anAllActors = aCopy.GetActors();
7177 anAllActors->InitTraversal();
7178 while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
7179 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
7180 anActor->SetOpenGLClippingPlane();
7182 vtkView->getRenderer()->ResetCameraClippingRange();
7189 \brief Adds preferences for dfont of VTK viewer
7191 \param pIf group identifier
7192 \param param parameter
7193 \return identifier of preferences
7195 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
7197 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
7199 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
7202 fam.append( tr( "SMESH_FONT_ARIAL" ) );
7203 fam.append( tr( "SMESH_FONT_COURIER" ) );
7204 fam.append( tr( "SMESH_FONT_TIMES" ) );
7206 setPreferenceProperty( tfont, "fonts", fam );
7208 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
7209 if ( needSize ) f = f | QtxFontEdit::Size;
7210 setPreferenceProperty( tfont, "features", f );
7216 \brief Actions after hypothesis edition
7217 Updates object browser after hypothesis edition
7219 void SMESHGUI::onHypothesisEdit( int result )
7222 SMESHGUI::Modified();
7223 updateObjBrowser( true );
7227 \brief Actions after choosing menu of control modes
7228 Updates control mode actions according to current selection
7230 void SMESHGUI::onUpdateControlActions()
7232 SALOME_ListIO selected;
7233 if ( LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr() )
7234 aSel->selectedObjects( selected );
7236 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
7237 if ( selected.Extent() ) {
7238 if ( selected.First()->hasEntry() ) {
7239 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( selected.First()->getEntry() )) {
7240 aControl = anActor->GetControlMode();
7241 SALOME_ListIteratorOfListIO it(selected);
7242 for ( it.Next(); it.More(); it.Next() ) {
7243 Handle(SALOME_InteractiveObject) anIO = it.Value();
7244 if ( anIO->hasEntry() ) {
7245 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
7246 if ( aControl != anActor->GetControlMode() ) {
7247 aControl = SMESH_Actor::eNone;
7257 int anAction = ActionToControl( aControl, true );
7259 action( anAction )->setChecked( true );
7261 QMenu* send = (QMenu*)sender();
7262 QList<QAction*> actions = send->actions();
7263 for ( int i = 0; i < actions.size(); i++ )
7264 actions[i]->setChecked( false );
7270 \brief Signal handler closing(SUIT_ViewWindow*) of a view
7271 \param pview view being closed
7273 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
7274 #ifndef DISABLE_PLOT2DVIEWER
7275 //Crear all Plot2d Viewers if need.
7276 SMESH::ClearPlot2Viewers(pview);
7278 EmitSignalCloseView();
7281 void SMESHGUI::message( const QString& msg )
7284 QStringList data = msg.split("/");
7285 if ( data.count() > 0 ) {
7286 if ( data.first() == "mesh_loading" ) {
7288 QString entry = data.count() > 1 ? data[1] : QString();
7289 if ( entry.isEmpty() )
7292 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
7294 _PTR(SObject) obj = study->FindObjectID( entry.toUtf8().constData() );
7297 name = SMESH::fromUtf8(obj->GetName());
7298 if ( name.isEmpty() )
7301 if ( data.last() == "stop" )
7302 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
7304 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
7305 QApplication::processEvents();
7311 \brief Connects or disconnects signals about activating and cloning view on the module slots
7312 \param pview view which is connected/disconnected
7314 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
7318 SUIT_ViewManager* viewMgr = pview->getViewManager();
7320 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7321 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7323 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7324 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7329 \brief Return \c true if object can be renamed
7331 bool SMESHGUI::renameAllowed( const QString& entry) const {
7332 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7336 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7340 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
7345 if(appStudy->isComponent(entry) || obj->isReference())
7348 // check type to prevent renaming of inappropriate objects
7349 int aType = SMESHGUI_Selection::type(qPrintable(entry));
7350 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7351 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7352 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7353 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7354 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
7361 Rename object by entry.
7362 \param entry entry of the object
7363 \param name new name of the object
7364 \brief Return \c true if rename operation finished successfully, \c false otherwise.
7366 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
7368 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7372 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7377 _PTR(Study) aStudy = appStudy->studyDS();
7382 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
7384 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
7389 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
7390 _PTR(GenericAttribute) anAttr;
7391 _PTR(AttributeName) aName;
7393 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
7395 // check type to prevent renaming of inappropriate objects
7396 int aType = SMESHGUI_Selection::type( qPrintable(entry));
7397 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7398 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7399 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7400 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7401 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
7402 if ( !name.isEmpty() ) {
7403 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qUtf8Printable(name) );
7405 // update name of group object and its actor
7406 Handle(SALOME_InteractiveObject) IObject =
7407 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
7409 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
7410 if( !aGroupObject->_is_nil() ) {
7411 aGroupObject->SetName( qUtf8Printable(name) );
7412 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
7413 anActor->setName( qUtf8Printable(name) );
7423 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
7425 static QList<QColor> colors;
7427 if ( colors.isEmpty() ) {
7429 for (int s = 0; s < 2 ; s++)
7431 for (int v = 100; v >= 40; v = v - 20)
7433 for (int h = 0; h < 359 ; h = h + 60)
7435 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
7440 static int currentColor = randomize( colors.size() );
7442 SALOMEDS::Color color;
7443 color.R = (double)colors[currentColor].red() / 255.0;
7444 color.G = (double)colors[currentColor].green() / 255.0;
7445 color.B = (double)colors[currentColor].blue() / 255.0;
7447 currentColor = (currentColor+1) % colors.count();