1 // Copyright (C) 2007-2020 CEA/DEN, EDF R&D, OPEN CASCADE
3 // Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
6 // This library is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU Lesser General Public
8 // License as published by the Free Software Foundation; either
9 // version 2.1 of the License, or (at your option) any later version.
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 // Lesser General Public License for more details.
16 // You should have received a copy of the GNU Lesser General Public
17 // License along with this library; if not, write to the Free Software
18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
22 // File : SMESHGUI.cxx
23 // Author : Nicolas REJNERI, Open CASCADE S.A.S.
25 #include <Standard_math.hxx> // E.A. must be included before Python.h to fix compilation on windows
27 #undef HAVE_FINITE // VSR: avoid compilation warning on Linux : "HAVE_FINITE" redefined
33 #include "SMESHGUI_Add0DElemsOnAllNodesDlg.h"
34 #include "SMESHGUI_AddMeshElementDlg.h"
35 #include "SMESHGUI_AddQuadraticElementDlg.h"
36 #include "SMESHGUI_BuildCompoundDlg.h"
37 #include "SMESHGUI_ClippingDlg.h"
38 #include "SMESHGUI_ComputeDlg.h"
39 #include "SMESHGUI_ConvToQuadOp.h"
40 #include "SMESHGUI_CopyMeshDlg.h"
41 #include "SMESHGUI_CreatePolyhedralVolumeDlg.h"
42 #include "SMESHGUI_DeleteGroupDlg.h"
43 #include "SMESHGUI_DisplayEntitiesDlg.h"
44 #include "SMESHGUI_Displayer.h"
45 #include "SMESHGUI_DuplicateNodesDlg.h"
46 #include "SMESHGUI_ExtrusionAlongPathDlg.h"
47 #include "SMESHGUI_ExtrusionDlg.h"
48 #include "SMESHGUI_FaceGroupsSeparatedByEdgesDlg.h"
49 #include "SMESHGUI_FieldSelectorWdg.h"
50 #include "SMESHGUI_FileInfoDlg.h"
51 #include "SMESHGUI_FileValidator.h"
52 #include "SMESHGUI_FilterDlg.h"
53 #include "SMESHGUI_FilterLibraryDlg.h"
54 #include "SMESHGUI_FilterUtils.h"
55 #include "SMESHGUI_FindElemByPointDlg.h"
56 #include "SMESHGUI_GEOMGenUtils.h"
57 #include "SMESHGUI_GroupDlg.h"
58 #include "SMESHGUI_GroupOnShapeDlg.h"
59 #include "SMESHGUI_GroupOpDlg.h"
60 #include "SMESHGUI_GroupUtils.h"
61 #include "SMESHGUI_Hypotheses.h"
62 #include "SMESHGUI_HypothesesUtils.h"
63 #include "SMESHGUI_Make2DFrom3DOp.h"
64 #include "SMESHGUI_MakeNodeAtPointDlg.h"
65 #include "SMESHGUI_Measurements.h"
66 #include "SMESHGUI_MergeDlg.h"
67 #include "SMESHGUI_MeshInfo.h"
68 #include "SMESHGUI_MeshOp.h"
69 #include "SMESHGUI_MeshOrderOp.h"
70 #include "SMESHGUI_MeshPatternDlg.h"
71 #include "SMESHGUI_MeshUtils.h"
72 #include "SMESHGUI_MultiEditDlg.h"
73 #include "SMESHGUI_NodesDlg.h"
74 #include "SMESHGUI_OffsetDlg.h"
75 #include "SMESHGUI_Operations.h"
76 #include "SMESHGUI_PatternUtils.h"
77 #include "SMESHGUI_Preferences_ScalarBarDlg.h"
78 #include "SMESHGUI_PropertiesDlg.h"
79 #include "SMESHGUI_RemoveElementsDlg.h"
80 #include "SMESHGUI_RemoveNodesDlg.h"
81 #include "SMESHGUI_RenumberingDlg.h"
82 #include "SMESHGUI_ReorientFacesDlg.h"
83 #include "SMESHGUI_RevolutionDlg.h"
84 #include "SMESHGUI_RotationDlg.h"
85 #include "SMESHGUI_ScaleDlg.h"
86 #include "SMESHGUI_Selection.h"
87 #include "SMESHGUI_SewingDlg.h"
88 #include "SMESHGUI_SingleEditDlg.h"
89 #include "SMESHGUI_SmoothingDlg.h"
90 #include "SMESHGUI_SpinBox.h"
91 #include "SMESHGUI_SplitBiQuad.h"
92 #include "SMESHGUI_SymmetryDlg.h"
93 #include "SMESHGUI_TranslationDlg.h"
94 #include "SMESHGUI_TransparencyDlg.h"
95 #include "SMESHGUI_Utils.h"
96 #include "SMESHGUI_VTKUtils.h"
98 #include "SMESH_version.h"
100 #include "SMESH_Actor.h"
101 #include "SMESH_ActorUtils.h"
102 #include "SMESH_Client.hxx"
103 #include "SMESH_Comment.hxx"
104 #include "SMESH_ControlsDef.hxx"
105 #include "SMESH_ScalarBarActor.h"
106 #include "SMESH_TypeFilter.hxx"
108 // SALOME GUI includes
109 #include <LightApp_DataOwner.h>
110 #include <LightApp_NameDlg.h>
111 #include <LightApp_Preferences.h>
112 #include <LightApp_SelectionMgr.h>
113 #include <LightApp_UpdateFlags.h>
114 #include <QtxFontEdit.h>
115 #include <QtxPopupMgr.h>
116 #include <SALOME_ListIO.hxx>
117 #include <SUIT_Desktop.h>
118 #include <SUIT_FileDlg.h>
119 #include <SUIT_MessageBox.h>
120 #include <SUIT_OverrideCursor.h>
121 #include <SUIT_ResourceMgr.h>
122 #include <SUIT_Session.h>
123 #include <SVTK_Renderer.h>
124 #include <SVTK_ViewManager.h>
125 #include <SVTK_ViewModel.h>
126 #include <SVTK_ViewWindow.h>
127 #include <SalomeApp_Application.h>
128 #include <SalomeApp_CheckFileDlg.h>
129 #include <SalomeApp_DataObject.h>
130 #include <SalomeApp_Study.h>
131 #include <SalomeApp_Tools.h>
132 #include <VTKViewer_Algorithm.h>
134 #ifndef DISABLE_PLOT2DVIEWER
135 #include <SPlot2d_ViewModel.h>
136 #include <SPlot2d_Histogram.h>
140 #include <SALOMEconfig.h>
141 #include CORBA_CLIENT_HEADER(SALOMEDS_Attributes)
142 #include CORBA_CLIENT_HEADER(SMESH_MeshEditor)
143 #include CORBA_CLIENT_HEADER(SMESH_Measurements)
144 #include CORBA_CLIENT_HEADER(SMESH_Mesh)
147 // #define INCLUDE_MENUITEM_DEF // VSR commented ????????
148 #include <QApplication>
150 #include <QDialogButtonBox>
154 #include <QTextStream>
158 #include <boost/shared_ptr.hpp>
161 #include <vtkCallbackCommand.h>
162 #include <vtkCamera.h>
163 #include <vtkLookupTable.h>
164 #include <vtkPlane.h>
165 #include <vtkRenderer.h>
167 // SALOME KERNEL includes
168 #include <SALOMEDSClient_ClientFactory.hxx>
169 #include <SALOMEDSClient_IParameters.hxx>
170 #include <SALOMEDSClient_SComponent.hxx>
171 #include <SALOMEDSClient_StudyBuilder.hxx>
172 #include <SALOMEDS_Study.hxx>
173 #include <SALOMEDS_SObject.hxx>
174 #include "utilities.h"
175 #include <SALOME_LifeCycleCORBA.hxx>
178 #include <Standard_ErrorHandler.hxx>
179 #include <NCollection_DataMap.hxx>
180 #include <NCollection_DoubleMap.hxx>
182 #include <Basics_Utils.hxx>
184 // Below macro, when uncommented, switches on simplified (more performant) algorithm
185 // of auto-color picking up
186 #define SIMPLE_AUTOCOLOR
191 //=============================================================
192 void ImportMeshesFromFile(SMESH::SMESH_Gen_ptr theComponentMesh,
195 void ExportMeshToFile(int theCommandID);
197 void SetDisplayMode(int theCommandID, VTK::MarkerMap& theMarkerMap);
199 void SetDisplayEntity(int theCommandID);
201 int ActionToControl( int theID, bool theReversed = false );
203 void Control( int theCommandID );
206 //================================================================================
208 * \brief Reads meshes from file
210 //================================================================================
212 void ImportMeshesFromFile( SMESH::SMESH_Gen_ptr theComponentMesh,
216 std::string myExtension;
218 if ( theCommandID == SMESHOp::OpImportMED ||
219 theCommandID == SMESHOp::OpPopupImportMED ) {
220 filter.append( QObject::tr( "MED_FILES_FILTER" ) + " (*.*med)" );
221 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
223 else if ( theCommandID == SMESHOp::OpImportUNV ||
224 theCommandID == SMESHOp::OpPopupImportUNV ) {
225 filter.append( QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)" );
227 else if ( theCommandID == SMESHOp::OpImportDAT ||
228 theCommandID == SMESHOp::OpPopupImportDAT ) {
229 filter.append( QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)" );
231 else if ( theCommandID == SMESHOp::OpImportSTL ||
232 theCommandID == SMESHOp::OpPopupImportSTL ) {
233 filter.append( QObject::tr( "STL_FILES_FILTER" ) + " (*.stl)" );
235 else if ( theCommandID == SMESHOp::OpImportCGNS ||
236 theCommandID == SMESHOp::OpPopupImportCGNS ) {
237 filter.append( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
239 else if ( theCommandID == SMESHOp::OpImportSAUV ||
240 theCommandID == SMESHOp::OpPopupImportSAUV ) {
241 filter.append( QObject::tr( "SAUV_FILES_FILTER" ) + " (*.sauv *.sauve)" );
242 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
244 else if ( theCommandID == SMESHOp::OpImportGMF ||
245 theCommandID == SMESHOp::OpPopupImportGMF ) {
246 filter.append( QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" );
247 filter.append( QObject::tr( "GMF_BINARY_FILES_FILTER") + " (*.meshb)" );
250 QString anInitialPath = "";
251 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
252 anInitialPath = QDir::currentPath();
254 QStringList filenames;
255 bool toCreateGroups = true;
257 // if ( theCommandID == SMESHOp::OpImportGMF ) { // GMF
258 // SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg
259 // ( SMESHGUI::desktop(), true, QObject::tr("SMESH_REQUIRED_GROUPS"), true, true );
260 // fd->setWindowTitle( QObject::tr( "SMESH_IMPORT_MESH" ) );
261 // fd->setNameFilters( filter );
262 // fd->SetChecked( true );
264 // filenames << fd->selectedFile();
265 // toCreateGroups = fd->IsChecked();
271 filenames = SUIT_FileDlg::getOpenFileNames( SMESHGUI::desktop(),
274 QObject::tr( "SMESH_IMPORT_MESH" ) );
276 if ( filenames.count() > 0 )
278 SUIT_OverrideCursor wc;
279 _PTR(Study) aStudy = SMESH::getStudy();
282 QStringList anEntryList;
283 bool isEmpty = false;
284 for ( QStringList::ConstIterator it = filenames.begin(); it != filenames.end(); ++it )
286 QString filename = *it;
287 SMESH::mesh_array_var aMeshes = new SMESH::mesh_array;
289 switch ( theCommandID ) {
290 case SMESHOp::OpImportDAT:
291 case SMESHOp::OpPopupImportDAT:
293 // DAT format (currently unsupported)
294 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
295 arg( QObject::tr( "SMESH_ERR_NOT_SUPPORTED_FORMAT" ) ) );
298 case SMESHOp::OpImportUNV:
299 case SMESHOp::OpPopupImportUNV:
302 aMeshes->length( 1 );
303 aMeshes[0] = theComponentMesh->CreateMeshesFromUNV( filename.toUtf8().constData() );
304 if ( aMeshes[0]->_is_nil() )
305 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
306 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
309 case SMESHOp::OpImportMED:
310 case SMESHOp::OpPopupImportMED:
313 SMESH::DriverMED_ReadStatus res;
314 aMeshes = theComponentMesh->CreateMeshesFromMED( filename.toUtf8().constData(), res );
315 if ( res != SMESH::DRS_OK ) {
316 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
317 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
321 case SMESHOp::OpImportSTL:
322 case SMESHOp::OpPopupImportSTL:
325 aMeshes->length( 1 );
326 aMeshes[0] = theComponentMesh->CreateMeshesFromSTL( filename.toUtf8().constData() );
327 if ( aMeshes[0]->_is_nil() ) {
328 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
329 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
333 case SMESHOp::OpImportCGNS:
334 case SMESHOp::OpPopupImportCGNS:
337 SMESH::DriverMED_ReadStatus res;
338 aMeshes = theComponentMesh->CreateMeshesFromCGNS( filename.toUtf8().constData(), res );
339 if ( res != SMESH::DRS_OK ) {
340 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
341 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
345 case SMESHOp::OpImportSAUV:
346 case SMESHOp::OpPopupImportSAUV:
349 SMESH::DriverMED_ReadStatus res;
350 aMeshes = theComponentMesh->CreateMeshesFromSAUV( filename.toUtf8().constData(), res );
351 if ( res != SMESH::DRS_OK ) {
352 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
353 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
357 case SMESHOp::OpImportGMF:
358 case SMESHOp::OpPopupImportGMF:
361 SMESH::ComputeError_var res;
362 aMeshes->length( 1 );
363 aMeshes[0] = theComponentMesh->CreateMeshesFromGMF( filename.toUtf8().constData(),
366 if ( res->code != SMESH::DRS_OK ) {
367 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
368 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res->code ).toLatin1().data() ) ) );
369 if ( strlen( res->comment.in() ) > 0 ) {
370 errors.back() += ": ";
371 errors.back() += res->comment.in();
378 catch ( const SALOME::SALOME_Exception& S_ex ) {
379 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
380 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
383 for ( int i = 0, iEnd = aMeshes->length(); i < iEnd; i++ )
385 _PTR(SObject) aMeshSO = SMESH::FindSObject( aMeshes[i] );
387 _PTR(StudyBuilder) aBuilder = aStudy->NewBuilder();
388 _PTR(AttributePixMap) aPixmap = aBuilder->FindOrCreateAttribute( aMeshSO, "AttributePixMap" );
389 aPixmap->SetPixMap( "ICON_SMESH_TREE_MESH_IMPORTED" );
390 if ( theCommandID == SMESHOp::OpImportUNV ) // mesh names aren't taken from the file for UNV import
391 SMESH::SetName( aMeshSO, QFileInfo(filename).fileName() );
393 anEntryList.append( aMeshSO->GetID().c_str() );
401 // update Object browser
402 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
404 // browse to the published meshes
405 if( LightApp_Application* anApp =
406 dynamic_cast<LightApp_Application*>( SUIT_Session::session()->activeApplication() ) )
407 anApp->browseObjects( anEntryList );
409 // show Error message box if there were errors
410 if ( errors.count() > 0 ) {
411 SUIT_MessageBox::critical( SMESHGUI::desktop(),
412 QObject::tr( "SMESH_ERROR" ),
413 QObject::tr( "SMESH_IMPORT_ERRORS" ) + "\n" + errors.join( "\n" ) );
416 // show warning message box, if some imported mesh is empty
418 SUIT_MessageBox::warning( SMESHGUI::desktop(),
419 QObject::tr( "SMESH_WRN_WARNING" ),
420 QObject::tr( "SMESH_DRS_SOME_EMPTY" ) );
425 //================================================================================
427 * \brief Export selected meshes or groups into a file
429 //================================================================================
431 void ExportMeshToFile( int theCommandID )
433 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
434 SALOME_ListIO selected;
436 aSel->selectedObjects( selected );
438 const bool isDAT = ( theCommandID == SMESHOp::OpExportDAT ||
439 theCommandID == SMESHOp::OpPopupExportDAT );
440 const bool isMED = ( theCommandID == SMESHOp::OpExportMED ||
441 theCommandID == SMESHOp::OpPopupExportMED );
442 const bool isUNV = ( theCommandID == SMESHOp::OpExportUNV ||
443 theCommandID == SMESHOp::OpPopupExportUNV );
444 const bool isSTL = ( theCommandID == SMESHOp::OpExportSTL ||
445 theCommandID == SMESHOp::OpPopupExportSTL );
446 const bool isCGNS= ( theCommandID == SMESHOp::OpExportCGNS ||
447 theCommandID == SMESHOp::OpPopupExportCGNS );
448 const bool isSAUV= ( theCommandID == SMESHOp::OpExportSAUV ||
449 theCommandID == SMESHOp::OpPopupExportSAUV );
450 const bool isGMF = ( theCommandID == SMESHOp::OpExportGMF ||
451 theCommandID == SMESHOp::OpPopupExportGMF );
453 const bool multiMeshSupported = ( isMED || isCGNS ); // file can hold several meshes
454 if ( selected.Extent() == 0 || ( selected.Extent() > 1 && !multiMeshSupported ))
456 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
457 bool aCheckWarn = true;
459 aCheckWarn = resMgr->booleanValue( "SMESH", "show_warning", false );
460 // get mesh object from selection and check duplication of their names
461 bool hasDuplicatedMeshNames = false;
462 QList< QPair< SMESH::SMESH_IDSource_var, QString > > aMeshList;
463 QList< QPair< SMESH::SMESH_IDSource_var, QString > >::iterator aMeshIter;
464 SALOME_ListIteratorOfListIO It( selected );
465 for( ; It.More(); It.Next() )
467 Handle(SALOME_InteractiveObject) anIObject = It.Value();
468 SMESH::SMESH_IDSource_var aMeshItem =
469 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIObject);
470 if ( aMeshItem->_is_nil() ) {
471 SUIT_MessageBox::warning( SMESHGUI::desktop(),
472 QObject::tr( "SMESH_WRN_WARNING" ),
473 QObject::tr( "SMESH_BAD_MESH_SELECTION" ));
476 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( aMeshItem );
477 if ( aCheckWarn && !aGroup->_is_nil() )
479 QMessageBox msgBox(SUIT_MessageBox::Warning,
480 QObject::tr("SMESH_WRN_WARNING"),
481 QObject::tr("SMESH_EXPORT_ONLY_GPOUP"),
482 QMessageBox::StandardButton::NoButton,
483 SMESHGUI::desktop());
484 QCheckBox dontShowCheckBox(QObject::tr("SMESH_WRN_SHOW_DLG_CHECKBOX"));
485 msgBox.addButton(QMessageBox::Ok);
486 msgBox.addButton(QMessageBox::Cancel);
487 msgBox.setDefaultButton(QMessageBox::Cancel);
488 QGridLayout* lt = qobject_cast<QGridLayout*>(msgBox.layout());
489 QDialogButtonBox* btnbox = msgBox.findChild<QDialogButtonBox*>();
490 lt->addWidget(&dontShowCheckBox, lt->rowCount(), lt->columnCount()-1, lt->rowCount(), lt->columnCount());
491 lt->addWidget(btnbox, lt->rowCount(), 0, lt->rowCount(), lt->columnCount());
492 if ( msgBox.exec() != QMessageBox::Ok )
495 if ( dontShowCheckBox.checkState() == Qt::Checked && resMgr )
496 resMgr->setValue( "SMESH", "show_warning", false);
499 QString aMeshName = anIObject->getName();
501 // check for name duplications
502 if ( !hasDuplicatedMeshNames )
503 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
504 if( aMeshName == (*aMeshIter).second ) {
505 hasDuplicatedMeshNames = true;
510 aMeshList.append( QPair< SMESH::SMESH_IDSource_var, QString >( aMeshItem, aMeshName ) );
513 if( hasDuplicatedMeshNames && isMED ) {
514 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
515 QObject::tr("SMESH_WRN_WARNING"),
516 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_MESH_NAMES"),
517 QObject::tr("SMESH_BUT_YES"),
518 QObject::tr("SMESH_BUT_NO"), 0, 1);
523 aMeshIter = aMeshList.begin();
524 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
525 SMESH::SMESH_Mesh_var aMesh = aMeshOrGroup->GetMesh();
526 QString aMeshName = (*aMeshIter).second;
528 if ( isMED || isCGNS || isSAUV ) // formats where group names must be unique
530 // check for equal group names within each mesh
531 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
532 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
533 if ( !aMeshItem->_is_nil() && aMeshItem->HasDuplicatedGroupNamesMED()) {
534 int aRet = SUIT_MessageBox::warning
535 (SMESHGUI::desktop(),
536 QObject::tr("SMESH_WRN_WARNING"),
537 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_GRP").arg((*aMeshIter).second),
538 QObject::tr("SMESH_BUT_YES"),
539 QObject::tr("SMESH_BUT_NO"), 0, 1);
546 // Warn the user about presence of not supported elements
548 std::vector< SMESH::EntityType > notSupportedElemTypes, presentNotSupported;
552 notSupportedElemTypes.push_back( SMESH::Entity_0D );
553 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
558 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
559 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
560 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
561 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
562 notSupportedElemTypes.push_back( SMESH::Entity_Pyramid );
563 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
564 notSupportedElemTypes.push_back( SMESH::Entity_0D );
565 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
570 notSupportedElemTypes.push_back( SMESH::Entity_Edge );
571 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Edge );
572 notSupportedElemTypes.push_back( SMESH::Entity_0D );
573 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
578 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
583 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
584 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Triangle );
585 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Quadrangle );
586 notSupportedElemTypes.push_back( SMESH::Entity_TriQuad_Hexa );
587 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
588 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
589 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
590 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
595 notSupportedElemTypes.push_back( SMESH::Entity_0D );
596 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
597 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
598 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Pyramid );
599 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Penta );
600 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Penta );
601 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
602 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
603 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
604 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
606 if ( ! notSupportedElemTypes.empty() )
608 SMESH::long_array_var nbElems = aMeshOrGroup->GetMeshInfo();
609 for ( size_t iType = 0; iType < notSupportedElemTypes.size(); ++iType )
610 if ( nbElems[ notSupportedElemTypes[ iType ]] > 0 )
611 presentNotSupported.push_back( notSupportedElemTypes[ iType ]);
613 if ( !presentNotSupported.empty() )
616 const char* typeMsg[] = {
617 "SMESH_NODES", "SMESH_ELEMS0D","SMESH_EDGES","SMESH_QUADRATIC_EDGES",
618 "SMESH_TRIANGLES", "SMESH_QUADRATIC_TRIANGLES", "SMESH_BIQUADRATIC_TRIANGLES",
619 "SMESH_QUADRANGLES","SMESH_QUADRATIC_QUADRANGLES", "SMESH_BIQUADRATIC_QUADRANGLES",
620 "SMESH_POLYGONS","SMESH_QUADRATIC_POLYGONS",
621 "SMESH_TETRAHEDRA","SMESH_QUADRATIC_TETRAHEDRONS","SMESH_PYRAMIDS",
622 "SMESH_QUADRATIC_PYRAMIDS","SMESH_HEXAHEDRA","SMESH_QUADRATIC_HEXAHEDRONS",
623 "SMESH_TRIQUADRATIC_HEXAHEDRONS","SMESH_PENTAHEDRA","SMESH_QUADRATIC_PENTAHEDRONS",
624 "SMESH_BIQUADRATIC_PENTAHEDRONS",
625 "SMESH_OCTAHEDRA","SMESH_POLYEDRONS","SMESH_QUADRATIC_POLYEDRONS","SMESH_BALLS"
627 // is typeMsg complete? (compilation failure mains that enum SMDSAbs_EntityType changed)
628 const int nbTypes = sizeof( typeMsg ) / sizeof( const char* );
629 int _assert[( nbTypes == SMESH::Entity_Last ) ? 2 : -1 ]; _assert[0]=_assert[1]=0;
631 QString andStr = " " + QObject::tr("SMESH_AND") + " ", comma(", ");
632 for ( size_t iType = 0; iType < presentNotSupported.size(); ++iType ) {
633 typeNames += QObject::tr( typeMsg[ presentNotSupported[ iType ]]);
634 if ( iType != presentNotSupported.size() - 1 )
635 typeNames += ( iType == presentNotSupported.size() - 2 ) ? andStr : comma;
637 int aRet = SUIT_MessageBox::warning
638 (SMESHGUI::desktop(),
639 QObject::tr("SMESH_WRN_WARNING"),
640 QObject::tr("EXPORT_NOT_SUPPORTED").arg(aMeshName).arg(format).arg(typeNames),
641 QObject::tr("SMESH_BUT_YES"),
642 QObject::tr("SMESH_BUT_NO"), 0, 1);
647 // Get parameters of export operation
650 int aFormat =-1; // for MED version used for write
651 bool isOkToWrite = true; // to check MED file version compatibility before adding a mesh in an existing file
653 // Init the parameters with the default values
654 bool aIsASCII_STL = true;
655 bool toCreateGroups = false;
657 toCreateGroups = resMgr->booleanValue( "SMESH", "auto_groups", false );
658 bool toOverwrite = true;
659 bool toFindOutDim = true;
660 double zTol = resMgr ? resMgr->doubleValue( "SMESH", "med_ztolerance", 0. ) : 0.;
662 QString aFilter, aTitle = QObject::tr("SMESH_EXPORT_MESH");
663 QString anInitialPath = "";
664 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
665 anInitialPath = QDir::currentPath();
667 QList< QPair< GEOM::ListOfFields_var, QString > > aFieldList;
669 // Get a file name to write in and additional options
670 if ( isUNV || isDAT || isGMF ) // Export w/o options
673 aFilter = QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)";
675 aFilter = QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)";
677 aFilter = QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" +
678 ";;" + QObject::tr( "GMF_BINARY_FILES_FILTER" ) + " (*.meshb)";
679 if ( anInitialPath.isEmpty() ) anInitialPath = SUIT_FileDlg::getLastVisitedPath();
680 aFilename = SUIT_FileDlg::getFileName(SMESHGUI::desktop(),
681 anInitialPath + QString("/") + aMeshName,
682 aFilter, aTitle, false);
684 else if ( isCGNS )// Export to CGNS
686 const char* theByTypeResource = "cgns_group_elems_by_type";
687 toCreateGroups = SMESHGUI::resourceMgr()->booleanValue( "SMESH", theByTypeResource, false );
689 QStringList checkBoxes;
690 checkBoxes << QObject::tr("CGNS_EXPORT_ELEMS_BY_TYPE");
692 SalomeApp_CheckFileDlg* fd =
693 new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true );
694 fd->setWindowTitle( aTitle );
695 fd->setNameFilter( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
696 if ( !anInitialPath.isEmpty() )
697 fd->setDirectory( anInitialPath );
698 fd->selectFile(aMeshName);
699 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
700 fd->setValidator( fv );
701 fd->SetChecked( toCreateGroups, 0 );
704 aFilename = fd->selectedFile();
705 toOverwrite = fv->isOverwrite(aFilename);
706 toCreateGroups = fd->IsChecked(0);
707 SMESHGUI::resourceMgr()->setValue("SMESH", theByTypeResource, toCreateGroups );
711 else if ( isSTL ) // Export to STL
713 QMap<QString, int> aFilterMap;
714 aFilterMap.insert( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)", 1 );
715 aFilterMap.insert( QObject::tr( "STL_BIN_FILES_FILTER" ) + " (*.stl)", 0 );
718 QMap<QString, int>::const_iterator it = aFilterMap.begin();
719 for ( ; it != aFilterMap.end(); ++it )
720 filters.push_back( it.key() );
722 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
723 fd->setWindowTitle( aTitle );
724 fd->setNameFilters( filters );
725 fd->selectNameFilter( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
726 if ( !anInitialPath.isEmpty() )
727 fd->setDirectory( anInitialPath );
728 fd->selectFile(aMeshName);
732 aFilename = fd->selectedFile();
733 aIsASCII_STL = (aFilterMap[fd->selectedNameFilter()]) == 1 ? true: false;
738 else if ( isMED || isSAUV ) // Export to MED or SAUV
740 int defaultVersion = 0;
741 QMap<QString, int> aFilterMap;
743 //filters << QObject::tr( "MED_FILES_FILTER" ) + " (*.med)";
744 //QString vmed (aMesh->GetVersionString(-1, 2));
745 SMESH::long_array_var mvok = aMesh->GetMEDVersionsCompatibleForAppend();
746 if ( mvok->length() > 0)
747 defaultVersion = mvok[0]; // the current version to set the default filter on it
748 for ( CORBA::ULong i = 0; i < mvok->length(); ++i )
750 QString vs = (char*)( SMESH_Comment( mvok[i]/10 ) << "." << mvok[i]%10 );
751 MESSAGE("MED version: " << vs.toStdString());
752 aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( vs ) + " (*.med)", mvok[i]);
756 aFilterMap.insert("All files (*)", -1 );
757 aFilterMap.insert("SAUV files (*.sauv)", defaultVersion ); // 0 = default filter (defaultVersion)
758 aFilterMap.insert("SAUV files (*.sauve)", -1 );
761 QMap<QString, int>::const_iterator it = aFilterMap.begin();
762 QString aDefaultFilter = it.key();
763 for ( ; it != aFilterMap.end(); ++it ) {
764 filters.push_back( it.key() );
765 if (it.value() == defaultVersion) // explicit default for MED = current MED version
766 aDefaultFilter = it.key();
768 QStringList checkBoxes;
769 checkBoxes << QObject::tr("SMESH_AUTO_GROUPS") << QObject::tr("SMESH_AUTO_DIM");
771 SMESHGUI_FieldSelectorWdg* fieldSelWdg = new SMESHGUI_FieldSelectorWdg();
772 QList< QWidget* > wdgList;
773 if ( fieldSelWdg->GetAllFields( aMeshList, aFieldList ))
774 wdgList.append( fieldSelWdg );
776 QWidget* zTolWdg = new QWidget();
777 QCheckBox* zTolCheck = new QCheckBox( QObject::tr( "SMESH_ZTOLERANCE" ), zTolWdg );
778 SMESHGUI_SpinBox* zTolSpin = new SMESHGUI_SpinBox( zTolWdg );
779 QHBoxLayout* zTolLayout = new QHBoxLayout( zTolWdg );
780 zTolLayout->addWidget( zTolCheck );
781 zTolLayout->addWidget( zTolSpin );
782 zTolLayout->setMargin( 0 );
783 zTolSpin->RangeStepAndValidator( 0, 1e+100, 1., "length_precision" );
784 zTolSpin->setValue( zTol );
785 QObject::connect( zTolCheck, SIGNAL( toggled(bool)), zTolSpin, SLOT( setEnabled(bool)));
786 zTolCheck->setChecked( resMgr->booleanValue( "SMESH", "enable_ztolerance", false ));
787 zTolSpin ->setEnabled( zTolCheck->isChecked() );
788 wdgList.append( zTolWdg );
790 SalomeApp_CheckFileDlg* fd =
791 new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true, wdgList );
792 fd->setWindowTitle( aTitle );
793 fd->setNameFilters( filters );
794 fd->selectNameFilter( aDefaultFilter );
795 fd->SetChecked( toCreateGroups, 0 );
796 fd->SetChecked( toFindOutDim, 1 );
797 if ( !anInitialPath.isEmpty() )
798 fd->setDirectory( anInitialPath );
799 fd->selectFile(aMeshName);
802 QListView *lview = fd->findChild<QListView*>("listView");
804 lview->setMinimumHeight(200);
806 QTreeView *tview = fd->findChild<QTreeView*>("treeView");
808 tview->setMinimumHeight(200);
811 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
812 fd->setValidator( fv );
817 //MESSAGE("******* Loop on file dialog ***********");
820 aFilename = fd->selectedFile();
822 aFilename = QString::null;
825 aFormat = aFilterMap[fd->selectedNameFilter()];
826 //MESSAGE("selected version: " << aFormat << " file: " << aFilename.toUtf8().constData());
827 toOverwrite = fv->isOverwrite(aFilename);
828 //MESSAGE("toOverwrite:" << toOverwrite);
830 if ( !aFilename.isEmpty() ) {
832 // append is only possible if the existing file format is compatible
833 bool isVersionOk = SMESHGUI::GetSMESHGen()->CheckWriteCompatibility( aFilename.toUtf8().constData() );
834 MESSAGE("Append check, isVersionOk:" << isVersionOk);
835 if ( !isVersionOk ) {
836 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
837 QObject::tr("SMESH_WRN_WARNING"),
838 QObject::tr("SMESH_EXPORT_MED_VERSION_COLLISION").arg(aFilename),
839 QObject::tr("SMESH_BUT_YES"),
840 QObject::tr("SMESH_BUT_NO"), 0, 1);
844 //MESSAGE("incompatible MED file version for add, overwrite accepted");
850 //MESSAGE("incompatible MED file version for add, overwrite refused");
853 QStringList aMeshNamesCollisionList;
854 SMESH::string_array_var aMeshNames = SMESHGUI::GetSMESHGen()->GetMeshNames( aFilename.toUtf8().constData() );
855 for( int i = 0, n = aMeshNames->length(); i < n; i++ ) {
856 QString anExistingMeshName( aMeshNames[ i ] );
857 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
858 QString anExportMeshName = (*aMeshIter).second;
859 if( anExportMeshName == anExistingMeshName ) {
860 aMeshNamesCollisionList.append( anExportMeshName );
865 if( !aMeshNamesCollisionList.isEmpty() ) {
867 QString aMeshNamesCollisionString = aMeshNamesCollisionList.join( ", " );
868 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
869 QObject::tr("SMESH_WRN_WARNING"),
870 QObject::tr("SMESH_EXPORT_MED_MESH_NAMES_COLLISION").arg(aMeshNamesCollisionString),
871 QObject::tr("SMESH_BUT_YES"),
872 QObject::tr("SMESH_BUT_NO"),
873 QObject::tr("SMESH_BUT_CANCEL"), 0, 2);
874 MESSAGE("answer collision name " << aRet);
885 toCreateGroups = fd->IsChecked(0);
886 toFindOutDim = fd->IsChecked(1);
887 zTol = zTolCheck->isChecked() ? zTolSpin->value() : -1;
888 fieldSelWdg->GetSelectedFields();
889 if ( resMgr ) resMgr->setValue( "SMESH", "enable_ztolerance", zTolCheck->isChecked() );
891 if ( !fieldSelWdg->parent() )
893 if ( !zTolWdg->parent() )
904 if ( !aFilename.isEmpty() ) {
905 // Check whether the file already exists and delete it if yes
906 QFile aFile( aFilename );
907 if ( aFile.exists() && toOverwrite )
909 SUIT_OverrideCursor wc;
912 // Renumbering is not needed since SMDS redesign in V6.2.0 (Nov 2010)
913 // bool Renumber = false;
914 // // PAL 14172 : Check of we have to renumber or not from the preferences before export
916 // Renumber= resMgr->booleanValue("renumbering");
918 // SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
919 // aMeshEditor->RenumberNodes();
920 // aMeshEditor->RenumberElements();
921 // if ( SMESHGUI::automaticUpdate() )
922 // SMESH::UpdateView();
924 if ( isMED && isOkToWrite)
926 MESSAGE("OK to write MED file "<< aFilename.toUtf8().constData());
927 aMeshIter = aMeshList.begin();
928 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
930 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
931 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
932 const GEOM::ListOfFields& fields = aFieldList[ aMeshIndex ].first.in();
933 const QString& geoAssFields = aFieldList[ aMeshIndex ].second;
934 const bool hasFields = ( fields.length() || !geoAssFields.isEmpty() );
935 if ( !hasFields && aMeshOrGroup->_is_equivalent( aMeshItem ) && zTol < 0 )
936 aMeshItem->ExportMED( aFilename.toUtf8().data(), toCreateGroups, aFormat,
937 toOverwrite && aMeshIndex == 0, toFindOutDim );
939 aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toUtf8().data(),
940 toCreateGroups, aFormat,
941 toOverwrite && aMeshIndex == 0, toFindOutDim,
942 fields, geoAssFields.toLatin1().data(), zTol );
947 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ )
949 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
950 if( !aMeshItem->_is_nil() )
951 aMeshItem->ExportSAUV( aFilename.toUtf8().data(), toCreateGroups );
956 if ( aMeshOrGroup->_is_equivalent( aMesh ))
957 aMesh->ExportDAT( aFilename.toUtf8().data() );
959 aMesh->ExportPartToDAT( aMeshOrGroup, aFilename.toUtf8().data() );
963 if ( aMeshOrGroup->_is_equivalent( aMesh ))
964 aMesh->ExportUNV( aFilename.toUtf8().data() );
966 aMesh->ExportPartToUNV( aMeshOrGroup, aFilename.toUtf8().data() );
970 if ( aMeshOrGroup->_is_equivalent( aMesh ))
971 aMesh->ExportSTL( aFilename.toUtf8().data(), aIsASCII_STL );
973 aMesh->ExportPartToSTL( aMeshOrGroup, aFilename.toUtf8().data(), aIsASCII_STL );
977 aMeshIter = aMeshList.begin();
978 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
980 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
981 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
982 aMeshItem->ExportCGNS( aMeshOrGroup,
983 aFilename.toUtf8().data(),
984 toOverwrite && aMeshIndex == 0,
990 toCreateGroups = true;
991 aMesh->ExportGMF( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups );
994 catch (const SALOME::SALOME_Exception& S_ex){
996 SUIT_MessageBox::warning(SMESHGUI::desktop(),
997 QObject::tr("SMESH_WRN_WARNING"),
998 QObject::tr("SMESH_EXPORT_FAILED") + SalomeApp_Tools::ExceptionToString(S_ex));
1004 inline void InverseEntityMode(unsigned int& theOutputMode,
1005 unsigned int theMode)
1007 bool anIsNotPresent = ~theOutputMode & theMode;
1009 theOutputMode |= theMode;
1011 theOutputMode &= ~theMode;
1014 void SetDisplayEntity(int theCommandID)
1016 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1017 SALOME_ListIO selected;
1019 aSel->selectedObjects( selected );
1021 if ( selected.Extent() >= 1 ) {
1022 SUIT_OverrideCursor wc;
1023 SALOME_ListIteratorOfListIO It( selected );
1024 for( ; It.More(); It.Next()){
1025 Handle(SALOME_InteractiveObject) IObject = It.Value();
1026 if(IObject->hasEntry()){
1027 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1028 unsigned int aMode = anActor->GetEntityMode();
1029 switch(theCommandID){
1030 case SMESHOp::OpDE0DElements: InverseEntityMode(aMode,SMESH_Actor::e0DElements); break;
1031 case SMESHOp::OpDEEdges: InverseEntityMode(aMode,SMESH_Actor::eEdges); break;
1032 case SMESHOp::OpDEFaces: InverseEntityMode(aMode,SMESH_Actor::eFaces); break;
1033 case SMESHOp::OpDEVolumes: InverseEntityMode(aMode,SMESH_Actor::eVolumes); break;
1034 case SMESHOp::OpDEBalls: InverseEntityMode(aMode,SMESH_Actor::eBallElem); break;
1035 case SMESHOp::OpDEAllEntity: aMode = SMESH_Actor::eAllEntity; break;
1038 anActor->SetEntityMode(aMode);
1047 SalomeApp_Application* app =
1048 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1052 LightApp_SelectionMgr* aSel = app->selectionMgr();
1053 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1054 if ( !aSel || !appStudy )
1057 SALOME_ListIO selected;
1058 aSel->selectedObjects( selected );
1059 if ( selected.IsEmpty() )
1062 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1064 _PTR(Study) aStudy = appStudy->studyDS();
1065 _PTR(SObject) aMainSObject = aStudy->FindObjectID( anIObject->getEntry() );
1066 SMESH::SMESH_Mesh_var aMainObject = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1067 if ( aMainObject->_is_nil() )
1070 SUIT_OverrideCursor wc;
1072 aMainObject->SetAutoColor( true ); // mesh groups are re-colored here
1074 QList<SALOMEDS::Color> aReservedColors;
1076 SMESH::ListOfGroups aListOfGroups = *aMainObject->GetGroups();
1077 for ( int i = 0, n = aListOfGroups.length(); i < n; i++ )
1079 SMESH::SMESH_GroupBase_var aGroupObject = aListOfGroups[i];
1081 #ifdef SIMPLE_AUTOCOLOR // simplified algorithm for auto-colors
1082 SALOMEDS::Color aColor = SMESHGUI::getPredefinedUniqueColor();
1083 #else // old algorithm for auto-colors
1084 SALOMEDS::Color aColor = SMESHGUI::getUniqueColor( aReservedColors );
1085 aReservedColors.append( aColor );
1086 #endif // SIMPLE_AUTOCOLOR
1087 aGroupObject->SetColor( aColor );
1089 _PTR(SObject) aGroupSObject = SMESH::FindSObject(aGroupObject);
1090 if ( aGroupSObject ) {
1093 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry(aGroupSObject->GetID().c_str())) {
1094 switch ( aGroupObject->GetType ()) {
1096 anActor->SetNodeColor( aColor.R, aColor.G, aColor.B ); break;
1098 anActor->SetEdgeColor( aColor.R, aColor.G, aColor.B ); break;
1100 anActor->Set0DColor( aColor.R, aColor.G, aColor.B ); break;
1102 anActor->SetBallColor( aColor.R, aColor.G, aColor.B ); break;
1104 SMESH::GetColor("SMESH", "volume_color", c, delta, "255,0,170|-100");
1105 anActor->SetVolumeColor( aColor.R, aColor.G, aColor.B, delta ); break;
1108 SMESH::GetColor("SMESH", "fill_color", c, delta, "0,170,255|-100");
1109 anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B, delta );
1115 SMESH::RepaintCurrentView();
1118 void OverallMeshQuality()
1120 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1121 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1122 SALOME_ListIO selected;
1124 aSel->selectedObjects( selected );
1126 if ( selected.IsEmpty() ) return;
1127 SALOME_ListIteratorOfListIO It( selected );
1128 for ( ; It.More(); It.Next() ) {
1129 SMESHGUI_CtrlInfoDlg* ctrlDlg = new SMESHGUI_CtrlInfoDlg( SMESHGUI::desktop() );
1130 ctrlDlg->showInfo( It.Value() );
1135 QString functorToString( SMESH::Controls::FunctorPtr f )
1137 QString type = QObject::tr( "UNKNOWN_CONTROL" );
1138 if ( dynamic_cast< SMESH::Controls::Volume* >( f.get() ) )
1139 type = QObject::tr( "VOLUME_3D_ELEMENTS" );
1140 else if ( dynamic_cast< SMESH::Controls::MaxElementLength2D* >( f.get() ) )
1141 type = QObject::tr( "MAX_ELEMENT_LENGTH_2D" );
1142 else if ( dynamic_cast< SMESH::Controls::MaxElementLength3D* >( f.get() ) )
1143 type = QObject::tr( "MAX_ELEMENT_LENGTH_3D" );
1144 else if ( dynamic_cast< SMESH::Controls::MinimumAngle* >( f.get() ) )
1145 type = QObject::tr( "MINIMUMANGLE_ELEMENTS" );
1146 else if ( dynamic_cast< SMESH::Controls::AspectRatio* >( f.get() ) )
1147 type = QObject::tr( "ASPECTRATIO_ELEMENTS" );
1148 else if ( dynamic_cast< SMESH::Controls::AspectRatio3D* >( f.get() ) )
1149 type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" );
1150 else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) )
1151 type = QObject::tr( "WARP_ELEMENTS" );
1152 else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) )
1153 type = QObject::tr( "TAPER_ELEMENTS" );
1154 else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) )
1155 type = QObject::tr( "SKEW_ELEMENTS" );
1156 else if ( dynamic_cast< SMESH::Controls::Area* >( f.get() ) )
1157 type = QObject::tr( "AREA_ELEMENTS" );
1158 else if ( dynamic_cast< SMESH::Controls::Length* >( f.get() ) )
1159 type = QObject::tr( "LENGTH_EDGES" );
1160 else if ( dynamic_cast< SMESH::Controls::Length2D* >( f.get() ) )
1161 type = QObject::tr( "LENGTH2D_EDGES" );
1162 else if ( dynamic_cast< SMESH::Controls::Deflection2D* >( f.get() ) )
1163 type = QObject::tr( "DEFLECTION2D_FACES" );
1164 else if ( dynamic_cast< SMESH::Controls::MultiConnection* >( f.get() ) )
1165 type = QObject::tr( "MULTI_BORDERS" );
1166 else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) )
1167 type = QObject::tr( "MULTI2D_BORDERS" );
1168 else if ( dynamic_cast< SMESH::Controls::FreeNodes* >( f.get() ) )
1169 type = QObject::tr( "FREE_NODES" );
1170 else if ( dynamic_cast< SMESH::Controls::FreeEdges* >( f.get() ) )
1171 type = QObject::tr( "FREE_EDGES" );
1172 else if ( dynamic_cast< SMESH::Controls::FreeBorders* >( f.get() ) )
1173 type = QObject::tr( "FREE_BORDERS" );
1174 else if ( dynamic_cast< SMESH::Controls::FreeFaces* >( f.get() ) )
1175 type = QObject::tr( "FREE_FACES" );
1176 else if ( dynamic_cast< SMESH::Controls::BareBorderVolume* >( f.get() ) )
1177 type = QObject::tr( "BARE_BORDER_VOLUME" );
1178 else if ( dynamic_cast< SMESH::Controls::BareBorderFace* >( f.get() ) )
1179 type = QObject::tr( "BARE_BORDER_FACE" );
1180 else if ( dynamic_cast< SMESH::Controls::OverConstrainedVolume* >( f.get() ) )
1181 type = QObject::tr( "OVER_CONSTRAINED_VOLUME" );
1182 else if ( dynamic_cast< SMESH::Controls::OverConstrainedFace* >( f.get() ) )
1183 type = QObject::tr( "OVER_CONSTRAINED_FACE" );
1184 else if ( dynamic_cast< SMESH::Controls::CoincidentNodes* >( f.get() ) )
1185 type = QObject::tr( "EQUAL_NODE" );
1186 else if ( dynamic_cast< SMESH::Controls::CoincidentElements1D* >( f.get() ) )
1187 type = QObject::tr( "EQUAL_EDGE" );
1188 else if ( dynamic_cast< SMESH::Controls::CoincidentElements2D* >( f.get() ) )
1189 type = QObject::tr( "EQUAL_FACE" );
1190 else if ( dynamic_cast< SMESH::Controls::CoincidentElements3D* >( f.get() ) )
1191 type = QObject::tr( "EQUAL_VOLUME" );
1192 else if ( dynamic_cast< SMESH::Controls::NodeConnectivityNumber* >( f.get() ) )
1193 type = QObject::tr( "NODE_CONNECTIVITY_NB" );
1197 void SaveDistribution()
1199 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1200 SALOME_ListIO selected;
1202 aSel->selectedObjects( selected );
1204 if ( selected.Extent() == 1 ) {
1205 Handle(SALOME_InteractiveObject) anIO = selected.First();
1206 if ( anIO->hasEntry() ) {
1207 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1209 anActor->GetScalarBarActor() &&
1210 anActor->GetControlMode() != SMESH_Actor::eNone )
1212 SMESH_ScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor();
1213 SMESH::Controls::FunctorPtr aFunctor = anActor->GetFunctor();
1214 if ( aScalarBarActor && aFunctor ) {
1215 SMESH::Controls::NumericalFunctor* aNumFun =
1216 dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
1218 std::vector<int> elements;
1219 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
1220 if ( mesh->_is_nil() ) {
1221 SMESH::SMESH_IDSource_var idSource =
1222 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
1223 if ( !idSource->_is_nil() )
1225 SMESH::long_array_var ids = idSource->GetIDs();
1226 elements.resize( ids->length() );
1227 for ( unsigned i = 0; i < elements.size(); ++i )
1228 elements[i] = ids[i];
1231 int nbIntervals = aScalarBarActor->GetMaximumNumberOfColors();
1232 vtkLookupTable* lookupTable =
1233 static_cast<vtkLookupTable*>(aScalarBarActor->GetLookupTable());
1234 double * minmax = lookupTable->GetRange();
1235 bool isLogarithmic = lookupTable->GetScale() == VTK_SCALE_LOG10;
1236 std::vector<int> nbEvents;
1237 std::vector<double> funValues;
1238 aNumFun->GetHistogram( nbIntervals, nbEvents, funValues,
1239 elements, minmax, isLogarithmic );
1240 QString anInitialPath = "";
1241 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
1242 anInitialPath = QDir::currentPath();
1243 QString aMeshName = anIO->getName();
1245 filter.append( QObject::tr( "TEXT_FILES_FILTER" ) + " (*.txt)" );
1246 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
1247 QString aFilename = anInitialPath + "/" + aMeshName + "_" +
1248 functorToString( aFunctor ).toLower().simplified().replace( QRegExp( " |-" ), "_" ) + ".txt";
1249 aFilename = SUIT_FileDlg::getFileName( SMESHGUI::desktop(),
1252 QObject::tr( "SMESH_SAVE_DISTRIBUTION" ),
1254 if ( !aFilename.isEmpty() ) {
1255 QFile f( aFilename );
1256 if ( f.open( QFile::WriteOnly | QFile::Truncate ) ) {
1257 QTextStream out( &f );
1258 out << "# Mesh: " << aMeshName << endl;
1259 out << "# Control: " << functorToString( aFunctor ) << endl;
1261 out.setFieldWidth( 10 );
1262 for ( int i = 0; i < (int)qMin( nbEvents.size(), funValues.size()-1 ); i++ )
1263 out << funValues[i] << "\t" << funValues[i+1] << "\t" << nbEvents[i] << endl;
1274 void ShowElement( int theCommandID )
1276 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1277 SALOME_ListIO selected;
1279 aSel->selectedObjects( selected );
1281 if ( selected.Extent() == 1 ) {
1282 Handle(SALOME_InteractiveObject) anIO = selected.First();
1283 if ( anIO->hasEntry() ) {
1284 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1286 anActor->GetScalarBarActor() &&
1287 anActor->GetControlMode() != SMESH_Actor::eNone )
1289 SMESH_ScalarBarActor *aScalarBarActor = anActor->GetScalarBarActor();
1290 if ( theCommandID == SMESHOp::OpShowDistribution ) {
1291 aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility());
1293 else if ( theCommandID == SMESHOp::OpShowScalarBar ) {
1294 aScalarBarActor->SetVisibility( !aScalarBarActor->GetVisibility());
1301 #ifndef DISABLE_PLOT2DVIEWER
1302 void PlotDistribution()
1304 SalomeApp_Application* app =
1305 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1309 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1310 SALOME_ListIO selected;
1312 aSel->selectedObjects( selected );
1314 if ( selected.Extent() == 1 ) {
1315 Handle(SALOME_InteractiveObject) anIO = selected.First();
1316 if ( anIO->hasEntry() ) {
1317 //Find Actor by entry before getting Plot2d viewer,
1318 //because after call getViewManager( Plot2d_Viewer::Type(), true ) active window is Plot2d Viewer
1319 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1321 SUIT_ViewManager* aViewManager =
1322 app->getViewManager( Plot2d_Viewer::Type(), true ); // create if necessary
1326 SPlot2d_Viewer* aView = dynamic_cast<SPlot2d_Viewer*>(aViewManager->getViewModel());
1330 Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
1334 if ( anActor && anActor->GetControlMode() != SMESH_Actor::eNone )
1336 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1337 QString functorName = functorToString( anActor->GetFunctor());
1338 QString aHistogramName("%1 : %2");
1339 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1340 aHistogram->setName(aHistogramName);
1341 aHistogram->setHorTitle(functorName);
1342 aHistogram->setVerTitle(QObject::tr("DISTRIBUTION_NB_ENT"));
1343 aPlot->displayObject(aHistogram, true);
1348 #endif //DISABLE_PLOT2DVIEWER
1350 void DisableAutoColor()
1352 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1353 SALOME_ListIO selected;
1355 aSel->selectedObjects( selected );
1357 if ( selected.Extent() ) {
1358 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1359 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1360 if ( !aMesh->_is_nil() ) {
1361 aMesh->SetAutoColor( false );
1368 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1369 SALOME_ListIO selected;
1371 aSel->selectedObjects( selected );
1372 if ( selected.Extent() )
1374 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1375 _PTR(Study) aStudy = SMESH::getStudy();
1376 _PTR(SObject) aSObj = aStudy->FindObjectID(anIObject->getEntry());
1378 if ( aStudy->GetUseCaseBuilder()->SortChildren( aSObj, true/*AscendingOrder*/ ) ) {
1379 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1386 // Break link with Shaper model
1387 void breakShaperLink()
1389 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1390 SALOME_ListIO selected;
1392 aSel->selectedObjects(selected);
1393 if (selected.Extent()) {
1394 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1395 _PTR(Study) aStudy = SMESH::getStudy();
1396 std::string aEntry = anIObject->getEntry();
1397 _PTR(SObject) aSObj = aStudy->FindObjectID(aEntry);
1399 std::string aName = aSObj->GetName();
1400 QMessageBox::StandardButton aRes = SUIT_MessageBox::warning(SMESHGUI::desktop(),
1401 QObject::tr("SMESH_WRN_WARNING"),
1402 QObject::tr("MSG_BREAK_SHAPER_LINK").arg(aName.c_str()),
1403 SUIT_MessageBox::Yes | SUIT_MessageBox::No, SUIT_MessageBox::No);
1404 if (aRes == SUIT_MessageBox::Yes) {
1405 SUIT_DataOwnerPtrList aList;
1406 aSel->selected(aList, "ObjectBrowser", true);
1407 SUIT_DataOwner* aOwn = aList.first();
1408 LightApp_DataOwner* sowner = dynamic_cast<LightApp_DataOwner*>(aOwn);
1409 QString aREntry = sowner->entry();
1411 static GEOM::GEOM_Gen_var geomGen;
1412 if (CORBA::is_nil(geomGen)) {
1413 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>
1414 (SUIT_Session::session()->activeApplication());
1416 SALOME_LifeCycleCORBA* ls = new SALOME_LifeCycleCORBA(app->namingService());
1417 Engines::EngineComponent_var comp =
1418 ls->FindOrLoad_Component("FactoryServer", "SHAPERSTUDY");
1419 geomGen = GEOM::GEOM_Gen::_narrow(comp);
1422 if (!CORBA::is_nil(geomGen))
1424 geomGen->BreakLink(aREntry.toStdString().c_str());
1425 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1427 // remove actors whose objects are removed by BreakLink()
1428 QList<SUIT_ViewWindow*> wndList = SMESHGUI::desktop()->windows();
1429 SUIT_ViewWindow* wnd;
1430 foreach(wnd, wndList)
1431 SMESH::UpdateActorsAfterUpdateStudy(wnd);
1439 //================================================================================
1441 * \brief Return true if a mesh icon == ICON_SMESH_TREE_GEOM_MODIF
1442 * which means that the mesh can't be modified. It should be either re-computed
1443 * or breakShaperLink()'ed. Warn the user about it.
1445 //================================================================================
1447 bool warnOnGeomModif()
1449 SALOME_ListIO selected;
1450 if ( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
1451 aSel->selectedObjects(selected,"",/*convertReferences=*/false);
1453 SALOME_ListIteratorOfListIO It( selected );
1454 for ( ; It.More(); It.Next() )
1456 Handle(SALOME_InteractiveObject) io = It.Value();
1457 if ( !io->hasEntry() ) continue;
1458 _PTR(SObject) so = SMESH::getStudy()->FindObjectID( io->getEntry() );
1459 SMESH::SMESH_Mesh_var mesh;
1460 while ( mesh->_is_nil() && so && so->GetID() != "0:" )
1462 CORBA::Object_var obj = SMESH::SObjectToObject( so );
1463 SMESH::SMESH_IDSource_var isrc = SMESH::SMESH_IDSource::_narrow( obj );
1464 if ( isrc->_is_nil() )
1465 so = so->GetFather();
1467 mesh = isrc->GetMesh();
1469 if ( mesh->_is_nil() ) continue;
1470 so = SMESH::FindSObject( mesh );
1471 if ( !so ) continue;
1472 _PTR(GenericAttribute) attr;
1473 so->FindAttribute( attr, "AttributePixMap" );
1474 _PTR(AttributePixMap) pixmap = attr;
1475 if ( !pixmap ) continue;
1477 if ( pixmap->GetPixMap() == "ICON_SMESH_TREE_GEOM_MODIF" )
1479 SUIT_MessageBox::warning(SMESHGUI::desktop(),
1480 QObject::tr("SMESH_WRN_WARNING"),
1481 QObject::tr("MSG_WARN_ON_GEOM_MODIF"));
1488 void SetDisplayMode(int theCommandID, VTK::MarkerMap& theMarkerMap)
1490 SALOME_ListIO selected;
1491 SalomeApp_Application* app =
1492 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1496 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1497 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1498 if ( !aSel || !appStudy )
1501 if ( theCommandID == SMESHOp::OpClipping ) { // Clipping dialog can be activated without selection
1502 if ( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
1503 aModule->EmitSignalDeactivateDialog();
1504 if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
1505 (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
1510 aSel->selectedObjects( selected );
1512 if ( selected.Extent() >= 1 )
1514 switch ( theCommandID ) {
1515 case SMESHOp::OpTransparency:
1517 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1518 (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
1521 case SMESHOp::OpProperties:
1524 QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
1525 QColor orientationColor, outlineColor, volumeColor;
1526 int deltaF = 0, deltaV = 0;
1529 double ballScale = 1.0;
1531 int outlineWidth = 1;
1532 double shrinkCoef = 0.0;
1533 double orientationScale = 0.0;
1534 bool orientation3d = false;
1535 VTK::MarkerType markerType = VTK::MT_NONE;
1536 VTK::MarkerScale markerScale = VTK::MS_NONE;
1538 bool hasNodes = false;
1539 int presentEntities = 0;
1540 bool firstTime = true;
1542 SALOME_ListIteratorOfListIO It( selected );
1543 for ( ; It.More(); It.Next() ) {
1544 Handle(SALOME_InteractiveObject) IObject = It.Value();
1545 if ( !IObject->hasEntry() ) continue;
1546 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1547 if ( !anActor || !anActor->GetObject() ) continue;
1550 // nodes: color, marker
1551 anActor->GetNodeColor( color[0], color[1], color[2] );
1552 nodeColor.setRgbF( color[0], color[1], color[2] );
1553 markerType = anActor->GetMarkerType();
1554 markerScale = anActor->GetMarkerScale();
1555 markerId = anActor->GetMarkerTexture();
1556 // edges: color, width
1557 anActor->GetEdgeColor( color[0], color[1], color[2] );
1558 edgeColor.setRgbF( color[0], color[1], color[2] );
1559 edgeWidth = qMax( (int)anActor->GetLineWidth(), 1 ); // minimum allowed width is 1
1560 // faces: front color, back color (delta)
1561 anActor->GetSufaceColor( color[0], color[1], color[2], deltaF );
1562 faceColor.setRgbF( color[0], color[1], color[2] );
1563 // faces: front color, back color (delta)
1564 anActor->GetVolumeColor( color[0], color[1], color[2], deltaV );
1565 volumeColor.setRgbF( color[0], color[1], color[2] );
1566 // 0d elements: color, size
1567 anActor->Get0DColor( color[0], color[1], color[2] );
1568 elem0dColor.setRgbF( color[0], color[1], color[2] );
1569 elem0dSize = qMax( (int)anActor->Get0DSize(), 1 ); // minimum allowed size is 1
1570 // balls: color, size
1571 anActor->GetBallColor( color[0], color[1], color[2] );
1572 ballColor.setRgbF( color[0], color[1], color[2] );
1573 //ballSize = qMax( (int)anActor->GetBallSize(), 1 ); // minimum allowed size is 1
1574 ballScale = qMax( (double)anActor->GetBallScale(), 1e-2 ); // minimum allowed scale is 1e-2
1576 anActor->GetOutlineColor( color[0], color[1], color[2] );
1577 outlineColor.setRgbF( color[0], color[1], color[2] );
1578 outlineWidth = qMax( (int)anActor->GetOutlineWidth(), 1 ); // minimum allowed width is 1
1579 // orientation vectors: color, scale, 3d flag
1580 anActor->GetFacesOrientationColor( color[0], color[1], color[2] );
1581 orientationColor.setRgbF( color[0], color[1], color[2] );
1582 orientationScale = anActor->GetFacesOrientationScale();
1583 orientation3d = anActor->GetFacesOrientation3DVectors();
1585 shrinkCoef = anActor->GetShrinkFactor();
1588 firstTime = false; // we only take properties from first object (for performance reasons)
1591 hasNodes = anActor->GetObject()->GetNbEntities( SMDSAbs_Node );
1592 if ( !(presentEntities & SMESH_Actor::eEdges) && anActor->GetObject()->GetNbEntities( SMDSAbs_Edge ) )
1593 presentEntities = presentEntities | SMESH_Actor::eEdges;
1594 if ( !(presentEntities & SMESH_Actor::eFaces) && anActor->GetObject()->GetNbEntities( SMDSAbs_Face ) )
1595 presentEntities = presentEntities | SMESH_Actor::eFaces;
1596 if ( !(presentEntities & SMESH_Actor::eVolumes) && anActor->GetObject()->GetNbEntities( SMDSAbs_Volume ) )
1597 presentEntities = presentEntities | SMESH_Actor::eVolumes;
1598 if ( !(presentEntities & SMESH_Actor::e0DElements) && anActor->GetObject()->GetNbEntities( SMDSAbs_0DElement ) )
1599 presentEntities = presentEntities | SMESH_Actor::e0DElements;
1600 if ( !(presentEntities & SMESH_Actor::eBallElem) && anActor->GetObject()->GetNbEntities( SMDSAbs_Ball ) )
1601 presentEntities = presentEntities | SMESH_Actor::eBallElem;
1603 // as we know that all types of elements are present, we can exit the loop
1604 if ( presentEntities == SMESH_Actor::eAllEntity )
1608 SMESHGUI_PropertiesDlg dlg( theMarkerMap, SMESHGUI::desktop() );
1609 // nodes: color, marker
1610 dlg.setNodeColor( nodeColor );
1611 if( markerType != VTK::MT_USER )
1612 dlg.setNodeMarker( markerType, markerScale );
1614 dlg.setNodeCustomMarker( markerId );
1615 // edges: color, line width
1616 dlg.setEdgeColor( edgeColor );
1617 dlg.setEdgeWidth( edgeWidth );
1618 // faces: front color, back color
1619 dlg.setFaceColor( faceColor, deltaF );
1620 // volumes: normal color, reversed color
1621 dlg.setVolumeColor( volumeColor, deltaV );
1622 // outlines: color, line width
1623 dlg.setOutlineColor( outlineColor );
1624 dlg.setOutlineWidth( outlineWidth );
1625 // 0d elements: color, size
1626 dlg.setElem0dColor( elem0dColor );
1627 dlg.setElem0dSize( elem0dSize );
1628 // balls: color, size
1629 dlg.setBallColor( ballColor );
1630 //dlg.setBallSize( ballSize );
1631 dlg.setBallScale( ballScale );
1632 // orientation: color, scale, 3d flag
1633 dlg.setOrientationColor( orientationColor );
1634 dlg.setOrientationSize( int( orientationScale * 100. ) );
1635 dlg.setOrientation3d( orientation3d );
1636 // shrink: scale factor
1637 dlg.setShrinkCoef( int( shrinkCoef * 100. ) );
1638 // hide unused controls
1639 dlg.showControls( presentEntities, hasNodes );
1642 nodeColor = dlg.nodeColor();
1643 markerType = dlg.nodeMarkerType();
1644 markerScale = dlg.nodeMarkerScale();
1645 markerId = dlg.nodeMarkerId();
1646 edgeColor = dlg.edgeColor();
1647 edgeWidth = dlg.edgeWidth();
1648 faceColor = dlg.faceColor();
1649 deltaF = dlg.faceColorDelta();
1650 volumeColor = dlg.volumeColor();
1651 deltaV = dlg.volumeColorDelta();
1652 outlineColor = dlg.outlineColor();
1653 outlineWidth = dlg.outlineWidth();
1654 elem0dColor = dlg.elem0dColor();
1655 elem0dSize = dlg.elem0dSize();
1656 ballColor = dlg.ballColor();
1657 // ballSize = dlg.ballSize();
1658 ballScale = dlg.ballScale();
1659 orientationColor = dlg.orientationColor();
1660 orientationScale = dlg.orientationSize() / 100.;
1661 orientation3d = dlg.orientation3d();
1662 shrinkCoef = dlg.shrinkCoef() / 100.;
1664 // store point markers that might be changed by the user
1665 theMarkerMap = dlg.customMarkers();
1667 // set properties from dialog box to the presentations
1668 SALOME_ListIteratorOfListIO It( selected );
1669 for ( ; It.More(); It.Next() ) {
1670 Handle(SALOME_InteractiveObject) IObject = It.Value();
1671 if ( !IObject->hasEntry() ) continue;
1672 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1673 if ( !anActor ) continue;
1675 // nodes: color, marker
1676 anActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
1677 if ( markerType != VTK::MT_USER ) {
1678 anActor->SetMarkerStd( markerType, markerScale );
1681 VTK::MarkerMap::const_iterator iter = theMarkerMap.find( markerId );
1682 if ( iter != theMarkerMap.end() )
1683 anActor->SetMarkerTexture( markerId, iter->second.second );
1685 // volumes: normal color, reversed color (delta)
1686 anActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
1687 // faces: front color, back color (delta)
1688 anActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
1689 // edges: color, width
1690 anActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
1691 anActor->SetLineWidth( edgeWidth );
1693 anActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
1694 anActor->SetOutlineWidth( outlineWidth );
1695 // 0D elements: color, size
1696 anActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
1697 anActor->Set0DSize( elem0dSize );
1698 // balls: color, size
1699 anActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
1700 // anActor->SetBallSize( ballSize );
1701 anActor->SetBallScale( ballScale );
1702 // orientation: color, scale, 3d flag
1703 anActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
1704 anActor->SetFacesOrientationScale( orientationScale );
1705 anActor->SetFacesOrientation3DVectors( orientation3d );
1707 anActor->SetShrinkFactor( shrinkCoef );
1709 // for groups, set also proper color
1710 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1711 if ( !aGroupObject->_is_nil() ) {
1712 SMESH::ElementType anElementType = aGroupObject->GetType();
1714 switch( anElementType ) {
1716 aColor = nodeColor; break;
1718 aColor = edgeColor; break;
1720 aColor = faceColor; break;
1722 aColor = volumeColor; break;
1724 aColor = elem0dColor; break;
1726 aColor = ballColor; break;
1730 if ( aColor.isValid() ) {
1731 SALOMEDS::Color aGroupColor;
1732 aGroupColor.R = aColor.redF();
1733 aGroupColor.G = aColor.greenF();
1734 aGroupColor.B = aColor.blueF();
1735 aGroupObject->SetColor( aGroupColor );
1737 } // if ( !aGroupObject->_is_nil() )
1738 } // for ( ; It.More(); It.Next() )
1739 SMESH::RepaintCurrentView();
1740 } // if ( dlg.exec() )
1742 } // case SMESHOp::OpProperties:
1743 } // switch(theCommandID)
1744 SUIT_OverrideCursor wc;
1745 SALOME_ListIteratorOfListIO It( selected );
1746 for( ; It.More(); It.Next()){
1747 Handle(SALOME_InteractiveObject) IObject = It.Value();
1748 if(IObject->hasEntry()){
1749 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1750 switch(theCommandID){
1751 case SMESHOp::OpDMWireframe:
1752 anActor->SetRepresentation(SMESH_Actor::eEdge);
1754 case SMESHOp::OpDMShading:
1755 anActor->SetRepresentation(SMESH_Actor::eSurface);
1757 case SMESHOp::OpDMShrink:
1758 if(anActor->IsShrunk())
1759 anActor->UnShrink();
1761 anActor->SetShrink();
1763 case SMESHOp::OpDMNodes:
1764 anActor->SetRepresentation(SMESH_Actor::ePoint);
1766 case SMESHOp::OpRepresentationLines:
1767 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1768 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1770 case SMESHOp::OpRepresentationArcs:
1771 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1772 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1778 SMESH::RepaintCurrentView();
1782 int ActionToControl( int theID, bool theReversed )
1784 NCollection_DoubleMap<int,int> ActionControl;
1785 ActionControl.Bind( 0, SMESH_Actor::eNone );
1786 ActionControl.Bind( SMESHOp::OpFreeNode, SMESH_Actor::eFreeNodes );
1787 ActionControl.Bind( SMESHOp::OpEqualNode, SMESH_Actor::eCoincidentNodes );
1788 ActionControl.Bind( SMESHOp::OpNodeConnectivityNb, SMESH_Actor::eNodeConnectivityNb );
1789 ActionControl.Bind( SMESHOp::OpFreeEdge, SMESH_Actor::eFreeEdges );
1790 ActionControl.Bind( SMESHOp::OpFreeBorder, SMESH_Actor::eFreeBorders );
1791 ActionControl.Bind( SMESHOp::OpLength, SMESH_Actor::eLength );
1792 ActionControl.Bind( SMESHOp::OpConnection, SMESH_Actor::eMultiConnection );
1793 ActionControl.Bind( SMESHOp::OpEqualEdge, SMESH_Actor::eCoincidentElems1D );
1794 ActionControl.Bind( SMESHOp::OpFreeFace, SMESH_Actor::eFreeFaces );
1795 ActionControl.Bind( SMESHOp::OpBareBorderFace, SMESH_Actor::eBareBorderFace );
1796 ActionControl.Bind( SMESHOp::OpOverConstrainedFace, SMESH_Actor::eOverConstrainedFace );
1797 ActionControl.Bind( SMESHOp::OpLength2D, SMESH_Actor::eLength2D );
1798 ActionControl.Bind( SMESHOp::OpDeflection2D, SMESH_Actor::eDeflection2D );
1799 ActionControl.Bind( SMESHOp::OpConnection2D, SMESH_Actor::eMultiConnection2D );
1800 ActionControl.Bind( SMESHOp::OpArea, SMESH_Actor::eArea );
1801 ActionControl.Bind( SMESHOp::OpTaper, SMESH_Actor::eTaper );
1802 ActionControl.Bind( SMESHOp::OpAspectRatio, SMESH_Actor::eAspectRatio );
1803 ActionControl.Bind( SMESHOp::OpMinimumAngle, SMESH_Actor::eMinimumAngle );
1804 ActionControl.Bind( SMESHOp::OpWarpingAngle, SMESH_Actor::eWarping );
1805 ActionControl.Bind( SMESHOp::OpSkew, SMESH_Actor::eSkew );
1806 ActionControl.Bind( SMESHOp::OpMaxElementLength2D, SMESH_Actor::eMaxElementLength2D );
1807 ActionControl.Bind( SMESHOp::OpEqualFace, SMESH_Actor::eCoincidentElems2D );
1808 ActionControl.Bind( SMESHOp::OpAspectRatio3D, SMESH_Actor::eAspectRatio3D );
1809 ActionControl.Bind( SMESHOp::OpVolume, SMESH_Actor::eVolume3D );
1810 ActionControl.Bind( SMESHOp::OpMaxElementLength3D, SMESH_Actor::eMaxElementLength3D );
1811 ActionControl.Bind( SMESHOp::OpBareBorderVolume, SMESH_Actor::eBareBorderVolume );
1812 ActionControl.Bind( SMESHOp::OpOverConstrainedVolume, SMESH_Actor::eOverConstrainedVolume );
1813 ActionControl.Bind( SMESHOp::OpEqualVolume, SMESH_Actor::eCoincidentElems3D );
1816 return ActionControl.IsBound2( theID ) ? ActionControl.Find2( theID ) : 0;
1817 return ActionControl.IsBound1( theID ) ? ActionControl.Find1( theID ) : 0;
1820 void Control( int theCommandID )
1822 SMESH_Actor::eControl aControl = SMESH_Actor::eControl( ActionToControl( theCommandID ));
1823 _PTR(Study) aStudy = SMESH::getStudy();
1825 SALOME_ListIO selected;
1826 if ( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
1827 aSel->selectedObjects( selected );
1829 if ( !selected.IsEmpty() ) {
1830 SALOME_ListIteratorOfListIO It(selected);
1831 for ( ; It.More(); It.Next())
1833 Handle(SALOME_InteractiveObject) anIO = It.Value();
1834 if ( !anIO.IsNull() ) {
1835 _PTR(SObject) SO = aStudy->FindObjectID( It.Value()->getEntry() );
1837 CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
1838 SMESH::SMESH_IDSource_var anIDSrc = SMESH::SMESH_IDSource::_narrow( aObject );
1839 if ( !anIDSrc->_is_nil() ) {
1840 SMESH_Actor *anActor = SMESH::FindActorByEntry( anIO->getEntry());
1841 if (( !anActor && selected.Extent() == 1 ) &&
1842 ( anActor = SMESH::CreateActor( anIO->getEntry() )))
1844 anActor->SetControlMode( aControl );
1845 SMESH::DisplayActor( SMESH::GetCurrentVtkView(), anActor );
1846 SMESH::UpdateView ( SMESH::eDisplay, anIO->getEntry() );
1850 if ( anActor->GetControlMode() != aControl )
1851 anActor->SetControlMode( aControl );
1852 QString functorName = functorToString( anActor->GetFunctor() );
1853 int anEntitiesCount = anActor->GetNumberControlEntities();
1854 if (anEntitiesCount >= 0)
1855 functorName = functorName + ": " + QString::number(anEntitiesCount);
1856 anActor->GetScalarBarActor()->SetTitle( functorName.toUtf8().constData() );
1857 SMESH::RepaintCurrentView();
1858 #ifndef DISABLE_PLOT2DVIEWER
1859 if ( anActor->GetPlot2Histogram() ) {
1860 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1861 QString aHistogramName("%1 : %2");
1862 aHistogramName = aHistogramName.arg( anIO->getName() ).arg( functorName );
1863 aHistogram->setName( aHistogramName );
1864 aHistogram->setHorTitle( functorName );
1865 SMESH::ProcessIn2DViewers( anActor );
1877 bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1878 SMESH::MeshObjectType theType,
1879 const QString theInTypeName,
1880 QString & theOutTypeName)
1882 SMESH_TypeFilter aTypeFilter( theType );
1884 if ( !theIO.IsNull() )
1886 entry = theIO->getEntry();
1887 LightApp_DataOwner owner( entry );
1888 if ( aTypeFilter.isOk( &owner )) {
1889 theOutTypeName = theInTypeName;
1897 QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1899 _PTR(Study) aStudy = SMESH::getStudy();
1900 _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1902 _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1903 CORBA::String_var anID = aSComp->GetID().c_str();
1904 if ( !strcmp(anID.in(),theIO->getEntry()) )
1910 CheckOIType ( theIO, SMESH::HYPOTHESIS, "Hypothesis", aTypeName ) ||
1911 CheckOIType ( theIO, SMESH::ALGORITHM, "Algorithm", aTypeName ) ||
1912 CheckOIType ( theIO, SMESH::MESH, "Mesh", aTypeName ) ||
1913 CheckOIType ( theIO, SMESH::SUBMESH, "SubMesh", aTypeName ) ||
1914 CheckOIType ( theIO, SMESH::GROUP, "Group", aTypeName )
1922 // QString CheckHomogeneousSelection()
1924 // LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1925 // SALOME_ListIO selected;
1927 // aSel->selectedObjects( selected );
1929 // QString RefType = CheckTypeObject(selected.First());
1930 // SALOME_ListIteratorOfListIO It(selected);
1931 // for ( ; It.More(); It.Next())
1933 // Handle(SALOME_InteractiveObject) IObject = It.Value();
1934 // QString Type = CheckTypeObject(IObject);
1935 // if ( Type.compare(RefType) != 0 )
1936 // return "Heterogeneous Selection";
1942 uint randomize( uint size )
1944 static bool initialized = false;
1945 if ( !initialized ) {
1946 qsrand( QDateTime::currentDateTime().toTime_t() );
1950 v = uint( (double)( v ) / RAND_MAX * size );
1951 v = qMax( uint(0), qMin ( v, size-1 ) );
1957 void SMESHGUI::OnEditDelete()
1959 // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1960 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1961 SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1963 _PTR(Study) aStudy = SMESH::getStudy();
1964 _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1965 _PTR(GenericAttribute) anAttr;
1966 _PTR(AttributeIOR) anIOR;
1968 const int objectCountLimit = 30; // PAL23599
1969 int objectCount = 0;
1971 QString aParentComponent = QString::null;
1973 for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1975 Handle(SALOME_InteractiveObject) anIO = anIt.Value();
1976 if ( anIO.IsNull() ) continue;
1978 QString father = "unknown", name;
1980 _PTR(SObject) aSO = aStudy->FindObjectID( anIO->getEntry() );
1982 father = QString::fromStdString( aSO->GetFatherComponent()->ComponentDataType() );
1983 // check if object is reference
1984 _PTR(SObject) aRefSObj;
1985 if ( aSO->ReferencedObject( aRefSObj ) ) {
1986 name = QString::fromStdString ( aRefSObj->GetName() );
1987 father = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1990 name = anIO->getName();
1993 if ( objectCount < objectCountLimit ) { // avoid occupying the whole screen
1994 aNameList.append("\n - ");
1995 aNameList.append( name );
1998 if( aParentComponent.isNull() )
1999 aParentComponent = father;
2000 else if( !aParentComponent.isEmpty() && aParentComponent!=father )
2001 aParentComponent = "";
2003 if ( objectCount >= objectCountLimit )
2004 aNameList.append("\n - ...");
2006 if ( objectCount == 0 )
2007 return; // No Valid Objects Selected
2009 if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
2010 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2011 QObject::tr("ERR_ERROR"),
2012 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
2015 // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
2016 if (SUIT_MessageBox::warning
2017 (SMESHGUI::desktop(),
2018 QObject::tr("SMESH_WRN_WARNING"),
2019 QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
2020 SUIT_MessageBox::Yes | SUIT_MessageBox::No,
2021 SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
2024 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2026 // Put one level of sub-objects of the selected SO's into a list
2027 // in order to get objects inside folders like "Assigned Algorithms"
2028 std::list< _PTR(SObject) > listSO;
2029 SALOME_ListIteratorOfListIO It(selected);
2030 for( ; It.More(); It.Next()) // loop on selected IO's
2032 Handle(SALOME_InteractiveObject) IObject = It.Value();
2033 if(IObject->hasEntry()) {
2034 _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
2036 // disable removal of "SMESH" component object
2037 if(aSO->FindAttribute(anAttr, "AttributeIOR")){
2039 if ( engineIOR() == anIOR->Value().c_str() )
2042 //Check the referenced object
2043 _PTR(SObject) aRefSObject;
2044 if ( aSO && aSO->ReferencedObject( aRefSObject ) )
2045 aSO = aRefSObject; // Delete main Object instead of reference
2047 listSO.push_back( aSO );
2049 _PTR(ChildIterator) it = aStudy->NewChildIterator( aSO );
2050 for (it->InitEx(false); it->More(); it->Next())
2051 listSO.push_back( it->Value() );
2054 // Check if none of objects to delete is referred from outside
2055 std::list< _PTR(SObject) >::reverse_iterator ritSO;
2056 std::vector< _PTR(SObject) > subSO;
2057 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
2059 _PTR(SObject) SO = *ritSO;
2060 if ( !SO ) continue;
2062 int nbChildren = SO->GetLastChildTag();
2064 subSO.reserve( 1 + nbChildren );
2065 subSO.push_back( SO );
2066 if ( nbChildren > 0 )
2068 _PTR(ChildIterator) it = aStudy->NewChildIterator( SO );
2069 for ( it->InitEx( true ); it->More(); it->Next() )
2070 subSO.push_back( it->Value() );
2072 for ( size_t i = 0; i < subSO.size(); ++i )
2074 std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( subSO[i] );
2075 for ( size_t j = 0; j < aReferences.size(); j++ ) {
2076 _PTR(SComponent) aComponent = aReferences[j]->GetFatherComponent();
2077 std::string type = aComponent->ComponentDataType();
2078 if ( type != "SMESH" )
2080 SUIT_MessageBox::warning( anApp->desktop(),
2081 QObject::tr("WRN_WARNING"),
2082 QObject::tr("DEP_OBJECT") );
2083 return; // outside SMESH, there is an object depending on a SMESH object
2089 // Treat SO's in the list starting from the back
2090 aStudyBuilder->NewCommand(); // There is a transaction
2091 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
2093 _PTR(SObject) SO = *ritSO;
2094 if ( !SO ) continue;
2095 std::string anEntry = SO->GetID();
2097 /** Erase graphical object and remove all its data **/
2098 if ( SO->FindAttribute( anAttr, "AttributeIOR" )) {
2099 SMESH::RemoveVisualObjectWithActors( anEntry.c_str(), true);
2101 /** Remove an object from data structures **/
2102 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
2103 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
2104 if ( !aGroup->_is_nil() ) { // DELETE GROUP
2105 SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
2106 aMesh->RemoveGroup( aGroup );
2108 else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
2109 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2110 aMesh->RemoveSubMesh( aSubMesh );
2113 Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
2114 ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
2115 QString objType = CheckTypeObject(IObject);
2116 if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
2117 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
2118 aStudyBuilder->RemoveObjectWithChildren( SO );
2120 else {// default action: remove SObject from the study
2121 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
2122 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
2124 aStudyBuilder->RemoveObjectWithChildren( SO );
2128 } /* listSO back loop */
2130 aStudyBuilder->CommitCommand();
2132 /* Clear any previous selection */
2134 aSel->setSelectedObjects( l1 );
2136 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
2140 SMESHGUI_EXPORT CAM_Module* createModule()
2142 return new SMESHGUI();
2145 SMESHGUI_EXPORT char* getModuleVersion() {
2146 return (char*)SMESH_VERSION_STR;
2150 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
2152 //=============================================================================
2156 //=============================================================================
2157 SMESHGUI::SMESHGUI() :
2158 SalomeApp_Module( "SMESH" )
2160 if ( CORBA::is_nil( myComponentSMESH ) )
2162 CORBA::Boolean anIsEmbeddedMode;
2163 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
2164 //MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
2166 // 0019923: EDF 765 SMESH : default values of hypothesis
2167 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
2168 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
2169 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
2170 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
2171 myComponentSMESH->SetDefaultNbSegments( nbSeg );
2173 const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif", "default_grp_color" };
2174 for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
2175 if ( aResourceMgr->hasValue( "SMESH", options[i] ))
2177 QString val = aResourceMgr->stringValue( "SMESH", options[i] );
2178 myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
2182 myActiveDialogBox = 0;
2183 myFilterLibraryDlg = 0;
2187 myEventCallbackCommand = vtkCallbackCommand::New();
2188 myEventCallbackCommand->Delete();
2189 myEventCallbackCommand->SetClientData( this );
2190 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
2193 /* load resources for all available meshers */
2194 SMESH::InitAvailableHypotheses();
2197 //=============================================================================
2201 //=============================================================================
2202 SMESHGUI::~SMESHGUI()
2206 //=============================================================================
2210 //=============================================================================
2211 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
2213 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2215 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
2220 //=============================================================================
2224 //=============================================================================
2225 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
2227 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2231 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2232 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2233 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2234 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2235 return autoUpdate && !exceeded;
2238 //=============================================================================
2242 //=============================================================================
2243 bool SMESHGUI::automaticUpdate( SMESH::SMESH_IDSource_ptr theMesh,
2244 int* entities, bool* limitExceeded, int* hidden, long* nbElements )
2246 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2250 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2251 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2252 bool incrementalLimit = resMgr->booleanValue( "SMESH", "incremental_limit", false );
2254 SMESH::long_array_var info = theMesh->GetMeshInfo();
2255 long nbOdElems = info[SMDSEntity_0D];
2256 long nbEdges = info[SMDSEntity_Edge] + info[SMDSEntity_Quad_Edge];
2257 long nbFaces = info[SMDSEntity_Triangle] + info[SMDSEntity_Quad_Triangle] + info[SMDSEntity_BiQuad_Triangle] +
2258 info[SMDSEntity_Quadrangle] + info[SMDSEntity_Quad_Quadrangle] + info[SMDSEntity_BiQuad_Quadrangle] +
2259 info[SMDSEntity_Polygon] + info[SMDSEntity_Quad_Polygon];
2260 long nbVolumes = info[SMDSEntity_Tetra] + info[SMDSEntity_Quad_Tetra] +
2261 info[SMDSEntity_Hexa] + info[SMDSEntity_Quad_Hexa] + info[SMDSEntity_TriQuad_Hexa] +
2262 info[SMDSEntity_Pyramid] + info[SMDSEntity_Quad_Pyramid] +
2263 info[SMDSEntity_Penta] + info[SMDSEntity_Quad_Penta] + info[SMDSEntity_BiQuad_Penta] +
2264 info[SMDSEntity_Polyhedra] +
2265 info[SMDSEntity_Hexagonal_Prism];
2266 long nbBalls = info[SMDSEntity_Ball];
2268 long requestedSize = nbOdElems + nbBalls + nbEdges + nbFaces + nbVolumes;
2269 *nbElements = requestedSize;
2271 *entities = SMESH_Actor::eAllEntity;
2274 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2276 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2278 if ( incrementalLimit ) {
2281 if ( nbOdElems > 0 ) {
2282 if ( total + nbOdElems > updateLimit ) {
2283 *entities = *entities & ~SMESH_Actor::e0DElements;
2284 *hidden = *hidden | SMESH_Actor::e0DElements;
2291 if ( nbEdges > 0 ) {
2292 if ( total + nbEdges > updateLimit ) {
2293 *entities = *entities & ~SMESH_Actor::eEdges;
2294 *hidden = *hidden | SMESH_Actor::eEdges;
2301 if ( nbFaces > 0 ) {
2302 if ( total + nbFaces > updateLimit ) {
2303 *entities = *entities & ~SMESH_Actor::eFaces;
2304 *hidden = *hidden | SMESH_Actor::eFaces;
2311 if ( nbVolumes > 0 ) {
2312 if ( total + nbVolumes > updateLimit ) {
2313 *entities = *entities & ~SMESH_Actor::eVolumes;
2314 *hidden = *hidden | SMESH_Actor::eVolumes;
2321 if ( nbBalls > 0 ) {
2322 if ( total + nbBalls > updateLimit ) {
2323 *entities = *entities & ~SMESH_Actor::eBallElem;
2324 *hidden = *hidden | SMESH_Actor::eBallElem;
2332 return autoUpdate && !exceeded;
2335 //=============================================================================
2339 //=============================================================================
2340 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
2342 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
2345 //=============================================================================
2349 //=============================================================================
2350 SMESHGUI* SMESHGUI::GetSMESHGUI()
2352 SMESHGUI* smeshMod = 0;
2353 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
2356 CAM_Module* module = app->module( "Mesh" );
2357 smeshMod = dynamic_cast<SMESHGUI*>( module );
2365 Standard_EXPORT SMESHGUI* GetComponentGUI()
2367 return SMESHGUI::GetSMESHGUI();
2371 //=============================================================================
2375 //=============================================================================
2376 void SMESHGUI::SetState(int aState)
2381 //=============================================================================
2385 //=============================================================================
2386 void SMESHGUI::ResetState()
2391 //=============================================================================
2395 //=============================================================================
2396 void SMESHGUI::EmitSignalDeactivateDialog()
2398 emit SignalDeactivateActiveDialog();
2401 //=============================================================================
2405 //=============================================================================
2406 void SMESHGUI::EmitSignalStudyFrameChanged()
2408 emit SignalStudyFrameChanged();
2411 //=============================================================================
2415 //=============================================================================
2416 void SMESHGUI::EmitSignalCloseAllDialogs()
2418 emit SignalCloseAllDialogs();
2421 //=============================================================================
2425 //=============================================================================
2426 void SMESHGUI::EmitSignalVisibilityChanged()
2428 emit SignalVisibilityChanged();
2431 //=============================================================================
2435 //=============================================================================
2436 void SMESHGUI::EmitSignalCloseView()
2438 emit SignalCloseView();
2441 //=============================================================================
2445 //=============================================================================
2446 void SMESHGUI::EmitSignalActivatedViewManager()
2448 emit SignalActivatedViewManager();
2451 //=============================================================================
2455 //=============================================================================
2456 QDialog *SMESHGUI::GetActiveDialogBox()
2458 return myActiveDialogBox;
2461 //=============================================================================
2465 //=============================================================================
2466 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2468 myActiveDialogBox = (QDialog *) aDlg;
2472 //=============================================================================
2476 //=============================================================================
2477 SUIT_Desktop* SMESHGUI::desktop()
2479 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2481 return app->desktop();
2486 //=============================================================================
2490 //=============================================================================
2491 SalomeApp_Study* SMESHGUI::activeStudy()
2493 SUIT_Application* app = SUIT_Session::session()->activeApplication();
2495 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2500 //=============================================================================
2504 //=============================================================================
2505 void SMESHGUI::Modified( bool theIsUpdateActions )
2507 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2508 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2509 appStudy->Modified();
2510 if( theIsUpdateActions )
2511 app->updateActions();
2516 //=============================================================================
2520 //=============================================================================
2521 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2523 /* Here the position is on the bottom right corner - 10 */
2524 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2526 SUIT_Desktop *PP = desktop();
2527 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2528 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2533 * \brief Verifies whether study of operation is locked
2534 * \param theMess - specifies whether message box must be shown if study is locked
2535 * \return State of study.
2537 * Verifies whether study of operation is locked. If second parameter is TRUE and study
2538 * is locked when corresponding message box appears
2540 bool SMESHGUI::isStudyLocked( bool theMessage )
2542 if ( SMESH::getStudy()->GetProperties()->IsLocked() )
2545 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2546 QObject::tr( "WRN_WARNING" ),
2547 QObject::tr( "WRN_STUDY_LOCKED" ) );
2553 //=============================================================================
2557 //=============================================================================
2558 bool SMESHGUI::OnGUIEvent( int theCommandID )
2560 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2564 SUIT_ResourceMgr* mgr = resourceMgr();
2568 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2569 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2571 //QAction* act = action( theCommandID );
2573 switch (theCommandID) {
2574 case SMESHOp::OpDelete:
2575 if(isStudyLocked()) break;
2578 case SMESHOp::OpImportDAT:
2579 case SMESHOp::OpImportUNV:
2580 case SMESHOp::OpImportMED:
2581 case SMESHOp::OpImportSTL:
2582 case SMESHOp::OpImportCGNS:
2583 case SMESHOp::OpImportSAUV:
2584 case SMESHOp::OpImportGMF:
2585 case SMESHOp::OpPopupImportDAT:
2586 case SMESHOp::OpPopupImportUNV:
2587 case SMESHOp::OpPopupImportMED:
2588 case SMESHOp::OpPopupImportSTL:
2589 case SMESHOp::OpPopupImportCGNS:
2590 case SMESHOp::OpPopupImportSAUV:
2591 case SMESHOp::OpPopupImportGMF:
2593 if(isStudyLocked()) break;
2594 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2598 case SMESHOp::OpFileInformation:
2600 SALOME_ListIO selected;
2601 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2603 aSel->selectedObjects( selected );
2604 if( selected.Extent() )
2606 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2607 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2608 if ( !aMesh->_is_nil() )
2610 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2616 case SMESHOp::OpExportDAT:
2617 case SMESHOp::OpExportMED:
2618 case SMESHOp::OpExportUNV:
2619 case SMESHOp::OpExportSTL:
2620 case SMESHOp::OpExportCGNS:
2621 case SMESHOp::OpExportSAUV:
2622 case SMESHOp::OpExportGMF:
2623 case SMESHOp::OpPopupExportDAT:
2624 case SMESHOp::OpPopupExportMED:
2625 case SMESHOp::OpPopupExportUNV:
2626 case SMESHOp::OpPopupExportSTL:
2627 case SMESHOp::OpPopupExportCGNS:
2628 case SMESHOp::OpPopupExportSAUV:
2629 case SMESHOp::OpPopupExportGMF:
2631 ::ExportMeshToFile(theCommandID);
2635 case SMESHOp::OpReset: // SCALAR BAR
2637 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2638 SALOME_ListIO selected;
2640 aSel->selectedObjects( selected );
2642 SALOME_ListIteratorOfListIO it(selected);
2643 for( ; it.More(); it.Next()) {
2644 Handle(SALOME_InteractiveObject) anIO = it.Value();
2645 if( anIO->hasEntry() ) {
2646 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2647 anActor->SetControlMode( SMESH_Actor::eNone );
2648 #ifndef DISABLE_PLOT2DVIEWER
2649 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2651 anActor->UpdateFilter();
2655 SMESH::UpdateView();
2658 case SMESHOp::OpScalarBarProperties:
2660 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2663 case SMESHOp::OpShowScalarBar:
2665 // show/hide scalar bar
2666 ::ShowElement(theCommandID);
2669 case SMESHOp::OpSaveDistribution:
2671 // dump control distribution data to the text file
2672 ::SaveDistribution();
2676 case SMESHOp::OpShowDistribution:
2678 // show/hide distribution
2679 ::ShowElement(theCommandID);
2683 #ifndef DISABLE_PLOT2DVIEWER
2684 case SMESHOp::OpPlotDistribution:
2686 // plot distribution
2687 ::PlotDistribution();
2693 case SMESHOp::OpAutoColor:
2697 case SMESHOp::OpDisableAutoColor:
2698 ::DisableAutoColor();
2701 case SMESHOp::OpClipping:
2702 case SMESHOp::OpTransparency:
2703 case SMESHOp::OpProperties: // Display preferences (colors, shrink size, line width, ...)
2706 case SMESHOp::OpDMWireframe:
2707 case SMESHOp::OpDMShading:
2708 case SMESHOp::OpDMNodes:
2709 case SMESHOp::OpDMShrink:
2710 ::SetDisplayMode(theCommandID, myMarkerMap);
2713 //2D quadratic representation
2714 case SMESHOp::OpRepresentationLines:
2715 case SMESHOp::OpRepresentationArcs:
2716 ::SetDisplayMode(theCommandID, myMarkerMap);
2720 case SMESHOp::OpDE0DElements:
2721 case SMESHOp::OpDEEdges:
2722 case SMESHOp::OpDEFaces:
2723 case SMESHOp::OpDEVolumes:
2724 case SMESHOp::OpDEBalls:
2725 case SMESHOp::OpDEAllEntity:
2726 ::SetDisplayEntity(theCommandID);
2729 // Choose entities to be displayed
2730 case SMESHOp::OpDEChoose:
2732 ( new SMESHGUI_DisplayEntitiesDlg( SMESHGUI::desktop() ) )->exec();
2736 case SMESHOp::OpOrientationOnFaces:
2738 SUIT_OverrideCursor wc;
2739 LightApp_SelectionMgr* mgr = selectionMgr();
2740 SALOME_ListIO selected; mgr->selectedObjects( selected );
2742 SALOME_ListIteratorOfListIO it(selected);
2743 for( ; it.More(); it.Next()) {
2744 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2745 if(anIObject->hasEntry()) {
2746 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2747 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2754 case SMESHOp::OpUpdate:
2756 if(isStudyLocked()) break;
2757 SUIT_OverrideCursor wc;
2760 SMESH::UpdateView();
2762 catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2763 SMESH::OnVisuException();
2765 catch (...) { // PAL16774 (Crash after display of many groups)
2766 SMESH::OnVisuException();
2770 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2771 aSel->selectedObjects( l );
2772 aSel->setSelectedObjects( l );
2776 case SMESHOp::OpHide:
2777 case SMESHOp::OpShow:
2778 case SMESHOp::OpShowOnly:
2780 SUIT_OverrideCursor wc;
2781 SMESH::EDisplaing anAction;
2782 switch (theCommandID) {
2783 case SMESHOp::OpHide: anAction = SMESH::eErase; break;
2784 case SMESHOp::OpShow: anAction = SMESH::eDisplay; break;
2785 case SMESHOp::OpShowOnly: anAction = SMESH::eDisplayOnly; break;
2788 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2789 SALOME_ListIO sel_objects, to_process;
2791 aSel->selectedObjects( sel_objects );
2793 if ( theCommandID==SMESHOp::OpShowOnly )
2795 //MESSAGE("anAction = SMESH::eDisplayOnly");
2796 startOperation( myEraseAll );
2799 extractContainers( sel_objects, to_process );
2804 SALOME_ListIteratorOfListIO It( to_process );
2805 for ( ; It.More(); It.Next())
2807 Handle(SALOME_InteractiveObject) IOS = It.Value();
2808 if ( IOS->hasEntry() )
2810 if ( !SMESH::UpdateView( anAction, IOS->getEntry() )) {
2811 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2812 break; // PAL16774 (Crash after display of many groups)
2814 if (anAction == SMESH::eDisplayOnly)
2815 anAction = SMESH::eDisplay;
2820 // PAL13338 + PAL15161 -->
2821 if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !isStudyLocked()) {
2822 SMESH::UpdateView();
2823 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2825 // PAL13338 + PAL15161 <--
2827 catch (...) { // PAL16774 (Crash after display of many groups)
2828 SMESH::OnVisuException();
2831 if (anAction == SMESH::eErase) {
2833 aSel->setSelectedObjects( l1 );
2836 aSel->setSelectedObjects( to_process );
2838 if ( vtkwnd && vtkwnd->GetRenderer() && !isStudyLocked() &&
2839 ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) )
2840 vtkwnd->GetRenderer()->AdjustActors();
2845 case SMESHOp::OpNode:
2847 if(isStudyLocked()) break;
2850 EmitSignalDeactivateDialog();
2852 ( new SMESHGUI_NodesDlg( this ) )->show();
2855 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"),tr("SMESH_WRN_VIEWER_VTK"));
2860 case SMESHOp::OpEditMeshOrSubMesh:
2861 case SMESHOp::OpEditMesh:
2862 case SMESHOp::OpEditSubMesh:
2863 case SMESHOp::OpMeshOrder:
2864 case SMESHOp::OpCreateSubMesh:
2865 if ( warnOnGeomModif() )
2866 break; // action forbiden as geometry modified
2868 case SMESHOp::OpCreateMesh:
2869 case SMESHOp::OpCompute:
2870 case SMESHOp::OpComputeSubMesh:
2871 case SMESHOp::OpPreCompute:
2872 case SMESHOp::OpEvaluate:
2873 startOperation( theCommandID );
2875 case SMESHOp::OpCopyMesh:
2877 if (isStudyLocked()) break;
2878 EmitSignalDeactivateDialog();
2879 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2882 case SMESHOp::OpBuildCompoundMesh:
2884 if (isStudyLocked()) break;
2885 EmitSignalDeactivateDialog();
2886 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2890 case SMESHOp::OpDiagonalInversion:
2891 case SMESHOp::OpUnionOfTwoTriangle:
2895 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2899 if ( isStudyLocked() )
2901 if ( warnOnGeomModif() )
2902 break; // action forbiden as geometry modified
2904 /*Standard_Boolean aRes;
2905 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2906 if ( aMesh->_is_nil() )
2908 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2909 tr( "SMESH_BAD_SELECTION" ) );
2913 EmitSignalDeactivateDialog();
2914 if ( theCommandID == SMESHOp::OpDiagonalInversion )
2915 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2917 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2920 case SMESHOp::OpOrientation:
2921 case SMESHOp::OpUnionOfTriangles:
2922 case SMESHOp::OpCuttingOfQuadrangles:
2923 case SMESHOp::OpSplitVolumes:
2927 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2931 if ( isStudyLocked() )
2933 if ( warnOnGeomModif() )
2934 break; // action forbiden as geometry modified
2936 EmitSignalDeactivateDialog();
2937 SMESHGUI_MultiEditDlg* aDlg = NULL;
2938 if ( theCommandID == SMESHOp::OpOrientation )
2939 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2940 else if ( theCommandID == SMESHOp::OpUnionOfTriangles )
2941 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2942 else if ( theCommandID == SMESHOp::OpSplitVolumes )
2943 aDlg = new SMESHGUI_SplitVolumesDlg(this);
2945 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2950 case SMESHOp::OpSmoothing:
2952 if(isStudyLocked()) break;
2953 if ( warnOnGeomModif() )
2954 break; // action forbiden as geometry modified
2956 EmitSignalDeactivateDialog();
2957 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2960 SUIT_MessageBox::warning(desktop(), tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2964 case SMESHOp::OpExtrusion:
2966 if (isStudyLocked()) break;
2967 if ( warnOnGeomModif() )
2968 break; // action forbiden as geometry modified
2970 EmitSignalDeactivateDialog();
2971 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2973 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2977 case SMESHOp::OpExtrusionAlongAPath:
2979 if (isStudyLocked()) break;
2980 if ( warnOnGeomModif() )
2981 break; // action forbiden as geometry modified
2983 EmitSignalDeactivateDialog();
2984 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2986 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2990 case SMESHOp::OpRevolution:
2992 if(isStudyLocked()) break;
2993 if ( warnOnGeomModif() )
2994 break; // action forbiden as geometry modified
2996 EmitSignalDeactivateDialog();
2997 ( new SMESHGUI_RevolutionDlg( this ) )->show();
3000 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3004 case SMESHOp::OpPatternMapping:
3006 if ( isStudyLocked() )
3008 if ( warnOnGeomModif() )
3009 break; // action forbiden as geometry modified
3012 EmitSignalDeactivateDialog();
3013 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
3016 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3020 case SMESHOp::OpSplitBiQuadratic:
3021 case SMESHOp::OpConvertMeshToQuadratic:
3022 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
3023 case SMESHOp::OpReorientFaces:
3024 case SMESHOp::OpCreateGeometryGroup:
3026 if ( warnOnGeomModif() )
3027 break; // action forbiden as geometry modified
3028 startOperation( theCommandID );
3031 case SMESHOp::OpCreateGroup:
3035 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3039 if(isStudyLocked()) break;
3040 if ( warnOnGeomModif() )
3041 break; // action forbiden as geometry modified
3042 EmitSignalDeactivateDialog();
3043 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
3045 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3046 SALOME_ListIO selected;
3048 aSel->selectedObjects( selected );
3050 int nbSel = selected.Extent();
3052 // check if mesh is selected
3053 aMesh = SMESH::GetMeshByIO( selected.First() );
3055 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
3060 case SMESHOp::OpConstructGroup:
3064 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3068 if(isStudyLocked()) break;
3069 if ( warnOnGeomModif() )
3070 break; // action forbiden as geometry modified
3071 EmitSignalDeactivateDialog();
3073 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3074 SALOME_ListIO selected;
3076 aSel->selectedObjects( selected );
3078 int nbSel = selected.Extent();
3080 // check if submesh is selected
3081 Handle(SALOME_InteractiveObject) IObject = selected.First();
3082 if (IObject->hasEntry()) {
3083 _PTR(SObject) aSObj = SMESH::getStudy()->FindObjectID(IObject->getEntry());
3085 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
3086 if (!aSubMesh->_is_nil()) {
3088 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
3089 // get submesh elements list by types
3090 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
3091 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
3092 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
3093 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
3094 // create group for each type o elements
3095 QString aName = IObject->getName();
3096 QStringList anEntryList;
3097 if (aNodes->length() > 0) {
3098 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
3099 aGroup->Add(aNodes.inout());
3100 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3101 anEntryList.append( aSObject->GetID().c_str() );
3103 if (aEdges->length() > 0) {
3104 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
3105 aGroup->Add(aEdges.inout());
3106 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3107 anEntryList.append( aSObject->GetID().c_str() );
3109 if (aFaces->length() > 0) {
3110 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
3111 aGroup->Add(aFaces.inout());
3112 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3113 anEntryList.append( aSObject->GetID().c_str() );
3115 if (aVolumes->length() > 0) {
3116 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
3117 aGroup->Add(aVolumes.inout());
3118 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3119 anEntryList.append( aSObject->GetID().c_str() );
3122 anApp->browseObjects( anEntryList );
3124 catch(const SALOME::SALOME_Exception & S_ex){
3125 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3132 SUIT_MessageBox::warning(desktop(),
3133 tr("SMESH_WRN_WARNING"),
3134 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
3139 case SMESHOp::OpEditGroup:
3143 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3147 if(isStudyLocked()) break;
3148 if ( warnOnGeomModif() )
3149 break; // action forbiden as geometry modified
3150 EmitSignalDeactivateDialog();
3152 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3153 SALOME_ListIO selected;
3155 aSel->selectedObjects( selected );
3157 SALOME_ListIteratorOfListIO It (selected);
3158 int nbSelectedGroups = 0;
3159 for ( ; It.More(); It.Next() )
3161 SMESH::SMESH_GroupBase_var aGroup =
3162 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
3163 if (!aGroup->_is_nil()) {
3165 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
3169 if (nbSelectedGroups == 0)
3171 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
3177 case SMESHOp::OpAddElemGroupPopup: // Add elements to group
3179 if(isStudyLocked()) break;
3180 if (myState == 800) {
3181 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3182 if (aDlg) aDlg->onAdd();
3187 case SMESHOp::OpRemoveElemGroupPopup: // Remove elements from group
3189 if(isStudyLocked()) break;
3190 if (myState == 800) {
3191 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3192 if (aDlg) aDlg->onRemove();
3197 case SMESHOp::OpEditGeomGroupAsGroup:
3201 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3205 if(isStudyLocked()) break;
3206 EmitSignalDeactivateDialog();
3208 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3209 SALOME_ListIO selected;
3211 aSel->selectedObjects( selected );
3213 SALOME_ListIteratorOfListIO It (selected);
3214 for ( ; It.More(); It.Next() )
3216 SMESH::SMESH_GroupOnGeom_var aGroup =
3217 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
3218 if (!aGroup->_is_nil()) {
3219 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3224 SMESH::SMESH_GroupOnFilter_var aGroup =
3225 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
3226 if (!aGroup->_is_nil()) {
3227 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3235 case SMESHOp::OpUnionGroups:
3236 case SMESHOp::OpIntersectGroups:
3237 case SMESHOp::OpCutGroups:
3241 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3245 if ( isStudyLocked() )
3247 if ( warnOnGeomModif() )
3248 break; // action forbiden as geometry modified
3250 EmitSignalDeactivateDialog();
3252 SMESHGUI_GroupOpDlg* aDlg = 0;
3253 if ( theCommandID == SMESHOp::OpUnionGroups )
3254 aDlg = new SMESHGUI_UnionGroupsDlg( this );
3255 else if ( theCommandID == SMESHOp::OpIntersectGroups )
3256 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3258 aDlg = new SMESHGUI_CutGroupsDlg( this );
3265 case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
3267 if ( isStudyLocked() )
3269 if ( warnOnGeomModif() )
3270 break; // action forbiden as geometry modified
3272 EmitSignalDeactivateDialog();
3273 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3279 case SMESHOp::OpFaceGroupsByEdges: // Create face groups separated by sharp edges
3281 if ( isStudyLocked() )
3283 if ( warnOnGeomModif() )
3284 break; // action forbiden as geometry modified
3286 EmitSignalDeactivateDialog();
3287 SMESHGUI_FaceGroupsSeparatedByEdgesDlg* aDlg = new SMESHGUI_FaceGroupsSeparatedByEdgesDlg( this );
3293 case SMESHOp::OpDeleteGroup: // Delete groups with their contents
3297 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3301 if ( isStudyLocked() )
3304 EmitSignalDeactivateDialog();
3306 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3310 case SMESHOp::OpMeshInformation:
3311 case SMESHOp::OpWhatIs:
3313 int page = theCommandID == SMESHOp::OpMeshInformation ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3314 EmitSignalDeactivateDialog();
3315 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3316 SALOME_ListIO selected;
3318 aSel->selectedObjects( selected );
3320 if ( selected.Extent() > 1 ) { // a dlg for each IO
3321 SALOME_ListIteratorOfListIO It( selected );
3322 for ( ; It.More(); It.Next() ) {
3323 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3324 dlg->showInfo( It.Value() );
3329 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3335 case SMESHOp::OpFindElementByPoint:
3337 startOperation( theCommandID );
3341 case SMESHOp::OpEditHypothesis:
3343 if(isStudyLocked()) break;
3344 if ( warnOnGeomModif() )
3345 break; // action forbiden as geometry modified
3347 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3348 SALOME_ListIO selected;
3350 aSel->selectedObjects( selected );
3352 int nbSel = selected.Extent();
3355 Handle(SALOME_InteractiveObject) anIObject = selected.First();
3356 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3358 if ( !aHypothesis->_is_nil() )
3360 SMESHGUI_GenericHypothesisCreator* aCreator =
3361 SMESH::GetHypothesisCreator( SMESH::toQStr( aHypothesis->GetName() ));
3364 // set geometry of mesh and sub-mesh to aCreator
3365 aSel->selectedObjects( selected, "", /*convertReferences=*/false);
3366 if ( selected.Extent() == 1 )
3368 QString subGeomID, meshGeomID;
3369 Handle(SALOME_InteractiveObject) hypIO = selected.First();
3370 if ( SMESH::GetGeomEntries( hypIO, subGeomID, meshGeomID ))
3372 if ( subGeomID.isEmpty() ) subGeomID = meshGeomID;
3373 aCreator->setShapeEntry( subGeomID );
3374 aCreator->setMainShapeEntry( meshGeomID );
3378 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3388 case SMESHOp::OpUnassign: // REMOVE HYPOTHESIS / ALGORITHMS
3390 if(isStudyLocked()) break;
3391 if ( warnOnGeomModif() )
3392 break; // action forbiden as geometry modified
3393 SUIT_OverrideCursor wc;
3395 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3396 SALOME_ListIO selected;
3398 aSel->selectedObjects( selected, QString::null, false );
3400 SALOME_ListIteratorOfListIO It(selected);
3401 for (int i = 0; It.More(); It.Next(), i++) {
3402 Handle(SALOME_InteractiveObject) IObject = It.Value();
3403 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3406 aSel->setSelectedObjects( l1 );
3411 case SMESHOp::OpElem0D:
3412 case SMESHOp::OpBall:
3413 case SMESHOp::OpEdge:
3414 case SMESHOp::OpTriangle:
3415 case SMESHOp::OpQuadrangle:
3416 case SMESHOp::OpPolygon:
3417 case SMESHOp::OpTetrahedron:
3418 case SMESHOp::OpHexahedron:
3419 case SMESHOp::OpPentahedron:
3420 case SMESHOp::OpPyramid:
3421 case SMESHOp::OpHexagonalPrism:
3423 if(isStudyLocked()) break;
3424 if ( warnOnGeomModif() )
3425 break; // action forbiden as geometry modified
3427 EmitSignalDeactivateDialog();
3428 SMDSAbs_EntityType type = SMDSEntity_Edge;
3429 switch (theCommandID) {
3430 case SMESHOp::OpElem0D: type = SMDSEntity_0D; break;
3431 case SMESHOp::OpBall: type = SMDSEntity_Ball; break;
3432 case SMESHOp::OpTriangle: type = SMDSEntity_Triangle; break;
3433 case SMESHOp::OpQuadrangle: type = SMDSEntity_Quadrangle; break;
3434 case SMESHOp::OpTetrahedron: type = SMDSEntity_Tetra; break;
3435 case SMESHOp::OpPolygon: type = SMDSEntity_Polygon; break;
3436 case SMESHOp::OpHexahedron: type = SMDSEntity_Hexa; break;
3437 case SMESHOp::OpPentahedron: type = SMDSEntity_Penta; break;
3438 case SMESHOp::OpPyramid: type = SMDSEntity_Pyramid; break;
3439 case SMESHOp::OpHexagonalPrism: type = SMDSEntity_Hexagonal_Prism; break;
3442 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3445 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3449 case SMESHOp::OpPolyhedron:
3451 if(isStudyLocked()) break;
3452 if ( warnOnGeomModif() )
3453 break; // action forbiden as geometry modified
3455 EmitSignalDeactivateDialog();
3456 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3459 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3463 case SMESHOp::OpQuadraticEdge:
3464 case SMESHOp::OpQuadraticTriangle:
3465 case SMESHOp::OpBiQuadraticTriangle:
3466 case SMESHOp::OpQuadraticQuadrangle:
3467 case SMESHOp::OpBiQuadraticQuadrangle:
3468 case SMESHOp::OpQuadraticPolygon:
3469 case SMESHOp::OpQuadraticTetrahedron:
3470 case SMESHOp::OpQuadraticPyramid:
3471 case SMESHOp::OpQuadraticPentahedron:
3472 case SMESHOp::OpBiQuadraticPentahedron:
3473 case SMESHOp::OpQuadraticHexahedron:
3474 case SMESHOp::OpTriQuadraticHexahedron:
3476 if(isStudyLocked()) break;
3477 if ( warnOnGeomModif() )
3478 break; // action forbiden as geometry modified
3480 EmitSignalDeactivateDialog();
3481 SMDSAbs_EntityType type = SMDSEntity_Last;
3483 switch (theCommandID) {
3484 case SMESHOp::OpQuadraticEdge: type = SMDSEntity_Quad_Edge; break;
3485 case SMESHOp::OpQuadraticTriangle: type = SMDSEntity_Quad_Triangle; break;
3486 case SMESHOp::OpBiQuadraticTriangle: type = SMDSEntity_BiQuad_Triangle; break;
3487 case SMESHOp::OpQuadraticQuadrangle: type = SMDSEntity_Quad_Quadrangle; break;
3488 case SMESHOp::OpBiQuadraticQuadrangle: type = SMDSEntity_BiQuad_Quadrangle; break;
3489 case SMESHOp::OpQuadraticPolygon: type = SMDSEntity_Quad_Polygon; break;
3490 case SMESHOp::OpQuadraticTetrahedron: type = SMDSEntity_Quad_Tetra; break;
3491 case SMESHOp::OpQuadraticPyramid: type = SMDSEntity_Quad_Pyramid; break;
3492 case SMESHOp::OpQuadraticPentahedron: type = SMDSEntity_Quad_Penta; break;
3493 case SMESHOp::OpBiQuadraticPentahedron: type = SMDSEntity_BiQuad_Penta; break;
3494 case SMESHOp::OpQuadraticHexahedron: type = SMDSEntity_Quad_Hexa; break;
3495 case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
3498 if ( type != SMDSEntity_Last )
3499 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3502 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3503 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3507 case SMESHOp::OpRemoveNodes:
3509 if(isStudyLocked()) break;
3510 if ( warnOnGeomModif() )
3511 break; // action forbiden as geometry modified
3513 EmitSignalDeactivateDialog();
3514 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3517 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3518 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3522 case SMESHOp::OpRemoveElements: // REMOVES ELEMENTS
3524 if(isStudyLocked()) break;
3525 if ( warnOnGeomModif() )
3526 break; // action forbiden as geometry modified
3528 EmitSignalDeactivateDialog();
3529 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3533 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3534 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3538 case SMESHOp::OpClearMesh: {
3540 if(isStudyLocked()) break;
3541 if ( warnOnGeomModif() )
3542 break; // action forbiden as geometry modified
3544 SALOME_ListIO selected;
3545 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3546 aSel->selectedObjects( selected );
3548 SUIT_OverrideCursor wc;
3549 SALOME_ListIteratorOfListIO It (selected);
3550 for ( ; It.More(); It.Next() )
3552 Handle(SALOME_InteractiveObject) IOS = It.Value();
3553 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3554 if ( aMesh->_is_nil()) continue;
3557 if ( aMesh->NbNodes() == 0 ) // imported mesh is not empty
3558 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3559 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3560 // hide groups and submeshes
3561 _PTR(ChildIterator) anIter =
3562 SMESH::getStudy()->NewChildIterator( aMeshSObj );
3563 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3565 _PTR(SObject) so = anIter->Value();
3566 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3569 catch (const SALOME::SALOME_Exception& S_ex){
3571 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3575 SMESH::UpdateView();
3579 case SMESHOp::OpRemoveOrphanNodes:
3581 if(isStudyLocked()) break;
3582 if ( warnOnGeomModif() )
3583 break; // action forbiden as geometry modified
3584 SALOME_ListIO selected;
3585 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3586 aSel->selectedObjects( selected );
3587 if ( selected.Extent() == 1 ) {
3588 Handle(SALOME_InteractiveObject) anIO = selected.First();
3589 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3590 if ( !aMesh->_is_nil() ) {
3591 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3592 tr( "SMESH_WARNING" ),
3593 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3594 SUIT_MessageBox::Yes |
3595 SUIT_MessageBox::No,
3596 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3599 SUIT_OverrideCursor wc;
3600 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3601 int removed = aMeshEditor->RemoveOrphanNodes();
3602 SUIT_MessageBox::information(SMESHGUI::desktop(),
3603 tr("SMESH_INFORMATION"),
3604 tr("NB_NODES_REMOVED").arg(removed));
3605 if ( removed > 0 ) {
3606 SMESH::UpdateView();
3607 SMESHGUI::Modified();
3610 catch (const SALOME::SALOME_Exception& S_ex) {
3611 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3620 case SMESHOp::OpRenumberingNodes:
3622 if(isStudyLocked()) break;
3623 if ( warnOnGeomModif() )
3624 break; // action forbiden as geometry modified
3626 EmitSignalDeactivateDialog();
3627 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3631 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3632 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3636 case SMESHOp::OpRenumberingElements:
3638 if(isStudyLocked()) break;
3639 if ( warnOnGeomModif() )
3640 break; // action forbiden as geometry modified
3642 EmitSignalDeactivateDialog();
3643 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3647 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3648 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3652 case SMESHOp::OpTranslation:
3654 if(isStudyLocked()) break;
3655 if ( warnOnGeomModif() )
3656 break; // action forbiden as geometry modified
3658 EmitSignalDeactivateDialog();
3659 ( new SMESHGUI_TranslationDlg( this ) )->show();
3662 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3663 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3667 case SMESHOp::OpRotation:
3669 if(isStudyLocked()) break;
3670 if ( warnOnGeomModif() )
3671 break; // action forbiden as geometry modified
3673 EmitSignalDeactivateDialog();
3674 ( new SMESHGUI_RotationDlg( this ) )->show();
3677 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3678 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3682 case SMESHOp::OpSymmetry:
3684 if(isStudyLocked()) break;
3685 if ( warnOnGeomModif() )
3686 break; // action forbiden as geometry modified
3688 EmitSignalDeactivateDialog();
3689 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3692 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3693 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3697 case SMESHOp::OpScale:
3699 if(isStudyLocked()) break;
3700 if ( warnOnGeomModif() )
3701 break; // action forbiden as geometry modified
3703 EmitSignalDeactivateDialog();
3704 ( new SMESHGUI_ScaleDlg( this ) )->show();
3707 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3708 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3713 case SMESHOp::OpOffset:
3715 if(isStudyLocked()) break;
3716 if ( warnOnGeomModif() )
3717 break; // action forbiden as geometry modified
3719 EmitSignalDeactivateDialog();
3720 ( new SMESHGUI_OffsetDlg( this ) )->show();
3723 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3724 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3729 case SMESHOp::OpSewing:
3731 if(isStudyLocked()) break;
3732 if ( warnOnGeomModif() )
3733 break; // action forbiden as geometry modified
3735 EmitSignalDeactivateDialog();
3736 ( new SMESHGUI_SewingDlg( this ) )->show();
3739 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3740 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3744 case SMESHOp::OpMergeNodes:
3746 if(isStudyLocked()) break;
3747 if ( warnOnGeomModif() )
3748 break; // action forbiden as geometry modified
3750 EmitSignalDeactivateDialog();
3751 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3754 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3755 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3759 case SMESHOp::OpMergeElements:
3761 if (isStudyLocked()) break;
3762 if ( warnOnGeomModif() )
3763 break; // action forbiden as geometry modified
3765 EmitSignalDeactivateDialog();
3766 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3768 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3769 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3774 case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
3775 if ( warnOnGeomModif() )
3776 break; // action forbiden as geometry modified
3777 startOperation( SMESHOp::OpMoveNode );
3780 case SMESHOp::OpDuplicateNodes:
3782 if(isStudyLocked()) break;
3783 if ( warnOnGeomModif() )
3784 break; // action forbiden as geometry modified
3786 EmitSignalDeactivateDialog();
3787 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3790 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3791 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3796 case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
3797 if ( warnOnGeomModif() )
3798 break; // action forbiden as geometry modified
3799 startOperation( SMESHOp::OpElem0DOnElemNodes );
3802 case SMESHOp::OpSelectFiltersLibrary: // Library of selection filters
3804 static QList<int> aTypes;
3805 if ( aTypes.isEmpty() )
3807 aTypes.append( SMESH::NODE );
3808 aTypes.append( SMESH::EDGE );
3809 aTypes.append( SMESH::FACE );
3810 aTypes.append( SMESH::VOLUME );
3812 if (!myFilterLibraryDlg)
3813 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3814 else if (myFilterLibraryDlg->isHidden())
3815 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3816 myFilterLibraryDlg->raise();
3820 case SMESHOp::OpFreeNode:
3821 case SMESHOp::OpEqualNode:
3822 case SMESHOp::OpNodeConnectivityNb:
3823 case SMESHOp::OpFreeEdge:
3824 case SMESHOp::OpFreeBorder:
3825 case SMESHOp::OpLength:
3826 case SMESHOp::OpConnection:
3827 case SMESHOp::OpEqualEdge:
3828 case SMESHOp::OpFreeFace:
3829 case SMESHOp::OpBareBorderFace:
3830 case SMESHOp::OpOverConstrainedFace:
3831 case SMESHOp::OpLength2D:
3832 case SMESHOp::OpDeflection2D:
3833 case SMESHOp::OpConnection2D:
3834 case SMESHOp::OpArea:
3835 case SMESHOp::OpTaper:
3836 case SMESHOp::OpAspectRatio:
3837 case SMESHOp::OpMinimumAngle:
3838 case SMESHOp::OpWarpingAngle:
3839 case SMESHOp::OpSkew:
3840 case SMESHOp::OpMaxElementLength2D:
3841 case SMESHOp::OpEqualFace:
3842 case SMESHOp::OpAspectRatio3D:
3843 case SMESHOp::OpVolume:
3844 case SMESHOp::OpMaxElementLength3D:
3845 case SMESHOp::OpBareBorderVolume:
3846 case SMESHOp::OpOverConstrainedVolume:
3847 case SMESHOp::OpEqualVolume:
3850 LightApp_SelectionMgr* mgr = selectionMgr();
3851 SALOME_ListIO selected; mgr->selectedObjects( selected );
3853 if( !selected.IsEmpty() ) {
3854 SUIT_OverrideCursor wc;
3855 ::Control( theCommandID );
3858 SUIT_MessageBox::warning(desktop(),
3859 tr( "SMESH_WRN_WARNING" ),
3860 tr( "SMESH_BAD_SELECTION" ) );
3864 SUIT_MessageBox::warning(desktop(),
3865 tr( "SMESH_WRN_WARNING" ),
3866 tr( "NOT_A_VTK_VIEWER" ) );
3869 case SMESHOp::OpOverallMeshQuality:
3870 OverallMeshQuality();
3872 case SMESHOp::OpNumberingNodes:
3874 SUIT_OverrideCursor wc;
3875 LightApp_SelectionMgr* mgr = selectionMgr();
3876 SALOME_ListIO selected; mgr->selectedObjects( selected );
3878 SALOME_ListIteratorOfListIO it(selected);
3879 for( ; it.More(); it.Next()) {
3880 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3881 if(anIObject->hasEntry()) {
3882 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3883 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3889 case SMESHOp::OpNumberingElements:
3891 SUIT_OverrideCursor wc;
3892 LightApp_SelectionMgr* mgr = selectionMgr();
3893 SALOME_ListIO selected; mgr->selectedObjects( selected );
3895 SALOME_ListIteratorOfListIO it(selected);
3896 for( ; it.More(); it.Next()) {
3897 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3898 if(anIObject->hasEntry())
3899 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3900 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3905 case SMESHOp::OpPropertiesLength:
3906 case SMESHOp::OpPropertiesArea:
3907 case SMESHOp::OpPropertiesVolume:
3908 case SMESHOp::OpMinimumDistance:
3909 case SMESHOp::OpBoundingBox:
3910 case SMESHOp::OpAngle:
3912 int page = SMESHGUI_MeasureDlg::MinDistance;
3913 if ( theCommandID == SMESHOp::OpBoundingBox )
3914 page = SMESHGUI_MeasureDlg::BoundingBox;
3915 else if ( theCommandID == SMESHOp::OpPropertiesLength )
3916 page = SMESHGUI_MeasureDlg::Length;
3917 else if ( theCommandID == SMESHOp::OpPropertiesArea )
3918 page = SMESHGUI_MeasureDlg::Area;
3919 else if ( theCommandID == SMESHOp::OpPropertiesVolume )
3920 page = SMESHGUI_MeasureDlg::Volume;
3921 else if ( theCommandID == SMESHOp::OpAngle )
3922 page = SMESHGUI_MeasureDlg::Angle;
3924 EmitSignalDeactivateDialog();
3925 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3929 case SMESHOp::OpSortChild:
3932 case SMESHOp::OpBreakLink:
3933 ::breakShaperLink();
3938 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3939 //updateObjBrowser();
3943 //=============================================================================
3947 //=============================================================================
3948 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3953 //=============================================================================
3957 //=============================================================================
3958 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3963 //=============================================================================
3967 //=============================================================================
3968 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3973 //=============================================================================
3974 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3975 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3977 //=============================================================================
3978 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3979 SUIT_ViewWindow* wnd )
3981 if(theIO->hasEntry()){
3982 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3983 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3987 //=======================================================================
3988 // function : createSMESHAction
3990 //=======================================================================
3991 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3992 const int key, const bool toggle, const QString& shortcutAction )
3995 QWidget* parent = application()->desktop();
3996 SUIT_ResourceMgr* resMgr = resourceMgr();
3998 if ( !icon_id.isEmpty() )
3999 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
4001 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
4002 if ( !pix.isNull() )
4003 icon = QIcon( pix );
4005 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
4006 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
4007 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
4009 createAction( id, tooltip, icon, menu, status_bar, key, parent,
4010 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
4013 //=======================================================================
4014 // function : createPopupItem
4016 //=======================================================================
4017 void SMESHGUI::createPopupItem( const int id,
4018 const QString& clients,
4019 const QString& types,
4020 const QString& theRule,
4023 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
4024 popupMgr()->insert( action( id ), pId, 0 );
4026 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4027 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4028 QString rule = "(%1) and (%2) and (%3)";
4029 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
4030 if( clients.isEmpty() )
4031 rule = rule.arg( QString( "true" ) );
4033 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
4034 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
4037 bool cont = myRules.contains( id );
4039 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
4041 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
4042 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
4045 //=======================================================================
4046 // function : initialize
4048 //=======================================================================
4049 void SMESHGUI::initialize( CAM_Application* app )
4051 SalomeApp_Module::initialize( app );
4053 // SUIT_ResourceMgr* mgr = app->resourceMgr();
4055 /* Automatic Update flag */
4056 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
4058 // ----- create actions --------------
4060 //createSMESHAction( SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
4061 createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_I) );
4062 createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
4063 createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL" );
4065 createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
4067 createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
4068 createSMESHAction( SMESHOp::OpImportGMF, "IMPORT_GMF" );
4069 createSMESHAction( SMESHOp::OpPopupImportUNV, "IMPORT_UNV");
4070 createSMESHAction( SMESHOp::OpPopupImportMED, "IMPORT_MED");
4071 createSMESHAction( SMESHOp::OpPopupImportSTL, "IMPORT_STL" );
4073 createSMESHAction( SMESHOp::OpPopupImportCGNS, "IMPORT_CGNS" );
4075 createSMESHAction( SMESHOp::OpPopupImportSAUV, "IMPORT_SAUV" );
4076 createSMESHAction( SMESHOp::OpPopupImportGMF, "IMPORT_GMF" );
4078 createSMESHAction( SMESHOp::OpExportDAT, "DAT" );
4079 createSMESHAction( SMESHOp::OpExportMED, "MED" );
4080 createSMESHAction( SMESHOp::OpExportUNV, "UNV" );
4081 createSMESHAction( SMESHOp::OpExportSTL, "STL" );
4083 createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
4085 createSMESHAction( SMESHOp::OpExportSAUV, "SAUV");
4086 createSMESHAction( SMESHOp::OpExportGMF, "GMF" );
4087 createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
4088 createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
4089 createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
4090 createSMESHAction( SMESHOp::OpPopupExportSTL, "STL" );
4092 createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
4094 createSMESHAction( SMESHOp::OpPopupExportSAUV, "SAUV");
4095 createSMESHAction( SMESHOp::OpPopupExportGMF, "GMF" );
4096 createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
4097 createSMESHAction( SMESHOp::OpDelete, "DELETE", "ICON_DELETE", Qt::Key_Delete );
4098 createSMESHAction( SMESHOp::OpSelectFiltersLibrary, "SEL_FILTER_LIB" );
4099 createSMESHAction( SMESHOp::OpCreateMesh, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
4100 createSMESHAction( SMESHOp::OpCreateSubMesh, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
4101 createSMESHAction( SMESHOp::OpEditMeshOrSubMesh, "EDIT_MESHSUBMESH", "ICON_DLG_EDIT_MESH" );
4102 createSMESHAction( SMESHOp::OpEditMesh, "EDIT_MESH", "ICON_DLG_EDIT_MESH" );
4103 createSMESHAction( SMESHOp::OpEditSubMesh, "EDIT_SUBMESH", "ICON_DLG_EDIT_MESH" );
4104 createSMESHAction( SMESHOp::OpBuildCompoundMesh, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
4105 createSMESHAction( SMESHOp::OpCopyMesh, "COPY_MESH", "ICON_COPY_MESH" );
4106 createSMESHAction( SMESHOp::OpCompute, "COMPUTE", "ICON_COMPUTE" );
4107 createSMESHAction( SMESHOp::OpComputeSubMesh, "COMPUTE_SUBMESH", "ICON_COMPUTE" );
4108 createSMESHAction( SMESHOp::OpPreCompute, "PRECOMPUTE", "ICON_PRECOMPUTE" );
4109 createSMESHAction( SMESHOp::OpEvaluate, "EVALUATE", "ICON_EVALUATE" );
4110 createSMESHAction( SMESHOp::OpMeshOrder, "MESH_ORDER", "ICON_MESH_ORDER");
4111 createSMESHAction( SMESHOp::OpCreateGroup, "CREATE_GROUP", "ICON_CREATE_GROUP" );
4112 createSMESHAction( SMESHOp::OpCreateGeometryGroup, "CREATE_GEO_GROUP", "ICON_CREATE_GEO_GROUP" );
4113 createSMESHAction( SMESHOp::OpConstructGroup, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
4114 createSMESHAction( SMESHOp::OpEditGroup, "EDIT_GROUP", "ICON_EDIT_GROUP" );
4115 createSMESHAction( SMESHOp::OpEditGeomGroupAsGroup, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
4116 createSMESHAction( SMESHOp::OpUnionGroups, "UN_GROUP", "ICON_UNION" );
4117 createSMESHAction( SMESHOp::OpIntersectGroups, "INT_GROUP", "ICON_INTERSECT" );
4118 createSMESHAction( SMESHOp::OpCutGroups, "CUT_GROUP", "ICON_CUT" );
4119 createSMESHAction( SMESHOp::OpGroupUnderlyingElem, "UNDERLYING_ELEMS", "ICON_UNDERLYING_ELEMS" );
4120 createSMESHAction( SMESHOp::OpFaceGroupsByEdges, "FACE_GROUPS_BY_EDGES", "ICON_FACE_GROUPS_BY_EDGES" );
4121 createSMESHAction( SMESHOp::OpAddElemGroupPopup, "ADD_TO_GROUP" );
4122 createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE_FROM_GROUP" );
4123 createSMESHAction( SMESHOp::OpDeleteGroup, "DEL_GROUP", "ICON_DEL_GROUP" );
4124 createSMESHAction( SMESHOp::OpMeshInformation , "ADV_INFO", "ICON_ADV_INFO" );
4125 //createSMESHAction( SMESHOp::OpStdInfo, "STD_INFO", "ICON_STD_INFO" );
4126 //createSMESHAction( SMESHOp::OpWhatIs, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4127 createSMESHAction( SMESHOp::OpFindElementByPoint, "FIND_ELEM", "ICON_FIND_ELEM" );
4129 createSMESHAction( SMESHOp::OpFreeNode, "FREE_NODE", "ICON_FREE_NODE", 0, true );
4130 createSMESHAction( SMESHOp::OpEqualNode, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
4131 createSMESHAction( SMESHOp::OpNodeConnectivityNb, "NODE_CONNECTIVITY_NB", "ICON_NODE_CONN_NB", 0, true );
4132 createSMESHAction( SMESHOp::OpFreeEdge, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
4133 createSMESHAction( SMESHOp::OpFreeBorder, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
4134 createSMESHAction( SMESHOp::OpLength, "LENGTH", "ICON_LENGTH", 0, true );
4135 createSMESHAction( SMESHOp::OpConnection, "CONNECTION", "ICON_CONNECTION", 0, true );
4136 createSMESHAction( SMESHOp::OpEqualEdge, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
4137 createSMESHAction( SMESHOp::OpFreeFace, "FREE_FACES", "ICON_FREE_FACES", 0, true );
4138 createSMESHAction( SMESHOp::OpBareBorderFace, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
4139 createSMESHAction( SMESHOp::OpOverConstrainedFace, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
4140 createSMESHAction( SMESHOp::OpLength2D, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
4141 createSMESHAction( SMESHOp::OpDeflection2D, "DEFLECTION_2D", "ICON_DEFLECTION_2D", 0, true );
4142 createSMESHAction( SMESHOp::OpConnection2D, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
4143 createSMESHAction( SMESHOp::OpArea, "AREA", "ICON_AREA", 0, true );
4144 createSMESHAction( SMESHOp::OpTaper, "TAPER", "ICON_TAPER", 0, true );
4145 createSMESHAction( SMESHOp::OpAspectRatio, "ASPECT", "ICON_ASPECT", 0, true );
4146 createSMESHAction( SMESHOp::OpMinimumAngle, "MIN_ANG", "ICON_ANGLE", 0, true );
4147 createSMESHAction( SMESHOp::OpWarpingAngle, "WARP", "ICON_WARP", 0, true );
4148 createSMESHAction( SMESHOp::OpSkew, "SKEW", "ICON_SKEW", 0, true );
4149 createSMESHAction( SMESHOp::OpMaxElementLength2D, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
4150 createSMESHAction( SMESHOp::OpEqualFace, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
4151 createSMESHAction( SMESHOp::OpAspectRatio3D, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
4152 createSMESHAction( SMESHOp::OpVolume, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
4153 createSMESHAction( SMESHOp::OpMaxElementLength3D, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
4154 createSMESHAction( SMESHOp::OpBareBorderVolume, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
4155 createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
4156 createSMESHAction( SMESHOp::OpEqualVolume, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
4157 createSMESHAction( SMESHOp::OpOverallMeshQuality, "OVERALL_MESH_QUALITY", "ICON_OVL_MESH_QUALITY" );
4159 createSMESHAction( SMESHOp::OpNode, "NODE", "ICON_DLG_NODE" );
4160 createSMESHAction( SMESHOp::OpElem0D, "ELEM0D", "ICON_DLG_ELEM0D" );
4161 createSMESHAction( SMESHOp::OpElem0DOnElemNodes, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
4162 createSMESHAction( SMESHOp::OpBall, "BALL", "ICON_DLG_BALL" );
4163 createSMESHAction( SMESHOp::OpEdge, "EDGE", "ICON_DLG_EDGE" );
4164 createSMESHAction( SMESHOp::OpTriangle, "TRIANGLE", "ICON_DLG_TRIANGLE" );
4165 createSMESHAction( SMESHOp::OpQuadrangle, "QUAD", "ICON_DLG_QUADRANGLE" );
4166 createSMESHAction( SMESHOp::OpPolygon, "POLYGON", "ICON_DLG_POLYGON" );
4167 createSMESHAction( SMESHOp::OpTetrahedron, "TETRA", "ICON_DLG_TETRAS" );
4168 createSMESHAction( SMESHOp::OpHexahedron, "HEXA", "ICON_DLG_HEXAS" );
4169 createSMESHAction( SMESHOp::OpPentahedron, "PENTA", "ICON_DLG_PENTA" );
4170 createSMESHAction( SMESHOp::OpPyramid , "PYRAMID", "ICON_DLG_PYRAMID" );
4171 createSMESHAction( SMESHOp::OpHexagonalPrism, "OCTA", "ICON_DLG_OCTA" );
4172 createSMESHAction( SMESHOp::OpPolyhedron, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
4173 createSMESHAction( SMESHOp::OpQuadraticEdge, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
4174 createSMESHAction( SMESHOp::OpQuadraticTriangle, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
4175 createSMESHAction( SMESHOp::OpBiQuadraticTriangle, "BIQUADRATIC_TRIANGLE", "ICON_DLG_BIQUADRATIC_TRIANGLE" );
4176 createSMESHAction( SMESHOp::OpQuadraticQuadrangle, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
4177 createSMESHAction( SMESHOp::OpBiQuadraticQuadrangle, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
4178 createSMESHAction( SMESHOp::OpQuadraticPolygon, "QUADRATIC_POLYGON", "ICON_DLG_QUADRATIC_POLYGON" );
4179 createSMESHAction( SMESHOp::OpQuadraticTetrahedron, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
4180 createSMESHAction( SMESHOp::OpQuadraticPyramid, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
4181 createSMESHAction( SMESHOp::OpQuadraticPentahedron, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
4182 createSMESHAction( SMESHOp::OpBiQuadraticPentahedron, "BIQUADRATIC_PENTAHEDRON", "ICON_DLG_BIQUADRATIC_PENTAHEDRON" );
4183 createSMESHAction( SMESHOp::OpQuadraticHexahedron, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
4184 createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
4186 createSMESHAction( SMESHOp::OpRemoveNodes, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
4187 createSMESHAction( SMESHOp::OpRemoveElements, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
4188 createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
4189 createSMESHAction( SMESHOp::OpClearMesh, "CLEAR_MESH", "ICON_CLEAR_MESH" );
4191 //createSMESHAction( SMESHOp::OpRenumberingNodes, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
4192 //createSMESHAction( SMESHOp::OpRenumberingElements, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
4194 createSMESHAction( SMESHOp::OpTranslation, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
4195 createSMESHAction( SMESHOp::OpRotation, "ROT", "ICON_DLG_MESH_ROTATION" );
4196 createSMESHAction( SMESHOp::OpSymmetry, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
4197 createSMESHAction( SMESHOp::OpScale, "SCALE", "ICON_DLG_MESH_SCALE" );
4198 createSMESHAction( SMESHOp::OpOffset, "OFFSET", "ICON_DLG_MESH_OFFSET" );
4199 createSMESHAction( SMESHOp::OpSewing, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
4200 createSMESHAction( SMESHOp::OpMergeNodes, "MERGE", "ICON_SMESH_MERGE_NODES" );
4201 createSMESHAction( SMESHOp::OpMergeElements, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
4202 createSMESHAction( SMESHOp::OpMoveNode, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
4203 createSMESHAction( SMESHOp::OpDuplicateNodes, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
4204 createSMESHAction( SMESHOp::OpDiagonalInversion, "INV", "ICON_DLG_MESH_DIAGONAL" );
4205 createSMESHAction( SMESHOp::OpUnionOfTwoTriangle, "UNION2", "ICON_UNION2TRI" );
4206 createSMESHAction( SMESHOp::OpOrientation, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
4207 createSMESHAction( SMESHOp::OpReorientFaces, "REORIENT_2D", "ICON_REORIENT_2D" );
4208 createSMESHAction( SMESHOp::OpUnionOfTriangles, "UNION", "ICON_UNIONTRI" );
4209 createSMESHAction( SMESHOp::OpCuttingOfQuadrangles, "CUT", "ICON_CUTQUAD" );
4210 createSMESHAction( SMESHOp::OpSplitVolumes, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
4211 createSMESHAction( SMESHOp::OpSplitBiQuadratic, "SPLIT_BIQUAD", "ICON_SPLIT_BIQUAD" );
4212 createSMESHAction( SMESHOp::OpSmoothing, "SMOOTH", "ICON_DLG_SMOOTHING" );
4213 createSMESHAction( SMESHOp::OpExtrusion, "EXTRUSION", "ICON_EXTRUSION" );
4214 createSMESHAction( SMESHOp::OpExtrusionAlongAPath, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
4215 createSMESHAction( SMESHOp::OpRevolution, "REVOLUTION", "ICON_REVOLUTION" );
4216 createSMESHAction( SMESHOp::OpPatternMapping, "MAP", "ICON_MAP" );
4217 createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
4218 createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D", "ICON_2D_FROM_3D" );
4220 createSMESHAction( SMESHOp::OpReset, "RESET" );
4221 createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
4222 createSMESHAction( SMESHOp::OpShowScalarBar, "SHOW_SCALAR_BAR","",0, true );
4223 createSMESHAction( SMESHOp::OpSaveDistribution, "SAVE_DISTRIBUTION" );
4224 createSMESHAction( SMESHOp::OpShowDistribution, "SHOW_DISTRIBUTION","",0, true );
4225 #ifndef DISABLE_PLOT2DVIEWER
4226 createSMESHAction( SMESHOp::OpPlotDistribution, "PLOT_DISTRIBUTION" );
4228 createSMESHAction( SMESHOp::OpDMWireframe, "WIRE", "ICON_WIRE", 0, true );
4229 createSMESHAction( SMESHOp::OpDMShading, "SHADE", "ICON_SHADE", 0, true );
4230 createSMESHAction( SMESHOp::OpDMNodes, "NODES", "ICON_POINTS", 0, true );
4231 createSMESHAction( SMESHOp::OpDMShrink, "SHRINK", "ICON_SHRINK", 0, true );
4232 createSMESHAction( SMESHOp::OpUpdate, "UPDATE", "ICON_UPDATE" );
4233 createSMESHAction( SMESHOp::OpDE0DElements, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
4234 createSMESHAction( SMESHOp::OpDEEdges, "EDGES", "ICON_DLG_EDGE", 0, true );
4235 createSMESHAction( SMESHOp::OpDEFaces, "FACES", "ICON_DLG_TRIANGLE", 0, true );
4236 createSMESHAction( SMESHOp::OpDEVolumes, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
4237 createSMESHAction( SMESHOp::OpDEBalls, "BALLS", "ICON_DLG_BALL", 0, true );
4238 createSMESHAction( SMESHOp::OpDEChoose, "CHOOSE", "ICON_DLG_CHOOSE", 0, false );
4239 createSMESHAction( SMESHOp::OpDEAllEntity, "ALL", "ICON_DLG_CHOOSE_ALL", 0, false );
4240 createSMESHAction( SMESHOp::OpOrientationOnFaces, "FACE_ORIENTATION", "", 0, true );
4242 createSMESHAction( SMESHOp::OpRepresentationLines, "LINE_REPRESENTATION", "", 0, true );
4243 createSMESHAction( SMESHOp::OpRepresentationArcs, "ARC_REPRESENTATION", "", 0, true );
4245 createSMESHAction( SMESHOp::OpEditHypothesis, "EDIT_HYPO" );
4246 createSMESHAction( SMESHOp::OpUnassign, "UNASSIGN" );
4247 createSMESHAction( SMESHOp::OpNumberingNodes, "NUM_NODES", "", 0, true );
4248 createSMESHAction( SMESHOp::OpNumberingElements, "NUM_ELEMENTS", "", 0, true );
4249 createSMESHAction( SMESHOp::OpProperties, "COLORS" );
4250 createSMESHAction( SMESHOp::OpTransparency, "TRANSP" );
4251 createSMESHAction( SMESHOp::OpClipping, "CLIP" );
4252 createSMESHAction( SMESHOp::OpAutoColor, "AUTO_COLOR" );
4253 createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
4255 createSMESHAction( SMESHOp::OpMinimumDistance, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
4256 createSMESHAction( SMESHOp::OpBoundingBox, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
4257 createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH", "ICON_MEASURE_LENGTH" );
4258 createSMESHAction( SMESHOp::OpPropertiesArea, "MEASURE_AREA", "ICON_MEASURE_AREA" );
4259 createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME", "ICON_MEASURE_VOLUME" );
4260 createSMESHAction( SMESHOp::OpAngle, "MEASURE_ANGLE", "ICON_MEASURE_ANGLE" );
4262 createSMESHAction( SMESHOp::OpHide, "HIDE", "ICON_HIDE" );
4263 createSMESHAction( SMESHOp::OpShow, "SHOW", "ICON_SHOW" );
4264 createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
4266 createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
4268 createSMESHAction( SMESHOp::OpBreakLink, "BREAK_SHAPER_LINK" );
4270 QList<int> aCtrlActions;
4271 aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode
4272 << SMESHOp::OpNodeConnectivityNb // node controls
4273 << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
4274 << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge // edge controls
4275 << SMESHOp::OpDeflection2D
4276 << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
4277 << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
4278 << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
4279 << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
4280 << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace // face controls
4281 << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
4282 << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
4283 << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume; // volume controls
4284 QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
4285 aCtrlGroup->setExclusive( true );
4286 for( int i = 0; i < aCtrlActions.size(); i++ )
4287 aCtrlGroup->addAction( action( aCtrlActions[i] ) );
4289 // ----- create menu --------------
4290 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
4291 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
4292 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
4293 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
4294 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
4295 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
4296 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
4297 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
4299 createMenu( separator(), fileId );
4301 QMenu* nodeMenu = new QMenu(); QMenu* edgeMenu = new QMenu();
4302 QMenu* faceMenu = new QMenu(); QMenu* volumeMenu = new QMenu();
4303 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
4304 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
4305 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10, -1, nodeMenu ),
4306 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10, -1, edgeMenu ),
4307 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10, -1, faceMenu ),
4308 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10, -1, volumeMenu ),
4309 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
4310 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
4311 //renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
4312 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
4313 basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
4315 //createMenu( SMESHOp::OpImportDAT, importId, -1 );
4316 createMenu( SMESHOp::OpImportUNV, importId, -1 );
4317 createMenu( SMESHOp::OpImportMED, importId, -1 );
4318 createMenu( SMESHOp::OpImportSTL, importId, -1 );
4320 createMenu( SMESHOp::OpImportCGNS, importId, -1 );
4322 createMenu( SMESHOp::OpImportSAUV, importId, -1 );
4323 createMenu( SMESHOp::OpImportGMF, importId, -1 );
4324 createMenu( SMESHOp::OpExportDAT, exportId, -1 );
4325 createMenu( SMESHOp::OpExportMED, exportId, -1 );
4326 createMenu( SMESHOp::OpExportUNV, exportId, -1 );
4327 createMenu( SMESHOp::OpExportSTL, exportId, -1 );
4329 createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
4331 createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
4332 createMenu( SMESHOp::OpExportGMF, exportId, -1 );
4333 createMenu( separator(), fileId, 10 );
4335 createMenu( SMESHOp::OpDelete, editId, -1 );
4337 createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
4339 createMenu( SMESHOp::OpCreateMesh, meshId, -1 ); // "Mesh" menu
4340 createMenu( SMESHOp::OpCreateSubMesh, meshId, -1 );
4341 createMenu( SMESHOp::OpEditMeshOrSubMesh, meshId, -1 );
4342 createMenu( SMESHOp::OpBuildCompoundMesh, meshId, -1 );
4343 createMenu( SMESHOp::OpCopyMesh, meshId, -1 );
4344 createMenu( separator(), meshId, -1 );
4345 createMenu( SMESHOp::OpCompute, meshId, -1 );
4346 createMenu( SMESHOp::OpPreCompute, meshId, -1 );
4347 createMenu( SMESHOp::OpEvaluate, meshId, -1 );
4348 createMenu( SMESHOp::OpMeshOrder, meshId, -1 );
4349 createMenu( separator(), meshId, -1 );
4350 createMenu( SMESHOp::OpCreateGroup, meshId, -1 );
4351 createMenu( SMESHOp::OpCreateGeometryGroup, meshId, -1 );
4352 createMenu( SMESHOp::OpConstructGroup, meshId, -1 );
4353 createMenu( SMESHOp::OpEditGroup, meshId, -1 );
4354 createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4355 createMenu( separator(), meshId, -1 );
4356 createMenu( SMESHOp::OpUnionGroups, meshId, -1 );
4357 createMenu( SMESHOp::OpIntersectGroups, meshId, -1 );
4358 createMenu( SMESHOp::OpCutGroups, meshId, -1 );
4359 createMenu( separator(), meshId, -1 );
4360 createMenu( SMESHOp::OpGroupUnderlyingElem, meshId, -1 );
4361 createMenu( SMESHOp::OpFaceGroupsByEdges, meshId, -1 );
4362 createMenu( separator(), meshId, -1 );
4363 createMenu( SMESHOp::OpMeshInformation, meshId, -1 );
4364 //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4365 //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4366 createMenu( SMESHOp::OpFindElementByPoint, meshId, -1 );
4367 createMenu( separator(), meshId, -1 );
4369 createMenu( SMESHOp::OpFreeNode, nodeId, -1 );
4370 createMenu( SMESHOp::OpEqualNode, nodeId, -1 );
4371 //createMenu( SMESHOp::OpNodeConnectivityNb, nodeId, -1 );
4372 createMenu( SMESHOp::OpFreeBorder, edgeId, -1 );
4373 createMenu( SMESHOp::OpLength, edgeId, -1 );
4374 createMenu( SMESHOp::OpConnection, edgeId, -1 );
4375 createMenu( SMESHOp::OpEqualEdge, edgeId, -1 );
4376 createMenu( SMESHOp::OpFreeEdge, faceId, -1 );
4377 createMenu( SMESHOp::OpFreeFace, faceId, -1 );
4378 createMenu( SMESHOp::OpBareBorderFace, faceId, -1 );
4379 createMenu( SMESHOp::OpOverConstrainedFace, faceId, -1 );
4380 createMenu( SMESHOp::OpLength2D, faceId, -1 );
4381 createMenu( SMESHOp::OpConnection2D, faceId, -1 );
4382 createMenu( SMESHOp::OpArea, faceId, -1 );
4383 createMenu( SMESHOp::OpTaper, faceId, -1 );
4384 createMenu( SMESHOp::OpAspectRatio, faceId, -1 );
4385 createMenu( SMESHOp::OpMinimumAngle, faceId, -1 );
4386 createMenu( SMESHOp::OpWarpingAngle, faceId, -1 );
4387 createMenu( SMESHOp::OpSkew, faceId, -1 );
4388 createMenu( SMESHOp::OpMaxElementLength2D, faceId, -1 );
4389 createMenu( SMESHOp::OpEqualFace, faceId, -1 );
4390 createMenu( SMESHOp::OpDeflection2D, faceId, -1 );
4391 createMenu( SMESHOp::OpAspectRatio3D, volumeId, -1 );
4392 createMenu( SMESHOp::OpVolume, volumeId, -1 );
4393 createMenu( SMESHOp::OpMaxElementLength3D, volumeId, -1 );
4394 createMenu( SMESHOp::OpBareBorderVolume, volumeId, -1 );
4395 createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4396 createMenu( SMESHOp::OpEqualVolume, volumeId, -1 );
4397 createMenu( separator(), ctrlId, -1 );
4398 createMenu( SMESHOp::OpReset, ctrlId, -1 );
4399 createMenu( separator(), ctrlId, -1 );
4400 createMenu( SMESHOp::OpOverallMeshQuality, ctrlId, -1 );
4402 createMenu( SMESHOp::OpNode, addId, -1 );
4403 createMenu( SMESHOp::OpElem0D, addId, -1 );
4404 createMenu( SMESHOp::OpElem0DOnElemNodes, addId, -1 );
4405 createMenu( SMESHOp::OpBall, addId, -1 );
4406 createMenu( SMESHOp::OpEdge, addId, -1 );
4407 createMenu( SMESHOp::OpTriangle, addId, -1 );
4408 createMenu( SMESHOp::OpQuadrangle, addId, -1 );
4409 createMenu( SMESHOp::OpPolygon, addId, -1 );
4410 createMenu( SMESHOp::OpTetrahedron, addId, -1 );
4411 createMenu( SMESHOp::OpHexahedron, addId, -1 );
4412 createMenu( SMESHOp::OpPentahedron, addId, -1 );
4413 createMenu( SMESHOp::OpPyramid, addId, -1 );
4414 createMenu( SMESHOp::OpHexagonalPrism, addId, -1 );
4415 createMenu( SMESHOp::OpPolyhedron, addId, -1 );
4416 createMenu( separator(), addId, -1 );
4417 createMenu( SMESHOp::OpQuadraticEdge, addId, -1 );
4418 createMenu( SMESHOp::OpQuadraticTriangle, addId, -1 );
4419 createMenu( SMESHOp::OpBiQuadraticTriangle , addId, -1 );
4420 createMenu( SMESHOp::OpQuadraticQuadrangle, addId, -1 );
4421 createMenu( SMESHOp::OpBiQuadraticQuadrangle, addId, -1 );
4422 createMenu( SMESHOp::OpQuadraticPolygon, addId, -1 );
4423 createMenu( SMESHOp::OpQuadraticTetrahedron, addId, -1 );
4424 createMenu( SMESHOp::OpQuadraticPyramid, addId, -1 );
4425 createMenu( SMESHOp::OpQuadraticPentahedron, addId, -1 );
4426 createMenu( SMESHOp::OpBiQuadraticPentahedron, addId, -1 );
4427 createMenu( SMESHOp::OpQuadraticHexahedron, addId, -1 );
4428 createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4430 createMenu( SMESHOp::OpRemoveNodes, removeId, -1 );
4431 createMenu( SMESHOp::OpRemoveElements, removeId, -1 );
4432 createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4433 createMenu( separator(), removeId, -1 );
4434 createMenu( SMESHOp::OpDeleteGroup, removeId, -1 );
4435 createMenu( separator(), removeId, -1 );
4436 createMenu( SMESHOp::OpClearMesh, removeId, -1 );
4438 //createMenu( SMESHOp::OpRenumberingNodes, renumId, -1 );
4439 //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4441 createMenu( SMESHOp::OpMergeNodes, transfId, -1 );
4442 createMenu( SMESHOp::OpMergeElements, transfId, -1 );
4443 createMenu( SMESHOp::OpTranslation, transfId, -1 );
4444 createMenu( SMESHOp::OpRotation, transfId, -1 );
4445 createMenu( SMESHOp::OpSymmetry, transfId, -1 );
4446 createMenu( SMESHOp::OpScale, transfId, -1 );
4447 createMenu( SMESHOp::OpOffset, transfId, -1 );
4448 createMenu( SMESHOp::OpSewing, transfId, -1 );
4449 createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4451 createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4452 createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4453 createMenu( SMESHOp::OpExtrusion, modifyId, -1 );
4454 createMenu( SMESHOp::OpExtrusionAlongAPath, modifyId, -1 );
4455 createMenu( SMESHOp::OpRevolution, modifyId, -1 );
4456 createMenu( SMESHOp::OpOrientation, modifyId, -1 );
4457 createMenu( SMESHOp::OpReorientFaces, modifyId, -1 );
4458 createMenu( SMESHOp::OpMoveNode, modifyId, -1 );
4459 createMenu( SMESHOp::OpDiagonalInversion, modifyId, -1 );
4460 createMenu( SMESHOp::OpUnionOfTwoTriangle, modifyId, -1 );
4461 createMenu( SMESHOp::OpUnionOfTriangles, modifyId, -1 );
4462 createMenu( SMESHOp::OpCuttingOfQuadrangles, modifyId, -1 );
4463 createMenu( SMESHOp::OpSplitVolumes, modifyId, -1 );
4464 createMenu( SMESHOp::OpSplitBiQuadratic, modifyId, -1 );
4465 createMenu( SMESHOp::OpSmoothing, modifyId, -1 );
4466 createMenu( SMESHOp::OpPatternMapping, modifyId, -1 );
4468 createMenu( SMESHOp::OpMinimumDistance, measureId, -1 );
4469 createMenu( SMESHOp::OpBoundingBox, measureId, -1 );
4470 createMenu( SMESHOp::OpAngle, measureId, -1 );
4471 createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4472 createMenu( SMESHOp::OpPropertiesArea, basicPropId, -1 );
4473 createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4474 createMenu( SMESHOp::OpUpdate, viewId, -1 );
4476 connect( nodeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4477 connect( edgeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4478 connect( faceMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4479 connect( volumeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4481 // ----- create toolbars --------------
4482 int meshTb = createTool( tr( "TB_MESH" ), QString( "SMESHMeshToolbar" ) ),
4483 info = createTool( tr( "TB_INFO" ), QString( "SMESHInformationToolbar" ) ),
4484 groupTb = createTool( tr( "TB_GROUP" ), QString( "SMESHGroupToolbar" ) ),
4485 ctrl0dTb = createTool( tr( "TB_CTRL0D" ), QString( "SMESHNodeControlsToolbar" ) ),
4486 ctrl1dTb = createTool( tr( "TB_CTRL1D" ), QString( "SMESHEdgeControlsToolbar" ) ),
4487 ctrl2dTb = createTool( tr( "TB_CTRL2D" ), QString( "SMESHFaceControlsToolbar" ) ),
4488 ctrl3dTb = createTool( tr( "TB_CTRL3D" ), QString( "SMESHVolumeControlsToolbar" ) ),
4489 addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ),
4490 addNonElemTb = createTool( tr( "TB_ADDNON" ), QString( "SMESHAddElementToolbar" ) ),
4491 remTb = createTool( tr( "TB_REM" ), QString( "SMESHRemoveToolbar" ) ),
4492 //renumbTb = createTool( tr( "TB_RENUMBER" ), QString( "SMESHRenumberingToolbar" ) ),
4493 transformTb = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ),
4494 modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ),
4495 measuremTb = createTool( tr( "TB_MEASUREM" ), QString( "SMESHMeasurementsToolbar" ) ),
4496 dispModeTb = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4498 createTool( SMESHOp::OpCreateMesh, meshTb );
4499 createTool( SMESHOp::OpCreateSubMesh, meshTb );
4500 createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4501 createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4502 createTool( SMESHOp::OpCopyMesh, meshTb );
4503 createTool( separator(), meshTb );
4504 createTool( SMESHOp::OpCompute, meshTb );
4505 createTool( SMESHOp::OpPreCompute, meshTb );
4506 createTool( SMESHOp::OpEvaluate, meshTb );
4507 createTool( SMESHOp::OpMeshOrder, meshTb );
4509 createTool( SMESHOp::OpCreateGroup, groupTb );
4510 createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4511 createTool( SMESHOp::OpConstructGroup, groupTb );
4512 createTool( SMESHOp::OpEditGroup, groupTb );
4514 createTool( SMESHOp::OpMeshInformation, info );
4515 //createTool( SMESHOp::OpStdInfo, meshTb );
4516 //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4517 createTool( SMESHOp::OpFindElementByPoint, info );
4519 createTool( SMESHOp::OpFreeNode, ctrl0dTb );
4520 createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4521 //createTool( SMESHOp::OpNodeConnectivityNb, ctrl0dTb );
4523 createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4524 createTool( SMESHOp::OpLength, ctrl1dTb );
4525 createTool( SMESHOp::OpConnection, ctrl1dTb );
4526 createTool( SMESHOp::OpEqualEdge, ctrl1dTb );
4528 createTool( SMESHOp::OpFreeEdge, ctrl2dTb );
4529 createTool( SMESHOp::OpFreeFace, ctrl2dTb );
4530 createTool( SMESHOp::OpBareBorderFace, ctrl2dTb );
4531 createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4532 createTool( SMESHOp::OpLength2D, ctrl2dTb );
4533 createTool( SMESHOp::OpConnection2D, ctrl2dTb );
4534 createTool( SMESHOp::OpArea, ctrl2dTb );
4535 createTool( SMESHOp::OpTaper, ctrl2dTb );
4536 createTool( SMESHOp::OpAspectRatio, ctrl2dTb );
4537 createTool( SMESHOp::OpMinimumAngle, ctrl2dTb );
4538 createTool( SMESHOp::OpWarpingAngle, ctrl2dTb );
4539 createTool( SMESHOp::OpSkew, ctrl2dTb );
4540 createTool( SMESHOp::OpMaxElementLength2D, ctrl2dTb );
4541 createTool( SMESHOp::OpEqualFace, ctrl2dTb );
4542 createTool( SMESHOp::OpDeflection2D, ctrl2dTb );
4544 createTool( SMESHOp::OpAspectRatio3D, ctrl3dTb );
4545 createTool( SMESHOp::OpVolume, ctrl3dTb );
4546 createTool( SMESHOp::OpMaxElementLength3D, ctrl3dTb );
4547 createTool( SMESHOp::OpBareBorderVolume, ctrl3dTb );
4548 createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
4549 createTool( SMESHOp::OpEqualVolume, ctrl3dTb );
4551 createTool( SMESHOp::OpNode, addElemTb );
4552 createTool( SMESHOp::OpElem0D, addElemTb );
4553 createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4554 createTool( SMESHOp::OpBall, addElemTb );
4555 createTool( SMESHOp::OpEdge, addElemTb );
4556 createTool( SMESHOp::OpTriangle, addElemTb );
4557 createTool( SMESHOp::OpQuadrangle, addElemTb );
4558 createTool( SMESHOp::OpPolygon, addElemTb );
4559 createTool( SMESHOp::OpTetrahedron, addElemTb );
4560 createTool( SMESHOp::OpHexahedron, addElemTb );
4561 createTool( SMESHOp::OpPentahedron, addElemTb );
4562 createTool( SMESHOp::OpPyramid, addElemTb );
4563 createTool( SMESHOp::OpHexagonalPrism, addElemTb );
4564 createTool( SMESHOp::OpPolyhedron, addElemTb );
4566 createTool( SMESHOp::OpQuadraticEdge, addNonElemTb );
4567 createTool( SMESHOp::OpQuadraticTriangle, addNonElemTb );
4568 createTool( SMESHOp::OpBiQuadraticTriangle, addNonElemTb );
4569 createTool( SMESHOp::OpQuadraticQuadrangle, addNonElemTb );
4570 createTool( SMESHOp::OpBiQuadraticQuadrangle, addNonElemTb );
4571 createTool( SMESHOp::OpQuadraticPolygon, addNonElemTb );
4572 createTool( SMESHOp::OpQuadraticTetrahedron, addNonElemTb );
4573 createTool( SMESHOp::OpQuadraticPyramid, addNonElemTb );
4574 createTool( SMESHOp::OpQuadraticPentahedron, addNonElemTb );
4575 createTool( SMESHOp::OpBiQuadraticPentahedron, addNonElemTb );
4576 createTool( SMESHOp::OpQuadraticHexahedron, addNonElemTb );
4577 createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4579 createTool( SMESHOp::OpRemoveNodes, remTb );
4580 createTool( SMESHOp::OpRemoveElements, remTb );
4581 createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4582 createTool( SMESHOp::OpClearMesh, remTb );
4584 //createTool( SMESHOp::OpRenumberingNodes, renumbTb );
4585 //createTool( SMESHOp::OpRenumberingElements, renumbTb );
4587 createTool( SMESHOp::OpMergeNodes, transformTb );
4588 createTool( SMESHOp::OpMergeElements, transformTb );
4589 createTool( SMESHOp::OpTranslation, transformTb );
4590 createTool( SMESHOp::OpRotation, transformTb );
4591 createTool( SMESHOp::OpSymmetry, transformTb );
4592 createTool( SMESHOp::OpScale, transformTb );
4593 createTool( SMESHOp::OpOffset, transformTb );
4594 createTool( SMESHOp::OpSewing, transformTb );
4595 createTool( SMESHOp::OpDuplicateNodes, transformTb );
4597 createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4598 createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4599 createTool( SMESHOp::OpExtrusion, modifyTb );
4600 createTool( SMESHOp::OpExtrusionAlongAPath, modifyTb );
4601 createTool( SMESHOp::OpRevolution, modifyTb );
4602 createTool( SMESHOp::OpOrientation, modifyTb );
4603 createTool( SMESHOp::OpReorientFaces, modifyTb );
4604 createTool( SMESHOp::OpMoveNode, modifyTb );
4605 createTool( SMESHOp::OpDiagonalInversion, modifyTb );
4606 createTool( SMESHOp::OpUnionOfTwoTriangle, modifyTb );
4607 createTool( SMESHOp::OpUnionOfTriangles, modifyTb );
4608 createTool( SMESHOp::OpCuttingOfQuadrangles, modifyTb );
4609 createTool( SMESHOp::OpSplitVolumes, modifyTb );
4610 createTool( SMESHOp::OpSplitBiQuadratic, modifyTb );
4611 createTool( SMESHOp::OpSmoothing, modifyTb );
4612 createTool( SMESHOp::OpPatternMapping, modifyTb );
4614 createTool( SMESHOp::OpMinimumDistance, measuremTb );
4616 createTool( SMESHOp::OpUpdate, dispModeTb );
4618 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4619 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4623 OB = "'ObjectBrowser'",
4624 View = "'" + SVTK_Viewer::Type() + "'",
4626 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4627 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4628 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4629 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4630 smesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::COMPONENT ) ),
4631 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4632 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4633 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4634 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4635 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4636 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4637 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4639 mesh_part = mesh + " " + subMesh + " " + group,
4640 mesh_group = mesh + " " + group,
4641 mesh_submesh = mesh + " " + subMesh,
4642 hyp_alg = hypo + " " + algo;
4644 // popup for object browser
4646 isInvisible("not( isVisible )"),
4647 isEmpty("numberOfNodes = 0"),
4648 isNotEmpty("numberOfNodes <> 0"),
4650 // has nodes, edges, etc in VISIBLE! actor
4651 hasNodes("(numberOfNodes > 0 ) && hasActor"),
4652 hasElems("(count( elemTypes ) > 0)"),
4653 hasDifferentElems("(count( elemTypes ) > 1)"),
4654 hasDifferentObjElems("(count( objElemTypes ) > 1)"),
4655 hasBalls("({'BallElem'} in elemTypes)"),
4656 hasElems0d("({'Elem0d'} in elemTypes)"),
4657 hasEdges("({'Edge'} in elemTypes)"),
4658 hasFaces("({'Face'} in elemTypes)"),
4659 hasVolumes("({'Volume'} in elemTypes)"),
4660 hasFacesOrVolumes("(({'Face'} in elemTypes) || ({'Volume'} in elemTypes)) ");
4662 createPopupItem( SMESHOp::OpFileInformation, OB, mesh, "&& selcount=1 && isImported" );
4663 createPopupItem( SMESHOp::OpCreateSubMesh, OB, mesh, "&& hasGeomReference");
4664 createPopupItem( SMESHOp::OpEditMesh, OB, mesh, "&& selcount=1" );
4665 createPopupItem( SMESHOp::OpEditSubMesh, OB, subMesh, "&& selcount=1 && hasGeomReference" );
4666 createPopupItem( SMESHOp::OpEditGroup, OB, group );
4667 createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4669 popupMgr()->insert( separator(), -1, 0 );
4670 createPopupItem( SMESHOp::OpCompute, OB, mesh, "&& selcount=1 && isComputable" );
4671 createPopupItem( SMESHOp::OpComputeSubMesh, OB, subMesh, "&& selcount=1 && isComputable" );
4672 createPopupItem( SMESHOp::OpPreCompute, OB, mesh, "&& selcount=1 && isPreComputable" );
4673 createPopupItem( SMESHOp::OpEvaluate, OB, mesh, "&& selcount=1 && isComputable" );
4674 createPopupItem( SMESHOp::OpMeshOrder, OB, mesh, "&& selcount=1 && isComputable && hasGeomReference" );
4675 createPopupItem( SMESHOp::OpUpdate, OB, mesh_part );
4676 createPopupItem( SMESHOp::OpMeshInformation, OB, mesh_part );
4677 createPopupItem( SMESHOp::OpFindElementByPoint,OB, mesh_group, "&& selcount=1" );
4678 createPopupItem( SMESHOp::OpOverallMeshQuality,OB, mesh_part );
4679 popupMgr()->insert( separator(), -1, 0 );
4680 createPopupItem( SMESHOp::OpCreateGroup, OB, mesh, "&& selcount=1" );
4681 createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh, "&& selcount=1 && hasGeomReference" );
4682 createPopupItem( SMESHOp::OpConstructGroup, OB, subMesh );
4683 popupMgr()->insert( separator(), -1, 0 );
4684 createPopupItem( SMESHOp::OpEditHypothesis, OB, hypo, "&& isEditableHyp");
4685 createPopupItem( SMESHOp::OpUnassign, OB, hyp_alg );
4686 popupMgr()->insert( separator(), -1, 0 );
4687 createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh_submesh );
4688 createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh_group, "&& selcount=1 && dim>=2");
4689 popupMgr()->insert( separator(), -1, 0 );
4690 createPopupItem( SMESHOp::OpClearMesh, OB, mesh );
4691 //popupMgr()->insert( separator(), -1, 0 );
4693 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4694 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4695 QString only_one_2D = only_one_non_empty + " && dim>1";
4697 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4698 createPopupItem( SMESHOp::OpPopupExportMED, OB, mesh_group, multiple_non_empty, anId );
4699 createPopupItem( SMESHOp::OpPopupExportUNV, OB, mesh_group, only_one_non_empty, anId );
4700 createPopupItem( SMESHOp::OpPopupExportSTL, OB, mesh_group, only_one_2D, anId );
4702 createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4704 createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, only_one_non_empty, anId );
4705 createPopupItem( SMESHOp::OpPopupExportGMF, OB, mesh_group, only_one_non_empty, anId );
4706 createPopupItem( SMESHOp::OpPopupExportDAT, OB, mesh_group, only_one_non_empty, anId );
4707 createPopupItem( SMESHOp::OpDelete, OB, mesh_part + " " + hyp_alg );
4708 createPopupItem( SMESHOp::OpDeleteGroup, OB, group );
4710 anId = popupMgr()->insert( tr( "MEN_IMPORT" ), -1, -1 ); // IMPORT submenu
4711 createPopupItem( SMESHOp::OpPopupImportMED, OB, smesh, "", anId );
4712 createPopupItem( SMESHOp::OpPopupImportUNV, OB, smesh, "", anId );
4713 createPopupItem( SMESHOp::OpPopupImportSTL, OB, smesh, "", anId );
4715 createPopupItem( SMESHOp::OpPopupImportCGNS, OB, smesh, "", anId );
4717 createPopupItem( SMESHOp::OpPopupImportSAUV, OB, smesh, "", anId );
4718 createPopupItem( SMESHOp::OpPopupImportGMF, OB, smesh, "", anId );
4719 createPopupItem( SMESHOp::OpPopupImportDAT, OB, smesh, "", anId );
4720 popupMgr()->insert( separator(), -1, 0 );
4723 createPopupItem( SMESHOp::OpEditGroup, View, group );
4724 createPopupItem( SMESHOp::OpAddElemGroupPopup, View, elems, "&& guiState = 800" );
4725 createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems, "&& guiState = 800" );
4727 popupMgr()->insert( separator(), -1, 0 );
4728 createPopupItem( SMESHOp::OpUpdate, View, mesh_part );
4729 createPopupItem( SMESHOp::OpMeshInformation, View, mesh_part );
4730 createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4731 createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh );
4732 popupMgr()->insert( separator(), -1, 0 );
4734 createPopupItem( SMESHOp::OpAutoColor, OB + " " + View, mesh, "&& (not isAutoColor)" );
4735 createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4736 popupMgr()->insert( separator(), -1, 0 );
4738 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4739 QString aType = QString( "%1type in {%2}" ).arg( lc );
4740 aType = aType.arg( mesh_part );
4741 QString aMeshInVTK = aClient + "&&" + aType;
4743 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4744 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4745 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4747 //-------------------------------------------------
4749 //-------------------------------------------------
4750 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4752 popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4753 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4754 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4756 popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4757 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4758 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4760 popupMgr()->insert( separator(), -1, -1 );
4762 //-------------------------------------------------
4764 //-------------------------------------------------
4765 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4767 popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4768 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4769 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4771 popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4772 popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4773 popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4775 popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4776 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4777 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4779 popupMgr()->insert( separator(), anId, -1 );
4781 popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4782 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4783 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4785 //-------------------------------------------------
4787 //-------------------------------------------------
4788 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4790 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4792 popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4793 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4794 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4796 popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4797 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4798 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4800 popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4801 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4802 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4804 popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4805 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4806 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4808 popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4809 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4810 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4812 popupMgr()->insert( separator(), anId, -1 );
4814 popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4815 popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&& $type in {" + mesh + "} &&" + hasDifferentObjElems, QtxPopupMgr::VisibleRule );
4817 popupMgr()->insert( separator(), anId, -1 );
4819 popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4820 popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4823 //-------------------------------------------------
4824 // Representation of the 2D Quadratic elements
4825 //-------------------------------------------------
4826 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4827 popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4828 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "&& isVisible && isQuadratic",QtxPopupMgr::VisibleRule );
4829 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4831 popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4832 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "&& isVisible && isQuadratic", QtxPopupMgr::VisibleRule );
4833 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4835 //-------------------------------------------------
4836 // Orientation of faces
4837 //-------------------------------------------------
4838 popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4839 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4840 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4842 //-------------------------------------------------
4844 //-------------------------------------------------
4845 popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4846 popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4848 //-------------------------------------------------
4850 //-------------------------------------------------
4851 popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4852 popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4854 //-------------------------------------------------
4856 //-------------------------------------------------
4858 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4859 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4860 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4861 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4863 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4865 popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4866 popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4868 popupMgr()->insert( separator(), anId, -1 );
4870 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4872 popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4873 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4874 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4876 popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4877 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4878 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4880 // popupMgr()->insert( action( SMESHOp::OpNodeConnectivityNb ), aSubId, -1 );
4881 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4882 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), "controlMode = 'eNodeConnectivityNb'", QtxPopupMgr::ToggleRule );
4884 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4886 popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4887 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVTK + "&&" + hasEdges + "&&" + hasFacesOrVolumes, QtxPopupMgr::VisibleRule );
4888 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4890 popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4891 popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4892 popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4894 popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4895 popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4896 popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4897 popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4898 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4899 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4901 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4903 popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4904 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4905 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4907 popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4908 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4909 QtxPopupMgr::VisibleRule );
4910 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4912 popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4913 popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4914 popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4916 popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4917 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4918 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4920 popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
4921 popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4922 popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4924 popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
4925 popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4926 popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4928 popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
4929 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4930 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4932 popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
4933 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4934 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4936 popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
4937 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4938 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4940 popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
4941 popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4942 popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4944 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
4945 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4946 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4948 popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
4949 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4950 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4952 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
4953 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4954 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4956 popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
4957 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4958 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4960 popupMgr()->insert ( action( SMESHOp::OpDeflection2D ), aSubId, -1 );
4961 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), aMeshInVtkHasFaces + " && hasGeomReference", QtxPopupMgr::VisibleRule );
4962 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), "controlMode = 'eDeflection2D'", QtxPopupMgr::ToggleRule );
4964 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4966 popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D ), aSubId, -1 );
4967 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4968 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4970 popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
4971 popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4972 popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4974 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
4975 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4976 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4978 popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
4979 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4980 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4982 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
4983 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4984 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4986 popupMgr()->insert ( action( SMESHOp::OpEqualVolume ), aSubId, -1 );
4987 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4988 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4990 popupMgr()->insert( separator(), anId, -1 );
4992 popupMgr()->insert( action( SMESHOp::OpShowScalarBar ), anId, -1 );
4993 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4994 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone' && isScalarBarVisible", QtxPopupMgr::ToggleRule );
4995 popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
4996 popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4998 popupMgr()->insert( separator(), anId, -1 );
5000 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
5002 popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
5003 popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
5005 popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
5006 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
5007 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isScalarBarVisible && isDistributionVisible", QtxPopupMgr::ToggleRule);
5009 #ifndef DISABLE_PLOT2DVIEWER
5010 popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
5011 popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
5014 //-------------------------------------------------
5016 //-------------------------------------------------
5017 popupMgr()->insert( separator(), -1, -1 );
5018 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
5019 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
5020 popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
5021 popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
5023 popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
5024 popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
5026 popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
5027 popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
5029 popupMgr()->insert( separator(), -1, -1 );
5031 //-------------------------------------------------
5033 //-------------------------------------------------
5034 popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
5035 popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
5037 popupMgr()->insert( separator(), -1, -1 );
5039 popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
5040 popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
5041 popupMgr()->insert( separator(), -1, -1 );
5043 popupMgr()->insert( action( SMESHOp::OpBreakLink), -1, -1 );
5044 popupMgr()->setRule( action( SMESHOp::OpBreakLink), "$component={'SHAPERSTUDY'} and client='ObjectBrowser' and canBreakLink", QtxPopupMgr::VisibleRule );
5046 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
5047 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
5049 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
5050 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
5053 //================================================================================
5055 * \brief Return true if SMESH or GEOM objects are selected.
5056 * Is called form LightApp_Module::activateModule() which clear selection if
5057 * not isSelectionCompatible()
5059 //================================================================================
5061 bool SMESHGUI::isSelectionCompatible()
5063 bool isCompatible = true;
5064 SALOME_ListIO selected;
5065 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
5066 Sel->selectedObjects( selected );
5068 SALOME_ListIteratorOfListIO It( selected );
5069 for ( ; isCompatible && It.More(); It.Next())
5071 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
5072 ( strcmp("SHAPERSTUDY", It.Value()->getComponentDataType()) == 0 ) ||
5073 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
5075 return isCompatible;
5079 bool SMESHGUI::reusableOperation( const int id )
5081 // compute, evaluate and precompute are not reusable operations
5082 return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate ) ? false : SalomeApp_Module::reusableOperation( id );
5085 bool SMESHGUI::activateModule( SUIT_Study* study )
5087 bool res = SalomeApp_Module::activateModule( study );
5089 setMenuShown( true );
5090 setToolShown( true );
5092 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
5093 PyGILState_STATE gstate = PyGILState_Ensure();
5094 PyObject* pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
5095 if ( !pluginsmanager ) {
5099 PyObject* result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toUtf8().data(),tr("SMESH_PLUGINS_OTHER").toUtf8().data());
5104 PyGILState_Release(gstate);
5105 // end of SMESH plugins loading
5107 // Reset actions accelerator keys
5108 action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
5110 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
5111 GetSMESHGen()->UpdateStudy();
5113 // get all view currently opened in the study and connect their signals to
5114 // the corresponding slots of the class.
5115 SUIT_Desktop* aDesk = study->application()->desktop();
5117 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
5118 SUIT_ViewWindow* wnd;
5119 foreach ( wnd, wndList )
5123 // remove actors whose objects are removed in GetSMESHGen()->UpdateStudy()
5124 SMESH::UpdateActorsAfterUpdateStudy(wnd);
5130 Py_XDECREF(pluginsmanager);
5134 bool SMESHGUI::deactivateModule( SUIT_Study* study )
5136 setMenuShown( false );
5137 setToolShown( false );
5139 EmitSignalCloseAllDialogs();
5141 // Unset actions accelerator keys
5142 action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
5144 return SalomeApp_Module::deactivateModule( study );
5147 void SMESHGUI::studyClosed( SUIT_Study* s )
5151 SMESH::RemoveVisuData();
5152 SalomeApp_Module::studyClosed( s );
5155 void SMESHGUI::OnGUIEvent()
5157 const QObject* obj = sender();
5158 if ( !obj || !obj->inherits( "QAction" ) )
5160 int id = actionId((QAction*)obj);
5165 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
5167 if ( CORBA::is_nil( myComponentSMESH ) )
5169 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
5170 return aGUI.myComponentSMESH;
5172 return myComponentSMESH;
5175 QString SMESHGUI::engineIOR() const
5177 CORBA::ORB_var anORB = getApp()->orb();
5178 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
5179 return QString( anIOR.in() );
5182 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
5184 SalomeApp_Module::contextMenuPopup( client, menu, title );
5186 selectionMgr()->selectedObjects( lst );
5187 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
5188 Handle(SALOME_InteractiveObject) io = lst.First();
5189 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
5190 _PTR(Study) study = appStudy->studyDS();
5191 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
5193 QString aName = SMESH::fromUtf8( obj->GetName());
5194 while ( !aName.isEmpty() && aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
5195 aName.remove(( aName.length() - 1 ), 1 );
5201 LightApp_Selection* SMESHGUI::createSelection() const
5203 return new SMESHGUI_Selection();
5206 void SMESHGUI::windows( QMap<int, int>& aMap ) const
5208 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
5209 aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
5210 #ifndef DISABLE_PYCONSOLE
5211 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
5215 void SMESHGUI::viewManagers( QStringList& list ) const
5217 list.append( SVTK_Viewer::Type() );
5220 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
5222 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
5223 SMESH::UpdateSelectionProp( this );
5225 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
5226 for(int i = 0; i < aViews.count() ; i++){
5227 SUIT_ViewWindow *sf = aViews[i];
5230 EmitSignalActivatedViewManager();
5234 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
5236 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
5237 myClippingPlaneInfoMap.erase( theViewManager );
5240 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
5242 theActor->AddObserver( SMESH::DeleteActorEvent,
5243 myEventCallbackCommand.GetPointer(),
5247 void SMESHGUI::ProcessEvents( vtkObject* theObject,
5248 unsigned long theEvent,
5249 void* theClientData,
5252 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
5253 if( theObject && (int) theEvent == SMESH::DeleteActorEvent ) {
5254 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
5255 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
5256 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
5257 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
5258 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
5259 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
5260 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
5261 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
5262 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
5263 SMESH::TActorList::iterator anIter3 = anActorList.begin();
5264 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
5265 if( anActor == *anIter3 ) {
5266 anActorList.erase( anIter3 );
5277 void SMESHGUI::createPreferences()
5279 // General tab ------------------------------------------------------------------------
5280 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
5282 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
5283 setPreferenceProperty( autoUpdate, "columns", 2 );
5284 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
5285 setPreferenceProperty( lim, "min", 0 );
5286 setPreferenceProperty( lim, "max", 100000000 );
5287 setPreferenceProperty( lim, "step", 1000 );
5288 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5289 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
5291 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
5292 setPreferenceProperty( dispgroup, "columns", 2 );
5294 addPreference( tr( "PREF_FITALL_ON_DISPLAYONLY" ), dispgroup, LightApp_Preferences::Bool, "SMESH", "fitall_on_displayonly" );
5296 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
5298 modes.append( tr("MEN_WIRE") );
5299 modes.append( tr("MEN_SHADE") );
5300 modes.append( tr("MEN_NODES") );
5301 modes.append( tr("MEN_SHRINK") );
5302 QList<QVariant> indices;
5303 indices.append( 0 );
5304 indices.append( 1 );
5305 indices.append( 2 );
5306 indices.append( 3 );
5307 setPreferenceProperty( dispmode, "strings", modes );
5308 setPreferenceProperty( dispmode, "indexes", indices );
5310 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
5311 setPreferenceProperty( arcgroup, "columns", 2 );
5312 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
5313 QStringList quadraticModes;
5314 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
5315 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
5317 indices.append( 0 );
5318 indices.append( 1 );
5319 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
5320 setPreferenceProperty( quadraticmode, "indexes", indices );
5322 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
5323 "SMESH", "max_angle" );
5324 setPreferenceProperty( maxAngle, "min", 1 );
5325 setPreferenceProperty( maxAngle, "max", 90 );
5327 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
5328 setPreferenceProperty( qaGroup, "columns", 2 );
5329 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
5330 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
5331 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
5332 setPreferenceProperty( prec, "min", 0 );
5333 setPreferenceProperty( prec, "max", 100 );
5334 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
5335 setPreferenceProperty( doubleNodesTol, "precision", 10 );
5336 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
5337 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
5338 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
5341 int cinc = addPreference(tr("PREF_CONTROLS_INCREMENT"), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_increment");
5342 setPreferenceProperty( cinc, "min", 0 );
5343 setPreferenceProperty( cinc, "max", 5 );
5346 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
5347 setPreferenceProperty( exportgroup, "columns", 2 );
5348 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
5349 addPreference( tr( "PREF_SHOW_WARN" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "show_warning" );
5350 int zTol = addPreference( tr( "PREF_ZTOLERANCE" ), exportgroup, LightApp_Preferences::DblSpin, "SMESH", "med_ztolerance" );
5351 setPreferenceProperty( zTol, "precision", 10 );
5352 setPreferenceProperty( zTol, "min", 0.0000000001 );
5353 setPreferenceProperty( zTol, "max", 1000000.0 );
5354 setPreferenceProperty( zTol, "step", 1. );
5355 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
5357 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
5358 setPreferenceProperty( computeGroup, "columns", 2 );
5359 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
5361 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5362 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5363 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5365 indices.append( 0 );
5366 indices.append( 1 );
5367 indices.append( 2 );
5368 setPreferenceProperty( notifyMode, "strings", modes );
5369 setPreferenceProperty( notifyMode, "indexes", indices );
5371 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5372 setPreferenceProperty( infoGroup, "columns", 2 );
5373 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5375 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5376 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5378 indices.append( 0 );
5379 indices.append( 1 );
5380 setPreferenceProperty( elemInfo, "strings", modes );
5381 setPreferenceProperty( elemInfo, "indexes", indices );
5382 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5383 setPreferenceProperty( nodesLim, "min", 0 );
5384 setPreferenceProperty( nodesLim, "max", 10000000 );
5385 setPreferenceProperty( nodesLim, "step", 10000 );
5386 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5387 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5388 setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5389 setPreferenceProperty( ctrlLim, "min", 0 );
5390 setPreferenceProperty( ctrlLim, "max", 10000000 );
5391 setPreferenceProperty( ctrlLim, "step", 1000 );
5392 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5393 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5394 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5395 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5396 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5398 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5399 setPreferenceProperty( segGroup, "columns", 2 );
5400 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5401 "SMESH", "segmentation" );
5402 setPreferenceProperty( segLen, "min", 1 );
5403 setPreferenceProperty( segLen, "max", 10000000 );
5404 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5405 "SMESH", "nb_segments_per_edge" );
5406 setPreferenceProperty( nbSeg, "min", 1 );
5407 setPreferenceProperty( nbSeg, "max", 10000000 );
5408 addPreference( tr( "PREF_USE_MESHGEMS_HYPOSET" ), segGroup, LightApp_Preferences::Bool, "SMESH", "use-meshgems-hypo-sets" );
5410 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5411 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5412 "SMESH", "forget_mesh_on_hyp_modif" );
5415 // Quantities with individual precision settings
5416 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5417 setPreferenceProperty( precGroup, "columns", 2 );
5419 const int nbQuantities = 6;
5420 int precs[nbQuantities], ii = 0;
5421 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5422 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5423 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5424 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5425 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5426 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5427 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5428 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5429 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5430 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5431 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5432 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5434 // Set property for precision value for spinboxes
5435 for ( ii = 0; ii < nbQuantities; ii++ ){
5436 setPreferenceProperty( precs[ii], "min", -14 );
5437 setPreferenceProperty( precs[ii], "max", 14 );
5438 setPreferenceProperty( precs[ii], "precision", 2 );
5441 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5442 setPreferenceProperty( previewGroup, "columns", 2 );
5443 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5444 setPreferenceProperty( chunkSize, "min", 1 );
5445 setPreferenceProperty( chunkSize, "max", 1000 );
5446 setPreferenceProperty( chunkSize, "step", 50 );
5448 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5449 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5451 // Mesh tab ------------------------------------------------------------------------
5452 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5453 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5454 setPreferenceProperty( nodeGroup, "columns", 3 );
5456 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5458 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5460 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5461 QList<QVariant> aMarkerTypeIndicesList;
5462 QList<QVariant> aMarkerTypeIconsList;
5463 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5464 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5465 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5466 aMarkerTypeIndicesList << i;
5467 aMarkerTypeIconsList << pixmap;
5469 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5470 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
5472 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5474 QList<QVariant> aMarkerScaleIndicesList;
5475 QStringList aMarkerScaleValuesList;
5476 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5477 aMarkerScaleIndicesList << i;
5478 //aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5479 aMarkerScaleValuesList << QString::number( i );
5481 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5482 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5484 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5485 //setPreferenceProperty( elemGroup, "columns", 2 );
5487 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5488 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5489 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5490 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5491 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5492 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5493 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5494 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5495 addPreference( tr( "PREF_PREVIEW_COLOR" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5498 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5499 setPreferenceProperty( grpGroup, "columns", 2 );
5501 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5502 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5504 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5505 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5506 /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5507 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5508 double ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5509 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5510 double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5511 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5512 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
5513 LightApp_Preferences::IntSpin, "SMESH", "element_width");
5514 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5515 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5516 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5517 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5519 setPreferenceProperty( size0d, "min", 1 );
5520 setPreferenceProperty( size0d, "max", 10 );
5522 // setPreferenceProperty( ballSize, "min", 1 );
5523 // setPreferenceProperty( ballSize, "max", 10 );
5525 setPreferenceProperty( ballDiameter, "min", 1e-7 );
5526 setPreferenceProperty( ballDiameter, "max", 1e9 );
5527 setPreferenceProperty( ballDiameter, "step", 0.1 );
5529 setPreferenceProperty( ballScale, "min", 1e-2 );
5530 setPreferenceProperty( ballScale, "max", 1e7 );
5531 setPreferenceProperty( ballScale, "step", 0.5 );
5533 setPreferenceProperty( elemW, "min", 1 );
5534 setPreferenceProperty( elemW, "max", 5 );
5536 setPreferenceProperty( outW, "min", 1 );
5537 setPreferenceProperty( outW, "max", 5 );
5539 setPreferenceProperty( shrink, "min", 0 );
5540 setPreferenceProperty( shrink, "max", 100 );
5542 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5543 setPreferenceProperty( numGroup, "columns", 2 );
5545 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5546 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5548 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5549 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5551 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5552 setPreferenceProperty( orientGroup, "columns", 1 );
5554 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5555 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5557 setPreferenceProperty( orientScale, "min", 0.05 );
5558 setPreferenceProperty( orientScale, "max", 0.5 );
5559 setPreferenceProperty( orientScale, "step", 0.05 );
5561 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5563 // Selection tab ------------------------------------------------------------------------
5564 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5566 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5567 setPreferenceProperty( selGroup, "columns", 2 );
5569 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5570 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5572 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5573 setPreferenceProperty( preGroup, "columns", 2 );
5575 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5577 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5578 setPreferenceProperty( precSelGroup, "columns", 2 );
5580 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5581 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5582 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5584 int sinc = addPreference(tr("PREF_SELECTION_INCREMENT"), selTab, LightApp_Preferences::IntSpin, "SMESH", "selection_increment");
5585 setPreferenceProperty( sinc, "min", 0 );
5586 setPreferenceProperty( sinc, "max", 5 );
5588 // Scalar Bar tab ------------------------------------------------------------------------
5589 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5590 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5591 setPreferenceProperty( fontGr, "columns", 2 );
5593 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5594 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5596 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5597 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5599 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5600 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5602 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5603 setPreferenceProperty( numcol, "min", 2 );
5604 setPreferenceProperty( numcol, "max", 256 );
5606 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5607 setPreferenceProperty( numlab, "min", 2 );
5608 setPreferenceProperty( numlab, "max", 65 );
5610 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5611 setPreferenceProperty( orientGr, "columns", 2 );
5612 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5613 QStringList orients;
5614 orients.append( tr( "SMESH_VERTICAL" ) );
5615 orients.append( tr( "SMESH_HORIZONTAL" ) );
5616 indices.clear(); indices.append( 0 ); indices.append( 1 );
5617 setPreferenceProperty( orient, "strings", orients );
5618 setPreferenceProperty( orient, "indexes", indices );
5620 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5621 setPreferenceProperty( posVSizeGr, "columns", 2 );
5622 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5623 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5624 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5625 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5626 setPreferenceProperty( xv, "step", 0.1 );
5627 setPreferenceProperty( xv, "min", 0.0 );
5628 setPreferenceProperty( xv, "max", 1.0 );
5629 setPreferenceProperty( yv, "step", 0.1 );
5630 setPreferenceProperty( yv, "min", 0.0 );
5631 setPreferenceProperty( yv, "max", 1.0 );
5632 setPreferenceProperty( wv, "step", 0.1 );
5633 setPreferenceProperty( wv, "min", 0.0 );
5634 setPreferenceProperty( wv, "max", 1.0 );
5635 setPreferenceProperty( hv, "min", 0.0 );
5636 setPreferenceProperty( hv, "max", 1.0 );
5637 setPreferenceProperty( hv, "step", 0.1 );
5639 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5640 setPreferenceProperty( posHSizeGr, "columns", 2 );
5641 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5642 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5643 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5644 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5645 setPreferenceProperty( xv, "min", 0.0 );
5646 setPreferenceProperty( xv, "max", 1.0 );
5647 setPreferenceProperty( xv, "step", 0.1 );
5648 setPreferenceProperty( xh, "min", 0.0 );
5649 setPreferenceProperty( xh, "max", 1.0 );
5650 setPreferenceProperty( xh, "step", 0.1 );
5651 setPreferenceProperty( yh, "min", 0.0 );
5652 setPreferenceProperty( yh, "max", 1.0 );
5653 setPreferenceProperty( yh, "step", 0.1 );
5654 setPreferenceProperty( wh, "min", 0.0 );
5655 setPreferenceProperty( wh, "max", 1.0 );
5656 setPreferenceProperty( wh, "step", 0.1 );
5657 setPreferenceProperty( hh, "min", 0.0 );
5658 setPreferenceProperty( hh, "max", 1.0 );
5659 setPreferenceProperty( hh, "step", 0.1 );
5661 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5662 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5663 setPreferenceProperty( distributionGr, "columns", 3 );
5665 types.append( tr( "SMESH_MONOCOLOR" ) );
5666 types.append( tr( "SMESH_MULTICOLOR" ) );
5667 indices.clear(); indices.append( 0 ); indices.append( 1 );
5668 setPreferenceProperty( coloringType, "strings", types );
5669 setPreferenceProperty( coloringType, "indexes", indices );
5670 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5674 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5676 if ( sect=="SMESH" ) {
5677 float sbX1 = 0.01, sbY1 = 0.01, sbW = 0.08, sbH = 0.08;
5678 float aTol = 1.00000009999999;
5679 std::string aWarning;
5680 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5682 if ( name == "selection_object_color" ||
5683 name == "selection_element_color" ||
5684 name == "highlight_color" ||
5685 name == "selection_precision_node" ||
5686 name == "selection_precision_element" ||
5687 name == "selection_precision_object" ||
5688 name == "selection_increment")
5690 SMESH::UpdateSelectionProp( this );
5692 else if (name == "scalar_bar_vertical_x" || name == "scalar_bar_vertical_width")
5694 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5695 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5696 if ( sbX1+sbW > aTol ) {
5697 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5700 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5701 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5704 else if (name == "scalar_bar_vertical_y" || name == "scalar_bar_vertical_height" )
5706 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5707 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5708 if ( sbY1 + sbH > aTol ) {
5709 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5710 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5711 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5714 else if (name == "scalar_bar_horizontal_x" || name == "scalar_bar_horizontal_width")
5716 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5717 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5718 if ( sbX1 + sbW > aTol ) {
5719 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5722 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5723 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5726 else if (name == "scalar_bar_horizontal_y" || name == "scalar_bar_horizontal_height")
5728 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5729 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5730 if ( sbY1 + sbH > aTol ) {
5731 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5734 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5735 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5738 else if ( name == "segmentation" )
5740 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5741 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5743 else if ( name == "nb_segments_per_edge" )
5745 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5746 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5748 else if ( name == "historical_python_dump" || name == "forget_mesh_on_hyp_modif" || name == "default_grp_color" )
5750 QString val = aResourceMgr->stringValue( "SMESH", name );
5751 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5753 else if ( name == "numbering_node_color" || name == "numbering_node_font" )
5755 SMESH::UpdateFontProp( this );
5757 else if ( name == "numbering_elem_color" || name == "numbering_elem_font" )
5759 SMESH::UpdateFontProp( this );
5762 if ( aWarning.size() != 0 ) {
5763 aWarning += "The default values are applied instead.";
5764 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5765 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5766 QObject::tr(aWarning.c_str()));
5771 //================================================================================
5773 * \brief Update something in accordance with update flags
5774 * \param theFlags - update flags
5776 * Update viewer or/and object browser etc. in accordance with update flags ( see
5777 * LightApp_UpdateFlags enumeration ).
5779 //================================================================================
5780 void SMESHGUI::update( const int flags )
5782 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5783 SMESH::UpdateView();
5785 SalomeApp_Module::update( flags );
5788 //================================================================================
5790 * \brief Set default selection mode
5792 * SLOT called when operation committed. Sets default selection mode
5794 //================================================================================
5795 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5797 SVTK_ViewWindow* vtkWnd =
5798 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5800 vtkWnd->SetSelectionMode( ActorSelection );
5803 //================================================================================
5805 * \brief Set default selection mode
5807 * SLOT called when operation aborted. Sets default selection mode
5809 //================================================================================
5810 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5812 SVTK_ViewWindow* vtkWnd =
5813 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5815 vtkWnd->SetSelectionMode( ActorSelection );
5818 //================================================================================
5820 * \brief Creates operation with given identifier
5821 * \param id - identifier of operation to be started
5822 * \return Pointer on created operation or NULL if operation is not created
5824 * Virtual method redefined from the base class creates operation with given id.
5825 * It is called called automatically from startOperation method of base class.
5827 //================================================================================
5828 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5830 LightApp_Operation* op = 0;
5831 // to do : create operation here
5834 case SMESHOp::OpSplitBiQuadratic:
5835 op = new SMESHGUI_SplitBiQuadOp();
5837 case SMESHOp::OpConvertMeshToQuadratic:
5838 op = new SMESHGUI_ConvToQuadOp();
5840 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5841 op = new SMESHGUI_Make2DFrom3DOp();
5843 case SMESHOp::OpReorientFaces:
5844 op = new SMESHGUI_ReorientFacesOp();
5846 case SMESHOp::OpCreateMesh:
5847 op = new SMESHGUI_MeshOp( true, true );
5849 case SMESHOp::OpCreateSubMesh:
5850 op = new SMESHGUI_MeshOp( true, false );
5852 case SMESHOp::OpEditMeshOrSubMesh:
5853 case SMESHOp::OpEditMesh:
5854 case SMESHOp::OpEditSubMesh:
5855 op = new SMESHGUI_MeshOp( false );
5857 case SMESHOp::OpCompute:
5858 case SMESHOp::OpComputeSubMesh:
5859 op = new SMESHGUI_ComputeOp();
5861 case SMESHOp::OpPreCompute:
5862 op = new SMESHGUI_PrecomputeOp();
5864 case SMESHOp::OpEvaluate:
5865 op = new SMESHGUI_EvaluateOp();
5867 case SMESHOp::OpMeshOrder:
5868 op = new SMESHGUI_MeshOrderOp();
5870 case SMESHOp::OpCreateGeometryGroup:
5871 op = new SMESHGUI_GroupOnShapeOp();
5873 case SMESHOp::OpFindElementByPoint:
5874 op = new SMESHGUI_FindElemByPointOp();
5876 case SMESHOp::OpMoveNode: // Make mesh pass through point
5877 op = new SMESHGUI_MakeNodeAtPointOp();
5879 case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
5880 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5887 op = SalomeApp_Module::createOperation( id );
5891 //================================================================================
5893 * \brief Stops current operations and starts a given one
5894 * \param id - The id of the operation to start
5896 //================================================================================
5898 void SMESHGUI::switchToOperation(int id)
5900 activeStudy()->abortAllOperations();
5901 startOperation( id );
5904 LightApp_Displayer* SMESHGUI::displayer()
5907 myDisplayer = new SMESHGUI_Displayer( getApp() );
5911 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5914 int aTolerance = 64;
5915 int anIterations = 0;
5921 if( anIterations % aPeriod == 0 )
5924 if( aTolerance < 1 )
5928 aHue = (int)( 360.0 * rand() / RAND_MAX );
5931 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5932 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5933 for( ; it != itEnd; ++it )
5935 SALOMEDS::Color anAutoColor = *it;
5936 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5939 aQColor.getHsv( &h, &s, &v );
5940 if( abs( h - aHue ) < aTolerance )
5952 aColor.setHsv( aHue, 255, 255 );
5954 SALOMEDS::Color aSColor;
5955 aSColor.R = aColor.redF();
5956 aSColor.G = aColor.greenF();
5957 aSColor.B = aColor.blueF();
5962 const char* gSeparator = "_"; // character used to separate parameter names
5963 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5964 const char* gPathSep = "|"; // character used to separate paths
5967 * \brief Store visual parameters
5969 * This method is called just before the study document is saved.
5970 * Store visual parameters in AttributeParameter attribute(s)
5972 void SMESHGUI::storeVisualParameters (int savePoint)
5975 Kernel_Utils::Localizer loc;
5977 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5978 if (!appStudy || !appStudy->studyDS())
5980 _PTR(Study) studyDS = appStudy->studyDS();
5982 // componentName is used for encoding of entries when storing them in IParameters
5983 std::string componentName = myComponentSMESH->ComponentDataType();
5984 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5985 //if (!aSComponent) return;
5988 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5989 componentName.c_str(),
5991 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5993 // store custom markers
5994 if( !myMarkerMap.empty() )
5996 VTK::MarkerMap::const_iterator anIter = myMarkerMap.begin();
5997 for( ; anIter != myMarkerMap.end(); anIter++ )
5999 int anId = anIter->first;
6000 VTK::MarkerData aMarkerData = anIter->second;
6001 std::string aMarkerFileName = aMarkerData.first;
6002 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
6003 if( aMarkerTexture.size() < 3 )
6004 continue; // should contain at least width, height and the first value
6006 QString aPropertyName( "texture" );
6007 aPropertyName += gSeparator;
6008 aPropertyName += QString::number( anId );
6010 QString aPropertyValue = aMarkerFileName.c_str();
6011 aPropertyValue += gPathSep;
6013 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
6014 ushort aWidth = *aTextureIter++;
6015 ushort aHeight = *aTextureIter++;
6016 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
6017 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
6018 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
6019 aPropertyValue += QString::number( *aTextureIter );
6021 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
6025 // viewers counters are used for storing view_numbers in IParameters
6028 // main cycle to store parameters of displayed objects
6029 QList<SUIT_ViewManager*> lst;
6030 QList<SUIT_ViewManager*>::Iterator it;
6031 getApp()->viewManagers(lst);
6032 for (it = lst.begin(); it != lst.end(); it++)
6034 SUIT_ViewManager* vman = *it;
6035 QString vType = vman->getType();
6037 // saving VTK actors properties
6038 if (vType == SVTK_Viewer::Type())
6040 // store the clipping planes attached to the view manager
6041 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
6042 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
6043 if( anIter != myClippingPlaneInfoMap.end() )
6044 aClippingPlaneInfoList = anIter->second;
6046 if( !aClippingPlaneInfoList.empty() ) {
6047 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
6048 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
6050 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
6051 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
6053 QString aPropertyName( "ClippingPlane" );
6054 aPropertyName += gSeparator;
6055 aPropertyName += QString::number( vtkViewers );
6056 aPropertyName += gSeparator;
6057 aPropertyName += QString::number( anId );
6059 QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
6060 aPropertyValue += gDigitsSep;
6061 aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
6062 aPropertyValue += gDigitsSep;
6063 if ( aPlane->PlaneMode == SMESH::Absolute ) {
6064 aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
6065 aPropertyValue += gDigitsSep;
6066 aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
6067 aPropertyValue += gDigitsSep;
6068 aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
6069 aPropertyValue += gDigitsSep;
6070 aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
6071 aPropertyValue += gDigitsSep;
6072 aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
6073 aPropertyValue += gDigitsSep;
6074 aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
6075 aPropertyValue += gDigitsSep;
6076 aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
6078 else if ( aPlane->PlaneMode == SMESH::Relative ) {
6079 aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
6080 aPropertyValue += gDigitsSep;
6081 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
6082 aPropertyValue += gDigitsSep;
6083 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
6084 aPropertyValue += gDigitsSep;
6085 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
6088 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
6092 QVector<SUIT_ViewWindow*> views = vman->getViews();
6093 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
6095 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
6097 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
6098 vtkActorCollection* allActors = aCopy.GetActors();
6099 allActors->InitTraversal();
6100 while (vtkActor* actor = allActors->GetNextActor())
6102 if (actor->GetVisibility()) // store only visible actors
6104 SMESH_Actor* aSmeshActor = 0;
6105 if (actor->IsA("SMESH_Actor"))
6106 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
6107 if (aSmeshActor && aSmeshActor->hasIO())
6109 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
6112 // entry is "encoded" = it does NOT contain component address,
6113 // since it is a subject to change on next component loading
6114 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
6116 std::string param, vtkParam = vType.toLatin1().data();
6117 vtkParam += gSeparator;
6118 vtkParam += QString::number(vtkViewers).toLatin1().data();
6119 vtkParam += gSeparator;
6122 param = vtkParam + "Visibility";
6123 ip->setParameter(entry, param, "On");
6126 param = vtkParam + "Representation";
6127 ip->setParameter(entry, param, QString::number
6128 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
6131 param = vtkParam + "IsShrunk";
6132 ip->setParameter(entry, param, QString::number
6133 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
6135 // Displayed entities
6136 unsigned int aMode = aSmeshActor->GetEntityMode();
6137 bool isE = aMode & SMESH_Actor::eEdges;
6138 bool isF = aMode & SMESH_Actor::eFaces;
6139 bool isV = aMode & SMESH_Actor::eVolumes;
6140 bool is0d = aMode & SMESH_Actor::e0DElements;
6141 bool isB = aMode & SMESH_Actor::eBallElem;
6143 QString modeStr ("e");
6144 modeStr += gDigitsSep; modeStr += QString::number(isE);
6145 modeStr += gDigitsSep; modeStr += "f";
6146 modeStr += gDigitsSep; modeStr += QString::number(isF);
6147 modeStr += gDigitsSep; modeStr += "v";
6148 modeStr += gDigitsSep; modeStr += QString::number(isV);
6149 modeStr += gDigitsSep; modeStr += "0d";
6150 modeStr += gDigitsSep; modeStr += QString::number(is0d);
6151 modeStr += gDigitsSep; modeStr += "b";
6152 modeStr += gDigitsSep; modeStr += QString::number(isB);
6154 param = vtkParam + "Entities";
6155 ip->setParameter(entry, param, modeStr.toLatin1().data());
6161 aSmeshActor->GetSufaceColor(r, g, b, delta);
6162 QStringList colorStr;
6163 colorStr << "surface";
6164 colorStr << QString::number(r);
6165 colorStr << QString::number(g);
6166 colorStr << QString::number(b);
6168 colorStr << "backsurface";
6169 colorStr << QString::number(delta);
6171 aSmeshActor->GetVolumeColor(r, g, b, delta);
6172 colorStr << "volume";
6173 colorStr << QString::number(r);
6174 colorStr << QString::number(g);
6175 colorStr << QString::number(b);
6176 colorStr << QString::number(delta);
6178 aSmeshActor->GetEdgeColor(r, g, b);
6180 colorStr << QString::number(r);
6181 colorStr << QString::number(g);
6182 colorStr << QString::number(b);
6184 aSmeshActor->GetNodeColor(r, g, b);
6186 colorStr << QString::number(r);
6187 colorStr << QString::number(g);
6188 colorStr << QString::number(b);
6190 aSmeshActor->GetOutlineColor(r, g, b);
6191 colorStr << "outline";
6192 colorStr << QString::number(r);
6193 colorStr << QString::number(g);
6194 colorStr << QString::number(b);
6196 aSmeshActor->Get0DColor(r, g, b);
6197 colorStr << "elem0d";
6198 colorStr << QString::number(r);
6199 colorStr << QString::number(g);
6200 colorStr << QString::number(b);
6202 aSmeshActor->GetBallColor(r, g, b);
6204 colorStr << QString::number(r);
6205 colorStr << QString::number(g);
6206 colorStr << QString::number(b);
6208 aSmeshActor->GetFacesOrientationColor(r, g, b);
6209 colorStr << "orientation";
6210 colorStr << QString::number(r);
6211 colorStr << QString::number(g);
6212 colorStr << QString::number(b);
6214 param = vtkParam + "Colors";
6215 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
6218 QStringList sizeStr;
6220 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
6221 sizeStr << "outline";
6222 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
6223 sizeStr << "elem0d";
6224 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
6226 //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
6227 sizeStr << QString::number((double)aSmeshActor->GetBallSize());
6228 sizeStr << QString::number((double)aSmeshActor->GetBallScale());
6229 sizeStr << "shrink";
6230 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
6231 sizeStr << "orientation";
6232 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
6233 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
6235 param = vtkParam + "Sizes";
6236 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
6241 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
6242 if( aMarkerType == VTK::MT_USER ) {
6243 markerStr += "custom";
6244 markerStr += gDigitsSep;
6245 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
6249 markerStr += gDigitsSep;
6250 markerStr += QString::number( (int)aMarkerType );
6251 markerStr += gDigitsSep;
6252 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
6255 param = vtkParam + "PointMarker";
6256 ip->setParameter(entry, param, markerStr.toLatin1().data());
6259 param = vtkParam + "Opacity";
6260 ip->setParameter(entry, param,
6261 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
6264 param = vtkParam + "ClippingPlane";
6266 if( !aClippingPlaneInfoList.empty() ) {
6267 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
6268 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
6270 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
6271 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
6272 SMESH::TActorList::iterator anIter2 = anActorList.begin();
6273 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
6274 if( aSmeshActor == *anIter2 ) {
6275 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
6276 QString::number( anId ).toLatin1().constData() );
6283 ip->setParameter( entry, param, "Off" );
6284 } // if (io->hasEntry())
6285 } // SMESH_Actor && hasIO
6287 } // while.. actors traversal
6291 } // if (SVTK view model)
6292 } // for (viewManagers)
6295 // data structures for clipping planes processing
6299 bool isOpenGLClipping;
6300 vtkIdType RelativeOrientation;
6303 int AbsoluteOrientation;
6304 double X, Y, Z, Dx, Dy, Dz;
6306 typedef std::list<TPlaneData> TPlaneDataList;
6307 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
6309 typedef std::list<vtkActor*> TActorList;
6312 TActorList ActorList;
6313 SUIT_ViewManager* ViewManager;
6315 typedef std::list<TPlaneInfo> TPlaneInfoList;
6316 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
6319 * \brief Restore visual parameters
6321 * This method is called after the study document is opened.
6322 * Restore visual parameters from AttributeParameter attribute(s)
6324 void SMESHGUI::restoreVisualParameters (int savePoint)
6327 Kernel_Utils::Localizer loc;
6329 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6330 if (!appStudy || !appStudy->studyDS())
6332 _PTR(Study) studyDS = appStudy->studyDS();
6334 // componentName is used for encoding of entries when storing them in IParameters
6335 std::string componentName = myComponentSMESH->ComponentDataType();
6338 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6339 componentName.c_str(),
6341 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6343 // restore custom markers and map of clipping planes
6344 TPlaneDataMap aPlaneDataMap;
6346 std::vector<std::string> properties = ip->getProperties();
6347 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
6349 std::string property = *propIt;
6350 QString aPropertyName( property.c_str() );
6351 QString aPropertyValue( ip->getProperty( property ).c_str() );
6353 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
6354 if( aPropertyNameList.isEmpty() )
6357 QString aPropertyType = aPropertyNameList[0];
6358 if( aPropertyType == "texture" )
6360 if( aPropertyNameList.size() != 2 )
6364 int anId = aPropertyNameList[1].toInt( &ok );
6365 if( !ok || anId < 1 )
6368 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
6369 if( aPropertyValueList.size() != 2 )
6372 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
6373 QString aMarkerTextureString = aPropertyValueList[1];
6374 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
6375 if( aMarkerTextureStringList.size() != 3 )
6379 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6384 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6388 VTK::MarkerTexture aMarkerTexture;
6389 aMarkerTexture.push_back( aWidth );
6390 aMarkerTexture.push_back( aHeight );
6392 QString aMarkerTextureData = aMarkerTextureStringList[2];
6393 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6395 QChar aChar = aMarkerTextureData.at( i );
6396 if( aChar.isDigit() )
6397 aMarkerTexture.push_back( aChar.digitValue() );
6400 myMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6402 else if( aPropertyType == "ClippingPlane" )
6404 if( aPropertyNameList.size() != 3 )
6408 int aViewId = aPropertyNameList[1].toInt( &ok );
6409 if( !ok || aViewId < 0 )
6413 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6414 if( !ok || aClippingPlaneId < 0 )
6417 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6418 if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6421 TPlaneData aPlaneData;
6422 aPlaneData.AbsoluteOrientation = false;
6423 aPlaneData.RelativeOrientation = 0;
6424 aPlaneData.Distance = aPlaneData.Angle[0] = aPlaneData.Angle[1] = 0;
6425 aPlaneData.X = aPlaneData.Y = aPlaneData.Z = 0;
6426 aPlaneData.Dx = aPlaneData.Dy = aPlaneData.Dz = 0;
6428 aPlaneData.Id = aClippingPlaneId;
6431 aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6436 aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6440 if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6443 aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6448 aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6453 aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6458 aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6463 aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6468 aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6473 aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6477 else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6479 aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6484 aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6489 aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6494 aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6499 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6500 aPlaneDataList.push_back( aPlaneData );
6504 TPlaneInfoMap aPlaneInfoMap;
6506 std::vector<std::string> entries = ip->getEntries();
6508 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6510 // entry is a normal entry - it should be "decoded" (setting base address of component)
6511 QString entry (ip->decodeEntry(*entIt).c_str());
6513 // Check that the entry corresponds to a real object in the Study
6514 // as the object may be deleted or modified after the visual state is saved.
6515 _PTR(SObject) so = studyDS->FindObjectID(entry.toUtf8().data());
6516 if (!so) continue; //Skip the not existent entry
6518 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6519 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6521 std::vector<std::string>::iterator namesIt = paramNames.begin();
6522 std::vector<std::string>::iterator valuesIt = paramValues.begin();
6524 // actors are stored in a map after displaying of them for
6525 // quicker access in the future: map < viewID to actor >
6526 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6528 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6530 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6531 // '_' is used as separator and should not be used in viewer type or parameter names.
6532 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6533 if (lst.size() != 3)
6536 QString viewerTypStr = lst[0];
6537 QString viewIndexStr = lst[1];
6538 QString paramNameStr = lst[2];
6541 int viewIndex = viewIndexStr.toUInt(&ok);
6542 if (!ok) // bad conversion of view index to integer
6546 if (viewerTypStr == SVTK_Viewer::Type())
6548 SMESH_Actor* aSmeshActor = 0;
6549 if (vtkActors.IsBound(viewIndex))
6550 aSmeshActor = vtkActors.Find(viewIndex);
6552 QList<SUIT_ViewManager*> lst;
6553 getApp()->viewManagers(viewerTypStr, lst);
6555 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6556 SUIT_ViewManager* vman = NULL;
6557 if (viewIndex >= 0 && viewIndex < lst.count())
6558 vman = lst.at(viewIndex);
6560 if (paramNameStr == "Visibility")
6562 if (!aSmeshActor && displayer() && vman)
6564 SUIT_ViewModel* vmodel = vman->getViewModel();
6565 // SVTK view model can be casted to SALOME_View
6566 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6568 // store displayed actor in a temporary map for quicker
6569 // access later when restoring other parameters
6570 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6571 vtkRenderer* Renderer = vtkView->getRenderer();
6572 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6573 vtkActorCollection* theActors = aCopy.GetActors();
6574 theActors->InitTraversal();
6575 bool isFound = false;
6576 vtkActor *ac = theActors->GetNextActor();
6577 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6578 if (ac->IsA("SMESH_Actor")) {
6579 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6580 if (aGeomAc->hasIO()) {
6581 Handle(SALOME_InteractiveObject) io = aGeomAc->getIO();
6582 if (io->hasEntry() && strcmp(io->getEntry(), entry.toUtf8().data()) == 0) {
6584 vtkActors.Bind(viewIndex, aGeomAc);
6590 } // if (paramNameStr == "Visibility")
6593 // the rest properties "work" with SMESH_Actor
6596 QString val ((*valuesIt).c_str());
6599 if (paramNameStr == "Representation") {
6600 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6603 else if (paramNameStr == "IsShrunk") {
6605 if (!aSmeshActor->IsShrunk())
6606 aSmeshActor->SetShrink();
6609 if (aSmeshActor->IsShrunk())
6610 aSmeshActor->UnShrink();
6613 // Displayed entities
6614 else if (paramNameStr == "Entities") {
6615 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6616 int aEntityMode = SMESH_Actor::eAllEntity;
6617 for ( int i = 0; i < mode.count(); i+=2 ) {
6618 if ( i < mode.count()-1 ) {
6619 QString type = mode[i];
6620 bool val = mode[i+1].toInt();
6621 if ( type == "e" && !val )
6622 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6623 else if ( type == "f" && !val )
6624 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6625 else if ( type == "v" && !val )
6626 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6627 else if ( type == "0d" && !val )
6628 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6629 else if ( type == "b" && !val )
6630 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6633 aSmeshActor->SetEntityMode( aEntityMode );
6636 else if (paramNameStr == "Colors") {
6637 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6644 QColor outlineColor;
6645 QColor orientationColor;
6651 // below lines are required to get default values for delta coefficients
6652 // of backface color for faces and color of reversed volumes
6653 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
6654 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6655 for ( int i = 0; i < colors.count(); i++ ) {
6656 QString type = colors[i];
6657 if ( type == "surface" ) {
6658 // face color is set by 3 values r:g:b, where
6659 // - r,g,b - is rgb color components
6660 if ( i+1 >= colors.count() ) break; // format error
6661 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6662 if ( i+2 >= colors.count() ) break; // format error
6663 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6664 if ( i+3 >= colors.count() ) break; // format error
6665 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6666 faceColor.setRgbF( r, g, b );
6669 else if ( type == "backsurface" ) {
6670 // backface color can be defined in several ways
6671 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6672 // - in latest versions, it is set as delta coefficient
6673 bool rgbOk = false, deltaOk;
6674 if ( i+1 >= colors.count() ) break; // format error
6675 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6676 int delta = colors[i+1].toInt( &deltaOk );
6678 if ( i+1 < colors.count() ) // index is shifted to 1
6679 g = colors[i+1].toDouble( &rgbOk );
6680 if ( rgbOk ) i++; // shift index
6681 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6682 b = colors[i+1].toDouble( &rgbOk );
6684 // - as currently there's no way to set directly backsurface color as it was before,
6685 // we ignore old dump where r,g,b triple was set
6686 // - also we check that delta parameter is set properly
6687 if ( !rgbOk && deltaOk )
6690 else if ( type == "volume" ) {
6691 // volume color is set by 4 values r:g:b:delta, where
6692 // - r,g,b - is a normal volume rgb color components
6693 // - delta - is a reversed volume color delta coefficient
6694 if ( i+1 >= colors.count() ) break; // format error
6695 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6696 if ( i+2 >= colors.count() ) break; // format error
6697 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6698 if ( i+3 >= colors.count() ) break; // format error
6699 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6700 if ( i+4 >= colors.count() ) break; // format error
6701 int delta = colors[i+4].toInt( &bOk );
6702 if ( !bOk ) break; // format error
6703 volumeColor.setRgbF( r, g, b );
6707 else if ( type == "edge" ) {
6708 // edge color is set by 3 values r:g:b, where
6709 // - r,g,b - is rgb color components
6710 if ( i+1 >= colors.count() ) break; // format error
6711 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6712 if ( i+2 >= colors.count() ) break; // format error
6713 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6714 if ( i+3 >= colors.count() ) break; // format error
6715 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6716 edgeColor.setRgbF( r, g, b );
6719 else if ( type == "node" ) {
6720 // node color is set by 3 values r:g:b, where
6721 // - r,g,b - is rgb color components
6722 if ( i+1 >= colors.count() ) break; // format error
6723 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6724 if ( i+2 >= colors.count() ) break; // format error
6725 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6726 if ( i+3 >= colors.count() ) break; // format error
6727 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6728 nodeColor.setRgbF( r, g, b );
6731 else if ( type == "elem0d" ) {
6732 // 0d element color is set by 3 values r:g:b, where
6733 // - r,g,b - is rgb color components
6734 if ( i+1 >= colors.count() ) break; // format error
6735 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6736 if ( i+2 >= colors.count() ) break; // format error
6737 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6738 if ( i+3 >= colors.count() ) break; // format error
6739 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6740 elem0dColor.setRgbF( r, g, b );
6743 else if ( type == "ball" ) {
6744 // ball color is set by 3 values r:g:b, where
6745 // - r,g,b - is rgb color components
6746 if ( i+1 >= colors.count() ) break; // format error
6747 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6748 if ( i+2 >= colors.count() ) break; // format error
6749 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6750 if ( i+3 >= colors.count() ) break; // format error
6751 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6752 ballColor.setRgbF( r, g, b );
6755 else if ( type == "outline" ) {
6756 // outline color is set by 3 values r:g:b, where
6757 // - r,g,b - is rgb color components
6758 if ( i+1 >= colors.count() ) break; // format error
6759 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6760 if ( i+2 >= colors.count() ) break; // format error
6761 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6762 if ( i+3 >= colors.count() ) break; // format error
6763 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6764 outlineColor.setRgbF( r, g, b );
6767 else if ( type == "orientation" ) {
6768 // orientation color is set by 3 values r:g:b, where
6769 // - r,g,b - is rgb color components
6770 if ( i+1 >= colors.count() ) break; // format error
6771 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6772 if ( i+2 >= colors.count() ) break; // format error
6773 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6774 if ( i+3 >= colors.count() ) break; // format error
6775 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6776 orientationColor.setRgbF( r, g, b );
6781 if ( nodeColor.isValid() )
6782 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6784 if ( edgeColor.isValid() )
6785 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6787 if ( faceColor.isValid() )
6788 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6790 if ( volumeColor.isValid() )
6791 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6792 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6793 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6795 if ( elem0dColor.isValid() )
6796 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6798 if ( ballColor.isValid() )
6799 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6801 if ( outlineColor.isValid() )
6802 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6803 // orientation color
6804 if ( orientationColor.isValid() )
6805 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6808 else if (paramNameStr == "Sizes") {
6809 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6812 int outlineWidth = -1;
6813 int elem0dSize = -1;
6814 //int ballSize = -1;
6815 double ballDiameter = -1.0;
6816 double ballScale = -1.0;
6817 double shrinkSize = -1;
6818 double orientationSize = -1;
6819 bool orientation3d = false;
6820 for ( int i = 0; i < sizes.count(); i++ ) {
6821 QString type = sizes[i];
6822 if ( type == "line" ) {
6823 // line (wireframe) width is given as single integer value
6824 if ( i+1 >= sizes.count() ) break; // format error
6825 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6829 if ( type == "outline" ) {
6830 // outline width is given as single integer value
6831 if ( i+1 >= sizes.count() ) break; // format error
6832 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6836 else if ( type == "elem0d" ) {
6837 // 0d element size is given as single integer value
6838 if ( i+1 >= sizes.count() ) break; // format error
6839 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6843 else if ( type == "ball" ) {
6844 // balls are specified by two values: size:scale, where
6845 // - size - is a integer value specifying size
6846 // - scale - is a double value specifying scale factor
6847 if ( i+1 >= sizes.count() ) break; // format error
6848 //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6849 double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6850 if ( i+2 >= sizes.count() ) break; // format error
6851 double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6857 else if ( type == "shrink" ) {
6858 // shrink factor is given as single floating point value
6859 if ( i+1 >= sizes.count() ) break; // format error
6860 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6864 else if ( type == "orientation" ) {
6865 // orientation vectors are specified by two values size:3d, where
6866 // - size - is a floating point value specifying scale factor
6867 // - 3d - is a boolean
6868 if ( i+1 >= sizes.count() ) break; // format error
6869 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6870 if ( i+2 >= sizes.count() ) break; // format error
6871 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6872 orientationSize = v1;
6873 orientation3d = (bool)v2;
6877 // line (wireframe) width
6878 if ( lineWidth > 0 )
6879 aSmeshActor->SetLineWidth( lineWidth );
6881 if ( outlineWidth > 0 )
6882 aSmeshActor->SetOutlineWidth( outlineWidth );
6883 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6884 aSmeshActor->SetOutlineWidth( lineWidth );
6886 if ( elem0dSize > 0 )
6887 aSmeshActor->Set0DSize( elem0dSize );
6889 /*if ( ballSize > 0 )
6890 aSmeshActor->SetBallSize( ballSize );*/
6892 if ( ballDiameter > 0 )
6893 aSmeshActor->SetBallSize( ballDiameter );
6895 if ( ballScale > 0.0 )
6896 aSmeshActor->SetBallScale( ballScale );
6898 if ( shrinkSize > 0 )
6899 aSmeshActor->SetShrinkFactor( shrinkSize );
6900 // orientation vectors
6901 if ( orientationSize > 0 ) {
6902 aSmeshActor->SetFacesOrientationScale( orientationSize );
6903 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6907 else if (paramNameStr == "PointMarker") {
6908 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6909 if( data.count() >= 2 ) {
6911 int aParam1 = data[1].toInt( &ok );
6913 if( data[0] == "std" && data.count() == 3 ) {
6914 int aParam2 = data[2].toInt( &ok );
6915 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6917 else if( data[0] == "custom" ) {
6918 VTK::MarkerMap::const_iterator markerIt = myMarkerMap.find( aParam1 );
6919 if( markerIt != myMarkerMap.end() ) {
6920 VTK::MarkerData aMarkerData = markerIt->second;
6921 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6928 else if (paramNameStr == "Opacity") {
6929 aSmeshActor->SetOpacity(val.toFloat());
6932 else if (paramNameStr.startsWith("ClippingPlane")) {
6933 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6934 // old format - val looks like "Off" or "1:0:0:0.5:0:0"
6935 // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
6936 // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
6937 // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
6938 // new format - val looks like "Off" or "0" (plane id)
6939 // (note: in new format "Off" value is used only for consistency,
6940 // so it is processed together with values in old format)
6941 bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
6942 if( anIsOldFormat ) {
6943 if (paramNameStr == "ClippingPlane1" || val == "Off")
6944 aSmeshActor->RemoveAllClippingPlanes();
6946 QList<SUIT_ViewManager*> lst;
6947 getApp()->viewManagers(viewerTypStr, lst);
6948 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6949 if (viewIndex >= 0 && viewIndex < lst.count()) {
6950 SUIT_ViewManager* vman = lst.at(viewIndex);
6951 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6953 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6955 SMESH::TActorList anActorList;
6956 anActorList.push_back( aSmeshActor );
6957 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
6958 aPlane->myViewWindow = vtkView;
6959 SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
6960 aPlane->PlaneMode = aMode;
6961 bool isOpenGLClipping = ( bool )vals[1].toInt();
6962 aPlane->IsOpenGLClipping = isOpenGLClipping;
6963 if ( aMode == SMESH::Absolute ) {
6964 aPlane->myAbsoluteOrientation = vals[2].toInt();
6965 aPlane->X = vals[3].toFloat();
6966 aPlane->Y = vals[4].toFloat();
6967 aPlane->Z = vals[5].toFloat();
6968 aPlane->Dx = vals[6].toFloat();
6969 aPlane->Dy = vals[7].toFloat();
6970 aPlane->Dz = vals[8].toFloat();
6972 else if ( aMode == SMESH::Relative ) {
6973 aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
6974 aPlane->myDistance = vals[3].toFloat();
6975 aPlane->myAngle[0] = vals[4].toFloat();
6976 aPlane->myAngle[1] = vals[5].toFloat();
6980 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6981 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6982 aClippingPlaneInfo.Plane = aPlane;
6983 aClippingPlaneInfo.ActorList = anActorList;
6984 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6992 int aPlaneId = val.toInt( &ok );
6993 if( ok && aPlaneId >= 0 ) {
6994 bool anIsDefinedPlane = false;
6995 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6996 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6997 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6998 TPlaneInfo& aPlaneInfo = *anIter;
6999 if( aPlaneInfo.PlaneId == aPlaneId ) {
7000 aPlaneInfo.ActorList.push_back( aSmeshActor );
7001 anIsDefinedPlane = true;
7005 if( !anIsDefinedPlane ) {
7006 TPlaneInfo aPlaneInfo;
7007 aPlaneInfo.PlaneId = aPlaneId;
7008 aPlaneInfo.ActorList.push_back( aSmeshActor );
7009 aPlaneInfo.ViewManager = vman;
7011 // to make the list sorted by plane id
7012 anIter = aPlaneInfoList.begin();
7013 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
7014 const TPlaneInfo& aPlaneInfoRef = *anIter;
7015 if( aPlaneInfoRef.PlaneId > aPlaneId )
7018 aPlaneInfoList.insert( anIter, aPlaneInfo );
7023 } // if (aSmeshActor)
7024 } // other parameters than Visibility
7026 } // for names/parameters iterator
7027 } // for entries iterator
7029 // take into account planes with empty list of actors referred to them
7030 QList<SUIT_ViewManager*> aVMList;
7031 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
7033 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
7034 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
7035 int aViewId = aPlaneDataIter->first;
7036 if( aViewId >= 0 && aViewId < aVMList.count() ) {
7037 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
7039 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
7041 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
7042 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
7043 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
7044 const TPlaneData& aPlaneData = *anIter2;
7045 int aPlaneId = aPlaneData.Id;
7047 bool anIsFound = false;
7048 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
7049 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
7050 const TPlaneInfo& aPlaneInfo = *anIter3;
7051 if( aPlaneInfo.PlaneId == aPlaneId ) {
7058 TPlaneInfo aPlaneInfo; // ActorList field is empty
7059 aPlaneInfo.PlaneId = aPlaneId;
7060 aPlaneInfo.ViewManager = aViewManager;
7062 // to make the list sorted by plane id
7063 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
7064 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
7065 const TPlaneInfo& aPlaneInfoRef = *anIter4;
7066 if( aPlaneInfoRef.PlaneId > aPlaneId )
7069 aPlaneInfoList.insert( anIter4, aPlaneInfo );
7075 // add clipping planes to actors according to the restored parameters
7076 // and update the clipping plane map
7077 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
7078 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
7079 int aViewId = anIter1->first;
7080 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
7082 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
7083 if( anIter2 == aPlaneDataMap.end() )
7085 const TPlaneDataList& aPlaneDataList = anIter2->second;
7087 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
7088 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
7089 const TPlaneInfo& aPlaneInfo = *anIter3;
7090 int aPlaneId = aPlaneInfo.PlaneId;
7091 const TActorList& anActorList = aPlaneInfo.ActorList;
7092 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
7096 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
7100 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
7102 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
7103 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
7104 const TPlaneData& aPlaneData = *anIter4;
7105 if( aPlaneData.Id == aPlaneId ) {
7106 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
7107 aPlane->myViewWindow = aViewWindow;
7108 aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
7109 aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
7110 if ( aPlane->PlaneMode == SMESH::Absolute ) {
7111 aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
7112 aPlane->X = aPlaneData.X;
7113 aPlane->Y = aPlaneData.Y;
7114 aPlane->Z = aPlaneData.Z;
7115 aPlane->Dx = aPlaneData.Dx;
7116 aPlane->Dy = aPlaneData.Dy;
7117 aPlane->Dz = aPlaneData.Dz;
7119 else if ( aPlane->PlaneMode == SMESH::Relative ) {
7120 aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
7121 aPlane->myDistance = aPlaneData.Distance;
7122 aPlane->myAngle[0] = aPlaneData.Angle[0];
7123 aPlane->myAngle[1] = aPlaneData.Angle[1];
7126 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
7127 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
7128 aClippingPlaneInfo.Plane = aPlane;
7129 aClippingPlaneInfo.ActorList = anActorList;
7130 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
7141 // update all VTK views
7142 QList<SUIT_ViewManager*> lst;
7143 getApp()->viewManagers(lst);
7144 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
7145 SUIT_ViewModel* vmodel = (*it)->getViewModel();
7146 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
7147 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
7148 // set OpenGL clipping planes
7149 VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
7150 vtkActorCollection* anAllActors = aCopy.GetActors();
7151 anAllActors->InitTraversal();
7152 while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
7153 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
7154 anActor->SetOpenGLClippingPlane();
7156 vtkView->getRenderer()->ResetCameraClippingRange();
7163 \brief Adds preferences for dfont of VTK viewer
7165 \param pIf group identifier
7166 \param param parameter
7167 \return identifier of preferences
7169 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
7171 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
7173 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
7176 fam.append( tr( "SMESH_FONT_ARIAL" ) );
7177 fam.append( tr( "SMESH_FONT_COURIER" ) );
7178 fam.append( tr( "SMESH_FONT_TIMES" ) );
7180 setPreferenceProperty( tfont, "fonts", fam );
7182 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
7183 if ( needSize ) f = f | QtxFontEdit::Size;
7184 setPreferenceProperty( tfont, "features", f );
7190 \brief Actions after hypothesis edition
7191 Updates object browser after hypothesis edition
7193 void SMESHGUI::onHypothesisEdit( int result )
7196 SMESHGUI::Modified();
7197 updateObjBrowser( true );
7201 \brief Actions after choosing menu of control modes
7202 Updates control mode actions according to current selection
7204 void SMESHGUI::onUpdateControlActions()
7206 SALOME_ListIO selected;
7207 if ( LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr() )
7208 aSel->selectedObjects( selected );
7210 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
7211 if ( selected.Extent() ) {
7212 if ( selected.First()->hasEntry() ) {
7213 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( selected.First()->getEntry() )) {
7214 aControl = anActor->GetControlMode();
7215 SALOME_ListIteratorOfListIO it(selected);
7216 for ( it.Next(); it.More(); it.Next() ) {
7217 Handle(SALOME_InteractiveObject) anIO = it.Value();
7218 if ( anIO->hasEntry() ) {
7219 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
7220 if ( aControl != anActor->GetControlMode() ) {
7221 aControl = SMESH_Actor::eNone;
7231 int anAction = ActionToControl( aControl, true );
7233 action( anAction )->setChecked( true );
7235 QMenu* send = (QMenu*)sender();
7236 QList<QAction*> actions = send->actions();
7237 for ( int i = 0; i < actions.size(); i++ )
7238 actions[i]->setChecked( false );
7244 \brief Signal handler closing(SUIT_ViewWindow*) of a view
7245 \param pview view being closed
7247 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
7248 #ifndef DISABLE_PLOT2DVIEWER
7249 //Crear all Plot2d Viewers if need.
7250 SMESH::ClearPlot2Viewers(pview);
7252 EmitSignalCloseView();
7255 void SMESHGUI::message( const QString& msg )
7258 QStringList data = msg.split("/");
7259 if ( data.count() > 0 ) {
7260 if ( data.first() == "mesh_loading" ) {
7262 QString entry = data.count() > 1 ? data[1] : QString();
7263 if ( entry.isEmpty() )
7266 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
7268 _PTR(SObject) obj = study->FindObjectID( entry.toUtf8().constData() );
7271 name = SMESH::fromUtf8(obj->GetName());
7272 if ( name.isEmpty() )
7275 if ( data.last() == "stop" )
7276 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
7278 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
7279 QApplication::processEvents();
7285 \brief Connects or disconnects signals about activating and cloning view on the module slots
7286 \param pview view which is connected/disconnected
7288 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
7292 SUIT_ViewManager* viewMgr = pview->getViewManager();
7294 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7295 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7297 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7298 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7303 \brief Return \c true if object can be renamed
7305 bool SMESHGUI::renameAllowed( const QString& entry) const {
7306 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7310 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7314 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
7319 if(appStudy->isComponent(entry) || obj->isReference())
7322 // check type to prevent renaming of inappropriate objects
7323 int aType = SMESHGUI_Selection::type(qPrintable(entry));
7324 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7325 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7326 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7327 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7328 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
7335 Rename object by entry.
7336 \param entry entry of the object
7337 \param name new name of the object
7338 \brief Return \c true if rename operation finished successfully, \c false otherwise.
7340 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
7342 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7346 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7351 _PTR(Study) aStudy = appStudy->studyDS();
7356 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
7358 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
7363 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
7364 _PTR(GenericAttribute) anAttr;
7365 _PTR(AttributeName) aName;
7367 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
7369 // check type to prevent renaming of inappropriate objects
7370 int aType = SMESHGUI_Selection::type( qPrintable(entry));
7371 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7372 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7373 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7374 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7375 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
7376 if ( !name.isEmpty() ) {
7377 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qUtf8Printable(name) );
7379 // update name of group object and its actor
7380 Handle(SALOME_InteractiveObject) IObject =
7381 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
7383 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
7384 if( !aGroupObject->_is_nil() ) {
7385 aGroupObject->SetName( qUtf8Printable(name) );
7386 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
7387 anActor->setName( qUtf8Printable(name) );
7397 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
7399 static QList<QColor> colors;
7401 if ( colors.isEmpty() ) {
7403 for (int s = 0; s < 2 ; s++)
7405 for (int v = 100; v >= 40; v = v - 20)
7407 for (int h = 0; h < 359 ; h = h + 60)
7409 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
7414 static int currentColor = randomize( colors.size() );
7416 SALOMEDS::Color color;
7417 color.R = (double)colors[currentColor].red() / 255.0;
7418 color.G = (double)colors[currentColor].green() / 255.0;
7419 color.B = (double)colors[currentColor].blue() / 255.0;
7421 currentColor = (currentColor+1) % colors.count();