1 // Copyright (C) 2007-2019 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_ControlsDef.hxx"
101 #include "SMESH_Actor.h"
102 #include "SMESH_ActorUtils.h"
103 #include "SMESH_Client.hxx"
104 #include "SMESH_ScalarBarActor.h"
105 #include <SMESH_Comment.hxx>
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("SMESH", It.Value()->getComponentDataType()) == 0 );
5074 return isCompatible;
5078 bool SMESHGUI::reusableOperation( const int id )
5080 // compute, evaluate and precompute are not reusable operations
5081 return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate ) ? false : SalomeApp_Module::reusableOperation( id );
5084 bool SMESHGUI::activateModule( SUIT_Study* study )
5086 bool res = SalomeApp_Module::activateModule( study );
5088 setMenuShown( true );
5089 setToolShown( true );
5091 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
5092 PyGILState_STATE gstate = PyGILState_Ensure();
5093 PyObject* pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
5094 if ( !pluginsmanager ) {
5098 PyObject* result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toUtf8().data(),tr("SMESH_PLUGINS_OTHER").toUtf8().data());
5103 PyGILState_Release(gstate);
5104 // end of SMESH plugins loading
5106 // Reset actions accelerator keys
5107 action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
5109 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
5110 GetSMESHGen()->UpdateStudy();
5112 // get all view currently opened in the study and connect their signals to
5113 // the corresponding slots of the class.
5114 SUIT_Desktop* aDesk = study->application()->desktop();
5116 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
5117 SUIT_ViewWindow* wnd;
5118 foreach ( wnd, wndList )
5122 // remove actors whose objects are removed in GetSMESHGen()->UpdateStudy()
5123 SMESH::UpdateActorsAfterUpdateStudy(wnd);
5129 Py_XDECREF(pluginsmanager);
5133 bool SMESHGUI::deactivateModule( SUIT_Study* study )
5135 setMenuShown( false );
5136 setToolShown( false );
5138 EmitSignalCloseAllDialogs();
5140 // Unset actions accelerator keys
5141 action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
5143 return SalomeApp_Module::deactivateModule( study );
5146 void SMESHGUI::studyClosed( SUIT_Study* s )
5150 SMESH::RemoveVisuData();
5151 SalomeApp_Module::studyClosed( s );
5154 void SMESHGUI::OnGUIEvent()
5156 const QObject* obj = sender();
5157 if ( !obj || !obj->inherits( "QAction" ) )
5159 int id = actionId((QAction*)obj);
5164 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
5166 if ( CORBA::is_nil( myComponentSMESH ) )
5168 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
5169 return aGUI.myComponentSMESH;
5171 return myComponentSMESH;
5174 QString SMESHGUI::engineIOR() const
5176 CORBA::ORB_var anORB = getApp()->orb();
5177 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
5178 return QString( anIOR.in() );
5181 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
5183 SalomeApp_Module::contextMenuPopup( client, menu, title );
5185 selectionMgr()->selectedObjects( lst );
5186 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
5187 Handle(SALOME_InteractiveObject) io = lst.First();
5188 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
5189 _PTR(Study) study = appStudy->studyDS();
5190 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
5192 QString aName = SMESH::fromUtf8( obj->GetName());
5193 while ( !aName.isEmpty() && aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
5194 aName.remove(( aName.length() - 1 ), 1 );
5200 LightApp_Selection* SMESHGUI::createSelection() const
5202 return new SMESHGUI_Selection();
5205 void SMESHGUI::windows( QMap<int, int>& aMap ) const
5207 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
5208 aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
5209 #ifndef DISABLE_PYCONSOLE
5210 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
5214 void SMESHGUI::viewManagers( QStringList& list ) const
5216 list.append( SVTK_Viewer::Type() );
5219 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
5221 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
5222 SMESH::UpdateSelectionProp( this );
5224 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
5225 for(int i = 0; i < aViews.count() ; i++){
5226 SUIT_ViewWindow *sf = aViews[i];
5229 EmitSignalActivatedViewManager();
5233 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
5235 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
5236 myClippingPlaneInfoMap.erase( theViewManager );
5239 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
5241 theActor->AddObserver( SMESH::DeleteActorEvent,
5242 myEventCallbackCommand.GetPointer(),
5246 void SMESHGUI::ProcessEvents( vtkObject* theObject,
5247 unsigned long theEvent,
5248 void* theClientData,
5251 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
5252 if( theObject && (int) theEvent == SMESH::DeleteActorEvent ) {
5253 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
5254 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
5255 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
5256 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
5257 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
5258 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
5259 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
5260 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
5261 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
5262 SMESH::TActorList::iterator anIter3 = anActorList.begin();
5263 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
5264 if( anActor == *anIter3 ) {
5265 anActorList.erase( anIter3 );
5276 void SMESHGUI::createPreferences()
5278 // General tab ------------------------------------------------------------------------
5279 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
5281 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
5282 setPreferenceProperty( autoUpdate, "columns", 2 );
5283 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
5284 setPreferenceProperty( lim, "min", 0 );
5285 setPreferenceProperty( lim, "max", 100000000 );
5286 setPreferenceProperty( lim, "step", 1000 );
5287 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5288 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
5290 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
5291 setPreferenceProperty( dispgroup, "columns", 2 );
5293 addPreference( tr( "PREF_FITALL_ON_DISPLAYONLY" ), dispgroup, LightApp_Preferences::Bool, "SMESH", "fitall_on_displayonly" );
5295 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
5297 modes.append( tr("MEN_WIRE") );
5298 modes.append( tr("MEN_SHADE") );
5299 modes.append( tr("MEN_NODES") );
5300 modes.append( tr("MEN_SHRINK") );
5301 QList<QVariant> indices;
5302 indices.append( 0 );
5303 indices.append( 1 );
5304 indices.append( 2 );
5305 indices.append( 3 );
5306 setPreferenceProperty( dispmode, "strings", modes );
5307 setPreferenceProperty( dispmode, "indexes", indices );
5309 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
5310 setPreferenceProperty( arcgroup, "columns", 2 );
5311 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
5312 QStringList quadraticModes;
5313 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
5314 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
5316 indices.append( 0 );
5317 indices.append( 1 );
5318 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
5319 setPreferenceProperty( quadraticmode, "indexes", indices );
5321 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
5322 "SMESH", "max_angle" );
5323 setPreferenceProperty( maxAngle, "min", 1 );
5324 setPreferenceProperty( maxAngle, "max", 90 );
5326 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
5327 setPreferenceProperty( qaGroup, "columns", 2 );
5328 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
5329 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
5330 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
5331 setPreferenceProperty( prec, "min", 0 );
5332 setPreferenceProperty( prec, "max", 100 );
5333 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
5334 setPreferenceProperty( doubleNodesTol, "precision", 10 );
5335 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
5336 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
5337 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
5340 int cinc = addPreference(tr("PREF_CONTROLS_INCREMENT"), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_increment");
5341 setPreferenceProperty( cinc, "min", 0 );
5342 setPreferenceProperty( cinc, "max", 5 );
5345 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
5346 setPreferenceProperty( exportgroup, "columns", 2 );
5347 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
5348 addPreference( tr( "PREF_SHOW_WARN" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "show_warning" );
5349 int zTol = addPreference( tr( "PREF_ZTOLERANCE" ), exportgroup, LightApp_Preferences::DblSpin, "SMESH", "med_ztolerance" );
5350 setPreferenceProperty( zTol, "precision", 10 );
5351 setPreferenceProperty( zTol, "min", 0.0000000001 );
5352 setPreferenceProperty( zTol, "max", 1000000.0 );
5353 setPreferenceProperty( zTol, "step", 1. );
5354 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
5356 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
5357 setPreferenceProperty( computeGroup, "columns", 2 );
5358 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
5360 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5361 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5362 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5364 indices.append( 0 );
5365 indices.append( 1 );
5366 indices.append( 2 );
5367 setPreferenceProperty( notifyMode, "strings", modes );
5368 setPreferenceProperty( notifyMode, "indexes", indices );
5370 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5371 setPreferenceProperty( infoGroup, "columns", 2 );
5372 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5374 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5375 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5377 indices.append( 0 );
5378 indices.append( 1 );
5379 setPreferenceProperty( elemInfo, "strings", modes );
5380 setPreferenceProperty( elemInfo, "indexes", indices );
5381 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5382 setPreferenceProperty( nodesLim, "min", 0 );
5383 setPreferenceProperty( nodesLim, "max", 10000000 );
5384 setPreferenceProperty( nodesLim, "step", 10000 );
5385 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5386 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5387 setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5388 setPreferenceProperty( ctrlLim, "min", 0 );
5389 setPreferenceProperty( ctrlLim, "max", 10000000 );
5390 setPreferenceProperty( ctrlLim, "step", 1000 );
5391 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5392 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5393 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5394 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5395 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5397 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5398 setPreferenceProperty( segGroup, "columns", 2 );
5399 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5400 "SMESH", "segmentation" );
5401 setPreferenceProperty( segLen, "min", 1 );
5402 setPreferenceProperty( segLen, "max", 10000000 );
5403 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5404 "SMESH", "nb_segments_per_edge" );
5405 setPreferenceProperty( nbSeg, "min", 1 );
5406 setPreferenceProperty( nbSeg, "max", 10000000 );
5407 addPreference( tr( "PREF_USE_MESHGEMS_HYPOSET" ), segGroup, LightApp_Preferences::Bool, "SMESH", "use-meshgems-hypo-sets" );
5409 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5410 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5411 "SMESH", "forget_mesh_on_hyp_modif" );
5414 // Quantities with individual precision settings
5415 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5416 setPreferenceProperty( precGroup, "columns", 2 );
5418 const int nbQuantities = 6;
5419 int precs[nbQuantities], ii = 0;
5420 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5421 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5422 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5423 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5424 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5425 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5426 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5427 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5428 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5429 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5430 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5431 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5433 // Set property for precision value for spinboxes
5434 for ( ii = 0; ii < nbQuantities; ii++ ){
5435 setPreferenceProperty( precs[ii], "min", -14 );
5436 setPreferenceProperty( precs[ii], "max", 14 );
5437 setPreferenceProperty( precs[ii], "precision", 2 );
5440 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5441 setPreferenceProperty( previewGroup, "columns", 2 );
5442 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5443 setPreferenceProperty( chunkSize, "min", 1 );
5444 setPreferenceProperty( chunkSize, "max", 1000 );
5445 setPreferenceProperty( chunkSize, "step", 50 );
5447 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5448 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5450 // Mesh tab ------------------------------------------------------------------------
5451 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5452 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5453 setPreferenceProperty( nodeGroup, "columns", 3 );
5455 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5457 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5459 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5460 QList<QVariant> aMarkerTypeIndicesList;
5461 QList<QVariant> aMarkerTypeIconsList;
5462 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5463 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5464 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5465 aMarkerTypeIndicesList << i;
5466 aMarkerTypeIconsList << pixmap;
5468 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5469 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
5471 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5473 QList<QVariant> aMarkerScaleIndicesList;
5474 QStringList aMarkerScaleValuesList;
5475 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5476 aMarkerScaleIndicesList << i;
5477 //aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5478 aMarkerScaleValuesList << QString::number( i );
5480 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5481 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5483 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5484 //setPreferenceProperty( elemGroup, "columns", 2 );
5486 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5487 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5488 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5489 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5490 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5491 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5492 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5493 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5494 addPreference( tr( "PREF_PREVIEW_COLOR" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5497 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5498 setPreferenceProperty( grpGroup, "columns", 2 );
5500 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5501 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5503 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5504 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5505 /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5506 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5507 double ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5508 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5509 double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5510 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5511 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
5512 LightApp_Preferences::IntSpin, "SMESH", "element_width");
5513 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5514 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5515 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5516 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5518 setPreferenceProperty( size0d, "min", 1 );
5519 setPreferenceProperty( size0d, "max", 10 );
5521 // setPreferenceProperty( ballSize, "min", 1 );
5522 // setPreferenceProperty( ballSize, "max", 10 );
5524 setPreferenceProperty( ballDiameter, "min", 1e-7 );
5525 setPreferenceProperty( ballDiameter, "max", 1e9 );
5526 setPreferenceProperty( ballDiameter, "step", 0.1 );
5528 setPreferenceProperty( ballScale, "min", 1e-2 );
5529 setPreferenceProperty( ballScale, "max", 1e7 );
5530 setPreferenceProperty( ballScale, "step", 0.5 );
5532 setPreferenceProperty( elemW, "min", 1 );
5533 setPreferenceProperty( elemW, "max", 5 );
5535 setPreferenceProperty( outW, "min", 1 );
5536 setPreferenceProperty( outW, "max", 5 );
5538 setPreferenceProperty( shrink, "min", 0 );
5539 setPreferenceProperty( shrink, "max", 100 );
5541 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5542 setPreferenceProperty( numGroup, "columns", 2 );
5544 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5545 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5547 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5548 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5550 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5551 setPreferenceProperty( orientGroup, "columns", 1 );
5553 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5554 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5556 setPreferenceProperty( orientScale, "min", 0.05 );
5557 setPreferenceProperty( orientScale, "max", 0.5 );
5558 setPreferenceProperty( orientScale, "step", 0.05 );
5560 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5562 // Selection tab ------------------------------------------------------------------------
5563 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5565 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5566 setPreferenceProperty( selGroup, "columns", 2 );
5568 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5569 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5571 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5572 setPreferenceProperty( preGroup, "columns", 2 );
5574 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5576 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5577 setPreferenceProperty( precSelGroup, "columns", 2 );
5579 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5580 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5581 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5583 int sinc = addPreference(tr("PREF_SELECTION_INCREMENT"), selTab, LightApp_Preferences::IntSpin, "SMESH", "selection_increment");
5584 setPreferenceProperty( sinc, "min", 0 );
5585 setPreferenceProperty( sinc, "max", 5 );
5587 // Scalar Bar tab ------------------------------------------------------------------------
5588 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5589 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5590 setPreferenceProperty( fontGr, "columns", 2 );
5592 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5593 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5595 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5596 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5598 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5599 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5601 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5602 setPreferenceProperty( numcol, "min", 2 );
5603 setPreferenceProperty( numcol, "max", 256 );
5605 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5606 setPreferenceProperty( numlab, "min", 2 );
5607 setPreferenceProperty( numlab, "max", 65 );
5609 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5610 setPreferenceProperty( orientGr, "columns", 2 );
5611 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5612 QStringList orients;
5613 orients.append( tr( "SMESH_VERTICAL" ) );
5614 orients.append( tr( "SMESH_HORIZONTAL" ) );
5615 indices.clear(); indices.append( 0 ); indices.append( 1 );
5616 setPreferenceProperty( orient, "strings", orients );
5617 setPreferenceProperty( orient, "indexes", indices );
5619 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5620 setPreferenceProperty( posVSizeGr, "columns", 2 );
5621 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5622 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5623 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5624 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5625 setPreferenceProperty( xv, "step", 0.1 );
5626 setPreferenceProperty( xv, "min", 0.0 );
5627 setPreferenceProperty( xv, "max", 1.0 );
5628 setPreferenceProperty( yv, "step", 0.1 );
5629 setPreferenceProperty( yv, "min", 0.0 );
5630 setPreferenceProperty( yv, "max", 1.0 );
5631 setPreferenceProperty( wv, "step", 0.1 );
5632 setPreferenceProperty( wv, "min", 0.0 );
5633 setPreferenceProperty( wv, "max", 1.0 );
5634 setPreferenceProperty( hv, "min", 0.0 );
5635 setPreferenceProperty( hv, "max", 1.0 );
5636 setPreferenceProperty( hv, "step", 0.1 );
5638 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5639 setPreferenceProperty( posHSizeGr, "columns", 2 );
5640 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5641 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5642 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5643 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5644 setPreferenceProperty( xv, "min", 0.0 );
5645 setPreferenceProperty( xv, "max", 1.0 );
5646 setPreferenceProperty( xv, "step", 0.1 );
5647 setPreferenceProperty( xh, "min", 0.0 );
5648 setPreferenceProperty( xh, "max", 1.0 );
5649 setPreferenceProperty( xh, "step", 0.1 );
5650 setPreferenceProperty( yh, "min", 0.0 );
5651 setPreferenceProperty( yh, "max", 1.0 );
5652 setPreferenceProperty( yh, "step", 0.1 );
5653 setPreferenceProperty( wh, "min", 0.0 );
5654 setPreferenceProperty( wh, "max", 1.0 );
5655 setPreferenceProperty( wh, "step", 0.1 );
5656 setPreferenceProperty( hh, "min", 0.0 );
5657 setPreferenceProperty( hh, "max", 1.0 );
5658 setPreferenceProperty( hh, "step", 0.1 );
5660 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5661 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5662 setPreferenceProperty( distributionGr, "columns", 3 );
5664 types.append( tr( "SMESH_MONOCOLOR" ) );
5665 types.append( tr( "SMESH_MULTICOLOR" ) );
5666 indices.clear(); indices.append( 0 ); indices.append( 1 );
5667 setPreferenceProperty( coloringType, "strings", types );
5668 setPreferenceProperty( coloringType, "indexes", indices );
5669 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5673 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5675 if ( sect=="SMESH" ) {
5676 float sbX1 = 0.01, sbY1 = 0.01, sbW = 0.08, sbH = 0.08;
5677 float aTol = 1.00000009999999;
5678 std::string aWarning;
5679 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5681 if ( name == "selection_object_color" ||
5682 name == "selection_element_color" ||
5683 name == "highlight_color" ||
5684 name == "selection_precision_node" ||
5685 name == "selection_precision_element" ||
5686 name == "selection_precision_object" ||
5687 name == "selection_increment")
5689 SMESH::UpdateSelectionProp( this );
5691 else if (name == "scalar_bar_vertical_x" || name == "scalar_bar_vertical_width")
5693 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5694 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5695 if ( sbX1+sbW > aTol ) {
5696 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5699 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5700 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5703 else if (name == "scalar_bar_vertical_y" || name == "scalar_bar_vertical_height" )
5705 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5706 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5707 if ( sbY1 + sbH > aTol ) {
5708 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5709 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5710 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5713 else if (name == "scalar_bar_horizontal_x" || name == "scalar_bar_horizontal_width")
5715 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5716 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5717 if ( sbX1 + sbW > aTol ) {
5718 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5721 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5722 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5725 else if (name == "scalar_bar_horizontal_y" || name == "scalar_bar_horizontal_height")
5727 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5728 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5729 if ( sbY1 + sbH > aTol ) {
5730 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5733 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5734 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5737 else if ( name == "segmentation" )
5739 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5740 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5742 else if ( name == "nb_segments_per_edge" )
5744 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5745 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5747 else if ( name == "historical_python_dump" || name == "forget_mesh_on_hyp_modif" || name == "default_grp_color" )
5749 QString val = aResourceMgr->stringValue( "SMESH", name );
5750 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5752 else if ( name == "numbering_node_color" || name == "numbering_node_font" )
5754 SMESH::UpdateFontProp( this );
5756 else if ( name == "numbering_elem_color" || name == "numbering_elem_font" )
5758 SMESH::UpdateFontProp( this );
5761 if ( aWarning.size() != 0 ) {
5762 aWarning += "The default values are applied instead.";
5763 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5764 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5765 QObject::tr(aWarning.c_str()));
5770 //================================================================================
5772 * \brief Update something in accordance with update flags
5773 * \param theFlags - update flags
5775 * Update viewer or/and object browser etc. in accordance with update flags ( see
5776 * LightApp_UpdateFlags enumeration ).
5778 //================================================================================
5779 void SMESHGUI::update( const int flags )
5781 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5782 SMESH::UpdateView();
5784 SalomeApp_Module::update( flags );
5787 //================================================================================
5789 * \brief Set default selection mode
5791 * SLOT called when operation committed. Sets default selection mode
5793 //================================================================================
5794 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5796 SVTK_ViewWindow* vtkWnd =
5797 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5799 vtkWnd->SetSelectionMode( ActorSelection );
5802 //================================================================================
5804 * \brief Set default selection mode
5806 * SLOT called when operation aborted. Sets default selection mode
5808 //================================================================================
5809 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5811 SVTK_ViewWindow* vtkWnd =
5812 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5814 vtkWnd->SetSelectionMode( ActorSelection );
5817 //================================================================================
5819 * \brief Creates operation with given identifier
5820 * \param id - identifier of operation to be started
5821 * \return Pointer on created operation or NULL if operation is not created
5823 * Virtual method redefined from the base class creates operation with given id.
5824 * It is called called automatically from startOperation method of base class.
5826 //================================================================================
5827 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5829 LightApp_Operation* op = 0;
5830 // to do : create operation here
5833 case SMESHOp::OpSplitBiQuadratic:
5834 op = new SMESHGUI_SplitBiQuadOp();
5836 case SMESHOp::OpConvertMeshToQuadratic:
5837 op = new SMESHGUI_ConvToQuadOp();
5839 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5840 op = new SMESHGUI_Make2DFrom3DOp();
5842 case SMESHOp::OpReorientFaces:
5843 op = new SMESHGUI_ReorientFacesOp();
5845 case SMESHOp::OpCreateMesh:
5846 op = new SMESHGUI_MeshOp( true, true );
5848 case SMESHOp::OpCreateSubMesh:
5849 op = new SMESHGUI_MeshOp( true, false );
5851 case SMESHOp::OpEditMeshOrSubMesh:
5852 case SMESHOp::OpEditMesh:
5853 case SMESHOp::OpEditSubMesh:
5854 op = new SMESHGUI_MeshOp( false );
5856 case SMESHOp::OpCompute:
5857 case SMESHOp::OpComputeSubMesh:
5858 op = new SMESHGUI_ComputeOp();
5860 case SMESHOp::OpPreCompute:
5861 op = new SMESHGUI_PrecomputeOp();
5863 case SMESHOp::OpEvaluate:
5864 op = new SMESHGUI_EvaluateOp();
5866 case SMESHOp::OpMeshOrder:
5867 op = new SMESHGUI_MeshOrderOp();
5869 case SMESHOp::OpCreateGeometryGroup:
5870 op = new SMESHGUI_GroupOnShapeOp();
5872 case SMESHOp::OpFindElementByPoint:
5873 op = new SMESHGUI_FindElemByPointOp();
5875 case SMESHOp::OpMoveNode: // Make mesh pass through point
5876 op = new SMESHGUI_MakeNodeAtPointOp();
5878 case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
5879 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5886 op = SalomeApp_Module::createOperation( id );
5890 //================================================================================
5892 * \brief Stops current operations and starts a given one
5893 * \param id - The id of the operation to start
5895 //================================================================================
5897 void SMESHGUI::switchToOperation(int id)
5899 activeStudy()->abortAllOperations();
5900 startOperation( id );
5903 LightApp_Displayer* SMESHGUI::displayer()
5906 myDisplayer = new SMESHGUI_Displayer( getApp() );
5910 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5913 int aTolerance = 64;
5914 int anIterations = 0;
5920 if( anIterations % aPeriod == 0 )
5923 if( aTolerance < 1 )
5927 aHue = (int)( 360.0 * rand() / RAND_MAX );
5930 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5931 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5932 for( ; it != itEnd; ++it )
5934 SALOMEDS::Color anAutoColor = *it;
5935 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5938 aQColor.getHsv( &h, &s, &v );
5939 if( abs( h - aHue ) < aTolerance )
5951 aColor.setHsv( aHue, 255, 255 );
5953 SALOMEDS::Color aSColor;
5954 aSColor.R = aColor.redF();
5955 aSColor.G = aColor.greenF();
5956 aSColor.B = aColor.blueF();
5961 const char* gSeparator = "_"; // character used to separate parameter names
5962 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5963 const char* gPathSep = "|"; // character used to separate paths
5966 * \brief Store visual parameters
5968 * This method is called just before the study document is saved.
5969 * Store visual parameters in AttributeParameter attribute(s)
5971 void SMESHGUI::storeVisualParameters (int savePoint)
5974 Kernel_Utils::Localizer loc;
5976 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5977 if (!appStudy || !appStudy->studyDS())
5979 _PTR(Study) studyDS = appStudy->studyDS();
5981 // componentName is used for encoding of entries when storing them in IParameters
5982 std::string componentName = myComponentSMESH->ComponentDataType();
5983 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5984 //if (!aSComponent) return;
5987 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5988 componentName.c_str(),
5990 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5992 // store custom markers
5993 if( !myMarkerMap.empty() )
5995 VTK::MarkerMap::const_iterator anIter = myMarkerMap.begin();
5996 for( ; anIter != myMarkerMap.end(); anIter++ )
5998 int anId = anIter->first;
5999 VTK::MarkerData aMarkerData = anIter->second;
6000 std::string aMarkerFileName = aMarkerData.first;
6001 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
6002 if( aMarkerTexture.size() < 3 )
6003 continue; // should contain at least width, height and the first value
6005 QString aPropertyName( "texture" );
6006 aPropertyName += gSeparator;
6007 aPropertyName += QString::number( anId );
6009 QString aPropertyValue = aMarkerFileName.c_str();
6010 aPropertyValue += gPathSep;
6012 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
6013 ushort aWidth = *aTextureIter++;
6014 ushort aHeight = *aTextureIter++;
6015 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
6016 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
6017 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
6018 aPropertyValue += QString::number( *aTextureIter );
6020 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
6024 // viewers counters are used for storing view_numbers in IParameters
6027 // main cycle to store parameters of displayed objects
6028 QList<SUIT_ViewManager*> lst;
6029 QList<SUIT_ViewManager*>::Iterator it;
6030 getApp()->viewManagers(lst);
6031 for (it = lst.begin(); it != lst.end(); it++)
6033 SUIT_ViewManager* vman = *it;
6034 QString vType = vman->getType();
6036 // saving VTK actors properties
6037 if (vType == SVTK_Viewer::Type())
6039 // store the clipping planes attached to the view manager
6040 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
6041 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
6042 if( anIter != myClippingPlaneInfoMap.end() )
6043 aClippingPlaneInfoList = anIter->second;
6045 if( !aClippingPlaneInfoList.empty() ) {
6046 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
6047 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
6049 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
6050 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
6052 QString aPropertyName( "ClippingPlane" );
6053 aPropertyName += gSeparator;
6054 aPropertyName += QString::number( vtkViewers );
6055 aPropertyName += gSeparator;
6056 aPropertyName += QString::number( anId );
6058 QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
6059 aPropertyValue += gDigitsSep;
6060 aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
6061 aPropertyValue += gDigitsSep;
6062 if ( aPlane->PlaneMode == SMESH::Absolute ) {
6063 aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
6064 aPropertyValue += gDigitsSep;
6065 aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
6066 aPropertyValue += gDigitsSep;
6067 aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
6068 aPropertyValue += gDigitsSep;
6069 aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
6070 aPropertyValue += gDigitsSep;
6071 aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
6072 aPropertyValue += gDigitsSep;
6073 aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
6074 aPropertyValue += gDigitsSep;
6075 aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
6077 else if ( aPlane->PlaneMode == SMESH::Relative ) {
6078 aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
6079 aPropertyValue += gDigitsSep;
6080 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
6081 aPropertyValue += gDigitsSep;
6082 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
6083 aPropertyValue += gDigitsSep;
6084 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
6087 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
6091 QVector<SUIT_ViewWindow*> views = vman->getViews();
6092 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
6094 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
6096 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
6097 vtkActorCollection* allActors = aCopy.GetActors();
6098 allActors->InitTraversal();
6099 while (vtkActor* actor = allActors->GetNextActor())
6101 if (actor->GetVisibility()) // store only visible actors
6103 SMESH_Actor* aSmeshActor = 0;
6104 if (actor->IsA("SMESH_Actor"))
6105 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
6106 if (aSmeshActor && aSmeshActor->hasIO())
6108 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
6111 // entry is "encoded" = it does NOT contain component address,
6112 // since it is a subject to change on next component loading
6113 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
6115 std::string param, vtkParam = vType.toLatin1().data();
6116 vtkParam += gSeparator;
6117 vtkParam += QString::number(vtkViewers).toLatin1().data();
6118 vtkParam += gSeparator;
6121 param = vtkParam + "Visibility";
6122 ip->setParameter(entry, param, "On");
6125 param = vtkParam + "Representation";
6126 ip->setParameter(entry, param, QString::number
6127 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
6130 param = vtkParam + "IsShrunk";
6131 ip->setParameter(entry, param, QString::number
6132 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
6134 // Displayed entities
6135 unsigned int aMode = aSmeshActor->GetEntityMode();
6136 bool isE = aMode & SMESH_Actor::eEdges;
6137 bool isF = aMode & SMESH_Actor::eFaces;
6138 bool isV = aMode & SMESH_Actor::eVolumes;
6139 bool is0d = aMode & SMESH_Actor::e0DElements;
6140 bool isB = aMode & SMESH_Actor::eBallElem;
6142 QString modeStr ("e");
6143 modeStr += gDigitsSep; modeStr += QString::number(isE);
6144 modeStr += gDigitsSep; modeStr += "f";
6145 modeStr += gDigitsSep; modeStr += QString::number(isF);
6146 modeStr += gDigitsSep; modeStr += "v";
6147 modeStr += gDigitsSep; modeStr += QString::number(isV);
6148 modeStr += gDigitsSep; modeStr += "0d";
6149 modeStr += gDigitsSep; modeStr += QString::number(is0d);
6150 modeStr += gDigitsSep; modeStr += "b";
6151 modeStr += gDigitsSep; modeStr += QString::number(isB);
6153 param = vtkParam + "Entities";
6154 ip->setParameter(entry, param, modeStr.toLatin1().data());
6160 aSmeshActor->GetSufaceColor(r, g, b, delta);
6161 QStringList colorStr;
6162 colorStr << "surface";
6163 colorStr << QString::number(r);
6164 colorStr << QString::number(g);
6165 colorStr << QString::number(b);
6167 colorStr << "backsurface";
6168 colorStr << QString::number(delta);
6170 aSmeshActor->GetVolumeColor(r, g, b, delta);
6171 colorStr << "volume";
6172 colorStr << QString::number(r);
6173 colorStr << QString::number(g);
6174 colorStr << QString::number(b);
6175 colorStr << QString::number(delta);
6177 aSmeshActor->GetEdgeColor(r, g, b);
6179 colorStr << QString::number(r);
6180 colorStr << QString::number(g);
6181 colorStr << QString::number(b);
6183 aSmeshActor->GetNodeColor(r, g, b);
6185 colorStr << QString::number(r);
6186 colorStr << QString::number(g);
6187 colorStr << QString::number(b);
6189 aSmeshActor->GetOutlineColor(r, g, b);
6190 colorStr << "outline";
6191 colorStr << QString::number(r);
6192 colorStr << QString::number(g);
6193 colorStr << QString::number(b);
6195 aSmeshActor->Get0DColor(r, g, b);
6196 colorStr << "elem0d";
6197 colorStr << QString::number(r);
6198 colorStr << QString::number(g);
6199 colorStr << QString::number(b);
6201 aSmeshActor->GetBallColor(r, g, b);
6203 colorStr << QString::number(r);
6204 colorStr << QString::number(g);
6205 colorStr << QString::number(b);
6207 aSmeshActor->GetFacesOrientationColor(r, g, b);
6208 colorStr << "orientation";
6209 colorStr << QString::number(r);
6210 colorStr << QString::number(g);
6211 colorStr << QString::number(b);
6213 param = vtkParam + "Colors";
6214 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
6217 QStringList sizeStr;
6219 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
6220 sizeStr << "outline";
6221 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
6222 sizeStr << "elem0d";
6223 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
6225 //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
6226 sizeStr << QString::number((double)aSmeshActor->GetBallSize());
6227 sizeStr << QString::number((double)aSmeshActor->GetBallScale());
6228 sizeStr << "shrink";
6229 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
6230 sizeStr << "orientation";
6231 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
6232 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
6234 param = vtkParam + "Sizes";
6235 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
6240 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
6241 if( aMarkerType == VTK::MT_USER ) {
6242 markerStr += "custom";
6243 markerStr += gDigitsSep;
6244 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
6248 markerStr += gDigitsSep;
6249 markerStr += QString::number( (int)aMarkerType );
6250 markerStr += gDigitsSep;
6251 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
6254 param = vtkParam + "PointMarker";
6255 ip->setParameter(entry, param, markerStr.toLatin1().data());
6258 param = vtkParam + "Opacity";
6259 ip->setParameter(entry, param,
6260 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
6263 param = vtkParam + "ClippingPlane";
6265 if( !aClippingPlaneInfoList.empty() ) {
6266 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
6267 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
6269 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
6270 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
6271 SMESH::TActorList::iterator anIter2 = anActorList.begin();
6272 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
6273 if( aSmeshActor == *anIter2 ) {
6274 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
6275 QString::number( anId ).toLatin1().constData() );
6282 ip->setParameter( entry, param, "Off" );
6283 } // if (io->hasEntry())
6284 } // SMESH_Actor && hasIO
6286 } // while.. actors traversal
6290 } // if (SVTK view model)
6291 } // for (viewManagers)
6294 // data structures for clipping planes processing
6298 bool isOpenGLClipping;
6299 vtkIdType RelativeOrientation;
6302 int AbsoluteOrientation;
6303 double X, Y, Z, Dx, Dy, Dz;
6305 typedef std::list<TPlaneData> TPlaneDataList;
6306 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
6308 typedef std::list<vtkActor*> TActorList;
6311 TActorList ActorList;
6312 SUIT_ViewManager* ViewManager;
6314 typedef std::list<TPlaneInfo> TPlaneInfoList;
6315 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
6318 * \brief Restore visual parameters
6320 * This method is called after the study document is opened.
6321 * Restore visual parameters from AttributeParameter attribute(s)
6323 void SMESHGUI::restoreVisualParameters (int savePoint)
6326 Kernel_Utils::Localizer loc;
6328 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6329 if (!appStudy || !appStudy->studyDS())
6331 _PTR(Study) studyDS = appStudy->studyDS();
6333 // componentName is used for encoding of entries when storing them in IParameters
6334 std::string componentName = myComponentSMESH->ComponentDataType();
6335 //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
6336 //if (!aSComponent) return;
6339 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6340 componentName.c_str(),
6342 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6344 // restore custom markers and map of clipping planes
6345 TPlaneDataMap aPlaneDataMap;
6347 std::vector<std::string> properties = ip->getProperties();
6348 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
6350 std::string property = *propIt;
6351 QString aPropertyName( property.c_str() );
6352 QString aPropertyValue( ip->getProperty( property ).c_str() );
6354 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
6355 if( aPropertyNameList.isEmpty() )
6358 QString aPropertyType = aPropertyNameList[0];
6359 if( aPropertyType == "texture" )
6361 if( aPropertyNameList.size() != 2 )
6365 int anId = aPropertyNameList[1].toInt( &ok );
6366 if( !ok || anId < 1 )
6369 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
6370 if( aPropertyValueList.size() != 2 )
6373 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
6374 QString aMarkerTextureString = aPropertyValueList[1];
6375 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
6376 if( aMarkerTextureStringList.size() != 3 )
6380 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6385 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6389 VTK::MarkerTexture aMarkerTexture;
6390 aMarkerTexture.push_back( aWidth );
6391 aMarkerTexture.push_back( aHeight );
6393 QString aMarkerTextureData = aMarkerTextureStringList[2];
6394 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6396 QChar aChar = aMarkerTextureData.at( i );
6397 if( aChar.isDigit() )
6398 aMarkerTexture.push_back( aChar.digitValue() );
6401 myMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6403 else if( aPropertyType == "ClippingPlane" )
6405 if( aPropertyNameList.size() != 3 )
6409 int aViewId = aPropertyNameList[1].toInt( &ok );
6410 if( !ok || aViewId < 0 )
6414 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6415 if( !ok || aClippingPlaneId < 0 )
6418 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6419 if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6422 TPlaneData aPlaneData;
6423 aPlaneData.AbsoluteOrientation = false;
6424 aPlaneData.RelativeOrientation = 0;
6425 aPlaneData.Distance = aPlaneData.Angle[0] = aPlaneData.Angle[1] = 0;
6426 aPlaneData.X = aPlaneData.Y = aPlaneData.Z = 0;
6427 aPlaneData.Dx = aPlaneData.Dy = aPlaneData.Dz = 0;
6429 aPlaneData.Id = aClippingPlaneId;
6432 aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6437 aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6441 if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6444 aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6449 aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6454 aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6459 aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6464 aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6469 aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6474 aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6478 else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6480 aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6485 aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6490 aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6495 aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6500 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6501 aPlaneDataList.push_back( aPlaneData );
6505 TPlaneInfoMap aPlaneInfoMap;
6507 std::vector<std::string> entries = ip->getEntries();
6509 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6511 // entry is a normal entry - it should be "decoded" (setting base address of component)
6512 QString entry (ip->decodeEntry(*entIt).c_str());
6514 // Check that the entry corresponds to a real object in the Study
6515 // as the object may be deleted or modified after the visual state is saved.
6516 _PTR(SObject) so = studyDS->FindObjectID(entry.toUtf8().data());
6517 if (!so) continue; //Skip the not existent entry
6519 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6520 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6522 std::vector<std::string>::iterator namesIt = paramNames.begin();
6523 std::vector<std::string>::iterator valuesIt = paramValues.begin();
6525 // actors are stored in a map after displaying of them for
6526 // quicker access in the future: map < viewID to actor >
6527 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6529 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6531 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6532 // '_' is used as separator and should not be used in viewer type or parameter names.
6533 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6534 if (lst.size() != 3)
6537 QString viewerTypStr = lst[0];
6538 QString viewIndexStr = lst[1];
6539 QString paramNameStr = lst[2];
6542 int viewIndex = viewIndexStr.toUInt(&ok);
6543 if (!ok) // bad conversion of view index to integer
6547 if (viewerTypStr == SVTK_Viewer::Type())
6549 SMESH_Actor* aSmeshActor = 0;
6550 if (vtkActors.IsBound(viewIndex))
6551 aSmeshActor = vtkActors.Find(viewIndex);
6553 QList<SUIT_ViewManager*> lst;
6554 getApp()->viewManagers(viewerTypStr, lst);
6556 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6557 SUIT_ViewManager* vman = NULL;
6558 if (viewIndex >= 0 && viewIndex < lst.count())
6559 vman = lst.at(viewIndex);
6561 if (paramNameStr == "Visibility")
6563 if (!aSmeshActor && displayer() && vman)
6565 SUIT_ViewModel* vmodel = vman->getViewModel();
6566 // SVTK view model can be casted to SALOME_View
6567 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6569 // store displayed actor in a temporary map for quicker
6570 // access later when restoring other parameters
6571 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6572 vtkRenderer* Renderer = vtkView->getRenderer();
6573 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6574 vtkActorCollection* theActors = aCopy.GetActors();
6575 theActors->InitTraversal();
6576 bool isFound = false;
6577 vtkActor *ac = theActors->GetNextActor();
6578 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6579 if (ac->IsA("SMESH_Actor")) {
6580 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6581 if (aGeomAc->hasIO()) {
6582 Handle(SALOME_InteractiveObject) io = aGeomAc->getIO();
6583 if (io->hasEntry() && strcmp(io->getEntry(), entry.toUtf8().data()) == 0) {
6585 vtkActors.Bind(viewIndex, aGeomAc);
6591 } // if (paramNameStr == "Visibility")
6594 // the rest properties "work" with SMESH_Actor
6597 QString val ((*valuesIt).c_str());
6600 if (paramNameStr == "Representation") {
6601 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6604 else if (paramNameStr == "IsShrunk") {
6606 if (!aSmeshActor->IsShrunk())
6607 aSmeshActor->SetShrink();
6610 if (aSmeshActor->IsShrunk())
6611 aSmeshActor->UnShrink();
6614 // Displayed entities
6615 else if (paramNameStr == "Entities") {
6616 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6617 int aEntityMode = SMESH_Actor::eAllEntity;
6618 for ( int i = 0; i < mode.count(); i+=2 ) {
6619 if ( i < mode.count()-1 ) {
6620 QString type = mode[i];
6621 bool val = mode[i+1].toInt();
6622 if ( type == "e" && !val )
6623 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6624 else if ( type == "f" && !val )
6625 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6626 else if ( type == "v" && !val )
6627 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6628 else if ( type == "0d" && !val )
6629 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6630 else if ( type == "b" && !val )
6631 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6634 aSmeshActor->SetEntityMode( aEntityMode );
6637 else if (paramNameStr == "Colors") {
6638 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6645 QColor outlineColor;
6646 QColor orientationColor;
6652 // below lines are required to get default values for delta coefficients
6653 // of backface color for faces and color of reversed volumes
6654 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
6655 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6656 for ( int i = 0; i < colors.count(); i++ ) {
6657 QString type = colors[i];
6658 if ( type == "surface" ) {
6659 // face color is set by 3 values r:g:b, where
6660 // - r,g,b - is rgb color components
6661 if ( i+1 >= colors.count() ) break; // format error
6662 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6663 if ( i+2 >= colors.count() ) break; // format error
6664 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6665 if ( i+3 >= colors.count() ) break; // format error
6666 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6667 faceColor.setRgbF( r, g, b );
6670 else if ( type == "backsurface" ) {
6671 // backface color can be defined in several ways
6672 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6673 // - in latest versions, it is set as delta coefficient
6674 bool rgbOk = false, deltaOk;
6675 if ( i+1 >= colors.count() ) break; // format error
6676 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6677 int delta = colors[i+1].toInt( &deltaOk );
6679 if ( i+1 < colors.count() ) // index is shifted to 1
6680 g = colors[i+1].toDouble( &rgbOk );
6681 if ( rgbOk ) i++; // shift index
6682 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6683 b = colors[i+1].toDouble( &rgbOk );
6685 // - as currently there's no way to set directly backsurface color as it was before,
6686 // we ignore old dump where r,g,b triple was set
6687 // - also we check that delta parameter is set properly
6688 if ( !rgbOk && deltaOk )
6691 else if ( type == "volume" ) {
6692 // volume color is set by 4 values r:g:b:delta, where
6693 // - r,g,b - is a normal volume rgb color components
6694 // - delta - is a reversed volume color delta coefficient
6695 if ( i+1 >= colors.count() ) break; // format error
6696 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6697 if ( i+2 >= colors.count() ) break; // format error
6698 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6699 if ( i+3 >= colors.count() ) break; // format error
6700 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6701 if ( i+4 >= colors.count() ) break; // format error
6702 int delta = colors[i+4].toInt( &bOk );
6703 if ( !bOk ) break; // format error
6704 volumeColor.setRgbF( r, g, b );
6708 else if ( type == "edge" ) {
6709 // edge color is set by 3 values r:g:b, where
6710 // - r,g,b - is rgb color components
6711 if ( i+1 >= colors.count() ) break; // format error
6712 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6713 if ( i+2 >= colors.count() ) break; // format error
6714 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6715 if ( i+3 >= colors.count() ) break; // format error
6716 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6717 edgeColor.setRgbF( r, g, b );
6720 else if ( type == "node" ) {
6721 // node color is set by 3 values r:g:b, where
6722 // - r,g,b - is rgb color components
6723 if ( i+1 >= colors.count() ) break; // format error
6724 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6725 if ( i+2 >= colors.count() ) break; // format error
6726 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6727 if ( i+3 >= colors.count() ) break; // format error
6728 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6729 nodeColor.setRgbF( r, g, b );
6732 else if ( type == "elem0d" ) {
6733 // 0d element color is set by 3 values r:g:b, where
6734 // - r,g,b - is rgb color components
6735 if ( i+1 >= colors.count() ) break; // format error
6736 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6737 if ( i+2 >= colors.count() ) break; // format error
6738 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6739 if ( i+3 >= colors.count() ) break; // format error
6740 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6741 elem0dColor.setRgbF( r, g, b );
6744 else if ( type == "ball" ) {
6745 // ball color is set by 3 values r:g:b, where
6746 // - r,g,b - is rgb color components
6747 if ( i+1 >= colors.count() ) break; // format error
6748 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6749 if ( i+2 >= colors.count() ) break; // format error
6750 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6751 if ( i+3 >= colors.count() ) break; // format error
6752 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6753 ballColor.setRgbF( r, g, b );
6756 else if ( type == "outline" ) {
6757 // outline color is set by 3 values r:g:b, where
6758 // - r,g,b - is rgb color components
6759 if ( i+1 >= colors.count() ) break; // format error
6760 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6761 if ( i+2 >= colors.count() ) break; // format error
6762 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6763 if ( i+3 >= colors.count() ) break; // format error
6764 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6765 outlineColor.setRgbF( r, g, b );
6768 else if ( type == "orientation" ) {
6769 // orientation color is set by 3 values r:g:b, where
6770 // - r,g,b - is rgb color components
6771 if ( i+1 >= colors.count() ) break; // format error
6772 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6773 if ( i+2 >= colors.count() ) break; // format error
6774 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6775 if ( i+3 >= colors.count() ) break; // format error
6776 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6777 orientationColor.setRgbF( r, g, b );
6782 if ( nodeColor.isValid() )
6783 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6785 if ( edgeColor.isValid() )
6786 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6788 if ( faceColor.isValid() )
6789 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6791 if ( volumeColor.isValid() )
6792 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6793 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6794 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6796 if ( elem0dColor.isValid() )
6797 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6799 if ( ballColor.isValid() )
6800 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6802 if ( outlineColor.isValid() )
6803 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6804 // orientation color
6805 if ( orientationColor.isValid() )
6806 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6809 else if (paramNameStr == "Sizes") {
6810 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6813 int outlineWidth = -1;
6814 int elem0dSize = -1;
6815 //int ballSize = -1;
6816 double ballDiameter = -1.0;
6817 double ballScale = -1.0;
6818 double shrinkSize = -1;
6819 double orientationSize = -1;
6820 bool orientation3d = false;
6821 for ( int i = 0; i < sizes.count(); i++ ) {
6822 QString type = sizes[i];
6823 if ( type == "line" ) {
6824 // line (wireframe) width is given as single integer value
6825 if ( i+1 >= sizes.count() ) break; // format error
6826 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6830 if ( type == "outline" ) {
6831 // outline width is given as single integer value
6832 if ( i+1 >= sizes.count() ) break; // format error
6833 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6837 else if ( type == "elem0d" ) {
6838 // 0d element size is given as single integer value
6839 if ( i+1 >= sizes.count() ) break; // format error
6840 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6844 else if ( type == "ball" ) {
6845 // balls are specified by two values: size:scale, where
6846 // - size - is a integer value specifying size
6847 // - scale - is a double value specifying scale factor
6848 if ( i+1 >= sizes.count() ) break; // format error
6849 //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6850 double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6851 if ( i+2 >= sizes.count() ) break; // format error
6852 double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6858 else if ( type == "shrink" ) {
6859 // shrink factor is given as single floating point value
6860 if ( i+1 >= sizes.count() ) break; // format error
6861 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6865 else if ( type == "orientation" ) {
6866 // orientation vectors are specified by two values size:3d, where
6867 // - size - is a floating point value specifying scale factor
6868 // - 3d - is a boolean
6869 if ( i+1 >= sizes.count() ) break; // format error
6870 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6871 if ( i+2 >= sizes.count() ) break; // format error
6872 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6873 orientationSize = v1;
6874 orientation3d = (bool)v2;
6878 // line (wireframe) width
6879 if ( lineWidth > 0 )
6880 aSmeshActor->SetLineWidth( lineWidth );
6882 if ( outlineWidth > 0 )
6883 aSmeshActor->SetOutlineWidth( outlineWidth );
6884 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6885 aSmeshActor->SetOutlineWidth( lineWidth );
6887 if ( elem0dSize > 0 )
6888 aSmeshActor->Set0DSize( elem0dSize );
6890 /*if ( ballSize > 0 )
6891 aSmeshActor->SetBallSize( ballSize );*/
6893 if ( ballDiameter > 0 )
6894 aSmeshActor->SetBallSize( ballDiameter );
6896 if ( ballScale > 0.0 )
6897 aSmeshActor->SetBallScale( ballScale );
6899 if ( shrinkSize > 0 )
6900 aSmeshActor->SetShrinkFactor( shrinkSize );
6901 // orientation vectors
6902 if ( orientationSize > 0 ) {
6903 aSmeshActor->SetFacesOrientationScale( orientationSize );
6904 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6908 else if (paramNameStr == "PointMarker") {
6909 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6910 if( data.count() >= 2 ) {
6912 int aParam1 = data[1].toInt( &ok );
6914 if( data[0] == "std" && data.count() == 3 ) {
6915 int aParam2 = data[2].toInt( &ok );
6916 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6918 else if( data[0] == "custom" ) {
6919 VTK::MarkerMap::const_iterator markerIt = myMarkerMap.find( aParam1 );
6920 if( markerIt != myMarkerMap.end() ) {
6921 VTK::MarkerData aMarkerData = markerIt->second;
6922 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6929 else if (paramNameStr == "Opacity") {
6930 aSmeshActor->SetOpacity(val.toFloat());
6933 else if (paramNameStr.startsWith("ClippingPlane")) {
6934 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6935 // old format - val looks like "Off" or "1:0:0:0.5:0:0"
6936 // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
6937 // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
6938 // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
6939 // new format - val looks like "Off" or "0" (plane id)
6940 // (note: in new format "Off" value is used only for consistency,
6941 // so it is processed together with values in old format)
6942 bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
6943 if( anIsOldFormat ) {
6944 if (paramNameStr == "ClippingPlane1" || val == "Off")
6945 aSmeshActor->RemoveAllClippingPlanes();
6947 QList<SUIT_ViewManager*> lst;
6948 getApp()->viewManagers(viewerTypStr, lst);
6949 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6950 if (viewIndex >= 0 && viewIndex < lst.count()) {
6951 SUIT_ViewManager* vman = lst.at(viewIndex);
6952 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6954 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6956 SMESH::TActorList anActorList;
6957 anActorList.push_back( aSmeshActor );
6958 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
6959 aPlane->myViewWindow = vtkView;
6960 SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
6961 aPlane->PlaneMode = aMode;
6962 bool isOpenGLClipping = ( bool )vals[1].toInt();
6963 aPlane->IsOpenGLClipping = isOpenGLClipping;
6964 if ( aMode == SMESH::Absolute ) {
6965 aPlane->myAbsoluteOrientation = vals[2].toInt();
6966 aPlane->X = vals[3].toFloat();
6967 aPlane->Y = vals[4].toFloat();
6968 aPlane->Z = vals[5].toFloat();
6969 aPlane->Dx = vals[6].toFloat();
6970 aPlane->Dy = vals[7].toFloat();
6971 aPlane->Dz = vals[8].toFloat();
6973 else if ( aMode == SMESH::Relative ) {
6974 aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
6975 aPlane->myDistance = vals[3].toFloat();
6976 aPlane->myAngle[0] = vals[4].toFloat();
6977 aPlane->myAngle[1] = vals[5].toFloat();
6981 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6982 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6983 aClippingPlaneInfo.Plane = aPlane;
6984 aClippingPlaneInfo.ActorList = anActorList;
6985 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6993 int aPlaneId = val.toInt( &ok );
6994 if( ok && aPlaneId >= 0 ) {
6995 bool anIsDefinedPlane = false;
6996 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6997 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6998 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6999 TPlaneInfo& aPlaneInfo = *anIter;
7000 if( aPlaneInfo.PlaneId == aPlaneId ) {
7001 aPlaneInfo.ActorList.push_back( aSmeshActor );
7002 anIsDefinedPlane = true;
7006 if( !anIsDefinedPlane ) {
7007 TPlaneInfo aPlaneInfo;
7008 aPlaneInfo.PlaneId = aPlaneId;
7009 aPlaneInfo.ActorList.push_back( aSmeshActor );
7010 aPlaneInfo.ViewManager = vman;
7012 // to make the list sorted by plane id
7013 anIter = aPlaneInfoList.begin();
7014 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
7015 const TPlaneInfo& aPlaneInfoRef = *anIter;
7016 if( aPlaneInfoRef.PlaneId > aPlaneId )
7019 aPlaneInfoList.insert( anIter, aPlaneInfo );
7024 } // if (aSmeshActor)
7025 } // other parameters than Visibility
7027 } // for names/parameters iterator
7028 } // for entries iterator
7030 // take into account planes with empty list of actors referred to them
7031 QList<SUIT_ViewManager*> aVMList;
7032 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
7034 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
7035 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
7036 int aViewId = aPlaneDataIter->first;
7037 if( aViewId >= 0 && aViewId < aVMList.count() ) {
7038 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
7040 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
7042 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
7043 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
7044 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
7045 const TPlaneData& aPlaneData = *anIter2;
7046 int aPlaneId = aPlaneData.Id;
7048 bool anIsFound = false;
7049 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
7050 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
7051 const TPlaneInfo& aPlaneInfo = *anIter3;
7052 if( aPlaneInfo.PlaneId == aPlaneId ) {
7059 TPlaneInfo aPlaneInfo; // ActorList field is empty
7060 aPlaneInfo.PlaneId = aPlaneId;
7061 aPlaneInfo.ViewManager = aViewManager;
7063 // to make the list sorted by plane id
7064 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
7065 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
7066 const TPlaneInfo& aPlaneInfoRef = *anIter4;
7067 if( aPlaneInfoRef.PlaneId > aPlaneId )
7070 aPlaneInfoList.insert( anIter4, aPlaneInfo );
7076 // add clipping planes to actors according to the restored parameters
7077 // and update the clipping plane map
7078 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
7079 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
7080 int aViewId = anIter1->first;
7081 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
7083 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
7084 if( anIter2 == aPlaneDataMap.end() )
7086 const TPlaneDataList& aPlaneDataList = anIter2->second;
7088 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
7089 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
7090 const TPlaneInfo& aPlaneInfo = *anIter3;
7091 int aPlaneId = aPlaneInfo.PlaneId;
7092 const TActorList& anActorList = aPlaneInfo.ActorList;
7093 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
7097 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
7101 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
7103 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
7104 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
7105 const TPlaneData& aPlaneData = *anIter4;
7106 if( aPlaneData.Id == aPlaneId ) {
7107 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
7108 aPlane->myViewWindow = aViewWindow;
7109 aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
7110 aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
7111 if ( aPlane->PlaneMode == SMESH::Absolute ) {
7112 aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
7113 aPlane->X = aPlaneData.X;
7114 aPlane->Y = aPlaneData.Y;
7115 aPlane->Z = aPlaneData.Z;
7116 aPlane->Dx = aPlaneData.Dx;
7117 aPlane->Dy = aPlaneData.Dy;
7118 aPlane->Dz = aPlaneData.Dz;
7120 else if ( aPlane->PlaneMode == SMESH::Relative ) {
7121 aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
7122 aPlane->myDistance = aPlaneData.Distance;
7123 aPlane->myAngle[0] = aPlaneData.Angle[0];
7124 aPlane->myAngle[1] = aPlaneData.Angle[1];
7127 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
7128 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
7129 aClippingPlaneInfo.Plane = aPlane;
7130 aClippingPlaneInfo.ActorList = anActorList;
7131 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
7142 // update all VTK views
7143 QList<SUIT_ViewManager*> lst;
7144 getApp()->viewManagers(lst);
7145 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
7146 SUIT_ViewModel* vmodel = (*it)->getViewModel();
7147 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
7148 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
7149 // set OpenGL clipping planes
7150 VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
7151 vtkActorCollection* anAllActors = aCopy.GetActors();
7152 anAllActors->InitTraversal();
7153 while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
7154 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
7155 anActor->SetOpenGLClippingPlane();
7157 vtkView->getRenderer()->ResetCameraClippingRange();
7164 \brief Adds preferences for dfont of VTK viewer
7166 \param pIf group identifier
7167 \param param parameter
7168 \return identifier of preferences
7170 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
7172 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
7174 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
7177 fam.append( tr( "SMESH_FONT_ARIAL" ) );
7178 fam.append( tr( "SMESH_FONT_COURIER" ) );
7179 fam.append( tr( "SMESH_FONT_TIMES" ) );
7181 setPreferenceProperty( tfont, "fonts", fam );
7183 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
7184 if ( needSize ) f = f | QtxFontEdit::Size;
7185 setPreferenceProperty( tfont, "features", f );
7191 \brief Actions after hypothesis edition
7192 Updates object browser after hypothesis edition
7194 void SMESHGUI::onHypothesisEdit( int result )
7197 SMESHGUI::Modified();
7198 updateObjBrowser( true );
7202 \brief Actions after choosing menu of control modes
7203 Updates control mode actions according to current selection
7205 void SMESHGUI::onUpdateControlActions()
7207 SALOME_ListIO selected;
7208 if ( LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr() )
7209 aSel->selectedObjects( selected );
7211 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
7212 if ( selected.Extent() ) {
7213 if ( selected.First()->hasEntry() ) {
7214 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( selected.First()->getEntry() )) {
7215 aControl = anActor->GetControlMode();
7216 SALOME_ListIteratorOfListIO it(selected);
7217 for ( it.Next(); it.More(); it.Next() ) {
7218 Handle(SALOME_InteractiveObject) anIO = it.Value();
7219 if ( anIO->hasEntry() ) {
7220 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
7221 if ( aControl != anActor->GetControlMode() ) {
7222 aControl = SMESH_Actor::eNone;
7232 int anAction = ActionToControl( aControl, true );
7234 action( anAction )->setChecked( true );
7236 QMenu* send = (QMenu*)sender();
7237 QList<QAction*> actions = send->actions();
7238 for ( int i = 0; i < actions.size(); i++ )
7239 actions[i]->setChecked( false );
7245 \brief Signal handler closing(SUIT_ViewWindow*) of a view
7246 \param pview view being closed
7248 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
7249 #ifndef DISABLE_PLOT2DVIEWER
7250 //Crear all Plot2d Viewers if need.
7251 SMESH::ClearPlot2Viewers(pview);
7253 EmitSignalCloseView();
7256 void SMESHGUI::message( const QString& msg )
7259 QStringList data = msg.split("/");
7260 if ( data.count() > 0 ) {
7261 if ( data.first() == "mesh_loading" ) {
7263 QString entry = data.count() > 1 ? data[1] : QString();
7264 if ( entry.isEmpty() )
7267 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
7269 _PTR(SObject) obj = study->FindObjectID( entry.toUtf8().constData() );
7272 name = SMESH::fromUtf8(obj->GetName());
7273 if ( name.isEmpty() )
7276 if ( data.last() == "stop" )
7277 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
7279 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
7280 QApplication::processEvents();
7286 \brief Connects or disconnects signals about activating and cloning view on the module slots
7287 \param pview view which is connected/disconnected
7289 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
7293 SUIT_ViewManager* viewMgr = pview->getViewManager();
7295 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7296 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7298 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7299 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7304 \brief Return \c true if object can be renamed
7306 bool SMESHGUI::renameAllowed( const QString& entry) const {
7307 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7311 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7315 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
7320 if(appStudy->isComponent(entry) || obj->isReference())
7323 // check type to prevent renaming of inappropriate objects
7324 int aType = SMESHGUI_Selection::type(qPrintable(entry));
7325 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7326 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7327 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7328 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7329 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
7336 Rename object by entry.
7337 \param entry entry of the object
7338 \param name new name of the object
7339 \brief Return \c true if rename operation finished successfully, \c false otherwise.
7341 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
7343 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7347 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7352 _PTR(Study) aStudy = appStudy->studyDS();
7357 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
7359 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
7364 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
7365 _PTR(GenericAttribute) anAttr;
7366 _PTR(AttributeName) aName;
7368 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
7370 // check type to prevent renaming of inappropriate objects
7371 int aType = SMESHGUI_Selection::type( qPrintable(entry));
7372 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7373 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7374 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7375 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7376 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
7377 if ( !name.isEmpty() ) {
7378 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qUtf8Printable(name) );
7380 // update name of group object and its actor
7381 Handle(SALOME_InteractiveObject) IObject =
7382 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
7384 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
7385 if( !aGroupObject->_is_nil() ) {
7386 aGroupObject->SetName( qUtf8Printable(name) );
7387 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
7388 anActor->setName( qUtf8Printable(name) );
7398 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
7400 static QList<QColor> colors;
7402 if ( colors.isEmpty() ) {
7404 for (int s = 0; s < 2 ; s++)
7406 for (int v = 100; v >= 40; v = v - 20)
7408 for (int h = 0; h < 359 ; h = h + 60)
7410 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
7415 static int currentColor = randomize( colors.size() );
7417 SALOMEDS::Color color;
7418 color.R = (double)colors[currentColor].red() / 255.0;
7419 color.G = (double)colors[currentColor].green() / 255.0;
7420 color.B = (double)colors[currentColor].blue() / 255.0;
7422 currentColor = (currentColor+1) % colors.count();