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 );
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" );
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 );
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 );
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,
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::OpPreCompute:
5885 op = new SMESHGUI_PrecomputeOp();
5887 case SMESHOp::OpEvaluate:
5888 op = new SMESHGUI_EvaluateOp();
5890 case SMESHOp::OpMeshOrder:
5891 op = new SMESHGUI_MeshOrderOp();
5893 case SMESHOp::OpCreateGeometryGroup:
5894 op = new SMESHGUI_GroupOnShapeOp();
5896 case SMESHOp::OpFindElementByPoint:
5897 op = new SMESHGUI_FindElemByPointOp();
5899 case SMESHOp::OpMoveNode: // Make mesh pass through point
5900 op = new SMESHGUI_MakeNodeAtPointOp();
5902 case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
5903 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5910 op = SalomeApp_Module::createOperation( id );
5914 //================================================================================
5916 * \brief Stops current operations and starts a given one
5917 * \param id - The id of the operation to start
5919 //================================================================================
5921 void SMESHGUI::switchToOperation(int id)
5923 activeStudy()->abortAllOperations();
5924 startOperation( id );
5927 LightApp_Displayer* SMESHGUI::displayer()
5930 myDisplayer = new SMESHGUI_Displayer( getApp() );
5934 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5937 int aTolerance = 64;
5938 int anIterations = 0;
5944 if( anIterations % aPeriod == 0 )
5947 if( aTolerance < 1 )
5951 aHue = (int)( 360.0 * rand() / RAND_MAX );
5954 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5955 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5956 for( ; it != itEnd; ++it )
5958 SALOMEDS::Color anAutoColor = *it;
5959 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5962 aQColor.getHsv( &h, &s, &v );
5963 if( abs( h - aHue ) < aTolerance )
5975 aColor.setHsv( aHue, 255, 255 );
5977 SALOMEDS::Color aSColor;
5978 aSColor.R = aColor.redF();
5979 aSColor.G = aColor.greenF();
5980 aSColor.B = aColor.blueF();
5985 const char* gSeparator = "_"; // character used to separate parameter names
5986 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5987 const char* gPathSep = "|"; // character used to separate paths
5990 * \brief Store visual parameters
5992 * This method is called just before the study document is saved.
5993 * Store visual parameters in AttributeParameter attribute(s)
5995 void SMESHGUI::storeVisualParameters (int savePoint)
5998 Kernel_Utils::Localizer loc;
6000 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6001 if (!appStudy || !appStudy->studyDS())
6003 _PTR(Study) studyDS = appStudy->studyDS();
6005 // componentName is used for encoding of entries when storing them in IParameters
6006 std::string componentName = myComponentSMESH->ComponentDataType();
6007 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
6008 //if (!aSComponent) return;
6011 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6012 componentName.c_str(),
6014 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6016 // store custom markers
6017 if( !myMarkerMap.empty() )
6019 VTK::MarkerMap::const_iterator anIter = myMarkerMap.begin();
6020 for( ; anIter != myMarkerMap.end(); anIter++ )
6022 int anId = anIter->first;
6023 VTK::MarkerData aMarkerData = anIter->second;
6024 std::string aMarkerFileName = aMarkerData.first;
6025 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
6026 if( aMarkerTexture.size() < 3 )
6027 continue; // should contain at least width, height and the first value
6029 QString aPropertyName( "texture" );
6030 aPropertyName += gSeparator;
6031 aPropertyName += QString::number( anId );
6033 QString aPropertyValue = aMarkerFileName.c_str();
6034 aPropertyValue += gPathSep;
6036 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
6037 ushort aWidth = *aTextureIter++;
6038 ushort aHeight = *aTextureIter++;
6039 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
6040 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
6041 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
6042 aPropertyValue += QString::number( *aTextureIter );
6044 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
6048 // viewers counters are used for storing view_numbers in IParameters
6051 // main cycle to store parameters of displayed objects
6052 QList<SUIT_ViewManager*> lst;
6053 QList<SUIT_ViewManager*>::Iterator it;
6054 getApp()->viewManagers(lst);
6055 for (it = lst.begin(); it != lst.end(); it++)
6057 SUIT_ViewManager* vman = *it;
6058 QString vType = vman->getType();
6060 // saving VTK actors properties
6061 if (vType == SVTK_Viewer::Type())
6063 // store the clipping planes attached to the view manager
6064 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
6065 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
6066 if( anIter != myClippingPlaneInfoMap.end() )
6067 aClippingPlaneInfoList = anIter->second;
6069 if( !aClippingPlaneInfoList.empty() ) {
6070 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
6071 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
6073 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
6074 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
6076 QString aPropertyName( "ClippingPlane" );
6077 aPropertyName += gSeparator;
6078 aPropertyName += QString::number( vtkViewers );
6079 aPropertyName += gSeparator;
6080 aPropertyName += QString::number( anId );
6082 QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
6083 aPropertyValue += gDigitsSep;
6084 aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
6085 aPropertyValue += gDigitsSep;
6086 if ( aPlane->PlaneMode == SMESH::Absolute ) {
6087 aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
6088 aPropertyValue += gDigitsSep;
6089 aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
6090 aPropertyValue += gDigitsSep;
6091 aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
6092 aPropertyValue += gDigitsSep;
6093 aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
6094 aPropertyValue += gDigitsSep;
6095 aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
6096 aPropertyValue += gDigitsSep;
6097 aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
6098 aPropertyValue += gDigitsSep;
6099 aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
6101 else if ( aPlane->PlaneMode == SMESH::Relative ) {
6102 aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
6103 aPropertyValue += gDigitsSep;
6104 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
6105 aPropertyValue += gDigitsSep;
6106 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
6107 aPropertyValue += gDigitsSep;
6108 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
6111 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
6115 QVector<SUIT_ViewWindow*> views = vman->getViews();
6116 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
6118 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
6120 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
6121 vtkActorCollection* allActors = aCopy.GetActors();
6122 allActors->InitTraversal();
6123 while (vtkActor* actor = allActors->GetNextActor())
6125 if (actor->GetVisibility()) // store only visible actors
6127 SMESH_Actor* aSmeshActor = 0;
6128 if (actor->IsA("SMESH_Actor"))
6129 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
6130 if (aSmeshActor && aSmeshActor->hasIO())
6132 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
6135 // entry is "encoded" = it does NOT contain component address,
6136 // since it is a subject to change on next component loading
6137 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
6139 std::string param, vtkParam = vType.toLatin1().data();
6140 vtkParam += gSeparator;
6141 vtkParam += QString::number(vtkViewers).toLatin1().data();
6142 vtkParam += gSeparator;
6145 param = vtkParam + "Visibility";
6146 ip->setParameter(entry, param, "On");
6149 param = vtkParam + "Representation";
6150 ip->setParameter(entry, param, QString::number
6151 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
6154 param = vtkParam + "IsShrunk";
6155 ip->setParameter(entry, param, QString::number
6156 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
6158 // Displayed entities
6159 unsigned int aMode = aSmeshActor->GetEntityMode();
6160 bool isE = aMode & SMESH_Actor::eEdges;
6161 bool isF = aMode & SMESH_Actor::eFaces;
6162 bool isV = aMode & SMESH_Actor::eVolumes;
6163 bool is0d = aMode & SMESH_Actor::e0DElements;
6164 bool isB = aMode & SMESH_Actor::eBallElem;
6166 QString modeStr ("e");
6167 modeStr += gDigitsSep; modeStr += QString::number(isE);
6168 modeStr += gDigitsSep; modeStr += "f";
6169 modeStr += gDigitsSep; modeStr += QString::number(isF);
6170 modeStr += gDigitsSep; modeStr += "v";
6171 modeStr += gDigitsSep; modeStr += QString::number(isV);
6172 modeStr += gDigitsSep; modeStr += "0d";
6173 modeStr += gDigitsSep; modeStr += QString::number(is0d);
6174 modeStr += gDigitsSep; modeStr += "b";
6175 modeStr += gDigitsSep; modeStr += QString::number(isB);
6177 param = vtkParam + "Entities";
6178 ip->setParameter(entry, param, modeStr.toLatin1().data());
6184 aSmeshActor->GetSufaceColor(r, g, b, delta);
6185 QStringList colorStr;
6186 colorStr << "surface";
6187 colorStr << QString::number(r);
6188 colorStr << QString::number(g);
6189 colorStr << QString::number(b);
6191 colorStr << "backsurface";
6192 colorStr << QString::number(delta);
6194 aSmeshActor->GetVolumeColor(r, g, b, delta);
6195 colorStr << "volume";
6196 colorStr << QString::number(r);
6197 colorStr << QString::number(g);
6198 colorStr << QString::number(b);
6199 colorStr << QString::number(delta);
6201 aSmeshActor->GetEdgeColor(r, g, b);
6203 colorStr << QString::number(r);
6204 colorStr << QString::number(g);
6205 colorStr << QString::number(b);
6207 aSmeshActor->GetNodeColor(r, g, b);
6209 colorStr << QString::number(r);
6210 colorStr << QString::number(g);
6211 colorStr << QString::number(b);
6213 aSmeshActor->GetOutlineColor(r, g, b);
6214 colorStr << "outline";
6215 colorStr << QString::number(r);
6216 colorStr << QString::number(g);
6217 colorStr << QString::number(b);
6219 aSmeshActor->Get0DColor(r, g, b);
6220 colorStr << "elem0d";
6221 colorStr << QString::number(r);
6222 colorStr << QString::number(g);
6223 colorStr << QString::number(b);
6225 aSmeshActor->GetBallColor(r, g, b);
6227 colorStr << QString::number(r);
6228 colorStr << QString::number(g);
6229 colorStr << QString::number(b);
6231 aSmeshActor->GetFacesOrientationColor(r, g, b);
6232 colorStr << "orientation";
6233 colorStr << QString::number(r);
6234 colorStr << QString::number(g);
6235 colorStr << QString::number(b);
6237 param = vtkParam + "Colors";
6238 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
6241 QStringList sizeStr;
6243 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
6244 sizeStr << "outline";
6245 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
6246 sizeStr << "elem0d";
6247 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
6249 //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
6250 sizeStr << QString::number((double)aSmeshActor->GetBallSize());
6251 sizeStr << QString::number((double)aSmeshActor->GetBallScale());
6252 sizeStr << "shrink";
6253 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
6254 sizeStr << "orientation";
6255 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
6256 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
6258 param = vtkParam + "Sizes";
6259 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
6264 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
6265 if( aMarkerType == VTK::MT_USER ) {
6266 markerStr += "custom";
6267 markerStr += gDigitsSep;
6268 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
6272 markerStr += gDigitsSep;
6273 markerStr += QString::number( (int)aMarkerType );
6274 markerStr += gDigitsSep;
6275 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
6278 param = vtkParam + "PointMarker";
6279 ip->setParameter(entry, param, markerStr.toLatin1().data());
6282 param = vtkParam + "Opacity";
6283 ip->setParameter(entry, param,
6284 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
6287 param = vtkParam + "ClippingPlane";
6289 if( !aClippingPlaneInfoList.empty() ) {
6290 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
6291 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
6293 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
6294 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
6295 SMESH::TActorList::iterator anIter2 = anActorList.begin();
6296 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
6297 if( aSmeshActor == *anIter2 ) {
6298 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
6299 QString::number( anId ).toLatin1().constData() );
6306 ip->setParameter( entry, param, "Off" );
6307 } // if (io->hasEntry())
6308 } // SMESH_Actor && hasIO
6310 } // while.. actors traversal
6314 } // if (SVTK view model)
6315 } // for (viewManagers)
6318 // data structures for clipping planes processing
6322 bool isOpenGLClipping;
6323 vtkIdType RelativeOrientation;
6326 int AbsoluteOrientation;
6327 double X, Y, Z, Dx, Dy, Dz;
6329 typedef std::list<TPlaneData> TPlaneDataList;
6330 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
6332 typedef std::list<vtkActor*> TActorList;
6335 TActorList ActorList;
6336 SUIT_ViewManager* ViewManager;
6338 typedef std::list<TPlaneInfo> TPlaneInfoList;
6339 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
6342 * \brief Restore visual parameters
6344 * This method is called after the study document is opened.
6345 * Restore visual parameters from AttributeParameter attribute(s)
6347 void SMESHGUI::restoreVisualParameters (int savePoint)
6350 Kernel_Utils::Localizer loc;
6352 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6353 if (!appStudy || !appStudy->studyDS())
6355 _PTR(Study) studyDS = appStudy->studyDS();
6357 // componentName is used for encoding of entries when storing them in IParameters
6358 std::string componentName = myComponentSMESH->ComponentDataType();
6361 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6362 componentName.c_str(),
6364 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6366 // restore custom markers and map of clipping planes
6367 TPlaneDataMap aPlaneDataMap;
6369 std::vector<std::string> properties = ip->getProperties();
6370 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
6372 std::string property = *propIt;
6373 QString aPropertyName( property.c_str() );
6374 QString aPropertyValue( ip->getProperty( property ).c_str() );
6376 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
6377 if( aPropertyNameList.isEmpty() )
6380 QString aPropertyType = aPropertyNameList[0];
6381 if( aPropertyType == "texture" )
6383 if( aPropertyNameList.size() != 2 )
6387 int anId = aPropertyNameList[1].toInt( &ok );
6388 if( !ok || anId < 1 )
6391 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
6392 if( aPropertyValueList.size() != 2 )
6395 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
6396 QString aMarkerTextureString = aPropertyValueList[1];
6397 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
6398 if( aMarkerTextureStringList.size() != 3 )
6402 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6407 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6411 VTK::MarkerTexture aMarkerTexture;
6412 aMarkerTexture.push_back( aWidth );
6413 aMarkerTexture.push_back( aHeight );
6415 QString aMarkerTextureData = aMarkerTextureStringList[2];
6416 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6418 QChar aChar = aMarkerTextureData.at( i );
6419 if( aChar.isDigit() )
6420 aMarkerTexture.push_back( aChar.digitValue() );
6423 myMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6425 else if( aPropertyType == "ClippingPlane" )
6427 if( aPropertyNameList.size() != 3 )
6431 int aViewId = aPropertyNameList[1].toInt( &ok );
6432 if( !ok || aViewId < 0 )
6436 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6437 if( !ok || aClippingPlaneId < 0 )
6440 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6441 if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6444 TPlaneData aPlaneData;
6445 aPlaneData.AbsoluteOrientation = false;
6446 aPlaneData.RelativeOrientation = 0;
6447 aPlaneData.Distance = aPlaneData.Angle[0] = aPlaneData.Angle[1] = 0;
6448 aPlaneData.X = aPlaneData.Y = aPlaneData.Z = 0;
6449 aPlaneData.Dx = aPlaneData.Dy = aPlaneData.Dz = 0;
6451 aPlaneData.Id = aClippingPlaneId;
6454 aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6459 aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6463 if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6466 aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6471 aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6476 aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6481 aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6486 aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6491 aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6496 aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6500 else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6502 aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6507 aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6512 aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6517 aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6522 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6523 aPlaneDataList.push_back( aPlaneData );
6527 TPlaneInfoMap aPlaneInfoMap;
6529 std::vector<std::string> entries = ip->getEntries();
6531 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6533 // entry is a normal entry - it should be "decoded" (setting base address of component)
6534 QString entry (ip->decodeEntry(*entIt).c_str());
6536 // Check that the entry corresponds to a real object in the Study
6537 // as the object may be deleted or modified after the visual state is saved.
6538 _PTR(SObject) so = studyDS->FindObjectID(entry.toUtf8().data());
6539 if (!so) continue; //Skip the not existent entry
6541 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6542 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6544 std::vector<std::string>::iterator namesIt = paramNames.begin();
6545 std::vector<std::string>::iterator valuesIt = paramValues.begin();
6547 // actors are stored in a map after displaying of them for
6548 // quicker access in the future: map < viewID to actor >
6549 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6551 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6553 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6554 // '_' is used as separator and should not be used in viewer type or parameter names.
6555 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6556 if (lst.size() != 3)
6559 QString viewerTypStr = lst[0];
6560 QString viewIndexStr = lst[1];
6561 QString paramNameStr = lst[2];
6564 int viewIndex = viewIndexStr.toUInt(&ok);
6565 if (!ok) // bad conversion of view index to integer
6569 if (viewerTypStr == SVTK_Viewer::Type())
6571 SMESH_Actor* aSmeshActor = 0;
6572 if (vtkActors.IsBound(viewIndex))
6573 aSmeshActor = vtkActors.Find(viewIndex);
6575 QList<SUIT_ViewManager*> lst;
6576 getApp()->viewManagers(viewerTypStr, lst);
6578 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6579 SUIT_ViewManager* vman = NULL;
6580 if (viewIndex >= 0 && viewIndex < lst.count())
6581 vman = lst.at(viewIndex);
6583 if (paramNameStr == "Visibility")
6585 if (!aSmeshActor && displayer() && vman)
6587 SUIT_ViewModel* vmodel = vman->getViewModel();
6588 // SVTK view model can be casted to SALOME_View
6589 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6591 // store displayed actor in a temporary map for quicker
6592 // access later when restoring other parameters
6593 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6594 vtkRenderer* Renderer = vtkView->getRenderer();
6595 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6596 vtkActorCollection* theActors = aCopy.GetActors();
6597 theActors->InitTraversal();
6598 bool isFound = false;
6599 vtkActor *ac = theActors->GetNextActor();
6600 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6601 if (ac->IsA("SMESH_Actor")) {
6602 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6603 if (aGeomAc->hasIO()) {
6604 Handle(SALOME_InteractiveObject) io = aGeomAc->getIO();
6605 if (io->hasEntry() && strcmp(io->getEntry(), entry.toUtf8().data()) == 0) {
6607 vtkActors.Bind(viewIndex, aGeomAc);
6613 } // if (paramNameStr == "Visibility")
6616 // the rest properties "work" with SMESH_Actor
6619 QString val ((*valuesIt).c_str());
6622 if (paramNameStr == "Representation") {
6623 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6626 else if (paramNameStr == "IsShrunk") {
6628 if (!aSmeshActor->IsShrunk())
6629 aSmeshActor->SetShrink();
6632 if (aSmeshActor->IsShrunk())
6633 aSmeshActor->UnShrink();
6636 // Displayed entities
6637 else if (paramNameStr == "Entities") {
6638 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6639 int aEntityMode = SMESH_Actor::eAllEntity;
6640 for ( int i = 0; i < mode.count(); i+=2 ) {
6641 if ( i < mode.count()-1 ) {
6642 QString type = mode[i];
6643 bool val = mode[i+1].toInt();
6644 if ( type == "e" && !val )
6645 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6646 else if ( type == "f" && !val )
6647 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6648 else if ( type == "v" && !val )
6649 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6650 else if ( type == "0d" && !val )
6651 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6652 else if ( type == "b" && !val )
6653 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6656 aSmeshActor->SetEntityMode( aEntityMode );
6659 else if (paramNameStr == "Colors") {
6660 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6667 QColor outlineColor;
6668 QColor orientationColor;
6674 // below lines are required to get default values for delta coefficients
6675 // of backface color for faces and color of reversed volumes
6676 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
6677 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6678 for ( int i = 0; i < colors.count(); i++ ) {
6679 QString type = colors[i];
6680 if ( type == "surface" ) {
6681 // face color is set by 3 values r:g:b, where
6682 // - r,g,b - is rgb color components
6683 if ( i+1 >= colors.count() ) break; // format error
6684 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6685 if ( i+2 >= colors.count() ) break; // format error
6686 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6687 if ( i+3 >= colors.count() ) break; // format error
6688 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6689 faceColor.setRgbF( r, g, b );
6692 else if ( type == "backsurface" ) {
6693 // backface color can be defined in several ways
6694 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6695 // - in latest versions, it is set as delta coefficient
6696 bool rgbOk = false, deltaOk;
6697 if ( i+1 >= colors.count() ) break; // format error
6698 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6699 int delta = colors[i+1].toInt( &deltaOk );
6701 if ( i+1 < colors.count() ) // index is shifted to 1
6702 g = colors[i+1].toDouble( &rgbOk );
6703 if ( rgbOk ) i++; // shift index
6704 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6705 b = colors[i+1].toDouble( &rgbOk );
6707 // - as currently there's no way to set directly backsurface color as it was before,
6708 // we ignore old dump where r,g,b triple was set
6709 // - also we check that delta parameter is set properly
6710 if ( !rgbOk && deltaOk )
6713 else if ( type == "volume" ) {
6714 // volume color is set by 4 values r:g:b:delta, where
6715 // - r,g,b - is a normal volume rgb color components
6716 // - delta - is a reversed volume color delta coefficient
6717 if ( i+1 >= colors.count() ) break; // format error
6718 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6719 if ( i+2 >= colors.count() ) break; // format error
6720 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6721 if ( i+3 >= colors.count() ) break; // format error
6722 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6723 if ( i+4 >= colors.count() ) break; // format error
6724 int delta = colors[i+4].toInt( &bOk );
6725 if ( !bOk ) break; // format error
6726 volumeColor.setRgbF( r, g, b );
6730 else if ( type == "edge" ) {
6731 // edge color is set by 3 values r:g:b, where
6732 // - r,g,b - is rgb color components
6733 if ( i+1 >= colors.count() ) break; // format error
6734 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6735 if ( i+2 >= colors.count() ) break; // format error
6736 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6737 if ( i+3 >= colors.count() ) break; // format error
6738 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6739 edgeColor.setRgbF( r, g, b );
6742 else if ( type == "node" ) {
6743 // node color is set by 3 values r:g:b, where
6744 // - r,g,b - is rgb color components
6745 if ( i+1 >= colors.count() ) break; // format error
6746 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6747 if ( i+2 >= colors.count() ) break; // format error
6748 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6749 if ( i+3 >= colors.count() ) break; // format error
6750 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6751 nodeColor.setRgbF( r, g, b );
6754 else if ( type == "elem0d" ) {
6755 // 0d element color is set by 3 values r:g:b, where
6756 // - r,g,b - is rgb color components
6757 if ( i+1 >= colors.count() ) break; // format error
6758 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6759 if ( i+2 >= colors.count() ) break; // format error
6760 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6761 if ( i+3 >= colors.count() ) break; // format error
6762 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6763 elem0dColor.setRgbF( r, g, b );
6766 else if ( type == "ball" ) {
6767 // ball color is set by 3 values r:g:b, where
6768 // - r,g,b - is rgb color components
6769 if ( i+1 >= colors.count() ) break; // format error
6770 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6771 if ( i+2 >= colors.count() ) break; // format error
6772 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6773 if ( i+3 >= colors.count() ) break; // format error
6774 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6775 ballColor.setRgbF( r, g, b );
6778 else if ( type == "outline" ) {
6779 // outline color is set by 3 values r:g:b, where
6780 // - r,g,b - is rgb color components
6781 if ( i+1 >= colors.count() ) break; // format error
6782 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6783 if ( i+2 >= colors.count() ) break; // format error
6784 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6785 if ( i+3 >= colors.count() ) break; // format error
6786 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6787 outlineColor.setRgbF( r, g, b );
6790 else if ( type == "orientation" ) {
6791 // orientation color is set by 3 values r:g:b, where
6792 // - r,g,b - is rgb color components
6793 if ( i+1 >= colors.count() ) break; // format error
6794 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6795 if ( i+2 >= colors.count() ) break; // format error
6796 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6797 if ( i+3 >= colors.count() ) break; // format error
6798 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6799 orientationColor.setRgbF( r, g, b );
6804 if ( nodeColor.isValid() )
6805 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6807 if ( edgeColor.isValid() )
6808 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6810 if ( faceColor.isValid() )
6811 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6813 if ( volumeColor.isValid() )
6814 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6815 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6816 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6818 if ( elem0dColor.isValid() )
6819 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6821 if ( ballColor.isValid() )
6822 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6824 if ( outlineColor.isValid() )
6825 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6826 // orientation color
6827 if ( orientationColor.isValid() )
6828 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6831 else if (paramNameStr == "Sizes") {
6832 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6835 int outlineWidth = -1;
6836 int elem0dSize = -1;
6837 //int ballSize = -1;
6838 double ballDiameter = -1.0;
6839 double ballScale = -1.0;
6840 double shrinkSize = -1;
6841 double orientationSize = -1;
6842 bool orientation3d = false;
6843 for ( int i = 0; i < sizes.count(); i++ ) {
6844 QString type = sizes[i];
6845 if ( type == "line" ) {
6846 // line (wireframe) width is given as single integer value
6847 if ( i+1 >= sizes.count() ) break; // format error
6848 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6852 if ( type == "outline" ) {
6853 // outline width is given as single integer value
6854 if ( i+1 >= sizes.count() ) break; // format error
6855 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6859 else if ( type == "elem0d" ) {
6860 // 0d element size is given as single integer value
6861 if ( i+1 >= sizes.count() ) break; // format error
6862 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6866 else if ( type == "ball" ) {
6867 // balls are specified by two values: size:scale, where
6868 // - size - is a integer value specifying size
6869 // - scale - is a double value specifying scale factor
6870 if ( i+1 >= sizes.count() ) break; // format error
6871 //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6872 double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6873 if ( i+2 >= sizes.count() ) break; // format error
6874 double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6880 else if ( type == "shrink" ) {
6881 // shrink factor is given as single floating point value
6882 if ( i+1 >= sizes.count() ) break; // format error
6883 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6887 else if ( type == "orientation" ) {
6888 // orientation vectors are specified by two values size:3d, where
6889 // - size - is a floating point value specifying scale factor
6890 // - 3d - is a boolean
6891 if ( i+1 >= sizes.count() ) break; // format error
6892 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6893 if ( i+2 >= sizes.count() ) break; // format error
6894 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6895 orientationSize = v1;
6896 orientation3d = (bool)v2;
6900 // line (wireframe) width
6901 if ( lineWidth > 0 )
6902 aSmeshActor->SetLineWidth( lineWidth );
6904 if ( outlineWidth > 0 )
6905 aSmeshActor->SetOutlineWidth( outlineWidth );
6906 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6907 aSmeshActor->SetOutlineWidth( lineWidth );
6909 if ( elem0dSize > 0 )
6910 aSmeshActor->Set0DSize( elem0dSize );
6912 /*if ( ballSize > 0 )
6913 aSmeshActor->SetBallSize( ballSize );*/
6915 if ( ballDiameter > 0 )
6916 aSmeshActor->SetBallSize( ballDiameter );
6918 if ( ballScale > 0.0 )
6919 aSmeshActor->SetBallScale( ballScale );
6921 if ( shrinkSize > 0 )
6922 aSmeshActor->SetShrinkFactor( shrinkSize );
6923 // orientation vectors
6924 if ( orientationSize > 0 ) {
6925 aSmeshActor->SetFacesOrientationScale( orientationSize );
6926 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6930 else if (paramNameStr == "PointMarker") {
6931 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6932 if( data.count() >= 2 ) {
6934 int aParam1 = data[1].toInt( &ok );
6936 if( data[0] == "std" && data.count() == 3 ) {
6937 int aParam2 = data[2].toInt( &ok );
6938 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6940 else if( data[0] == "custom" ) {
6941 VTK::MarkerMap::const_iterator markerIt = myMarkerMap.find( aParam1 );
6942 if( markerIt != myMarkerMap.end() ) {
6943 VTK::MarkerData aMarkerData = markerIt->second;
6944 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6951 else if (paramNameStr == "Opacity") {
6952 aSmeshActor->SetOpacity(val.toFloat());
6955 else if (paramNameStr.startsWith("ClippingPlane")) {
6956 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6957 // old format - val looks like "Off" or "1:0:0:0.5:0:0"
6958 // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
6959 // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
6960 // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
6961 // new format - val looks like "Off" or "0" (plane id)
6962 // (note: in new format "Off" value is used only for consistency,
6963 // so it is processed together with values in old format)
6964 bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
6965 if( anIsOldFormat ) {
6966 if (paramNameStr == "ClippingPlane1" || val == "Off")
6967 aSmeshActor->RemoveAllClippingPlanes();
6969 QList<SUIT_ViewManager*> lst;
6970 getApp()->viewManagers(viewerTypStr, lst);
6971 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6972 if (viewIndex >= 0 && viewIndex < lst.count()) {
6973 SUIT_ViewManager* vman = lst.at(viewIndex);
6974 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6976 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6978 SMESH::TActorList anActorList;
6979 anActorList.push_back( aSmeshActor );
6980 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
6981 aPlane->myViewWindow = vtkView;
6982 SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
6983 aPlane->PlaneMode = aMode;
6984 bool isOpenGLClipping = ( bool )vals[1].toInt();
6985 aPlane->IsOpenGLClipping = isOpenGLClipping;
6986 if ( aMode == SMESH::Absolute ) {
6987 aPlane->myAbsoluteOrientation = vals[2].toInt();
6988 aPlane->X = vals[3].toFloat();
6989 aPlane->Y = vals[4].toFloat();
6990 aPlane->Z = vals[5].toFloat();
6991 aPlane->Dx = vals[6].toFloat();
6992 aPlane->Dy = vals[7].toFloat();
6993 aPlane->Dz = vals[8].toFloat();
6995 else if ( aMode == SMESH::Relative ) {
6996 aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
6997 aPlane->myDistance = vals[3].toFloat();
6998 aPlane->myAngle[0] = vals[4].toFloat();
6999 aPlane->myAngle[1] = vals[5].toFloat();
7003 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
7004 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
7005 aClippingPlaneInfo.Plane = aPlane;
7006 aClippingPlaneInfo.ActorList = anActorList;
7007 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
7015 int aPlaneId = val.toInt( &ok );
7016 if( ok && aPlaneId >= 0 ) {
7017 bool anIsDefinedPlane = false;
7018 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
7019 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
7020 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
7021 TPlaneInfo& aPlaneInfo = *anIter;
7022 if( aPlaneInfo.PlaneId == aPlaneId ) {
7023 aPlaneInfo.ActorList.push_back( aSmeshActor );
7024 anIsDefinedPlane = true;
7028 if( !anIsDefinedPlane ) {
7029 TPlaneInfo aPlaneInfo;
7030 aPlaneInfo.PlaneId = aPlaneId;
7031 aPlaneInfo.ActorList.push_back( aSmeshActor );
7032 aPlaneInfo.ViewManager = vman;
7034 // to make the list sorted by plane id
7035 anIter = aPlaneInfoList.begin();
7036 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
7037 const TPlaneInfo& aPlaneInfoRef = *anIter;
7038 if( aPlaneInfoRef.PlaneId > aPlaneId )
7041 aPlaneInfoList.insert( anIter, aPlaneInfo );
7046 } // if (aSmeshActor)
7047 } // other parameters than Visibility
7049 } // for names/parameters iterator
7050 } // for entries iterator
7052 // take into account planes with empty list of actors referred to them
7053 QList<SUIT_ViewManager*> aVMList;
7054 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
7056 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
7057 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
7058 int aViewId = aPlaneDataIter->first;
7059 if( aViewId >= 0 && aViewId < aVMList.count() ) {
7060 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
7062 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
7064 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
7065 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
7066 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
7067 const TPlaneData& aPlaneData = *anIter2;
7068 int aPlaneId = aPlaneData.Id;
7070 bool anIsFound = false;
7071 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
7072 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
7073 const TPlaneInfo& aPlaneInfo = *anIter3;
7074 if( aPlaneInfo.PlaneId == aPlaneId ) {
7081 TPlaneInfo aPlaneInfo; // ActorList field is empty
7082 aPlaneInfo.PlaneId = aPlaneId;
7083 aPlaneInfo.ViewManager = aViewManager;
7085 // to make the list sorted by plane id
7086 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
7087 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
7088 const TPlaneInfo& aPlaneInfoRef = *anIter4;
7089 if( aPlaneInfoRef.PlaneId > aPlaneId )
7092 aPlaneInfoList.insert( anIter4, aPlaneInfo );
7098 // add clipping planes to actors according to the restored parameters
7099 // and update the clipping plane map
7100 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
7101 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
7102 int aViewId = anIter1->first;
7103 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
7105 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
7106 if( anIter2 == aPlaneDataMap.end() )
7108 const TPlaneDataList& aPlaneDataList = anIter2->second;
7110 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
7111 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
7112 const TPlaneInfo& aPlaneInfo = *anIter3;
7113 int aPlaneId = aPlaneInfo.PlaneId;
7114 const TActorList& anActorList = aPlaneInfo.ActorList;
7115 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
7119 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
7123 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
7125 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
7126 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
7127 const TPlaneData& aPlaneData = *anIter4;
7128 if( aPlaneData.Id == aPlaneId ) {
7129 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
7130 aPlane->myViewWindow = aViewWindow;
7131 aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
7132 aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
7133 if ( aPlane->PlaneMode == SMESH::Absolute ) {
7134 aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
7135 aPlane->X = aPlaneData.X;
7136 aPlane->Y = aPlaneData.Y;
7137 aPlane->Z = aPlaneData.Z;
7138 aPlane->Dx = aPlaneData.Dx;
7139 aPlane->Dy = aPlaneData.Dy;
7140 aPlane->Dz = aPlaneData.Dz;
7142 else if ( aPlane->PlaneMode == SMESH::Relative ) {
7143 aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
7144 aPlane->myDistance = aPlaneData.Distance;
7145 aPlane->myAngle[0] = aPlaneData.Angle[0];
7146 aPlane->myAngle[1] = aPlaneData.Angle[1];
7149 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
7150 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
7151 aClippingPlaneInfo.Plane = aPlane;
7152 aClippingPlaneInfo.ActorList = anActorList;
7153 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
7164 // update all VTK views
7165 QList<SUIT_ViewManager*> lst;
7166 getApp()->viewManagers(lst);
7167 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
7168 SUIT_ViewModel* vmodel = (*it)->getViewModel();
7169 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
7170 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
7171 // set OpenGL clipping planes
7172 VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
7173 vtkActorCollection* anAllActors = aCopy.GetActors();
7174 anAllActors->InitTraversal();
7175 while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
7176 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
7177 anActor->SetOpenGLClippingPlane();
7179 vtkView->getRenderer()->ResetCameraClippingRange();
7186 \brief Adds preferences for dfont of VTK viewer
7188 \param pIf group identifier
7189 \param param parameter
7190 \return identifier of preferences
7192 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
7194 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
7196 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
7199 fam.append( tr( "SMESH_FONT_ARIAL" ) );
7200 fam.append( tr( "SMESH_FONT_COURIER" ) );
7201 fam.append( tr( "SMESH_FONT_TIMES" ) );
7203 setPreferenceProperty( tfont, "fonts", fam );
7205 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
7206 if ( needSize ) f = f | QtxFontEdit::Size;
7207 setPreferenceProperty( tfont, "features", f );
7213 \brief Actions after hypothesis edition
7214 Updates object browser after hypothesis edition
7216 void SMESHGUI::onHypothesisEdit( int result )
7219 SMESHGUI::Modified();
7220 updateObjBrowser( true );
7224 \brief Actions after choosing menu of control modes
7225 Updates control mode actions according to current selection
7227 void SMESHGUI::onUpdateControlActions()
7229 SALOME_ListIO selected;
7230 if ( LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr() )
7231 aSel->selectedObjects( selected );
7233 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
7234 if ( selected.Extent() ) {
7235 if ( selected.First()->hasEntry() ) {
7236 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( selected.First()->getEntry() )) {
7237 aControl = anActor->GetControlMode();
7238 SALOME_ListIteratorOfListIO it(selected);
7239 for ( it.Next(); it.More(); it.Next() ) {
7240 Handle(SALOME_InteractiveObject) anIO = it.Value();
7241 if ( anIO->hasEntry() ) {
7242 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
7243 if ( aControl != anActor->GetControlMode() ) {
7244 aControl = SMESH_Actor::eNone;
7254 int anAction = ActionToControl( aControl, true );
7256 action( anAction )->setChecked( true );
7258 QMenu* send = (QMenu*)sender();
7259 QList<QAction*> actions = send->actions();
7260 for ( int i = 0; i < actions.size(); i++ )
7261 actions[i]->setChecked( false );
7267 \brief Signal handler closing(SUIT_ViewWindow*) of a view
7268 \param pview view being closed
7270 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
7271 #ifndef DISABLE_PLOT2DVIEWER
7272 //Crear all Plot2d Viewers if need.
7273 SMESH::ClearPlot2Viewers(pview);
7275 EmitSignalCloseView();
7278 void SMESHGUI::message( const QString& msg )
7281 QStringList data = msg.split("/");
7282 if ( data.count() > 0 ) {
7283 if ( data.first() == "mesh_loading" ) {
7285 QString entry = data.count() > 1 ? data[1] : QString();
7286 if ( entry.isEmpty() )
7289 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
7291 _PTR(SObject) obj = study->FindObjectID( entry.toUtf8().constData() );
7294 name = SMESH::fromUtf8(obj->GetName());
7295 if ( name.isEmpty() )
7298 if ( data.last() == "stop" )
7299 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
7301 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
7302 QApplication::processEvents();
7308 \brief Connects or disconnects signals about activating and cloning view on the module slots
7309 \param pview view which is connected/disconnected
7311 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
7315 SUIT_ViewManager* viewMgr = pview->getViewManager();
7317 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7318 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7320 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7321 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7326 \brief Return \c true if object can be renamed
7328 bool SMESHGUI::renameAllowed( const QString& entry) const {
7329 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7333 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7337 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
7342 if(appStudy->isComponent(entry) || obj->isReference())
7345 // check type to prevent renaming of inappropriate objects
7346 int aType = SMESHGUI_Selection::type(qPrintable(entry));
7347 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7348 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7349 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7350 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7351 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
7358 Rename object by entry.
7359 \param entry entry of the object
7360 \param name new name of the object
7361 \brief Return \c true if rename operation finished successfully, \c false otherwise.
7363 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
7365 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7369 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7374 _PTR(Study) aStudy = appStudy->studyDS();
7379 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
7381 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
7386 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
7387 _PTR(GenericAttribute) anAttr;
7388 _PTR(AttributeName) aName;
7390 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
7392 // check type to prevent renaming of inappropriate objects
7393 int aType = SMESHGUI_Selection::type( qPrintable(entry));
7394 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7395 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7396 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7397 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7398 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
7399 if ( !name.isEmpty() ) {
7400 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qUtf8Printable(name) );
7402 // update name of group object and its actor
7403 Handle(SALOME_InteractiveObject) IObject =
7404 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
7406 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
7407 if( !aGroupObject->_is_nil() ) {
7408 aGroupObject->SetName( qUtf8Printable(name) );
7409 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
7410 anActor->setName( qUtf8Printable(name) );
7420 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
7422 static QList<QColor> colors;
7424 if ( colors.isEmpty() ) {
7426 for (int s = 0; s < 2 ; s++)
7428 for (int v = 100; v >= 40; v = v - 20)
7430 for (int h = 0; h < 359 ; h = h + 60)
7432 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
7437 static int currentColor = randomize( colors.size() );
7439 SALOMEDS::Color color;
7440 color.R = (double)colors[currentColor].red() / 255.0;
7441 color.G = (double)colors[currentColor].green() / 255.0;
7442 color.B = (double)colors[currentColor].blue() / 255.0;
7444 currentColor = (currentColor+1) % colors.count();