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 void SetDisplayMode(int theCommandID, VTK::MarkerMap& theMarkerMap)
1441 SALOME_ListIO selected;
1442 SalomeApp_Application* app =
1443 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1447 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1448 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1449 if ( !aSel || !appStudy )
1452 if ( theCommandID == SMESHOp::OpClipping ) { // Clipping dialog can be activated without selection
1453 if ( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
1454 aModule->EmitSignalDeactivateDialog();
1455 if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
1456 (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
1461 aSel->selectedObjects( selected );
1463 if ( selected.Extent() >= 1 )
1465 switch ( theCommandID ) {
1466 case SMESHOp::OpTransparency:
1468 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1469 (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
1472 case SMESHOp::OpProperties:
1475 QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
1476 QColor orientationColor, outlineColor, volumeColor;
1477 int deltaF = 0, deltaV = 0;
1480 double ballScale = 1.0;
1482 int outlineWidth = 1;
1483 double shrinkCoef = 0.0;
1484 double orientationScale = 0.0;
1485 bool orientation3d = false;
1486 VTK::MarkerType markerType = VTK::MT_NONE;
1487 VTK::MarkerScale markerScale = VTK::MS_NONE;
1489 bool hasNodes = false;
1490 int presentEntities = 0;
1491 bool firstTime = true;
1493 SALOME_ListIteratorOfListIO It( selected );
1494 for ( ; It.More(); It.Next() ) {
1495 Handle(SALOME_InteractiveObject) IObject = It.Value();
1496 if ( !IObject->hasEntry() ) continue;
1497 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1498 if ( !anActor || !anActor->GetObject() ) continue;
1501 // nodes: color, marker
1502 anActor->GetNodeColor( color[0], color[1], color[2] );
1503 nodeColor.setRgbF( color[0], color[1], color[2] );
1504 markerType = anActor->GetMarkerType();
1505 markerScale = anActor->GetMarkerScale();
1506 markerId = anActor->GetMarkerTexture();
1507 // edges: color, width
1508 anActor->GetEdgeColor( color[0], color[1], color[2] );
1509 edgeColor.setRgbF( color[0], color[1], color[2] );
1510 edgeWidth = qMax( (int)anActor->GetLineWidth(), 1 ); // minimum allowed width is 1
1511 // faces: front color, back color (delta)
1512 anActor->GetSufaceColor( color[0], color[1], color[2], deltaF );
1513 faceColor.setRgbF( color[0], color[1], color[2] );
1514 // faces: front color, back color (delta)
1515 anActor->GetVolumeColor( color[0], color[1], color[2], deltaV );
1516 volumeColor.setRgbF( color[0], color[1], color[2] );
1517 // 0d elements: color, size
1518 anActor->Get0DColor( color[0], color[1], color[2] );
1519 elem0dColor.setRgbF( color[0], color[1], color[2] );
1520 elem0dSize = qMax( (int)anActor->Get0DSize(), 1 ); // minimum allowed size is 1
1521 // balls: color, size
1522 anActor->GetBallColor( color[0], color[1], color[2] );
1523 ballColor.setRgbF( color[0], color[1], color[2] );
1524 //ballSize = qMax( (int)anActor->GetBallSize(), 1 ); // minimum allowed size is 1
1525 ballScale = qMax( (double)anActor->GetBallScale(), 1e-2 ); // minimum allowed scale is 1e-2
1527 anActor->GetOutlineColor( color[0], color[1], color[2] );
1528 outlineColor.setRgbF( color[0], color[1], color[2] );
1529 outlineWidth = qMax( (int)anActor->GetOutlineWidth(), 1 ); // minimum allowed width is 1
1530 // orientation vectors: color, scale, 3d flag
1531 anActor->GetFacesOrientationColor( color[0], color[1], color[2] );
1532 orientationColor.setRgbF( color[0], color[1], color[2] );
1533 orientationScale = anActor->GetFacesOrientationScale();
1534 orientation3d = anActor->GetFacesOrientation3DVectors();
1536 shrinkCoef = anActor->GetShrinkFactor();
1539 firstTime = false; // we only take properties from first object (for performance reasons)
1542 hasNodes = anActor->GetObject()->GetNbEntities( SMDSAbs_Node );
1543 if ( !(presentEntities & SMESH_Actor::eEdges) && anActor->GetObject()->GetNbEntities( SMDSAbs_Edge ) )
1544 presentEntities = presentEntities | SMESH_Actor::eEdges;
1545 if ( !(presentEntities & SMESH_Actor::eFaces) && anActor->GetObject()->GetNbEntities( SMDSAbs_Face ) )
1546 presentEntities = presentEntities | SMESH_Actor::eFaces;
1547 if ( !(presentEntities & SMESH_Actor::eVolumes) && anActor->GetObject()->GetNbEntities( SMDSAbs_Volume ) )
1548 presentEntities = presentEntities | SMESH_Actor::eVolumes;
1549 if ( !(presentEntities & SMESH_Actor::e0DElements) && anActor->GetObject()->GetNbEntities( SMDSAbs_0DElement ) )
1550 presentEntities = presentEntities | SMESH_Actor::e0DElements;
1551 if ( !(presentEntities & SMESH_Actor::eBallElem) && anActor->GetObject()->GetNbEntities( SMDSAbs_Ball ) )
1552 presentEntities = presentEntities | SMESH_Actor::eBallElem;
1554 // as we know that all types of elements are present, we can exit the loop
1555 if ( presentEntities == SMESH_Actor::eAllEntity )
1559 SMESHGUI_PropertiesDlg dlg( theMarkerMap, SMESHGUI::desktop() );
1560 // nodes: color, marker
1561 dlg.setNodeColor( nodeColor );
1562 if( markerType != VTK::MT_USER )
1563 dlg.setNodeMarker( markerType, markerScale );
1565 dlg.setNodeCustomMarker( markerId );
1566 // edges: color, line width
1567 dlg.setEdgeColor( edgeColor );
1568 dlg.setEdgeWidth( edgeWidth );
1569 // faces: front color, back color
1570 dlg.setFaceColor( faceColor, deltaF );
1571 // volumes: normal color, reversed color
1572 dlg.setVolumeColor( volumeColor, deltaV );
1573 // outlines: color, line width
1574 dlg.setOutlineColor( outlineColor );
1575 dlg.setOutlineWidth( outlineWidth );
1576 // 0d elements: color, size
1577 dlg.setElem0dColor( elem0dColor );
1578 dlg.setElem0dSize( elem0dSize );
1579 // balls: color, size
1580 dlg.setBallColor( ballColor );
1581 //dlg.setBallSize( ballSize );
1582 dlg.setBallScale( ballScale );
1583 // orientation: color, scale, 3d flag
1584 dlg.setOrientationColor( orientationColor );
1585 dlg.setOrientationSize( int( orientationScale * 100. ) );
1586 dlg.setOrientation3d( orientation3d );
1587 // shrink: scale factor
1588 dlg.setShrinkCoef( int( shrinkCoef * 100. ) );
1589 // hide unused controls
1590 dlg.showControls( presentEntities, hasNodes );
1593 nodeColor = dlg.nodeColor();
1594 markerType = dlg.nodeMarkerType();
1595 markerScale = dlg.nodeMarkerScale();
1596 markerId = dlg.nodeMarkerId();
1597 edgeColor = dlg.edgeColor();
1598 edgeWidth = dlg.edgeWidth();
1599 faceColor = dlg.faceColor();
1600 deltaF = dlg.faceColorDelta();
1601 volumeColor = dlg.volumeColor();
1602 deltaV = dlg.volumeColorDelta();
1603 outlineColor = dlg.outlineColor();
1604 outlineWidth = dlg.outlineWidth();
1605 elem0dColor = dlg.elem0dColor();
1606 elem0dSize = dlg.elem0dSize();
1607 ballColor = dlg.ballColor();
1608 // ballSize = dlg.ballSize();
1609 ballScale = dlg.ballScale();
1610 orientationColor = dlg.orientationColor();
1611 orientationScale = dlg.orientationSize() / 100.;
1612 orientation3d = dlg.orientation3d();
1613 shrinkCoef = dlg.shrinkCoef() / 100.;
1615 // store point markers that might be changed by the user
1616 theMarkerMap = dlg.customMarkers();
1618 // set properties from dialog box to the presentations
1619 SALOME_ListIteratorOfListIO It( selected );
1620 for ( ; It.More(); It.Next() ) {
1621 Handle(SALOME_InteractiveObject) IObject = It.Value();
1622 if ( !IObject->hasEntry() ) continue;
1623 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1624 if ( !anActor ) continue;
1626 // nodes: color, marker
1627 anActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
1628 if ( markerType != VTK::MT_USER ) {
1629 anActor->SetMarkerStd( markerType, markerScale );
1632 VTK::MarkerMap::const_iterator iter = theMarkerMap.find( markerId );
1633 if ( iter != theMarkerMap.end() )
1634 anActor->SetMarkerTexture( markerId, iter->second.second );
1636 // volumes: normal color, reversed color (delta)
1637 anActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
1638 // faces: front color, back color (delta)
1639 anActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
1640 // edges: color, width
1641 anActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
1642 anActor->SetLineWidth( edgeWidth );
1644 anActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
1645 anActor->SetOutlineWidth( outlineWidth );
1646 // 0D elements: color, size
1647 anActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
1648 anActor->Set0DSize( elem0dSize );
1649 // balls: color, size
1650 anActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
1651 // anActor->SetBallSize( ballSize );
1652 anActor->SetBallScale( ballScale );
1653 // orientation: color, scale, 3d flag
1654 anActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
1655 anActor->SetFacesOrientationScale( orientationScale );
1656 anActor->SetFacesOrientation3DVectors( orientation3d );
1658 anActor->SetShrinkFactor( shrinkCoef );
1660 // for groups, set also proper color
1661 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1662 if ( !aGroupObject->_is_nil() ) {
1663 SMESH::ElementType anElementType = aGroupObject->GetType();
1665 switch( anElementType ) {
1667 aColor = nodeColor; break;
1669 aColor = edgeColor; break;
1671 aColor = faceColor; break;
1673 aColor = volumeColor; break;
1675 aColor = elem0dColor; break;
1677 aColor = ballColor; break;
1681 if ( aColor.isValid() ) {
1682 SALOMEDS::Color aGroupColor;
1683 aGroupColor.R = aColor.redF();
1684 aGroupColor.G = aColor.greenF();
1685 aGroupColor.B = aColor.blueF();
1686 aGroupObject->SetColor( aGroupColor );
1688 } // if ( !aGroupObject->_is_nil() )
1689 } // for ( ; It.More(); It.Next() )
1690 SMESH::RepaintCurrentView();
1691 } // if ( dlg.exec() )
1693 } // case SMESHOp::OpProperties:
1694 } // switch(theCommandID)
1695 SUIT_OverrideCursor wc;
1696 SALOME_ListIteratorOfListIO It( selected );
1697 for( ; It.More(); It.Next()){
1698 Handle(SALOME_InteractiveObject) IObject = It.Value();
1699 if(IObject->hasEntry()){
1700 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1701 switch(theCommandID){
1702 case SMESHOp::OpDMWireframe:
1703 anActor->SetRepresentation(SMESH_Actor::eEdge);
1705 case SMESHOp::OpDMShading:
1706 anActor->SetRepresentation(SMESH_Actor::eSurface);
1708 case SMESHOp::OpDMShrink:
1709 if(anActor->IsShrunk())
1710 anActor->UnShrink();
1712 anActor->SetShrink();
1714 case SMESHOp::OpDMNodes:
1715 anActor->SetRepresentation(SMESH_Actor::ePoint);
1717 case SMESHOp::OpRepresentationLines:
1718 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1719 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1721 case SMESHOp::OpRepresentationArcs:
1722 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1723 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1729 SMESH::RepaintCurrentView();
1733 int ActionToControl( int theID, bool theReversed )
1735 NCollection_DoubleMap<int,int> ActionControl;
1736 ActionControl.Bind( 0, SMESH_Actor::eNone );
1737 ActionControl.Bind( SMESHOp::OpFreeNode, SMESH_Actor::eFreeNodes );
1738 ActionControl.Bind( SMESHOp::OpEqualNode, SMESH_Actor::eCoincidentNodes );
1739 ActionControl.Bind( SMESHOp::OpNodeConnectivityNb, SMESH_Actor::eNodeConnectivityNb );
1740 ActionControl.Bind( SMESHOp::OpFreeEdge, SMESH_Actor::eFreeEdges );
1741 ActionControl.Bind( SMESHOp::OpFreeBorder, SMESH_Actor::eFreeBorders );
1742 ActionControl.Bind( SMESHOp::OpLength, SMESH_Actor::eLength );
1743 ActionControl.Bind( SMESHOp::OpConnection, SMESH_Actor::eMultiConnection );
1744 ActionControl.Bind( SMESHOp::OpEqualEdge, SMESH_Actor::eCoincidentElems1D );
1745 ActionControl.Bind( SMESHOp::OpFreeFace, SMESH_Actor::eFreeFaces );
1746 ActionControl.Bind( SMESHOp::OpBareBorderFace, SMESH_Actor::eBareBorderFace );
1747 ActionControl.Bind( SMESHOp::OpOverConstrainedFace, SMESH_Actor::eOverConstrainedFace );
1748 ActionControl.Bind( SMESHOp::OpLength2D, SMESH_Actor::eLength2D );
1749 ActionControl.Bind( SMESHOp::OpDeflection2D, SMESH_Actor::eDeflection2D );
1750 ActionControl.Bind( SMESHOp::OpConnection2D, SMESH_Actor::eMultiConnection2D );
1751 ActionControl.Bind( SMESHOp::OpArea, SMESH_Actor::eArea );
1752 ActionControl.Bind( SMESHOp::OpTaper, SMESH_Actor::eTaper );
1753 ActionControl.Bind( SMESHOp::OpAspectRatio, SMESH_Actor::eAspectRatio );
1754 ActionControl.Bind( SMESHOp::OpMinimumAngle, SMESH_Actor::eMinimumAngle );
1755 ActionControl.Bind( SMESHOp::OpWarpingAngle, SMESH_Actor::eWarping );
1756 ActionControl.Bind( SMESHOp::OpSkew, SMESH_Actor::eSkew );
1757 ActionControl.Bind( SMESHOp::OpMaxElementLength2D, SMESH_Actor::eMaxElementLength2D );
1758 ActionControl.Bind( SMESHOp::OpEqualFace, SMESH_Actor::eCoincidentElems2D );
1759 ActionControl.Bind( SMESHOp::OpAspectRatio3D, SMESH_Actor::eAspectRatio3D );
1760 ActionControl.Bind( SMESHOp::OpVolume, SMESH_Actor::eVolume3D );
1761 ActionControl.Bind( SMESHOp::OpMaxElementLength3D, SMESH_Actor::eMaxElementLength3D );
1762 ActionControl.Bind( SMESHOp::OpBareBorderVolume, SMESH_Actor::eBareBorderVolume );
1763 ActionControl.Bind( SMESHOp::OpOverConstrainedVolume, SMESH_Actor::eOverConstrainedVolume );
1764 ActionControl.Bind( SMESHOp::OpEqualVolume, SMESH_Actor::eCoincidentElems3D );
1767 return ActionControl.IsBound2( theID ) ? ActionControl.Find2( theID ) : 0;
1768 return ActionControl.IsBound1( theID ) ? ActionControl.Find1( theID ) : 0;
1771 void Control( int theCommandID )
1773 SMESH_Actor::eControl aControl = SMESH_Actor::eControl( ActionToControl( theCommandID ));
1774 _PTR(Study) aStudy = SMESH::getStudy();
1776 SALOME_ListIO selected;
1777 if ( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
1778 aSel->selectedObjects( selected );
1780 if ( !selected.IsEmpty() ) {
1781 SALOME_ListIteratorOfListIO It(selected);
1782 for ( ; It.More(); It.Next())
1784 Handle(SALOME_InteractiveObject) anIO = It.Value();
1785 if ( !anIO.IsNull() ) {
1786 _PTR(SObject) SO = aStudy->FindObjectID( It.Value()->getEntry() );
1788 CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
1789 SMESH::SMESH_IDSource_var anIDSrc = SMESH::SMESH_IDSource::_narrow( aObject );
1790 if ( !anIDSrc->_is_nil() ) {
1791 SMESH_Actor *anActor = SMESH::FindActorByEntry( anIO->getEntry());
1792 if (( !anActor && selected.Extent() == 1 ) &&
1793 ( anActor = SMESH::CreateActor( anIO->getEntry() )))
1795 anActor->SetControlMode( aControl );
1796 SMESH::DisplayActor( SMESH::GetCurrentVtkView(), anActor );
1797 SMESH::UpdateView ( SMESH::eDisplay, anIO->getEntry() );
1801 if ( anActor->GetControlMode() != aControl )
1802 anActor->SetControlMode( aControl );
1803 QString functorName = functorToString( anActor->GetFunctor() );
1804 int anEntitiesCount = anActor->GetNumberControlEntities();
1805 if (anEntitiesCount >= 0)
1806 functorName = functorName + ": " + QString::number(anEntitiesCount);
1807 anActor->GetScalarBarActor()->SetTitle( functorName.toUtf8().constData() );
1808 SMESH::RepaintCurrentView();
1809 #ifndef DISABLE_PLOT2DVIEWER
1810 if ( anActor->GetPlot2Histogram() ) {
1811 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1812 QString aHistogramName("%1 : %2");
1813 aHistogramName = aHistogramName.arg( anIO->getName() ).arg( functorName );
1814 aHistogram->setName( aHistogramName );
1815 aHistogram->setHorTitle( functorName );
1816 SMESH::ProcessIn2DViewers( anActor );
1828 bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1829 SMESH::MeshObjectType theType,
1830 const QString theInTypeName,
1831 QString & theOutTypeName)
1833 SMESH_TypeFilter aTypeFilter( theType );
1835 if ( !theIO.IsNull() )
1837 entry = theIO->getEntry();
1838 LightApp_DataOwner owner( entry );
1839 if ( aTypeFilter.isOk( &owner )) {
1840 theOutTypeName = theInTypeName;
1848 QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1850 _PTR(Study) aStudy = SMESH::getStudy();
1851 _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1853 _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1854 CORBA::String_var anID = aSComp->GetID().c_str();
1855 if ( !strcmp(anID.in(),theIO->getEntry()) )
1861 CheckOIType ( theIO, SMESH::HYPOTHESIS, "Hypothesis", aTypeName ) ||
1862 CheckOIType ( theIO, SMESH::ALGORITHM, "Algorithm", aTypeName ) ||
1863 CheckOIType ( theIO, SMESH::MESH, "Mesh", aTypeName ) ||
1864 CheckOIType ( theIO, SMESH::SUBMESH, "SubMesh", aTypeName ) ||
1865 CheckOIType ( theIO, SMESH::GROUP, "Group", aTypeName )
1873 // QString CheckHomogeneousSelection()
1875 // LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1876 // SALOME_ListIO selected;
1878 // aSel->selectedObjects( selected );
1880 // QString RefType = CheckTypeObject(selected.First());
1881 // SALOME_ListIteratorOfListIO It(selected);
1882 // for ( ; It.More(); It.Next())
1884 // Handle(SALOME_InteractiveObject) IObject = It.Value();
1885 // QString Type = CheckTypeObject(IObject);
1886 // if ( Type.compare(RefType) != 0 )
1887 // return "Heterogeneous Selection";
1893 uint randomize( uint size )
1895 static bool initialized = false;
1896 if ( !initialized ) {
1897 qsrand( QDateTime::currentDateTime().toTime_t() );
1901 v = uint( (double)( v ) / RAND_MAX * size );
1902 v = qMax( uint(0), qMin ( v, size-1 ) );
1908 void SMESHGUI::OnEditDelete()
1910 // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1911 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1912 SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1914 _PTR(Study) aStudy = SMESH::getStudy();
1915 _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1916 _PTR(GenericAttribute) anAttr;
1917 _PTR(AttributeIOR) anIOR;
1919 const int objectCountLimit = 30; // PAL23599
1920 int objectCount = 0;
1922 QString aParentComponent = QString::null;
1924 for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1926 Handle(SALOME_InteractiveObject) anIO = anIt.Value();
1927 if ( anIO.IsNull() ) continue;
1929 QString father = "unknown", name;
1931 _PTR(SObject) aSO = aStudy->FindObjectID( anIO->getEntry() );
1933 father = QString::fromStdString( aSO->GetFatherComponent()->ComponentDataType() );
1934 // check if object is reference
1935 _PTR(SObject) aRefSObj;
1936 if ( aSO->ReferencedObject( aRefSObj ) ) {
1937 name = QString::fromStdString ( aRefSObj->GetName() );
1938 father = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1941 name = anIO->getName();
1944 if ( objectCount < objectCountLimit ) { // avoid occupying the whole screen
1945 aNameList.append("\n - ");
1946 aNameList.append( name );
1949 if( aParentComponent.isNull() )
1950 aParentComponent = father;
1951 else if( !aParentComponent.isEmpty() && aParentComponent!=father )
1952 aParentComponent = "";
1954 if ( objectCount >= objectCountLimit )
1955 aNameList.append("\n - ...");
1957 if ( objectCount == 0 )
1958 return; // No Valid Objects Selected
1960 if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
1961 SUIT_MessageBox::warning( SMESHGUI::desktop(),
1962 QObject::tr("ERR_ERROR"),
1963 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
1966 // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
1967 if (SUIT_MessageBox::warning
1968 (SMESHGUI::desktop(),
1969 QObject::tr("SMESH_WRN_WARNING"),
1970 QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
1971 SUIT_MessageBox::Yes | SUIT_MessageBox::No,
1972 SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
1975 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1977 // Put one level of sub-objects of the selected SO's into a list
1978 // in order to get objects inside folders like "Assigned Algorithms"
1979 std::list< _PTR(SObject) > listSO;
1980 SALOME_ListIteratorOfListIO It(selected);
1981 for( ; It.More(); It.Next()) // loop on selected IO's
1983 Handle(SALOME_InteractiveObject) IObject = It.Value();
1984 if(IObject->hasEntry()) {
1985 _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
1987 // disable removal of "SMESH" component object
1988 if(aSO->FindAttribute(anAttr, "AttributeIOR")){
1990 if ( engineIOR() == anIOR->Value().c_str() )
1993 //Check the referenced object
1994 _PTR(SObject) aRefSObject;
1995 if ( aSO && aSO->ReferencedObject( aRefSObject ) )
1996 aSO = aRefSObject; // Delete main Object instead of reference
1998 listSO.push_back( aSO );
2000 _PTR(ChildIterator) it = aStudy->NewChildIterator( aSO );
2001 for (it->InitEx(false); it->More(); it->Next())
2002 listSO.push_back( it->Value() );
2005 // Check if none of objects to delete is referred from outside
2006 std::list< _PTR(SObject) >::reverse_iterator ritSO;
2007 std::vector< _PTR(SObject) > subSO;
2008 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
2010 _PTR(SObject) SO = *ritSO;
2011 if ( !SO ) continue;
2013 int nbChildren = SO->GetLastChildTag();
2015 subSO.reserve( 1 + nbChildren );
2016 subSO.push_back( SO );
2017 if ( nbChildren > 0 )
2019 _PTR(ChildIterator) it = aStudy->NewChildIterator( SO );
2020 for ( it->InitEx( true ); it->More(); it->Next() )
2021 subSO.push_back( it->Value() );
2023 for ( size_t i = 0; i < subSO.size(); ++i )
2025 std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( subSO[i] );
2026 for ( size_t j = 0; j < aReferences.size(); j++ ) {
2027 _PTR(SComponent) aComponent = aReferences[j]->GetFatherComponent();
2028 std::string type = aComponent->ComponentDataType();
2029 if ( type != "SMESH" )
2031 SUIT_MessageBox::warning( anApp->desktop(),
2032 QObject::tr("WRN_WARNING"),
2033 QObject::tr("DEP_OBJECT") );
2034 return; // outside SMESH, there is an object depending on a SMESH object
2040 // Treat SO's in the list starting from the back
2041 aStudyBuilder->NewCommand(); // There is a transaction
2042 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
2044 _PTR(SObject) SO = *ritSO;
2045 if ( !SO ) continue;
2046 std::string anEntry = SO->GetID();
2048 /** Erase graphical object and remove all its data **/
2049 if ( SO->FindAttribute( anAttr, "AttributeIOR" )) {
2050 SMESH::RemoveVisualObjectWithActors( anEntry.c_str(), true);
2052 /** Remove an object from data structures **/
2053 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
2054 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
2055 if ( !aGroup->_is_nil() ) { // DELETE GROUP
2056 SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
2057 aMesh->RemoveGroup( aGroup );
2059 else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
2060 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2061 aMesh->RemoveSubMesh( aSubMesh );
2064 Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
2065 ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
2066 QString objType = CheckTypeObject(IObject);
2067 if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
2068 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
2069 aStudyBuilder->RemoveObjectWithChildren( SO );
2071 else {// default action: remove SObject from the study
2072 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
2073 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
2075 aStudyBuilder->RemoveObjectWithChildren( SO );
2079 } /* listSO back loop */
2081 aStudyBuilder->CommitCommand();
2083 /* Clear any previous selection */
2085 aSel->setSelectedObjects( l1 );
2087 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
2091 SMESHGUI_EXPORT CAM_Module* createModule()
2093 return new SMESHGUI();
2096 SMESHGUI_EXPORT char* getModuleVersion() {
2097 return (char*)SMESH_VERSION_STR;
2101 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
2103 //=============================================================================
2107 //=============================================================================
2108 SMESHGUI::SMESHGUI() :
2109 SalomeApp_Module( "SMESH" )
2111 if ( CORBA::is_nil( myComponentSMESH ) )
2113 CORBA::Boolean anIsEmbeddedMode;
2114 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
2115 //MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
2117 // 0019923: EDF 765 SMESH : default values of hypothesis
2118 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
2119 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
2120 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
2121 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
2122 myComponentSMESH->SetDefaultNbSegments( nbSeg );
2124 const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif", "default_grp_color" };
2125 for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
2126 if ( aResourceMgr->hasValue( "SMESH", options[i] ))
2128 QString val = aResourceMgr->stringValue( "SMESH", options[i] );
2129 myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
2133 myActiveDialogBox = 0;
2134 myFilterLibraryDlg = 0;
2138 myEventCallbackCommand = vtkCallbackCommand::New();
2139 myEventCallbackCommand->Delete();
2140 myEventCallbackCommand->SetClientData( this );
2141 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
2144 /* load resources for all available meshers */
2145 SMESH::InitAvailableHypotheses();
2148 //=============================================================================
2152 //=============================================================================
2153 SMESHGUI::~SMESHGUI()
2157 //=============================================================================
2161 //=============================================================================
2162 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
2164 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2166 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
2171 //=============================================================================
2175 //=============================================================================
2176 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
2178 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2182 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2183 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2184 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2185 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2186 return autoUpdate && !exceeded;
2189 //=============================================================================
2193 //=============================================================================
2194 bool SMESHGUI::automaticUpdate( SMESH::SMESH_IDSource_ptr theMesh,
2195 int* entities, bool* limitExceeded, int* hidden, long* nbElements )
2197 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2201 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2202 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2203 bool incrementalLimit = resMgr->booleanValue( "SMESH", "incremental_limit", false );
2205 SMESH::long_array_var info = theMesh->GetMeshInfo();
2206 long nbOdElems = info[SMDSEntity_0D];
2207 long nbEdges = info[SMDSEntity_Edge] + info[SMDSEntity_Quad_Edge];
2208 long nbFaces = info[SMDSEntity_Triangle] + info[SMDSEntity_Quad_Triangle] + info[SMDSEntity_BiQuad_Triangle] +
2209 info[SMDSEntity_Quadrangle] + info[SMDSEntity_Quad_Quadrangle] + info[SMDSEntity_BiQuad_Quadrangle] +
2210 info[SMDSEntity_Polygon] + info[SMDSEntity_Quad_Polygon];
2211 long nbVolumes = info[SMDSEntity_Tetra] + info[SMDSEntity_Quad_Tetra] +
2212 info[SMDSEntity_Hexa] + info[SMDSEntity_Quad_Hexa] + info[SMDSEntity_TriQuad_Hexa] +
2213 info[SMDSEntity_Pyramid] + info[SMDSEntity_Quad_Pyramid] +
2214 info[SMDSEntity_Penta] + info[SMDSEntity_Quad_Penta] + info[SMDSEntity_BiQuad_Penta] +
2215 info[SMDSEntity_Polyhedra] +
2216 info[SMDSEntity_Hexagonal_Prism];
2217 long nbBalls = info[SMDSEntity_Ball];
2219 long requestedSize = nbOdElems + nbBalls + nbEdges + nbFaces + nbVolumes;
2220 *nbElements = requestedSize;
2222 *entities = SMESH_Actor::eAllEntity;
2225 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2227 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2229 if ( incrementalLimit ) {
2232 if ( nbOdElems > 0 ) {
2233 if ( total + nbOdElems > updateLimit ) {
2234 *entities = *entities & ~SMESH_Actor::e0DElements;
2235 *hidden = *hidden | SMESH_Actor::e0DElements;
2242 if ( nbEdges > 0 ) {
2243 if ( total + nbEdges > updateLimit ) {
2244 *entities = *entities & ~SMESH_Actor::eEdges;
2245 *hidden = *hidden | SMESH_Actor::eEdges;
2252 if ( nbFaces > 0 ) {
2253 if ( total + nbFaces > updateLimit ) {
2254 *entities = *entities & ~SMESH_Actor::eFaces;
2255 *hidden = *hidden | SMESH_Actor::eFaces;
2262 if ( nbVolumes > 0 ) {
2263 if ( total + nbVolumes > updateLimit ) {
2264 *entities = *entities & ~SMESH_Actor::eVolumes;
2265 *hidden = *hidden | SMESH_Actor::eVolumes;
2272 if ( nbBalls > 0 ) {
2273 if ( total + nbBalls > updateLimit ) {
2274 *entities = *entities & ~SMESH_Actor::eBallElem;
2275 *hidden = *hidden | SMESH_Actor::eBallElem;
2283 return autoUpdate && !exceeded;
2286 //=============================================================================
2290 //=============================================================================
2291 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
2293 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
2296 //=============================================================================
2300 //=============================================================================
2301 SMESHGUI* SMESHGUI::GetSMESHGUI()
2303 SMESHGUI* smeshMod = 0;
2304 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
2307 CAM_Module* module = app->module( "Mesh" );
2308 smeshMod = dynamic_cast<SMESHGUI*>( module );
2316 Standard_EXPORT SMESHGUI* GetComponentGUI()
2318 return SMESHGUI::GetSMESHGUI();
2322 //=============================================================================
2326 //=============================================================================
2327 void SMESHGUI::SetState(int aState)
2332 //=============================================================================
2336 //=============================================================================
2337 void SMESHGUI::ResetState()
2342 //=============================================================================
2346 //=============================================================================
2347 void SMESHGUI::EmitSignalDeactivateDialog()
2349 emit SignalDeactivateActiveDialog();
2352 //=============================================================================
2356 //=============================================================================
2357 void SMESHGUI::EmitSignalStudyFrameChanged()
2359 emit SignalStudyFrameChanged();
2362 //=============================================================================
2366 //=============================================================================
2367 void SMESHGUI::EmitSignalCloseAllDialogs()
2369 emit SignalCloseAllDialogs();
2372 //=============================================================================
2376 //=============================================================================
2377 void SMESHGUI::EmitSignalVisibilityChanged()
2379 emit SignalVisibilityChanged();
2382 //=============================================================================
2386 //=============================================================================
2387 void SMESHGUI::EmitSignalCloseView()
2389 emit SignalCloseView();
2392 //=============================================================================
2396 //=============================================================================
2397 void SMESHGUI::EmitSignalActivatedViewManager()
2399 emit SignalActivatedViewManager();
2402 //=============================================================================
2406 //=============================================================================
2407 QDialog *SMESHGUI::GetActiveDialogBox()
2409 return myActiveDialogBox;
2412 //=============================================================================
2416 //=============================================================================
2417 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2419 myActiveDialogBox = (QDialog *) aDlg;
2423 //=============================================================================
2427 //=============================================================================
2428 SUIT_Desktop* SMESHGUI::desktop()
2430 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2432 return app->desktop();
2437 //=============================================================================
2441 //=============================================================================
2442 SalomeApp_Study* SMESHGUI::activeStudy()
2444 SUIT_Application* app = SUIT_Session::session()->activeApplication();
2446 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2451 //=============================================================================
2455 //=============================================================================
2456 void SMESHGUI::Modified( bool theIsUpdateActions )
2458 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2459 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2460 appStudy->Modified();
2461 if( theIsUpdateActions )
2462 app->updateActions();
2467 //=============================================================================
2471 //=============================================================================
2472 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2474 /* Here the position is on the bottom right corner - 10 */
2475 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2477 SUIT_Desktop *PP = desktop();
2478 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2479 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2484 * \brief Verifies whether study of operation is locked
2485 * \param theMess - specifies whether message box must be shown if study is locked
2486 * \return State of study.
2488 * Verifies whether study of operation is locked. If second parameter is TRUE and study
2489 * is locked when corresponding message box appears
2491 bool SMESHGUI::isStudyLocked( bool theMessage )
2493 if ( SMESH::getStudy()->GetProperties()->IsLocked() )
2496 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2497 QObject::tr( "WRN_WARNING" ),
2498 QObject::tr( "WRN_STUDY_LOCKED" ) );
2504 //=============================================================================
2508 //=============================================================================
2509 bool SMESHGUI::OnGUIEvent( int theCommandID )
2511 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2515 SUIT_ResourceMgr* mgr = resourceMgr();
2519 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2520 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2522 //QAction* act = action( theCommandID );
2524 switch (theCommandID) {
2525 case SMESHOp::OpDelete:
2526 if(isStudyLocked()) break;
2529 case SMESHOp::OpImportDAT:
2530 case SMESHOp::OpImportUNV:
2531 case SMESHOp::OpImportMED:
2532 case SMESHOp::OpImportSTL:
2533 case SMESHOp::OpImportCGNS:
2534 case SMESHOp::OpImportSAUV:
2535 case SMESHOp::OpImportGMF:
2536 case SMESHOp::OpPopupImportDAT:
2537 case SMESHOp::OpPopupImportUNV:
2538 case SMESHOp::OpPopupImportMED:
2539 case SMESHOp::OpPopupImportSTL:
2540 case SMESHOp::OpPopupImportCGNS:
2541 case SMESHOp::OpPopupImportSAUV:
2542 case SMESHOp::OpPopupImportGMF:
2544 if(isStudyLocked()) break;
2545 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2549 case SMESHOp::OpFileInformation:
2551 SALOME_ListIO selected;
2552 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2554 aSel->selectedObjects( selected );
2555 if( selected.Extent() )
2557 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2558 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2559 if ( !aMesh->_is_nil() )
2561 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2567 case SMESHOp::OpExportDAT:
2568 case SMESHOp::OpExportMED:
2569 case SMESHOp::OpExportUNV:
2570 case SMESHOp::OpExportSTL:
2571 case SMESHOp::OpExportCGNS:
2572 case SMESHOp::OpExportSAUV:
2573 case SMESHOp::OpExportGMF:
2574 case SMESHOp::OpPopupExportDAT:
2575 case SMESHOp::OpPopupExportMED:
2576 case SMESHOp::OpPopupExportUNV:
2577 case SMESHOp::OpPopupExportSTL:
2578 case SMESHOp::OpPopupExportCGNS:
2579 case SMESHOp::OpPopupExportSAUV:
2580 case SMESHOp::OpPopupExportGMF:
2582 ::ExportMeshToFile(theCommandID);
2586 case SMESHOp::OpReset: // SCALAR BAR
2588 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2589 SALOME_ListIO selected;
2591 aSel->selectedObjects( selected );
2593 SALOME_ListIteratorOfListIO it(selected);
2594 for( ; it.More(); it.Next()) {
2595 Handle(SALOME_InteractiveObject) anIO = it.Value();
2596 if( anIO->hasEntry() ) {
2597 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2598 anActor->SetControlMode( SMESH_Actor::eNone );
2599 #ifndef DISABLE_PLOT2DVIEWER
2600 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2602 anActor->UpdateFilter();
2606 SMESH::UpdateView();
2609 case SMESHOp::OpScalarBarProperties:
2611 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2614 case SMESHOp::OpShowScalarBar:
2616 // show/hide scalar bar
2617 ::ShowElement(theCommandID);
2620 case SMESHOp::OpSaveDistribution:
2622 // dump control distribution data to the text file
2623 ::SaveDistribution();
2627 case SMESHOp::OpShowDistribution:
2629 // show/hide distribution
2630 ::ShowElement(theCommandID);
2634 #ifndef DISABLE_PLOT2DVIEWER
2635 case SMESHOp::OpPlotDistribution:
2637 // plot distribution
2638 ::PlotDistribution();
2644 case SMESHOp::OpAutoColor:
2648 case SMESHOp::OpDisableAutoColor:
2649 ::DisableAutoColor();
2652 case SMESHOp::OpClipping:
2653 case SMESHOp::OpTransparency:
2654 case SMESHOp::OpProperties: // Display preferences (colors, shrink size, line width, ...)
2657 case SMESHOp::OpDMWireframe:
2658 case SMESHOp::OpDMShading:
2659 case SMESHOp::OpDMNodes:
2660 case SMESHOp::OpDMShrink:
2661 ::SetDisplayMode(theCommandID, myMarkerMap);
2664 //2D quadratic representation
2665 case SMESHOp::OpRepresentationLines:
2666 case SMESHOp::OpRepresentationArcs:
2667 ::SetDisplayMode(theCommandID, myMarkerMap);
2671 case SMESHOp::OpDE0DElements:
2672 case SMESHOp::OpDEEdges:
2673 case SMESHOp::OpDEFaces:
2674 case SMESHOp::OpDEVolumes:
2675 case SMESHOp::OpDEBalls:
2676 case SMESHOp::OpDEAllEntity:
2677 ::SetDisplayEntity(theCommandID);
2680 // Choose entities to be displayed
2681 case SMESHOp::OpDEChoose:
2683 ( new SMESHGUI_DisplayEntitiesDlg( SMESHGUI::desktop() ) )->exec();
2687 case SMESHOp::OpOrientationOnFaces:
2689 SUIT_OverrideCursor wc;
2690 LightApp_SelectionMgr* mgr = selectionMgr();
2691 SALOME_ListIO selected; mgr->selectedObjects( selected );
2693 SALOME_ListIteratorOfListIO it(selected);
2694 for( ; it.More(); it.Next()) {
2695 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2696 if(anIObject->hasEntry()) {
2697 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2698 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2705 case SMESHOp::OpUpdate:
2707 if(isStudyLocked()) break;
2708 SUIT_OverrideCursor wc;
2711 SMESH::UpdateView();
2713 catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2714 SMESH::OnVisuException();
2716 catch (...) { // PAL16774 (Crash after display of many groups)
2717 SMESH::OnVisuException();
2721 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2722 aSel->selectedObjects( l );
2723 aSel->setSelectedObjects( l );
2727 case SMESHOp::OpHide:
2728 case SMESHOp::OpShow:
2729 case SMESHOp::OpShowOnly:
2731 SUIT_OverrideCursor wc;
2732 SMESH::EDisplaing anAction;
2733 switch (theCommandID) {
2734 case SMESHOp::OpHide: anAction = SMESH::eErase; break;
2735 case SMESHOp::OpShow: anAction = SMESH::eDisplay; break;
2736 case SMESHOp::OpShowOnly: anAction = SMESH::eDisplayOnly; break;
2739 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2740 SALOME_ListIO sel_objects, to_process;
2742 aSel->selectedObjects( sel_objects );
2744 if ( theCommandID==SMESHOp::OpShowOnly )
2746 //MESSAGE("anAction = SMESH::eDisplayOnly");
2747 startOperation( myEraseAll );
2750 extractContainers( sel_objects, to_process );
2755 SALOME_ListIteratorOfListIO It( to_process );
2756 for ( ; It.More(); It.Next())
2758 Handle(SALOME_InteractiveObject) IOS = It.Value();
2759 if ( IOS->hasEntry() )
2761 if ( !SMESH::UpdateView( anAction, IOS->getEntry() )) {
2762 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2763 break; // PAL16774 (Crash after display of many groups)
2765 if (anAction == SMESH::eDisplayOnly)
2766 anAction = SMESH::eDisplay;
2771 // PAL13338 + PAL15161 -->
2772 if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !isStudyLocked()) {
2773 SMESH::UpdateView();
2774 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2776 // PAL13338 + PAL15161 <--
2778 catch (...) { // PAL16774 (Crash after display of many groups)
2779 SMESH::OnVisuException();
2782 if (anAction == SMESH::eErase) {
2784 aSel->setSelectedObjects( l1 );
2787 aSel->setSelectedObjects( to_process );
2789 if ( vtkwnd && vtkwnd->GetRenderer() && !isStudyLocked() &&
2790 ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) )
2791 vtkwnd->GetRenderer()->AdjustActors();
2796 case SMESHOp::OpNode:
2798 if(isStudyLocked()) break;
2801 EmitSignalDeactivateDialog();
2803 ( new SMESHGUI_NodesDlg( this ) )->show();
2806 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"),tr("SMESH_WRN_VIEWER_VTK"));
2811 case SMESHOp::OpCreateMesh:
2812 case SMESHOp::OpCreateSubMesh:
2813 case SMESHOp::OpEditMeshOrSubMesh:
2814 case SMESHOp::OpEditMesh:
2815 case SMESHOp::OpEditSubMesh:
2816 case SMESHOp::OpCompute:
2817 case SMESHOp::OpComputeSubMesh:
2818 case SMESHOp::OpPreCompute:
2819 case SMESHOp::OpEvaluate:
2820 case SMESHOp::OpMeshOrder:
2821 startOperation( theCommandID );
2823 case SMESHOp::OpCopyMesh:
2825 if (isStudyLocked()) break;
2826 EmitSignalDeactivateDialog();
2827 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2830 case SMESHOp::OpBuildCompoundMesh:
2832 if (isStudyLocked()) break;
2833 EmitSignalDeactivateDialog();
2834 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2838 case SMESHOp::OpDiagonalInversion:
2839 case SMESHOp::OpUnionOfTwoTriangle:
2843 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2847 if ( isStudyLocked() )
2850 /*Standard_Boolean aRes;
2851 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2852 if ( aMesh->_is_nil() )
2854 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2855 tr( "SMESH_BAD_SELECTION" ) );
2859 EmitSignalDeactivateDialog();
2860 if ( theCommandID == SMESHOp::OpDiagonalInversion )
2861 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2863 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2866 case SMESHOp::OpOrientation:
2867 case SMESHOp::OpUnionOfTriangles:
2868 case SMESHOp::OpCuttingOfQuadrangles:
2869 case SMESHOp::OpSplitVolumes:
2873 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2877 if ( isStudyLocked() )
2880 EmitSignalDeactivateDialog();
2881 SMESHGUI_MultiEditDlg* aDlg = NULL;
2882 if ( theCommandID == SMESHOp::OpOrientation )
2883 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2884 else if ( theCommandID == SMESHOp::OpUnionOfTriangles )
2885 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2886 else if ( theCommandID == SMESHOp::OpSplitVolumes )
2887 aDlg = new SMESHGUI_SplitVolumesDlg(this);
2889 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2894 case SMESHOp::OpSmoothing:
2896 if(isStudyLocked()) break;
2898 EmitSignalDeactivateDialog();
2899 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2902 SUIT_MessageBox::warning(desktop(), tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2906 case SMESHOp::OpExtrusion:
2908 if (isStudyLocked()) break;
2910 EmitSignalDeactivateDialog();
2911 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2913 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2917 case SMESHOp::OpExtrusionAlongAPath:
2919 if (isStudyLocked()) break;
2921 EmitSignalDeactivateDialog();
2922 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2924 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2928 case SMESHOp::OpRevolution:
2930 if(isStudyLocked()) break;
2932 EmitSignalDeactivateDialog();
2933 ( new SMESHGUI_RevolutionDlg( this ) )->show();
2936 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2940 case SMESHOp::OpPatternMapping:
2942 if ( isStudyLocked() )
2946 EmitSignalDeactivateDialog();
2947 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2950 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2954 case SMESHOp::OpSplitBiQuadratic:
2955 case SMESHOp::OpConvertMeshToQuadratic:
2956 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
2957 case SMESHOp::OpReorientFaces:
2958 case SMESHOp::OpCreateGeometryGroup:
2960 startOperation( theCommandID );
2963 case SMESHOp::OpCreateGroup:
2967 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2971 if(isStudyLocked()) break;
2972 EmitSignalDeactivateDialog();
2973 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2975 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2976 SALOME_ListIO selected;
2978 aSel->selectedObjects( selected );
2980 int nbSel = selected.Extent();
2982 // check if mesh is selected
2983 aMesh = SMESH::GetMeshByIO( selected.First() );
2985 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2990 case SMESHOp::OpConstructGroup:
2994 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2998 if(isStudyLocked()) break;
2999 EmitSignalDeactivateDialog();
3001 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3002 SALOME_ListIO selected;
3004 aSel->selectedObjects( selected );
3006 int nbSel = selected.Extent();
3008 // check if submesh is selected
3009 Handle(SALOME_InteractiveObject) IObject = selected.First();
3010 if (IObject->hasEntry()) {
3011 _PTR(SObject) aSObj = SMESH::getStudy()->FindObjectID(IObject->getEntry());
3013 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
3014 if (!aSubMesh->_is_nil()) {
3016 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
3017 // get submesh elements list by types
3018 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
3019 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
3020 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
3021 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
3022 // create group for each type o elements
3023 QString aName = IObject->getName();
3024 QStringList anEntryList;
3025 if (aNodes->length() > 0) {
3026 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
3027 aGroup->Add(aNodes.inout());
3028 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3029 anEntryList.append( aSObject->GetID().c_str() );
3031 if (aEdges->length() > 0) {
3032 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
3033 aGroup->Add(aEdges.inout());
3034 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3035 anEntryList.append( aSObject->GetID().c_str() );
3037 if (aFaces->length() > 0) {
3038 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
3039 aGroup->Add(aFaces.inout());
3040 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3041 anEntryList.append( aSObject->GetID().c_str() );
3043 if (aVolumes->length() > 0) {
3044 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
3045 aGroup->Add(aVolumes.inout());
3046 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3047 anEntryList.append( aSObject->GetID().c_str() );
3050 anApp->browseObjects( anEntryList );
3052 catch(const SALOME::SALOME_Exception & S_ex){
3053 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3060 SUIT_MessageBox::warning(desktop(),
3061 tr("SMESH_WRN_WARNING"),
3062 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
3067 case SMESHOp::OpEditGroup:
3071 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3075 if(isStudyLocked()) break;
3076 EmitSignalDeactivateDialog();
3078 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3079 SALOME_ListIO selected;
3081 aSel->selectedObjects( selected );
3083 SALOME_ListIteratorOfListIO It (selected);
3084 int nbSelectedGroups = 0;
3085 for ( ; It.More(); It.Next() )
3087 SMESH::SMESH_GroupBase_var aGroup =
3088 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
3089 if (!aGroup->_is_nil()) {
3091 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
3095 if (nbSelectedGroups == 0)
3097 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
3103 case SMESHOp::OpAddElemGroupPopup: // Add elements to group
3105 if(isStudyLocked()) break;
3106 if (myState == 800) {
3107 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3108 if (aDlg) aDlg->onAdd();
3113 case SMESHOp::OpRemoveElemGroupPopup: // Remove elements from group
3115 if(isStudyLocked()) break;
3116 if (myState == 800) {
3117 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3118 if (aDlg) aDlg->onRemove();
3123 case SMESHOp::OpEditGeomGroupAsGroup:
3127 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3131 if(isStudyLocked()) break;
3132 EmitSignalDeactivateDialog();
3134 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3135 SALOME_ListIO selected;
3137 aSel->selectedObjects( selected );
3139 SALOME_ListIteratorOfListIO It (selected);
3140 for ( ; It.More(); It.Next() )
3142 SMESH::SMESH_GroupOnGeom_var aGroup =
3143 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
3144 if (!aGroup->_is_nil()) {
3145 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3150 SMESH::SMESH_GroupOnFilter_var aGroup =
3151 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
3152 if (!aGroup->_is_nil()) {
3153 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3161 case SMESHOp::OpUnionGroups:
3162 case SMESHOp::OpIntersectGroups:
3163 case SMESHOp::OpCutGroups:
3167 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3171 if ( isStudyLocked() )
3174 EmitSignalDeactivateDialog();
3176 SMESHGUI_GroupOpDlg* aDlg = 0;
3177 if ( theCommandID == SMESHOp::OpUnionGroups )
3178 aDlg = new SMESHGUI_UnionGroupsDlg( this );
3179 else if ( theCommandID == SMESHOp::OpIntersectGroups )
3180 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3182 aDlg = new SMESHGUI_CutGroupsDlg( this );
3189 case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
3191 if ( isStudyLocked() )
3194 EmitSignalDeactivateDialog();
3195 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3201 case SMESHOp::OpFaceGroupsByEdges: // Create face groups separated by sharp edges
3203 if ( isStudyLocked() )
3206 EmitSignalDeactivateDialog();
3207 SMESHGUI_FaceGroupsSeparatedByEdgesDlg* aDlg = new SMESHGUI_FaceGroupsSeparatedByEdgesDlg( this );
3213 case SMESHOp::OpDeleteGroup: // Delete groups with their contents
3217 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3221 if ( isStudyLocked() )
3224 EmitSignalDeactivateDialog();
3226 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3230 case SMESHOp::OpMeshInformation:
3231 case SMESHOp::OpWhatIs:
3233 int page = theCommandID == SMESHOp::OpMeshInformation ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3234 EmitSignalDeactivateDialog();
3235 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3236 SALOME_ListIO selected;
3238 aSel->selectedObjects( selected );
3240 if ( selected.Extent() > 1 ) { // a dlg for each IO
3241 SALOME_ListIteratorOfListIO It( selected );
3242 for ( ; It.More(); It.Next() ) {
3243 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3244 dlg->showInfo( It.Value() );
3249 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3255 case SMESHOp::OpFindElementByPoint:
3257 startOperation( theCommandID );
3261 case SMESHOp::OpEditHypothesis:
3263 if(isStudyLocked()) break;
3265 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3266 SALOME_ListIO selected;
3268 aSel->selectedObjects( selected );
3270 int nbSel = selected.Extent();
3273 Handle(SALOME_InteractiveObject) anIObject = selected.First();
3274 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3276 if ( !aHypothesis->_is_nil() )
3278 SMESHGUI_GenericHypothesisCreator* aCreator =
3279 SMESH::GetHypothesisCreator( SMESH::toQStr( aHypothesis->GetName() ));
3282 // set geometry of mesh and sub-mesh to aCreator
3283 aSel->selectedObjects( selected, "", /*convertReferences=*/false);
3284 if ( selected.Extent() == 1 )
3286 QString subGeomID, meshGeomID;
3287 Handle(SALOME_InteractiveObject) hypIO = selected.First();
3288 if ( SMESH::GetGeomEntries( hypIO, subGeomID, meshGeomID ))
3290 if ( subGeomID.isEmpty() ) subGeomID = meshGeomID;
3291 aCreator->setShapeEntry( subGeomID );
3292 aCreator->setMainShapeEntry( meshGeomID );
3296 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3306 case SMESHOp::OpUnassign: // REMOVE HYPOTHESIS / ALGORITHMS
3308 if(isStudyLocked()) break;
3309 SUIT_OverrideCursor wc;
3311 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3312 SALOME_ListIO selected;
3314 aSel->selectedObjects( selected, QString::null, false );
3316 SALOME_ListIteratorOfListIO It(selected);
3317 for (int i = 0; It.More(); It.Next(), i++) {
3318 Handle(SALOME_InteractiveObject) IObject = It.Value();
3319 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3322 aSel->setSelectedObjects( l1 );
3327 case SMESHOp::OpElem0D:
3328 case SMESHOp::OpBall:
3329 case SMESHOp::OpEdge:
3330 case SMESHOp::OpTriangle:
3331 case SMESHOp::OpQuadrangle:
3332 case SMESHOp::OpPolygon:
3333 case SMESHOp::OpTetrahedron:
3334 case SMESHOp::OpHexahedron:
3335 case SMESHOp::OpPentahedron:
3336 case SMESHOp::OpPyramid:
3337 case SMESHOp::OpHexagonalPrism:
3339 if(isStudyLocked()) break;
3341 EmitSignalDeactivateDialog();
3342 SMDSAbs_EntityType type = SMDSEntity_Edge;
3343 switch (theCommandID) {
3344 case SMESHOp::OpElem0D: type = SMDSEntity_0D; break;
3345 case SMESHOp::OpBall: type = SMDSEntity_Ball; break;
3346 case SMESHOp::OpTriangle: type = SMDSEntity_Triangle; break;
3347 case SMESHOp::OpQuadrangle: type = SMDSEntity_Quadrangle; break;
3348 case SMESHOp::OpTetrahedron: type = SMDSEntity_Tetra; break;
3349 case SMESHOp::OpPolygon: type = SMDSEntity_Polygon; break;
3350 case SMESHOp::OpHexahedron: type = SMDSEntity_Hexa; break;
3351 case SMESHOp::OpPentahedron: type = SMDSEntity_Penta; break;
3352 case SMESHOp::OpPyramid: type = SMDSEntity_Pyramid; break;
3353 case SMESHOp::OpHexagonalPrism: type = SMDSEntity_Hexagonal_Prism; break;
3356 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3359 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3363 case SMESHOp::OpPolyhedron:
3365 if(isStudyLocked()) break;
3367 EmitSignalDeactivateDialog();
3368 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3371 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3375 case SMESHOp::OpQuadraticEdge:
3376 case SMESHOp::OpQuadraticTriangle:
3377 case SMESHOp::OpBiQuadraticTriangle:
3378 case SMESHOp::OpQuadraticQuadrangle:
3379 case SMESHOp::OpBiQuadraticQuadrangle:
3380 case SMESHOp::OpQuadraticPolygon:
3381 case SMESHOp::OpQuadraticTetrahedron:
3382 case SMESHOp::OpQuadraticPyramid:
3383 case SMESHOp::OpQuadraticPentahedron:
3384 case SMESHOp::OpBiQuadraticPentahedron:
3385 case SMESHOp::OpQuadraticHexahedron:
3386 case SMESHOp::OpTriQuadraticHexahedron:
3388 if(isStudyLocked()) break;
3390 EmitSignalDeactivateDialog();
3391 SMDSAbs_EntityType type = SMDSEntity_Last;
3393 switch (theCommandID) {
3394 case SMESHOp::OpQuadraticEdge: type = SMDSEntity_Quad_Edge; break;
3395 case SMESHOp::OpQuadraticTriangle: type = SMDSEntity_Quad_Triangle; break;
3396 case SMESHOp::OpBiQuadraticTriangle: type = SMDSEntity_BiQuad_Triangle; break;
3397 case SMESHOp::OpQuadraticQuadrangle: type = SMDSEntity_Quad_Quadrangle; break;
3398 case SMESHOp::OpBiQuadraticQuadrangle: type = SMDSEntity_BiQuad_Quadrangle; break;
3399 case SMESHOp::OpQuadraticPolygon: type = SMDSEntity_Quad_Polygon; break;
3400 case SMESHOp::OpQuadraticTetrahedron: type = SMDSEntity_Quad_Tetra; break;
3401 case SMESHOp::OpQuadraticPyramid: type = SMDSEntity_Quad_Pyramid; break;
3402 case SMESHOp::OpQuadraticPentahedron: type = SMDSEntity_Quad_Penta; break;
3403 case SMESHOp::OpBiQuadraticPentahedron: type = SMDSEntity_BiQuad_Penta; break;
3404 case SMESHOp::OpQuadraticHexahedron: type = SMDSEntity_Quad_Hexa; break;
3405 case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
3408 if ( type != SMDSEntity_Last )
3409 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3412 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3413 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3417 case SMESHOp::OpRemoveNodes:
3419 if(isStudyLocked()) break;
3421 EmitSignalDeactivateDialog();
3422 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3425 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3426 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3430 case SMESHOp::OpRemoveElements: // REMOVES ELEMENTS
3432 if(isStudyLocked()) break;
3434 EmitSignalDeactivateDialog();
3435 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3439 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3440 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3444 case SMESHOp::OpClearMesh: {
3446 if(isStudyLocked()) break;
3448 SALOME_ListIO selected;
3449 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3450 aSel->selectedObjects( selected );
3452 SUIT_OverrideCursor wc;
3453 SALOME_ListIteratorOfListIO It (selected);
3454 for ( ; It.More(); It.Next() )
3456 Handle(SALOME_InteractiveObject) IOS = It.Value();
3457 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3458 if ( aMesh->_is_nil()) continue;
3461 if ( aMesh->NbNodes() == 0 ) // imported mesh is not empty
3462 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3463 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3464 // hide groups and submeshes
3465 _PTR(ChildIterator) anIter =
3466 SMESH::getStudy()->NewChildIterator( aMeshSObj );
3467 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3469 _PTR(SObject) so = anIter->Value();
3470 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3473 catch (const SALOME::SALOME_Exception& S_ex){
3475 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3479 SMESH::UpdateView();
3483 case SMESHOp::OpRemoveOrphanNodes:
3485 if(isStudyLocked()) break;
3486 SALOME_ListIO selected;
3487 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3488 aSel->selectedObjects( selected );
3489 if ( selected.Extent() == 1 ) {
3490 Handle(SALOME_InteractiveObject) anIO = selected.First();
3491 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3492 if ( !aMesh->_is_nil() ) {
3493 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3494 tr( "SMESH_WARNING" ),
3495 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3496 SUIT_MessageBox::Yes |
3497 SUIT_MessageBox::No,
3498 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3501 SUIT_OverrideCursor wc;
3502 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3503 int removed = aMeshEditor->RemoveOrphanNodes();
3504 SUIT_MessageBox::information(SMESHGUI::desktop(),
3505 tr("SMESH_INFORMATION"),
3506 tr("NB_NODES_REMOVED").arg(removed));
3507 if ( removed > 0 ) {
3508 SMESH::UpdateView();
3509 SMESHGUI::Modified();
3512 catch (const SALOME::SALOME_Exception& S_ex) {
3513 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3522 case SMESHOp::OpRenumberingNodes:
3524 if(isStudyLocked()) break;
3526 EmitSignalDeactivateDialog();
3527 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3531 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3532 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3536 case SMESHOp::OpRenumberingElements:
3538 if(isStudyLocked()) break;
3540 EmitSignalDeactivateDialog();
3541 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3545 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3546 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3550 case SMESHOp::OpTranslation:
3552 if(isStudyLocked()) break;
3554 EmitSignalDeactivateDialog();
3555 ( new SMESHGUI_TranslationDlg( this ) )->show();
3558 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3559 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3563 case SMESHOp::OpRotation:
3565 if(isStudyLocked()) break;
3567 EmitSignalDeactivateDialog();
3568 ( new SMESHGUI_RotationDlg( this ) )->show();
3571 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3572 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3576 case SMESHOp::OpSymmetry:
3578 if(isStudyLocked()) break;
3580 EmitSignalDeactivateDialog();
3581 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3584 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3585 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3589 case SMESHOp::OpScale:
3591 if(isStudyLocked()) break;
3593 EmitSignalDeactivateDialog();
3594 ( new SMESHGUI_ScaleDlg( this ) )->show();
3597 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3598 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3603 case SMESHOp::OpOffset:
3605 if(isStudyLocked()) break;
3607 EmitSignalDeactivateDialog();
3608 ( new SMESHGUI_OffsetDlg( this ) )->show();
3611 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3612 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3617 case SMESHOp::OpSewing:
3619 if(isStudyLocked()) break;
3621 EmitSignalDeactivateDialog();
3622 ( new SMESHGUI_SewingDlg( this ) )->show();
3625 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3626 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3630 case SMESHOp::OpMergeNodes:
3632 if(isStudyLocked()) break;
3634 EmitSignalDeactivateDialog();
3635 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3638 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3639 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3643 case SMESHOp::OpMergeElements:
3645 if (isStudyLocked()) break;
3647 EmitSignalDeactivateDialog();
3648 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3650 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3651 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3656 case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
3657 startOperation( SMESHOp::OpMoveNode );
3660 case SMESHOp::OpDuplicateNodes:
3662 if(isStudyLocked()) break;
3664 EmitSignalDeactivateDialog();
3665 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3668 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3669 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3674 case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
3675 startOperation( SMESHOp::OpElem0DOnElemNodes );
3678 case SMESHOp::OpSelectFiltersLibrary: // Library of selection filters
3680 static QList<int> aTypes;
3681 if ( aTypes.isEmpty() )
3683 aTypes.append( SMESH::NODE );
3684 aTypes.append( SMESH::EDGE );
3685 aTypes.append( SMESH::FACE );
3686 aTypes.append( SMESH::VOLUME );
3688 if (!myFilterLibraryDlg)
3689 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3690 else if (myFilterLibraryDlg->isHidden())
3691 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3692 myFilterLibraryDlg->raise();
3696 case SMESHOp::OpFreeNode:
3697 case SMESHOp::OpEqualNode:
3698 case SMESHOp::OpNodeConnectivityNb:
3699 case SMESHOp::OpFreeEdge:
3700 case SMESHOp::OpFreeBorder:
3701 case SMESHOp::OpLength:
3702 case SMESHOp::OpConnection:
3703 case SMESHOp::OpEqualEdge:
3704 case SMESHOp::OpFreeFace:
3705 case SMESHOp::OpBareBorderFace:
3706 case SMESHOp::OpOverConstrainedFace:
3707 case SMESHOp::OpLength2D:
3708 case SMESHOp::OpDeflection2D:
3709 case SMESHOp::OpConnection2D:
3710 case SMESHOp::OpArea:
3711 case SMESHOp::OpTaper:
3712 case SMESHOp::OpAspectRatio:
3713 case SMESHOp::OpMinimumAngle:
3714 case SMESHOp::OpWarpingAngle:
3715 case SMESHOp::OpSkew:
3716 case SMESHOp::OpMaxElementLength2D:
3717 case SMESHOp::OpEqualFace:
3718 case SMESHOp::OpAspectRatio3D:
3719 case SMESHOp::OpVolume:
3720 case SMESHOp::OpMaxElementLength3D:
3721 case SMESHOp::OpBareBorderVolume:
3722 case SMESHOp::OpOverConstrainedVolume:
3723 case SMESHOp::OpEqualVolume:
3726 LightApp_SelectionMgr* mgr = selectionMgr();
3727 SALOME_ListIO selected; mgr->selectedObjects( selected );
3729 if( !selected.IsEmpty() ) {
3730 SUIT_OverrideCursor wc;
3731 ::Control( theCommandID );
3734 SUIT_MessageBox::warning(desktop(),
3735 tr( "SMESH_WRN_WARNING" ),
3736 tr( "SMESH_BAD_SELECTION" ) );
3740 SUIT_MessageBox::warning(desktop(),
3741 tr( "SMESH_WRN_WARNING" ),
3742 tr( "NOT_A_VTK_VIEWER" ) );
3745 case SMESHOp::OpOverallMeshQuality:
3746 OverallMeshQuality();
3748 case SMESHOp::OpNumberingNodes:
3750 SUIT_OverrideCursor wc;
3751 LightApp_SelectionMgr* mgr = selectionMgr();
3752 SALOME_ListIO selected; mgr->selectedObjects( selected );
3754 SALOME_ListIteratorOfListIO it(selected);
3755 for( ; it.More(); it.Next()) {
3756 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3757 if(anIObject->hasEntry()) {
3758 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3759 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3765 case SMESHOp::OpNumberingElements:
3767 SUIT_OverrideCursor wc;
3768 LightApp_SelectionMgr* mgr = selectionMgr();
3769 SALOME_ListIO selected; mgr->selectedObjects( selected );
3771 SALOME_ListIteratorOfListIO it(selected);
3772 for( ; it.More(); it.Next()) {
3773 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3774 if(anIObject->hasEntry())
3775 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3776 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3781 case SMESHOp::OpPropertiesLength:
3782 case SMESHOp::OpPropertiesArea:
3783 case SMESHOp::OpPropertiesVolume:
3784 case SMESHOp::OpMinimumDistance:
3785 case SMESHOp::OpBoundingBox:
3786 case SMESHOp::OpAngle:
3788 int page = SMESHGUI_MeasureDlg::MinDistance;
3789 if ( theCommandID == SMESHOp::OpBoundingBox )
3790 page = SMESHGUI_MeasureDlg::BoundingBox;
3791 else if ( theCommandID == SMESHOp::OpPropertiesLength )
3792 page = SMESHGUI_MeasureDlg::Length;
3793 else if ( theCommandID == SMESHOp::OpPropertiesArea )
3794 page = SMESHGUI_MeasureDlg::Area;
3795 else if ( theCommandID == SMESHOp::OpPropertiesVolume )
3796 page = SMESHGUI_MeasureDlg::Volume;
3797 else if ( theCommandID == SMESHOp::OpAngle )
3798 page = SMESHGUI_MeasureDlg::Angle;
3800 EmitSignalDeactivateDialog();
3801 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3805 case SMESHOp::OpSortChild:
3808 case SMESHOp::OpBreakLink:
3809 ::breakShaperLink();
3814 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3815 //updateObjBrowser();
3819 //=============================================================================
3823 //=============================================================================
3824 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3829 //=============================================================================
3833 //=============================================================================
3834 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3839 //=============================================================================
3843 //=============================================================================
3844 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3849 //=============================================================================
3850 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3851 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3853 //=============================================================================
3854 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3855 SUIT_ViewWindow* wnd )
3857 if(theIO->hasEntry()){
3858 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3859 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3863 //=======================================================================
3864 // function : createSMESHAction
3866 //=======================================================================
3867 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3868 const int key, const bool toggle, const QString& shortcutAction )
3871 QWidget* parent = application()->desktop();
3872 SUIT_ResourceMgr* resMgr = resourceMgr();
3874 if ( !icon_id.isEmpty() )
3875 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3877 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3878 if ( !pix.isNull() )
3879 icon = QIcon( pix );
3881 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3882 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3883 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3885 createAction( id, tooltip, icon, menu, status_bar, key, parent,
3886 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3889 //=======================================================================
3890 // function : createPopupItem
3892 //=======================================================================
3893 void SMESHGUI::createPopupItem( const int id,
3894 const QString& clients,
3895 const QString& types,
3896 const QString& theRule,
3899 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3900 popupMgr()->insert( action( id ), pId, 0 );
3902 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3903 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
3904 QString rule = "(%1) and (%2) and (%3)";
3905 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3906 if( clients.isEmpty() )
3907 rule = rule.arg( QString( "true" ) );
3909 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3910 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3913 bool cont = myRules.contains( id );
3915 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3917 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3918 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3921 //=======================================================================
3922 // function : initialize
3924 //=======================================================================
3925 void SMESHGUI::initialize( CAM_Application* app )
3927 SalomeApp_Module::initialize( app );
3929 // SUIT_ResourceMgr* mgr = app->resourceMgr();
3931 /* Automatic Update flag */
3932 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3934 // ----- create actions --------------
3936 //createSMESHAction( SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
3937 createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_I) );
3938 createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
3939 createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL" );
3941 createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
3943 createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
3944 createSMESHAction( SMESHOp::OpImportGMF, "IMPORT_GMF" );
3945 createSMESHAction( SMESHOp::OpPopupImportUNV, "IMPORT_UNV");
3946 createSMESHAction( SMESHOp::OpPopupImportMED, "IMPORT_MED");
3947 createSMESHAction( SMESHOp::OpPopupImportSTL, "IMPORT_STL" );
3949 createSMESHAction( SMESHOp::OpPopupImportCGNS, "IMPORT_CGNS" );
3951 createSMESHAction( SMESHOp::OpPopupImportSAUV, "IMPORT_SAUV" );
3952 createSMESHAction( SMESHOp::OpPopupImportGMF, "IMPORT_GMF" );
3954 createSMESHAction( SMESHOp::OpExportDAT, "DAT" );
3955 createSMESHAction( SMESHOp::OpExportMED, "MED" );
3956 createSMESHAction( SMESHOp::OpExportUNV, "UNV" );
3957 createSMESHAction( SMESHOp::OpExportSTL, "STL" );
3959 createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
3961 createSMESHAction( SMESHOp::OpExportSAUV, "SAUV");
3962 createSMESHAction( SMESHOp::OpExportGMF, "GMF" );
3963 createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
3964 createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
3965 createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
3966 createSMESHAction( SMESHOp::OpPopupExportSTL, "STL" );
3968 createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
3970 createSMESHAction( SMESHOp::OpPopupExportSAUV, "SAUV");
3971 createSMESHAction( SMESHOp::OpPopupExportGMF, "GMF" );
3972 createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
3973 createSMESHAction( SMESHOp::OpDelete, "DELETE", "ICON_DELETE", Qt::Key_Delete );
3974 createSMESHAction( SMESHOp::OpSelectFiltersLibrary, "SEL_FILTER_LIB" );
3975 createSMESHAction( SMESHOp::OpCreateMesh, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
3976 createSMESHAction( SMESHOp::OpCreateSubMesh, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
3977 createSMESHAction( SMESHOp::OpEditMeshOrSubMesh, "EDIT_MESHSUBMESH", "ICON_DLG_EDIT_MESH" );
3978 createSMESHAction( SMESHOp::OpEditMesh, "EDIT_MESH", "ICON_DLG_EDIT_MESH" );
3979 createSMESHAction( SMESHOp::OpEditSubMesh, "EDIT_SUBMESH", "ICON_DLG_EDIT_MESH" );
3980 createSMESHAction( SMESHOp::OpBuildCompoundMesh, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
3981 createSMESHAction( SMESHOp::OpCopyMesh, "COPY_MESH", "ICON_COPY_MESH" );
3982 createSMESHAction( SMESHOp::OpCompute, "COMPUTE", "ICON_COMPUTE" );
3983 createSMESHAction( SMESHOp::OpComputeSubMesh, "COMPUTE_SUBMESH", "ICON_COMPUTE" );
3984 createSMESHAction( SMESHOp::OpPreCompute, "PRECOMPUTE", "ICON_PRECOMPUTE" );
3985 createSMESHAction( SMESHOp::OpEvaluate, "EVALUATE", "ICON_EVALUATE" );
3986 createSMESHAction( SMESHOp::OpMeshOrder, "MESH_ORDER", "ICON_MESH_ORDER");
3987 createSMESHAction( SMESHOp::OpCreateGroup, "CREATE_GROUP", "ICON_CREATE_GROUP" );
3988 createSMESHAction( SMESHOp::OpCreateGeometryGroup, "CREATE_GEO_GROUP", "ICON_CREATE_GEO_GROUP" );
3989 createSMESHAction( SMESHOp::OpConstructGroup, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
3990 createSMESHAction( SMESHOp::OpEditGroup, "EDIT_GROUP", "ICON_EDIT_GROUP" );
3991 createSMESHAction( SMESHOp::OpEditGeomGroupAsGroup, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3992 createSMESHAction( SMESHOp::OpUnionGroups, "UN_GROUP", "ICON_UNION" );
3993 createSMESHAction( SMESHOp::OpIntersectGroups, "INT_GROUP", "ICON_INTERSECT" );
3994 createSMESHAction( SMESHOp::OpCutGroups, "CUT_GROUP", "ICON_CUT" );
3995 createSMESHAction( SMESHOp::OpGroupUnderlyingElem, "UNDERLYING_ELEMS", "ICON_UNDERLYING_ELEMS" );
3996 createSMESHAction( SMESHOp::OpFaceGroupsByEdges, "FACE_GROUPS_BY_EDGES", "ICON_FACE_GROUPS_BY_EDGES" );
3997 createSMESHAction( SMESHOp::OpAddElemGroupPopup, "ADD_TO_GROUP" );
3998 createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE_FROM_GROUP" );
3999 createSMESHAction( SMESHOp::OpDeleteGroup, "DEL_GROUP", "ICON_DEL_GROUP" );
4000 createSMESHAction( SMESHOp::OpMeshInformation , "ADV_INFO", "ICON_ADV_INFO" );
4001 //createSMESHAction( SMESHOp::OpStdInfo, "STD_INFO", "ICON_STD_INFO" );
4002 //createSMESHAction( SMESHOp::OpWhatIs, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4003 createSMESHAction( SMESHOp::OpFindElementByPoint, "FIND_ELEM", "ICON_FIND_ELEM" );
4005 createSMESHAction( SMESHOp::OpFreeNode, "FREE_NODE", "ICON_FREE_NODE", 0, true );
4006 createSMESHAction( SMESHOp::OpEqualNode, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
4007 createSMESHAction( SMESHOp::OpNodeConnectivityNb, "NODE_CONNECTIVITY_NB", "ICON_NODE_CONN_NB", 0, true );
4008 createSMESHAction( SMESHOp::OpFreeEdge, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
4009 createSMESHAction( SMESHOp::OpFreeBorder, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
4010 createSMESHAction( SMESHOp::OpLength, "LENGTH", "ICON_LENGTH", 0, true );
4011 createSMESHAction( SMESHOp::OpConnection, "CONNECTION", "ICON_CONNECTION", 0, true );
4012 createSMESHAction( SMESHOp::OpEqualEdge, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
4013 createSMESHAction( SMESHOp::OpFreeFace, "FREE_FACES", "ICON_FREE_FACES", 0, true );
4014 createSMESHAction( SMESHOp::OpBareBorderFace, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
4015 createSMESHAction( SMESHOp::OpOverConstrainedFace, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
4016 createSMESHAction( SMESHOp::OpLength2D, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
4017 createSMESHAction( SMESHOp::OpDeflection2D, "DEFLECTION_2D", "ICON_DEFLECTION_2D", 0, true );
4018 createSMESHAction( SMESHOp::OpConnection2D, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
4019 createSMESHAction( SMESHOp::OpArea, "AREA", "ICON_AREA", 0, true );
4020 createSMESHAction( SMESHOp::OpTaper, "TAPER", "ICON_TAPER", 0, true );
4021 createSMESHAction( SMESHOp::OpAspectRatio, "ASPECT", "ICON_ASPECT", 0, true );
4022 createSMESHAction( SMESHOp::OpMinimumAngle, "MIN_ANG", "ICON_ANGLE", 0, true );
4023 createSMESHAction( SMESHOp::OpWarpingAngle, "WARP", "ICON_WARP", 0, true );
4024 createSMESHAction( SMESHOp::OpSkew, "SKEW", "ICON_SKEW", 0, true );
4025 createSMESHAction( SMESHOp::OpMaxElementLength2D, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
4026 createSMESHAction( SMESHOp::OpEqualFace, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
4027 createSMESHAction( SMESHOp::OpAspectRatio3D, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
4028 createSMESHAction( SMESHOp::OpVolume, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
4029 createSMESHAction( SMESHOp::OpMaxElementLength3D, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
4030 createSMESHAction( SMESHOp::OpBareBorderVolume, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
4031 createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
4032 createSMESHAction( SMESHOp::OpEqualVolume, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
4033 createSMESHAction( SMESHOp::OpOverallMeshQuality, "OVERALL_MESH_QUALITY", "ICON_OVL_MESH_QUALITY" );
4035 createSMESHAction( SMESHOp::OpNode, "NODE", "ICON_DLG_NODE" );
4036 createSMESHAction( SMESHOp::OpElem0D, "ELEM0D", "ICON_DLG_ELEM0D" );
4037 createSMESHAction( SMESHOp::OpElem0DOnElemNodes, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
4038 createSMESHAction( SMESHOp::OpBall, "BALL", "ICON_DLG_BALL" );
4039 createSMESHAction( SMESHOp::OpEdge, "EDGE", "ICON_DLG_EDGE" );
4040 createSMESHAction( SMESHOp::OpTriangle, "TRIANGLE", "ICON_DLG_TRIANGLE" );
4041 createSMESHAction( SMESHOp::OpQuadrangle, "QUAD", "ICON_DLG_QUADRANGLE" );
4042 createSMESHAction( SMESHOp::OpPolygon, "POLYGON", "ICON_DLG_POLYGON" );
4043 createSMESHAction( SMESHOp::OpTetrahedron, "TETRA", "ICON_DLG_TETRAS" );
4044 createSMESHAction( SMESHOp::OpHexahedron, "HEXA", "ICON_DLG_HEXAS" );
4045 createSMESHAction( SMESHOp::OpPentahedron, "PENTA", "ICON_DLG_PENTA" );
4046 createSMESHAction( SMESHOp::OpPyramid , "PYRAMID", "ICON_DLG_PYRAMID" );
4047 createSMESHAction( SMESHOp::OpHexagonalPrism, "OCTA", "ICON_DLG_OCTA" );
4048 createSMESHAction( SMESHOp::OpPolyhedron, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
4049 createSMESHAction( SMESHOp::OpQuadraticEdge, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
4050 createSMESHAction( SMESHOp::OpQuadraticTriangle, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
4051 createSMESHAction( SMESHOp::OpBiQuadraticTriangle, "BIQUADRATIC_TRIANGLE", "ICON_DLG_BIQUADRATIC_TRIANGLE" );
4052 createSMESHAction( SMESHOp::OpQuadraticQuadrangle, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
4053 createSMESHAction( SMESHOp::OpBiQuadraticQuadrangle, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
4054 createSMESHAction( SMESHOp::OpQuadraticPolygon, "QUADRATIC_POLYGON", "ICON_DLG_QUADRATIC_POLYGON" );
4055 createSMESHAction( SMESHOp::OpQuadraticTetrahedron, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
4056 createSMESHAction( SMESHOp::OpQuadraticPyramid, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
4057 createSMESHAction( SMESHOp::OpQuadraticPentahedron, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
4058 createSMESHAction( SMESHOp::OpBiQuadraticPentahedron, "BIQUADRATIC_PENTAHEDRON", "ICON_DLG_BIQUADRATIC_PENTAHEDRON" );
4059 createSMESHAction( SMESHOp::OpQuadraticHexahedron, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
4060 createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
4062 createSMESHAction( SMESHOp::OpRemoveNodes, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
4063 createSMESHAction( SMESHOp::OpRemoveElements, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
4064 createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
4065 createSMESHAction( SMESHOp::OpClearMesh, "CLEAR_MESH", "ICON_CLEAR_MESH" );
4067 //createSMESHAction( SMESHOp::OpRenumberingNodes, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
4068 //createSMESHAction( SMESHOp::OpRenumberingElements, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
4070 createSMESHAction( SMESHOp::OpTranslation, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
4071 createSMESHAction( SMESHOp::OpRotation, "ROT", "ICON_DLG_MESH_ROTATION" );
4072 createSMESHAction( SMESHOp::OpSymmetry, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
4073 createSMESHAction( SMESHOp::OpScale, "SCALE", "ICON_DLG_MESH_SCALE" );
4074 createSMESHAction( SMESHOp::OpOffset, "OFFSET", "ICON_DLG_MESH_OFFSET" );
4075 createSMESHAction( SMESHOp::OpSewing, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
4076 createSMESHAction( SMESHOp::OpMergeNodes, "MERGE", "ICON_SMESH_MERGE_NODES" );
4077 createSMESHAction( SMESHOp::OpMergeElements, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
4078 createSMESHAction( SMESHOp::OpMoveNode, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
4079 createSMESHAction( SMESHOp::OpDuplicateNodes, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
4080 createSMESHAction( SMESHOp::OpDiagonalInversion, "INV", "ICON_DLG_MESH_DIAGONAL" );
4081 createSMESHAction( SMESHOp::OpUnionOfTwoTriangle, "UNION2", "ICON_UNION2TRI" );
4082 createSMESHAction( SMESHOp::OpOrientation, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
4083 createSMESHAction( SMESHOp::OpReorientFaces, "REORIENT_2D", "ICON_REORIENT_2D" );
4084 createSMESHAction( SMESHOp::OpUnionOfTriangles, "UNION", "ICON_UNIONTRI" );
4085 createSMESHAction( SMESHOp::OpCuttingOfQuadrangles, "CUT", "ICON_CUTQUAD" );
4086 createSMESHAction( SMESHOp::OpSplitVolumes, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
4087 createSMESHAction( SMESHOp::OpSplitBiQuadratic, "SPLIT_BIQUAD", "ICON_SPLIT_BIQUAD" );
4088 createSMESHAction( SMESHOp::OpSmoothing, "SMOOTH", "ICON_DLG_SMOOTHING" );
4089 createSMESHAction( SMESHOp::OpExtrusion, "EXTRUSION", "ICON_EXTRUSION" );
4090 createSMESHAction( SMESHOp::OpExtrusionAlongAPath, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
4091 createSMESHAction( SMESHOp::OpRevolution, "REVOLUTION", "ICON_REVOLUTION" );
4092 createSMESHAction( SMESHOp::OpPatternMapping, "MAP", "ICON_MAP" );
4093 createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
4094 createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D", "ICON_2D_FROM_3D" );
4096 createSMESHAction( SMESHOp::OpReset, "RESET" );
4097 createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
4098 createSMESHAction( SMESHOp::OpShowScalarBar, "SHOW_SCALAR_BAR","",0, true );
4099 createSMESHAction( SMESHOp::OpSaveDistribution, "SAVE_DISTRIBUTION" );
4100 createSMESHAction( SMESHOp::OpShowDistribution, "SHOW_DISTRIBUTION","",0, true );
4101 #ifndef DISABLE_PLOT2DVIEWER
4102 createSMESHAction( SMESHOp::OpPlotDistribution, "PLOT_DISTRIBUTION" );
4104 createSMESHAction( SMESHOp::OpDMWireframe, "WIRE", "ICON_WIRE", 0, true );
4105 createSMESHAction( SMESHOp::OpDMShading, "SHADE", "ICON_SHADE", 0, true );
4106 createSMESHAction( SMESHOp::OpDMNodes, "NODES", "ICON_POINTS", 0, true );
4107 createSMESHAction( SMESHOp::OpDMShrink, "SHRINK", "ICON_SHRINK", 0, true );
4108 createSMESHAction( SMESHOp::OpUpdate, "UPDATE", "ICON_UPDATE" );
4109 createSMESHAction( SMESHOp::OpDE0DElements, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
4110 createSMESHAction( SMESHOp::OpDEEdges, "EDGES", "ICON_DLG_EDGE", 0, true );
4111 createSMESHAction( SMESHOp::OpDEFaces, "FACES", "ICON_DLG_TRIANGLE", 0, true );
4112 createSMESHAction( SMESHOp::OpDEVolumes, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
4113 createSMESHAction( SMESHOp::OpDEBalls, "BALLS", "ICON_DLG_BALL", 0, true );
4114 createSMESHAction( SMESHOp::OpDEChoose, "CHOOSE", "ICON_DLG_CHOOSE", 0, false );
4115 createSMESHAction( SMESHOp::OpDEAllEntity, "ALL", "ICON_DLG_CHOOSE_ALL", 0, false );
4116 createSMESHAction( SMESHOp::OpOrientationOnFaces, "FACE_ORIENTATION", "", 0, true );
4118 createSMESHAction( SMESHOp::OpRepresentationLines, "LINE_REPRESENTATION", "", 0, true );
4119 createSMESHAction( SMESHOp::OpRepresentationArcs, "ARC_REPRESENTATION", "", 0, true );
4121 createSMESHAction( SMESHOp::OpEditHypothesis, "EDIT_HYPO" );
4122 createSMESHAction( SMESHOp::OpUnassign, "UNASSIGN" );
4123 createSMESHAction( SMESHOp::OpNumberingNodes, "NUM_NODES", "", 0, true );
4124 createSMESHAction( SMESHOp::OpNumberingElements, "NUM_ELEMENTS", "", 0, true );
4125 createSMESHAction( SMESHOp::OpProperties, "COLORS" );
4126 createSMESHAction( SMESHOp::OpTransparency, "TRANSP" );
4127 createSMESHAction( SMESHOp::OpClipping, "CLIP" );
4128 createSMESHAction( SMESHOp::OpAutoColor, "AUTO_COLOR" );
4129 createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
4131 createSMESHAction( SMESHOp::OpMinimumDistance, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
4132 createSMESHAction( SMESHOp::OpBoundingBox, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
4133 createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH", "ICON_MEASURE_LENGTH" );
4134 createSMESHAction( SMESHOp::OpPropertiesArea, "MEASURE_AREA", "ICON_MEASURE_AREA" );
4135 createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME", "ICON_MEASURE_VOLUME" );
4136 createSMESHAction( SMESHOp::OpAngle, "MEASURE_ANGLE", "ICON_MEASURE_ANGLE" );
4138 createSMESHAction( SMESHOp::OpHide, "HIDE", "ICON_HIDE" );
4139 createSMESHAction( SMESHOp::OpShow, "SHOW", "ICON_SHOW" );
4140 createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
4142 createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
4144 createSMESHAction( SMESHOp::OpBreakLink, "BREAK_SHAPER_LINK" );
4146 QList<int> aCtrlActions;
4147 aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode
4148 << SMESHOp::OpNodeConnectivityNb // node controls
4149 << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
4150 << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge // edge controls
4151 << SMESHOp::OpDeflection2D
4152 << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
4153 << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
4154 << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
4155 << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
4156 << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace // face controls
4157 << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
4158 << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
4159 << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume; // volume controls
4160 QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
4161 aCtrlGroup->setExclusive( true );
4162 for( int i = 0; i < aCtrlActions.size(); i++ )
4163 aCtrlGroup->addAction( action( aCtrlActions[i] ) );
4165 // ----- create menu --------------
4166 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
4167 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
4168 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
4169 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
4170 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
4171 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
4172 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
4173 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
4175 createMenu( separator(), fileId );
4177 QMenu* nodeMenu = new QMenu(); QMenu* edgeMenu = new QMenu();
4178 QMenu* faceMenu = new QMenu(); QMenu* volumeMenu = new QMenu();
4179 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
4180 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
4181 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10, -1, nodeMenu ),
4182 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10, -1, edgeMenu ),
4183 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10, -1, faceMenu ),
4184 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10, -1, volumeMenu ),
4185 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
4186 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
4187 //renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
4188 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
4189 basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
4191 //createMenu( SMESHOp::OpImportDAT, importId, -1 );
4192 createMenu( SMESHOp::OpImportUNV, importId, -1 );
4193 createMenu( SMESHOp::OpImportMED, importId, -1 );
4194 createMenu( SMESHOp::OpImportSTL, importId, -1 );
4196 createMenu( SMESHOp::OpImportCGNS, importId, -1 );
4198 createMenu( SMESHOp::OpImportSAUV, importId, -1 );
4199 createMenu( SMESHOp::OpImportGMF, importId, -1 );
4200 createMenu( SMESHOp::OpExportDAT, exportId, -1 );
4201 createMenu( SMESHOp::OpExportMED, exportId, -1 );
4202 createMenu( SMESHOp::OpExportUNV, exportId, -1 );
4203 createMenu( SMESHOp::OpExportSTL, exportId, -1 );
4205 createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
4207 createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
4208 createMenu( SMESHOp::OpExportGMF, exportId, -1 );
4209 createMenu( separator(), fileId, 10 );
4211 createMenu( SMESHOp::OpDelete, editId, -1 );
4213 createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
4215 createMenu( SMESHOp::OpCreateMesh, meshId, -1 ); // "Mesh" menu
4216 createMenu( SMESHOp::OpCreateSubMesh, meshId, -1 );
4217 createMenu( SMESHOp::OpEditMeshOrSubMesh, meshId, -1 );
4218 createMenu( SMESHOp::OpBuildCompoundMesh, meshId, -1 );
4219 createMenu( SMESHOp::OpCopyMesh, meshId, -1 );
4220 createMenu( separator(), meshId, -1 );
4221 createMenu( SMESHOp::OpCompute, meshId, -1 );
4222 createMenu( SMESHOp::OpPreCompute, meshId, -1 );
4223 createMenu( SMESHOp::OpEvaluate, meshId, -1 );
4224 createMenu( SMESHOp::OpMeshOrder, meshId, -1 );
4225 createMenu( separator(), meshId, -1 );
4226 createMenu( SMESHOp::OpCreateGroup, meshId, -1 );
4227 createMenu( SMESHOp::OpCreateGeometryGroup, meshId, -1 );
4228 createMenu( SMESHOp::OpConstructGroup, meshId, -1 );
4229 createMenu( SMESHOp::OpEditGroup, meshId, -1 );
4230 createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4231 createMenu( separator(), meshId, -1 );
4232 createMenu( SMESHOp::OpUnionGroups, meshId, -1 );
4233 createMenu( SMESHOp::OpIntersectGroups, meshId, -1 );
4234 createMenu( SMESHOp::OpCutGroups, meshId, -1 );
4235 createMenu( separator(), meshId, -1 );
4236 createMenu( SMESHOp::OpGroupUnderlyingElem, meshId, -1 );
4237 createMenu( SMESHOp::OpFaceGroupsByEdges, meshId, -1 );
4238 createMenu( separator(), meshId, -1 );
4239 createMenu( SMESHOp::OpMeshInformation, meshId, -1 );
4240 //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4241 //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4242 createMenu( SMESHOp::OpFindElementByPoint, meshId, -1 );
4243 createMenu( separator(), meshId, -1 );
4245 createMenu( SMESHOp::OpFreeNode, nodeId, -1 );
4246 createMenu( SMESHOp::OpEqualNode, nodeId, -1 );
4247 //createMenu( SMESHOp::OpNodeConnectivityNb, nodeId, -1 );
4248 createMenu( SMESHOp::OpFreeBorder, edgeId, -1 );
4249 createMenu( SMESHOp::OpLength, edgeId, -1 );
4250 createMenu( SMESHOp::OpConnection, edgeId, -1 );
4251 createMenu( SMESHOp::OpEqualEdge, edgeId, -1 );
4252 createMenu( SMESHOp::OpFreeEdge, faceId, -1 );
4253 createMenu( SMESHOp::OpFreeFace, faceId, -1 );
4254 createMenu( SMESHOp::OpBareBorderFace, faceId, -1 );
4255 createMenu( SMESHOp::OpOverConstrainedFace, faceId, -1 );
4256 createMenu( SMESHOp::OpLength2D, faceId, -1 );
4257 createMenu( SMESHOp::OpConnection2D, faceId, -1 );
4258 createMenu( SMESHOp::OpArea, faceId, -1 );
4259 createMenu( SMESHOp::OpTaper, faceId, -1 );
4260 createMenu( SMESHOp::OpAspectRatio, faceId, -1 );
4261 createMenu( SMESHOp::OpMinimumAngle, faceId, -1 );
4262 createMenu( SMESHOp::OpWarpingAngle, faceId, -1 );
4263 createMenu( SMESHOp::OpSkew, faceId, -1 );
4264 createMenu( SMESHOp::OpMaxElementLength2D, faceId, -1 );
4265 createMenu( SMESHOp::OpEqualFace, faceId, -1 );
4266 createMenu( SMESHOp::OpDeflection2D, faceId, -1 );
4267 createMenu( SMESHOp::OpAspectRatio3D, volumeId, -1 );
4268 createMenu( SMESHOp::OpVolume, volumeId, -1 );
4269 createMenu( SMESHOp::OpMaxElementLength3D, volumeId, -1 );
4270 createMenu( SMESHOp::OpBareBorderVolume, volumeId, -1 );
4271 createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4272 createMenu( SMESHOp::OpEqualVolume, volumeId, -1 );
4273 createMenu( separator(), ctrlId, -1 );
4274 createMenu( SMESHOp::OpReset, ctrlId, -1 );
4275 createMenu( separator(), ctrlId, -1 );
4276 createMenu( SMESHOp::OpOverallMeshQuality, ctrlId, -1 );
4278 createMenu( SMESHOp::OpNode, addId, -1 );
4279 createMenu( SMESHOp::OpElem0D, addId, -1 );
4280 createMenu( SMESHOp::OpElem0DOnElemNodes, addId, -1 );
4281 createMenu( SMESHOp::OpBall, addId, -1 );
4282 createMenu( SMESHOp::OpEdge, addId, -1 );
4283 createMenu( SMESHOp::OpTriangle, addId, -1 );
4284 createMenu( SMESHOp::OpQuadrangle, addId, -1 );
4285 createMenu( SMESHOp::OpPolygon, addId, -1 );
4286 createMenu( SMESHOp::OpTetrahedron, addId, -1 );
4287 createMenu( SMESHOp::OpHexahedron, addId, -1 );
4288 createMenu( SMESHOp::OpPentahedron, addId, -1 );
4289 createMenu( SMESHOp::OpPyramid, addId, -1 );
4290 createMenu( SMESHOp::OpHexagonalPrism, addId, -1 );
4291 createMenu( SMESHOp::OpPolyhedron, addId, -1 );
4292 createMenu( separator(), addId, -1 );
4293 createMenu( SMESHOp::OpQuadraticEdge, addId, -1 );
4294 createMenu( SMESHOp::OpQuadraticTriangle, addId, -1 );
4295 createMenu( SMESHOp::OpBiQuadraticTriangle , addId, -1 );
4296 createMenu( SMESHOp::OpQuadraticQuadrangle, addId, -1 );
4297 createMenu( SMESHOp::OpBiQuadraticQuadrangle, addId, -1 );
4298 createMenu( SMESHOp::OpQuadraticPolygon, addId, -1 );
4299 createMenu( SMESHOp::OpQuadraticTetrahedron, addId, -1 );
4300 createMenu( SMESHOp::OpQuadraticPyramid, addId, -1 );
4301 createMenu( SMESHOp::OpQuadraticPentahedron, addId, -1 );
4302 createMenu( SMESHOp::OpBiQuadraticPentahedron, addId, -1 );
4303 createMenu( SMESHOp::OpQuadraticHexahedron, addId, -1 );
4304 createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4306 createMenu( SMESHOp::OpRemoveNodes, removeId, -1 );
4307 createMenu( SMESHOp::OpRemoveElements, removeId, -1 );
4308 createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4309 createMenu( separator(), removeId, -1 );
4310 createMenu( SMESHOp::OpDeleteGroup, removeId, -1 );
4311 createMenu( separator(), removeId, -1 );
4312 createMenu( SMESHOp::OpClearMesh, removeId, -1 );
4314 //createMenu( SMESHOp::OpRenumberingNodes, renumId, -1 );
4315 //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4317 createMenu( SMESHOp::OpMergeNodes, transfId, -1 );
4318 createMenu( SMESHOp::OpMergeElements, transfId, -1 );
4319 createMenu( SMESHOp::OpTranslation, transfId, -1 );
4320 createMenu( SMESHOp::OpRotation, transfId, -1 );
4321 createMenu( SMESHOp::OpSymmetry, transfId, -1 );
4322 createMenu( SMESHOp::OpScale, transfId, -1 );
4323 createMenu( SMESHOp::OpOffset, transfId, -1 );
4324 createMenu( SMESHOp::OpSewing, transfId, -1 );
4325 createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4327 createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4328 createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4329 createMenu( SMESHOp::OpExtrusion, modifyId, -1 );
4330 createMenu( SMESHOp::OpExtrusionAlongAPath, modifyId, -1 );
4331 createMenu( SMESHOp::OpRevolution, modifyId, -1 );
4332 createMenu( SMESHOp::OpOrientation, modifyId, -1 );
4333 createMenu( SMESHOp::OpReorientFaces, modifyId, -1 );
4334 createMenu( SMESHOp::OpMoveNode, modifyId, -1 );
4335 createMenu( SMESHOp::OpDiagonalInversion, modifyId, -1 );
4336 createMenu( SMESHOp::OpUnionOfTwoTriangle, modifyId, -1 );
4337 createMenu( SMESHOp::OpUnionOfTriangles, modifyId, -1 );
4338 createMenu( SMESHOp::OpCuttingOfQuadrangles, modifyId, -1 );
4339 createMenu( SMESHOp::OpSplitVolumes, modifyId, -1 );
4340 createMenu( SMESHOp::OpSplitBiQuadratic, modifyId, -1 );
4341 createMenu( SMESHOp::OpSmoothing, modifyId, -1 );
4342 createMenu( SMESHOp::OpPatternMapping, modifyId, -1 );
4344 createMenu( SMESHOp::OpMinimumDistance, measureId, -1 );
4345 createMenu( SMESHOp::OpBoundingBox, measureId, -1 );
4346 createMenu( SMESHOp::OpAngle, measureId, -1 );
4347 createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4348 createMenu( SMESHOp::OpPropertiesArea, basicPropId, -1 );
4349 createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4350 createMenu( SMESHOp::OpUpdate, viewId, -1 );
4352 connect( nodeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4353 connect( edgeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4354 connect( faceMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4355 connect( volumeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4357 // ----- create toolbars --------------
4358 int meshTb = createTool( tr( "TB_MESH" ), QString( "SMESHMeshToolbar" ) ),
4359 info = createTool( tr( "TB_INFO" ), QString( "SMESHInformationToolbar" ) ),
4360 groupTb = createTool( tr( "TB_GROUP" ), QString( "SMESHGroupToolbar" ) ),
4361 ctrl0dTb = createTool( tr( "TB_CTRL0D" ), QString( "SMESHNodeControlsToolbar" ) ),
4362 ctrl1dTb = createTool( tr( "TB_CTRL1D" ), QString( "SMESHEdgeControlsToolbar" ) ),
4363 ctrl2dTb = createTool( tr( "TB_CTRL2D" ), QString( "SMESHFaceControlsToolbar" ) ),
4364 ctrl3dTb = createTool( tr( "TB_CTRL3D" ), QString( "SMESHVolumeControlsToolbar" ) ),
4365 addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ),
4366 addNonElemTb = createTool( tr( "TB_ADDNON" ), QString( "SMESHAddElementToolbar" ) ),
4367 remTb = createTool( tr( "TB_REM" ), QString( "SMESHRemoveToolbar" ) ),
4368 //renumbTb = createTool( tr( "TB_RENUMBER" ), QString( "SMESHRenumberingToolbar" ) ),
4369 transformTb = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ),
4370 modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ),
4371 measuremTb = createTool( tr( "TB_MEASUREM" ), QString( "SMESHMeasurementsToolbar" ) ),
4372 dispModeTb = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4374 createTool( SMESHOp::OpCreateMesh, meshTb );
4375 createTool( SMESHOp::OpCreateSubMesh, meshTb );
4376 createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4377 createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4378 createTool( SMESHOp::OpCopyMesh, meshTb );
4379 createTool( separator(), meshTb );
4380 createTool( SMESHOp::OpCompute, meshTb );
4381 createTool( SMESHOp::OpPreCompute, meshTb );
4382 createTool( SMESHOp::OpEvaluate, meshTb );
4383 createTool( SMESHOp::OpMeshOrder, meshTb );
4385 createTool( SMESHOp::OpCreateGroup, groupTb );
4386 createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4387 createTool( SMESHOp::OpConstructGroup, groupTb );
4388 createTool( SMESHOp::OpEditGroup, groupTb );
4390 createTool( SMESHOp::OpMeshInformation, info );
4391 //createTool( SMESHOp::OpStdInfo, meshTb );
4392 //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4393 createTool( SMESHOp::OpFindElementByPoint, info );
4395 createTool( SMESHOp::OpFreeNode, ctrl0dTb );
4396 createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4397 //createTool( SMESHOp::OpNodeConnectivityNb, ctrl0dTb );
4399 createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4400 createTool( SMESHOp::OpLength, ctrl1dTb );
4401 createTool( SMESHOp::OpConnection, ctrl1dTb );
4402 createTool( SMESHOp::OpEqualEdge, ctrl1dTb );
4404 createTool( SMESHOp::OpFreeEdge, ctrl2dTb );
4405 createTool( SMESHOp::OpFreeFace, ctrl2dTb );
4406 createTool( SMESHOp::OpBareBorderFace, ctrl2dTb );
4407 createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4408 createTool( SMESHOp::OpLength2D, ctrl2dTb );
4409 createTool( SMESHOp::OpConnection2D, ctrl2dTb );
4410 createTool( SMESHOp::OpArea, ctrl2dTb );
4411 createTool( SMESHOp::OpTaper, ctrl2dTb );
4412 createTool( SMESHOp::OpAspectRatio, ctrl2dTb );
4413 createTool( SMESHOp::OpMinimumAngle, ctrl2dTb );
4414 createTool( SMESHOp::OpWarpingAngle, ctrl2dTb );
4415 createTool( SMESHOp::OpSkew, ctrl2dTb );
4416 createTool( SMESHOp::OpMaxElementLength2D, ctrl2dTb );
4417 createTool( SMESHOp::OpEqualFace, ctrl2dTb );
4418 createTool( SMESHOp::OpDeflection2D, ctrl2dTb );
4420 createTool( SMESHOp::OpAspectRatio3D, ctrl3dTb );
4421 createTool( SMESHOp::OpVolume, ctrl3dTb );
4422 createTool( SMESHOp::OpMaxElementLength3D, ctrl3dTb );
4423 createTool( SMESHOp::OpBareBorderVolume, ctrl3dTb );
4424 createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
4425 createTool( SMESHOp::OpEqualVolume, ctrl3dTb );
4427 createTool( SMESHOp::OpNode, addElemTb );
4428 createTool( SMESHOp::OpElem0D, addElemTb );
4429 createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4430 createTool( SMESHOp::OpBall, addElemTb );
4431 createTool( SMESHOp::OpEdge, addElemTb );
4432 createTool( SMESHOp::OpTriangle, addElemTb );
4433 createTool( SMESHOp::OpQuadrangle, addElemTb );
4434 createTool( SMESHOp::OpPolygon, addElemTb );
4435 createTool( SMESHOp::OpTetrahedron, addElemTb );
4436 createTool( SMESHOp::OpHexahedron, addElemTb );
4437 createTool( SMESHOp::OpPentahedron, addElemTb );
4438 createTool( SMESHOp::OpPyramid, addElemTb );
4439 createTool( SMESHOp::OpHexagonalPrism, addElemTb );
4440 createTool( SMESHOp::OpPolyhedron, addElemTb );
4442 createTool( SMESHOp::OpQuadraticEdge, addNonElemTb );
4443 createTool( SMESHOp::OpQuadraticTriangle, addNonElemTb );
4444 createTool( SMESHOp::OpBiQuadraticTriangle, addNonElemTb );
4445 createTool( SMESHOp::OpQuadraticQuadrangle, addNonElemTb );
4446 createTool( SMESHOp::OpBiQuadraticQuadrangle, addNonElemTb );
4447 createTool( SMESHOp::OpQuadraticPolygon, addNonElemTb );
4448 createTool( SMESHOp::OpQuadraticTetrahedron, addNonElemTb );
4449 createTool( SMESHOp::OpQuadraticPyramid, addNonElemTb );
4450 createTool( SMESHOp::OpQuadraticPentahedron, addNonElemTb );
4451 createTool( SMESHOp::OpBiQuadraticPentahedron, addNonElemTb );
4452 createTool( SMESHOp::OpQuadraticHexahedron, addNonElemTb );
4453 createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4455 createTool( SMESHOp::OpRemoveNodes, remTb );
4456 createTool( SMESHOp::OpRemoveElements, remTb );
4457 createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4458 createTool( SMESHOp::OpClearMesh, remTb );
4460 //createTool( SMESHOp::OpRenumberingNodes, renumbTb );
4461 //createTool( SMESHOp::OpRenumberingElements, renumbTb );
4463 createTool( SMESHOp::OpMergeNodes, transformTb );
4464 createTool( SMESHOp::OpMergeElements, transformTb );
4465 createTool( SMESHOp::OpTranslation, transformTb );
4466 createTool( SMESHOp::OpRotation, transformTb );
4467 createTool( SMESHOp::OpSymmetry, transformTb );
4468 createTool( SMESHOp::OpScale, transformTb );
4469 createTool( SMESHOp::OpOffset, transformTb );
4470 createTool( SMESHOp::OpSewing, transformTb );
4471 createTool( SMESHOp::OpDuplicateNodes, transformTb );
4473 createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4474 createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4475 createTool( SMESHOp::OpExtrusion, modifyTb );
4476 createTool( SMESHOp::OpExtrusionAlongAPath, modifyTb );
4477 createTool( SMESHOp::OpRevolution, modifyTb );
4478 createTool( SMESHOp::OpOrientation, modifyTb );
4479 createTool( SMESHOp::OpReorientFaces, modifyTb );
4480 createTool( SMESHOp::OpMoveNode, modifyTb );
4481 createTool( SMESHOp::OpDiagonalInversion, modifyTb );
4482 createTool( SMESHOp::OpUnionOfTwoTriangle, modifyTb );
4483 createTool( SMESHOp::OpUnionOfTriangles, modifyTb );
4484 createTool( SMESHOp::OpCuttingOfQuadrangles, modifyTb );
4485 createTool( SMESHOp::OpSplitVolumes, modifyTb );
4486 createTool( SMESHOp::OpSplitBiQuadratic, modifyTb );
4487 createTool( SMESHOp::OpSmoothing, modifyTb );
4488 createTool( SMESHOp::OpPatternMapping, modifyTb );
4490 createTool( SMESHOp::OpMinimumDistance, measuremTb );
4492 createTool( SMESHOp::OpUpdate, dispModeTb );
4494 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4495 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4499 OB = "'ObjectBrowser'",
4500 View = "'" + SVTK_Viewer::Type() + "'",
4502 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4503 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4504 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4505 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4506 smesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::COMPONENT ) ),
4507 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4508 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4509 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4510 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4511 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4512 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4513 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4515 mesh_part = mesh + " " + subMesh + " " + group,
4516 mesh_group = mesh + " " + group,
4517 mesh_submesh = mesh + " " + subMesh,
4518 hyp_alg = hypo + " " + algo;
4520 // popup for object browser
4522 isInvisible("not( isVisible )"),
4523 isEmpty("numberOfNodes = 0"),
4524 isNotEmpty("numberOfNodes <> 0"),
4526 // has nodes, edges, etc in VISIBLE! actor
4527 hasNodes("(numberOfNodes > 0 ) && hasActor"),
4528 hasElems("(count( elemTypes ) > 0)"),
4529 hasDifferentElems("(count( elemTypes ) > 1)"),
4530 hasDifferentObjElems("(count( objElemTypes ) > 1)"),
4531 hasBalls("({'BallElem'} in elemTypes)"),
4532 hasElems0d("({'Elem0d'} in elemTypes)"),
4533 hasEdges("({'Edge'} in elemTypes)"),
4534 hasFaces("({'Face'} in elemTypes)"),
4535 hasVolumes("({'Volume'} in elemTypes)"),
4536 hasFacesOrVolumes("(({'Face'} in elemTypes) || ({'Volume'} in elemTypes)) ");
4538 createPopupItem( SMESHOp::OpFileInformation, OB, mesh, "&& selcount=1 && isImported" );
4539 createPopupItem( SMESHOp::OpCreateSubMesh, OB, mesh, "&& hasGeomReference");
4540 createPopupItem( SMESHOp::OpEditMesh, OB, mesh, "&& selcount=1" );
4541 createPopupItem( SMESHOp::OpEditSubMesh, OB, subMesh, "&& selcount=1 && hasGeomReference" );
4542 createPopupItem( SMESHOp::OpEditGroup, OB, group );
4543 createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4545 popupMgr()->insert( separator(), -1, 0 );
4546 createPopupItem( SMESHOp::OpCompute, OB, mesh, "&& selcount=1 && isComputable" );
4547 createPopupItem( SMESHOp::OpComputeSubMesh, OB, subMesh, "&& selcount=1 && isComputable" );
4548 createPopupItem( SMESHOp::OpPreCompute, OB, mesh, "&& selcount=1 && isPreComputable" );
4549 createPopupItem( SMESHOp::OpEvaluate, OB, mesh, "&& selcount=1 && isComputable" );
4550 createPopupItem( SMESHOp::OpMeshOrder, OB, mesh, "&& selcount=1 && isComputable && hasGeomReference" );
4551 createPopupItem( SMESHOp::OpUpdate, OB, mesh_part );
4552 createPopupItem( SMESHOp::OpMeshInformation, OB, mesh_part );
4553 createPopupItem( SMESHOp::OpFindElementByPoint,OB, mesh_group, "&& selcount=1" );
4554 createPopupItem( SMESHOp::OpOverallMeshQuality,OB, mesh_part );
4555 popupMgr()->insert( separator(), -1, 0 );
4556 createPopupItem( SMESHOp::OpCreateGroup, OB, mesh, "&& selcount=1" );
4557 createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh, "&& selcount=1 && hasGeomReference" );
4558 createPopupItem( SMESHOp::OpConstructGroup, OB, subMesh );
4559 popupMgr()->insert( separator(), -1, 0 );
4560 createPopupItem( SMESHOp::OpEditHypothesis, OB, hypo, "&& isEditableHyp");
4561 createPopupItem( SMESHOp::OpUnassign, OB, hyp_alg );
4562 popupMgr()->insert( separator(), -1, 0 );
4563 createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh_submesh );
4564 createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh_group, "&& selcount=1 && dim>=2");
4565 popupMgr()->insert( separator(), -1, 0 );
4566 createPopupItem( SMESHOp::OpClearMesh, OB, mesh );
4567 //popupMgr()->insert( separator(), -1, 0 );
4569 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4570 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4571 QString only_one_2D = only_one_non_empty + " && dim>1";
4573 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4574 createPopupItem( SMESHOp::OpPopupExportMED, OB, mesh_group, multiple_non_empty, anId );
4575 createPopupItem( SMESHOp::OpPopupExportUNV, OB, mesh_group, only_one_non_empty, anId );
4576 createPopupItem( SMESHOp::OpPopupExportSTL, OB, mesh_group, only_one_2D, anId );
4578 createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4580 createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, only_one_non_empty, anId );
4581 createPopupItem( SMESHOp::OpPopupExportGMF, OB, mesh_group, only_one_non_empty, anId );
4582 createPopupItem( SMESHOp::OpPopupExportDAT, OB, mesh_group, only_one_non_empty, anId );
4583 createPopupItem( SMESHOp::OpDelete, OB, mesh_part + " " + hyp_alg );
4584 createPopupItem( SMESHOp::OpDeleteGroup, OB, group );
4586 anId = popupMgr()->insert( tr( "MEN_IMPORT" ), -1, -1 ); // IMPORT submenu
4587 createPopupItem( SMESHOp::OpPopupImportMED, OB, smesh, "", anId );
4588 createPopupItem( SMESHOp::OpPopupImportUNV, OB, smesh, "", anId );
4589 createPopupItem( SMESHOp::OpPopupImportSTL, OB, smesh, "", anId );
4591 createPopupItem( SMESHOp::OpPopupImportCGNS, OB, smesh, "", anId );
4593 createPopupItem( SMESHOp::OpPopupImportSAUV, OB, smesh, "", anId );
4594 createPopupItem( SMESHOp::OpPopupImportGMF, OB, smesh, "", anId );
4595 createPopupItem( SMESHOp::OpPopupImportDAT, OB, smesh, "", anId );
4596 popupMgr()->insert( separator(), -1, 0 );
4599 createPopupItem( SMESHOp::OpEditGroup, View, group );
4600 createPopupItem( SMESHOp::OpAddElemGroupPopup, View, elems, "&& guiState = 800" );
4601 createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems, "&& guiState = 800" );
4603 popupMgr()->insert( separator(), -1, 0 );
4604 createPopupItem( SMESHOp::OpUpdate, View, mesh_part );
4605 createPopupItem( SMESHOp::OpMeshInformation, View, mesh_part );
4606 createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4607 createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh );
4608 popupMgr()->insert( separator(), -1, 0 );
4610 createPopupItem( SMESHOp::OpAutoColor, OB + " " + View, mesh, "&& (not isAutoColor)" );
4611 createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4612 popupMgr()->insert( separator(), -1, 0 );
4614 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4615 QString aType = QString( "%1type in {%2}" ).arg( lc );
4616 aType = aType.arg( mesh_part );
4617 QString aMeshInVTK = aClient + "&&" + aType;
4619 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4620 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4621 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4623 //-------------------------------------------------
4625 //-------------------------------------------------
4626 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4628 popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4629 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4630 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4632 popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4633 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4634 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4636 popupMgr()->insert( separator(), -1, -1 );
4638 //-------------------------------------------------
4640 //-------------------------------------------------
4641 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4643 popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4644 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4645 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4647 popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4648 popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4649 popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4651 popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4652 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4653 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4655 popupMgr()->insert( separator(), anId, -1 );
4657 popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4658 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4659 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4661 //-------------------------------------------------
4663 //-------------------------------------------------
4664 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4666 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4668 popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4669 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4670 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4672 popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4673 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4674 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4676 popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4677 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4678 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4680 popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4681 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4682 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4684 popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4685 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4686 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4688 popupMgr()->insert( separator(), anId, -1 );
4690 popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4691 popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&& $type in {" + mesh + "} &&" + hasDifferentObjElems, QtxPopupMgr::VisibleRule );
4693 popupMgr()->insert( separator(), anId, -1 );
4695 popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4696 popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4699 //-------------------------------------------------
4700 // Representation of the 2D Quadratic elements
4701 //-------------------------------------------------
4702 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4703 popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4704 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "&& isVisible && isQuadratic",QtxPopupMgr::VisibleRule );
4705 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4707 popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4708 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "&& isVisible && isQuadratic", QtxPopupMgr::VisibleRule );
4709 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4711 //-------------------------------------------------
4712 // Orientation of faces
4713 //-------------------------------------------------
4714 popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4715 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4716 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4718 //-------------------------------------------------
4720 //-------------------------------------------------
4721 popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4722 popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4724 //-------------------------------------------------
4726 //-------------------------------------------------
4727 popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4728 popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4730 //-------------------------------------------------
4732 //-------------------------------------------------
4734 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4735 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4736 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4737 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4739 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4741 popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4742 popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4744 popupMgr()->insert( separator(), anId, -1 );
4746 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4748 popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4749 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4750 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4752 popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4753 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4754 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4756 // popupMgr()->insert( action( SMESHOp::OpNodeConnectivityNb ), aSubId, -1 );
4757 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4758 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), "controlMode = 'eNodeConnectivityNb'", QtxPopupMgr::ToggleRule );
4760 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4762 popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4763 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVTK + "&&" + hasEdges + "&&" + hasFacesOrVolumes, QtxPopupMgr::VisibleRule );
4764 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4766 popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4767 popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4768 popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4770 popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4771 popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4772 popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4773 popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4774 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4775 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4777 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4779 popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4780 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4781 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4783 popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4784 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4785 QtxPopupMgr::VisibleRule );
4786 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4788 popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4789 popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4790 popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4792 popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4793 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4794 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4796 popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
4797 popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4798 popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4800 popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
4801 popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4802 popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4804 popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
4805 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4806 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4808 popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
4809 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4810 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4812 popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
4813 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4814 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4816 popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
4817 popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4818 popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4820 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
4821 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4822 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4824 popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
4825 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4826 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4828 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
4829 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4830 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4832 popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
4833 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4834 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4836 popupMgr()->insert ( action( SMESHOp::OpDeflection2D ), aSubId, -1 );
4837 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), aMeshInVtkHasFaces + " && hasGeomReference", QtxPopupMgr::VisibleRule );
4838 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), "controlMode = 'eDeflection2D'", QtxPopupMgr::ToggleRule );
4840 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4842 popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D ), aSubId, -1 );
4843 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4844 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4846 popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
4847 popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4848 popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4850 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
4851 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4852 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4854 popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
4855 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4856 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4858 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
4859 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4860 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4862 popupMgr()->insert ( action( SMESHOp::OpEqualVolume ), aSubId, -1 );
4863 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4864 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4866 popupMgr()->insert( separator(), anId, -1 );
4868 popupMgr()->insert( action( SMESHOp::OpShowScalarBar ), anId, -1 );
4869 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4870 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone' && isScalarBarVisible", QtxPopupMgr::ToggleRule );
4871 popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
4872 popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4874 popupMgr()->insert( separator(), anId, -1 );
4876 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4878 popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
4879 popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4881 popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
4882 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4883 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isScalarBarVisible && isDistributionVisible", QtxPopupMgr::ToggleRule);
4885 #ifndef DISABLE_PLOT2DVIEWER
4886 popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
4887 popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4890 //-------------------------------------------------
4892 //-------------------------------------------------
4893 popupMgr()->insert( separator(), -1, -1 );
4894 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4895 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4896 popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
4897 popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4899 popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
4900 popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4902 popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
4903 popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4905 popupMgr()->insert( separator(), -1, -1 );
4907 //-------------------------------------------------
4909 //-------------------------------------------------
4910 popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
4911 popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4913 popupMgr()->insert( separator(), -1, -1 );
4915 popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
4916 popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
4917 popupMgr()->insert( separator(), -1, -1 );
4919 popupMgr()->insert( action( SMESHOp::OpBreakLink), -1, -1 );
4920 popupMgr()->setRule( action( SMESHOp::OpBreakLink), "$component={'SHAPERSTUDY'} and client='ObjectBrowser' and canBreakLink", QtxPopupMgr::VisibleRule );
4922 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4923 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4925 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4926 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4929 //================================================================================
4931 * \brief Return true if SMESH or GEOM objects are selected.
4932 * Is called form LightApp_Module::activateModule() which clear selection if
4933 * not isSelectionCompatible()
4935 //================================================================================
4937 bool SMESHGUI::isSelectionCompatible()
4939 bool isCompatible = true;
4940 SALOME_ListIO selected;
4941 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4942 Sel->selectedObjects( selected );
4944 SALOME_ListIteratorOfListIO It( selected );
4945 for ( ; isCompatible && It.More(); It.Next())
4947 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4948 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4950 return isCompatible;
4954 bool SMESHGUI::reusableOperation( const int id )
4956 // compute, evaluate and precompute are not reusable operations
4957 return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate ) ? false : SalomeApp_Module::reusableOperation( id );
4960 bool SMESHGUI::activateModule( SUIT_Study* study )
4962 bool res = SalomeApp_Module::activateModule( study );
4964 setMenuShown( true );
4965 setToolShown( true );
4967 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4968 PyGILState_STATE gstate = PyGILState_Ensure();
4969 PyObject* pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4970 if ( !pluginsmanager ) {
4974 PyObject* result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toUtf8().data(),tr("SMESH_PLUGINS_OTHER").toUtf8().data());
4979 PyGILState_Release(gstate);
4980 // end of SMESH plugins loading
4982 // Reset actions accelerator keys
4983 action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
4985 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4986 GetSMESHGen()->UpdateStudy();
4988 // get all view currently opened in the study and connect their signals to
4989 // the corresponding slots of the class.
4990 SUIT_Desktop* aDesk = study->application()->desktop();
4992 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4993 SUIT_ViewWindow* wnd;
4994 foreach(wnd, wndList)
4998 // remove actors whose objects are removed in GetSMESHGen()->UpdateStudy()
4999 SMESH::UpdateActorsAfterUpdateStudy(wnd);
5005 Py_XDECREF(pluginsmanager);
5009 bool SMESHGUI::deactivateModule( SUIT_Study* study )
5011 setMenuShown( false );
5012 setToolShown( false );
5014 EmitSignalCloseAllDialogs();
5016 // Unset actions accelerator keys
5017 action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
5019 return SalomeApp_Module::deactivateModule( study );
5022 void SMESHGUI::studyClosed( SUIT_Study* s )
5026 SMESH::RemoveVisuData();
5027 SalomeApp_Module::studyClosed( s );
5030 void SMESHGUI::OnGUIEvent()
5032 const QObject* obj = sender();
5033 if ( !obj || !obj->inherits( "QAction" ) )
5035 int id = actionId((QAction*)obj);
5040 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
5042 if ( CORBA::is_nil( myComponentSMESH ) )
5044 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
5045 return aGUI.myComponentSMESH;
5047 return myComponentSMESH;
5050 QString SMESHGUI::engineIOR() const
5052 CORBA::ORB_var anORB = getApp()->orb();
5053 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
5054 return QString( anIOR.in() );
5057 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
5059 SalomeApp_Module::contextMenuPopup( client, menu, title );
5061 selectionMgr()->selectedObjects( lst );
5062 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
5063 Handle(SALOME_InteractiveObject) io = lst.First();
5064 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
5065 _PTR(Study) study = appStudy->studyDS();
5066 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
5068 QString aName = SMESH::fromUtf8( obj->GetName());
5069 while ( !aName.isEmpty() && aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
5070 aName.remove(( aName.length() - 1 ), 1 );
5076 LightApp_Selection* SMESHGUI::createSelection() const
5078 return new SMESHGUI_Selection();
5081 void SMESHGUI::windows( QMap<int, int>& aMap ) const
5083 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
5084 aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
5085 #ifndef DISABLE_PYCONSOLE
5086 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
5090 void SMESHGUI::viewManagers( QStringList& list ) const
5092 list.append( SVTK_Viewer::Type() );
5095 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
5097 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
5098 SMESH::UpdateSelectionProp( this );
5100 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
5101 for(int i = 0; i < aViews.count() ; i++){
5102 SUIT_ViewWindow *sf = aViews[i];
5105 EmitSignalActivatedViewManager();
5109 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
5111 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
5112 myClippingPlaneInfoMap.erase( theViewManager );
5115 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
5117 theActor->AddObserver( SMESH::DeleteActorEvent,
5118 myEventCallbackCommand.GetPointer(),
5122 void SMESHGUI::ProcessEvents( vtkObject* theObject,
5123 unsigned long theEvent,
5124 void* theClientData,
5127 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
5128 if( theObject && (int) theEvent == SMESH::DeleteActorEvent ) {
5129 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
5130 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
5131 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
5132 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
5133 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
5134 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
5135 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
5136 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
5137 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
5138 SMESH::TActorList::iterator anIter3 = anActorList.begin();
5139 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
5140 if( anActor == *anIter3 ) {
5141 anActorList.erase( anIter3 );
5152 void SMESHGUI::createPreferences()
5154 // General tab ------------------------------------------------------------------------
5155 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
5157 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
5158 setPreferenceProperty( autoUpdate, "columns", 2 );
5159 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
5160 setPreferenceProperty( lim, "min", 0 );
5161 setPreferenceProperty( lim, "max", 100000000 );
5162 setPreferenceProperty( lim, "step", 1000 );
5163 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5164 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
5166 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
5167 setPreferenceProperty( dispgroup, "columns", 2 );
5169 addPreference( tr( "PREF_FITALL_ON_DISPLAYONLY" ), dispgroup, LightApp_Preferences::Bool, "SMESH", "fitall_on_displayonly" );
5171 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
5173 modes.append( tr("MEN_WIRE") );
5174 modes.append( tr("MEN_SHADE") );
5175 modes.append( tr("MEN_NODES") );
5176 modes.append( tr("MEN_SHRINK") );
5177 QList<QVariant> indices;
5178 indices.append( 0 );
5179 indices.append( 1 );
5180 indices.append( 2 );
5181 indices.append( 3 );
5182 setPreferenceProperty( dispmode, "strings", modes );
5183 setPreferenceProperty( dispmode, "indexes", indices );
5185 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
5186 setPreferenceProperty( arcgroup, "columns", 2 );
5187 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
5188 QStringList quadraticModes;
5189 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
5190 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
5192 indices.append( 0 );
5193 indices.append( 1 );
5194 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
5195 setPreferenceProperty( quadraticmode, "indexes", indices );
5197 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
5198 "SMESH", "max_angle" );
5199 setPreferenceProperty( maxAngle, "min", 1 );
5200 setPreferenceProperty( maxAngle, "max", 90 );
5202 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
5203 setPreferenceProperty( qaGroup, "columns", 2 );
5204 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
5205 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
5206 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
5207 setPreferenceProperty( prec, "min", 0 );
5208 setPreferenceProperty( prec, "max", 100 );
5209 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
5210 setPreferenceProperty( doubleNodesTol, "precision", 10 );
5211 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
5212 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
5213 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
5216 int cinc = addPreference(tr("PREF_CONTROLS_INCREMENT"), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_increment");
5217 setPreferenceProperty( cinc, "min", 0 );
5218 setPreferenceProperty( cinc, "max", 5 );
5221 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
5222 setPreferenceProperty( exportgroup, "columns", 2 );
5223 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
5224 addPreference( tr( "PREF_SHOW_WARN" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "show_warning" );
5225 int zTol = addPreference( tr( "PREF_ZTOLERANCE" ), exportgroup, LightApp_Preferences::DblSpin, "SMESH", "med_ztolerance" );
5226 setPreferenceProperty( zTol, "precision", 10 );
5227 setPreferenceProperty( zTol, "min", 0.0000000001 );
5228 setPreferenceProperty( zTol, "max", 1000000.0 );
5229 setPreferenceProperty( zTol, "step", 1. );
5230 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
5232 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
5233 setPreferenceProperty( computeGroup, "columns", 2 );
5234 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
5236 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5237 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5238 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5240 indices.append( 0 );
5241 indices.append( 1 );
5242 indices.append( 2 );
5243 setPreferenceProperty( notifyMode, "strings", modes );
5244 setPreferenceProperty( notifyMode, "indexes", indices );
5246 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5247 setPreferenceProperty( infoGroup, "columns", 2 );
5248 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5250 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5251 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5253 indices.append( 0 );
5254 indices.append( 1 );
5255 setPreferenceProperty( elemInfo, "strings", modes );
5256 setPreferenceProperty( elemInfo, "indexes", indices );
5257 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5258 setPreferenceProperty( nodesLim, "min", 0 );
5259 setPreferenceProperty( nodesLim, "max", 10000000 );
5260 setPreferenceProperty( nodesLim, "step", 10000 );
5261 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5262 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5263 setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5264 setPreferenceProperty( ctrlLim, "min", 0 );
5265 setPreferenceProperty( ctrlLim, "max", 10000000 );
5266 setPreferenceProperty( ctrlLim, "step", 1000 );
5267 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5268 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5269 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5270 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5271 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5273 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5274 setPreferenceProperty( segGroup, "columns", 2 );
5275 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5276 "SMESH", "segmentation" );
5277 setPreferenceProperty( segLen, "min", 1 );
5278 setPreferenceProperty( segLen, "max", 10000000 );
5279 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5280 "SMESH", "nb_segments_per_edge" );
5281 setPreferenceProperty( nbSeg, "min", 1 );
5282 setPreferenceProperty( nbSeg, "max", 10000000 );
5284 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5285 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5286 "SMESH", "forget_mesh_on_hyp_modif" );
5289 // Quantities with individual precision settings
5290 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5291 setPreferenceProperty( precGroup, "columns", 2 );
5293 const int nbQuantities = 6;
5294 int precs[nbQuantities], ii = 0;
5295 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5296 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5297 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5298 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5299 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5300 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5301 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5302 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5303 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5304 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5305 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5306 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5308 // Set property for precision value for spinboxes
5309 for ( ii = 0; ii < nbQuantities; ii++ ){
5310 setPreferenceProperty( precs[ii], "min", -14 );
5311 setPreferenceProperty( precs[ii], "max", 14 );
5312 setPreferenceProperty( precs[ii], "precision", 2 );
5315 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5316 setPreferenceProperty( previewGroup, "columns", 2 );
5317 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5318 setPreferenceProperty( chunkSize, "min", 1 );
5319 setPreferenceProperty( chunkSize, "max", 1000 );
5320 setPreferenceProperty( chunkSize, "step", 50 );
5322 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5323 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5325 // Mesh tab ------------------------------------------------------------------------
5326 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5327 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5328 setPreferenceProperty( nodeGroup, "columns", 3 );
5330 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5332 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5334 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5335 QList<QVariant> aMarkerTypeIndicesList;
5336 QList<QVariant> aMarkerTypeIconsList;
5337 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5338 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5339 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5340 aMarkerTypeIndicesList << i;
5341 aMarkerTypeIconsList << pixmap;
5343 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5344 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
5346 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5348 QList<QVariant> aMarkerScaleIndicesList;
5349 QStringList aMarkerScaleValuesList;
5350 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5351 aMarkerScaleIndicesList << i;
5352 //aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5353 aMarkerScaleValuesList << QString::number( i );
5355 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5356 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5358 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5359 //setPreferenceProperty( elemGroup, "columns", 2 );
5361 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5362 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5363 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5364 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5365 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5366 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5367 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5368 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5369 addPreference( tr( "PREF_PREVIEW_COLOR" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5372 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5373 setPreferenceProperty( grpGroup, "columns", 2 );
5375 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5376 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5378 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5379 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5380 /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5381 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5382 double ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5383 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5384 double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5385 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5386 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
5387 LightApp_Preferences::IntSpin, "SMESH", "element_width");
5388 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5389 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5390 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5391 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5393 setPreferenceProperty( size0d, "min", 1 );
5394 setPreferenceProperty( size0d, "max", 10 );
5396 // setPreferenceProperty( ballSize, "min", 1 );
5397 // setPreferenceProperty( ballSize, "max", 10 );
5399 setPreferenceProperty( ballDiameter, "min", 1e-7 );
5400 setPreferenceProperty( ballDiameter, "max", 1e9 );
5401 setPreferenceProperty( ballDiameter, "step", 0.1 );
5403 setPreferenceProperty( ballScale, "min", 1e-2 );
5404 setPreferenceProperty( ballScale, "max", 1e7 );
5405 setPreferenceProperty( ballScale, "step", 0.5 );
5407 setPreferenceProperty( elemW, "min", 1 );
5408 setPreferenceProperty( elemW, "max", 5 );
5410 setPreferenceProperty( outW, "min", 1 );
5411 setPreferenceProperty( outW, "max", 5 );
5413 setPreferenceProperty( shrink, "min", 0 );
5414 setPreferenceProperty( shrink, "max", 100 );
5416 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5417 setPreferenceProperty( numGroup, "columns", 2 );
5419 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5420 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5422 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5423 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5425 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5426 setPreferenceProperty( orientGroup, "columns", 1 );
5428 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5429 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5431 setPreferenceProperty( orientScale, "min", 0.05 );
5432 setPreferenceProperty( orientScale, "max", 0.5 );
5433 setPreferenceProperty( orientScale, "step", 0.05 );
5435 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5437 // Selection tab ------------------------------------------------------------------------
5438 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5440 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5441 setPreferenceProperty( selGroup, "columns", 2 );
5443 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5444 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5446 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5447 setPreferenceProperty( preGroup, "columns", 2 );
5449 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5451 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5452 setPreferenceProperty( precSelGroup, "columns", 2 );
5454 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5455 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5456 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5458 int sinc = addPreference(tr("PREF_SELECTION_INCREMENT"), selTab, LightApp_Preferences::IntSpin, "SMESH", "selection_increment");
5459 setPreferenceProperty( sinc, "min", 0 );
5460 setPreferenceProperty( sinc, "max", 5 );
5462 // Scalar Bar tab ------------------------------------------------------------------------
5463 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5464 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5465 setPreferenceProperty( fontGr, "columns", 2 );
5467 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5468 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5470 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5471 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5473 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5474 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5476 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5477 setPreferenceProperty( numcol, "min", 2 );
5478 setPreferenceProperty( numcol, "max", 256 );
5480 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5481 setPreferenceProperty( numlab, "min", 2 );
5482 setPreferenceProperty( numlab, "max", 65 );
5484 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5485 setPreferenceProperty( orientGr, "columns", 2 );
5486 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5487 QStringList orients;
5488 orients.append( tr( "SMESH_VERTICAL" ) );
5489 orients.append( tr( "SMESH_HORIZONTAL" ) );
5490 indices.clear(); indices.append( 0 ); indices.append( 1 );
5491 setPreferenceProperty( orient, "strings", orients );
5492 setPreferenceProperty( orient, "indexes", indices );
5494 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5495 setPreferenceProperty( posVSizeGr, "columns", 2 );
5496 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5497 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5498 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5499 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5500 setPreferenceProperty( xv, "step", 0.1 );
5501 setPreferenceProperty( xv, "min", 0.0 );
5502 setPreferenceProperty( xv, "max", 1.0 );
5503 setPreferenceProperty( yv, "step", 0.1 );
5504 setPreferenceProperty( yv, "min", 0.0 );
5505 setPreferenceProperty( yv, "max", 1.0 );
5506 setPreferenceProperty( wv, "step", 0.1 );
5507 setPreferenceProperty( wv, "min", 0.0 );
5508 setPreferenceProperty( wv, "max", 1.0 );
5509 setPreferenceProperty( hv, "min", 0.0 );
5510 setPreferenceProperty( hv, "max", 1.0 );
5511 setPreferenceProperty( hv, "step", 0.1 );
5513 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5514 setPreferenceProperty( posHSizeGr, "columns", 2 );
5515 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5516 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5517 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5518 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5519 setPreferenceProperty( xv, "min", 0.0 );
5520 setPreferenceProperty( xv, "max", 1.0 );
5521 setPreferenceProperty( xv, "step", 0.1 );
5522 setPreferenceProperty( xh, "min", 0.0 );
5523 setPreferenceProperty( xh, "max", 1.0 );
5524 setPreferenceProperty( xh, "step", 0.1 );
5525 setPreferenceProperty( yh, "min", 0.0 );
5526 setPreferenceProperty( yh, "max", 1.0 );
5527 setPreferenceProperty( yh, "step", 0.1 );
5528 setPreferenceProperty( wh, "min", 0.0 );
5529 setPreferenceProperty( wh, "max", 1.0 );
5530 setPreferenceProperty( wh, "step", 0.1 );
5531 setPreferenceProperty( hh, "min", 0.0 );
5532 setPreferenceProperty( hh, "max", 1.0 );
5533 setPreferenceProperty( hh, "step", 0.1 );
5535 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5536 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5537 setPreferenceProperty( distributionGr, "columns", 3 );
5539 types.append( tr( "SMESH_MONOCOLOR" ) );
5540 types.append( tr( "SMESH_MULTICOLOR" ) );
5541 indices.clear(); indices.append( 0 ); indices.append( 1 );
5542 setPreferenceProperty( coloringType, "strings", types );
5543 setPreferenceProperty( coloringType, "indexes", indices );
5544 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5548 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5550 if ( sect=="SMESH" ) {
5551 float sbX1 = 0.01, sbY1 = 0.01, sbW = 0.08, sbH = 0.08;
5552 float aTol = 1.00000009999999;
5553 std::string aWarning;
5554 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5556 if ( name == "selection_object_color" ||
5557 name == "selection_element_color" ||
5558 name == "highlight_color" ||
5559 name == "selection_precision_node" ||
5560 name == "selection_precision_element" ||
5561 name == "selection_precision_object" ||
5562 name == "selection_increment")
5564 SMESH::UpdateSelectionProp( this );
5566 else if (name == "scalar_bar_vertical_x" || name == "scalar_bar_vertical_width")
5568 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5569 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5570 if ( sbX1+sbW > aTol ) {
5571 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5574 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5575 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5578 else if (name == "scalar_bar_vertical_y" || name == "scalar_bar_vertical_height" )
5580 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5581 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5582 if ( sbY1 + sbH > aTol ) {
5583 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5584 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5585 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5588 else if (name == "scalar_bar_horizontal_x" || name == "scalar_bar_horizontal_width")
5590 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5591 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5592 if ( sbX1 + sbW > aTol ) {
5593 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5596 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5597 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5600 else if (name == "scalar_bar_horizontal_y" || name == "scalar_bar_horizontal_height")
5602 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5603 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5604 if ( sbY1 + sbH > aTol ) {
5605 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5608 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5609 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5612 else if ( name == "segmentation" )
5614 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5615 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5617 else if ( name == "nb_segments_per_edge" )
5619 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5620 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5622 else if ( name == "historical_python_dump" || name == "forget_mesh_on_hyp_modif" || name == "default_grp_color" )
5624 QString val = aResourceMgr->stringValue( "SMESH", name );
5625 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5627 else if ( name == "numbering_node_color" || name == "numbering_node_font" )
5629 SMESH::UpdateFontProp( this );
5631 else if ( name == "numbering_elem_color" || name == "numbering_elem_font" )
5633 SMESH::UpdateFontProp( this );
5636 if ( aWarning.size() != 0 ) {
5637 aWarning += "The default values are applied instead.";
5638 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5639 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5640 QObject::tr(aWarning.c_str()));
5645 //================================================================================
5647 * \brief Update something in accordance with update flags
5648 * \param theFlags - update flags
5650 * Update viewer or/and object browser etc. in accordance with update flags ( see
5651 * LightApp_UpdateFlags enumeration ).
5653 //================================================================================
5654 void SMESHGUI::update( const int flags )
5656 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5657 SMESH::UpdateView();
5659 SalomeApp_Module::update( flags );
5662 //================================================================================
5664 * \brief Set default selection mode
5666 * SLOT called when operation committed. Sets default selection mode
5668 //================================================================================
5669 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5671 SVTK_ViewWindow* vtkWnd =
5672 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5674 vtkWnd->SetSelectionMode( ActorSelection );
5677 //================================================================================
5679 * \brief Set default selection mode
5681 * SLOT called when operation aborted. Sets default selection mode
5683 //================================================================================
5684 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5686 SVTK_ViewWindow* vtkWnd =
5687 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5689 vtkWnd->SetSelectionMode( ActorSelection );
5692 //================================================================================
5694 * \brief Creates operation with given identifier
5695 * \param id - identifier of operation to be started
5696 * \return Pointer on created operation or NULL if operation is not created
5698 * Virtual method redefined from the base class creates operation with given id.
5699 * It is called called automatically from startOperation method of base class.
5701 //================================================================================
5702 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5704 LightApp_Operation* op = 0;
5705 // to do : create operation here
5708 case SMESHOp::OpSplitBiQuadratic:
5709 op = new SMESHGUI_SplitBiQuadOp();
5711 case SMESHOp::OpConvertMeshToQuadratic:
5712 op = new SMESHGUI_ConvToQuadOp();
5714 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5715 op = new SMESHGUI_Make2DFrom3DOp();
5717 case SMESHOp::OpReorientFaces:
5718 op = new SMESHGUI_ReorientFacesOp();
5720 case SMESHOp::OpCreateMesh:
5721 op = new SMESHGUI_MeshOp( true, true );
5723 case SMESHOp::OpCreateSubMesh:
5724 op = new SMESHGUI_MeshOp( true, false );
5726 case SMESHOp::OpEditMeshOrSubMesh:
5727 case SMESHOp::OpEditMesh:
5728 case SMESHOp::OpEditSubMesh:
5729 op = new SMESHGUI_MeshOp( false );
5731 case SMESHOp::OpCompute:
5732 case SMESHOp::OpComputeSubMesh:
5733 op = new SMESHGUI_ComputeOp();
5735 case SMESHOp::OpPreCompute:
5736 op = new SMESHGUI_PrecomputeOp();
5738 case SMESHOp::OpEvaluate:
5739 op = new SMESHGUI_EvaluateOp();
5741 case SMESHOp::OpMeshOrder:
5742 op = new SMESHGUI_MeshOrderOp();
5744 case SMESHOp::OpCreateGeometryGroup:
5745 op = new SMESHGUI_GroupOnShapeOp();
5747 case SMESHOp::OpFindElementByPoint:
5748 op = new SMESHGUI_FindElemByPointOp();
5750 case SMESHOp::OpMoveNode: // Make mesh pass through point
5751 op = new SMESHGUI_MakeNodeAtPointOp();
5753 case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
5754 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5761 op = SalomeApp_Module::createOperation( id );
5765 //================================================================================
5767 * \brief Stops current operations and starts a given one
5768 * \param id - The id of the operation to start
5770 //================================================================================
5772 void SMESHGUI::switchToOperation(int id)
5774 activeStudy()->abortAllOperations();
5775 startOperation( id );
5778 LightApp_Displayer* SMESHGUI::displayer()
5781 myDisplayer = new SMESHGUI_Displayer( getApp() );
5785 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5788 int aTolerance = 64;
5789 int anIterations = 0;
5795 if( anIterations % aPeriod == 0 )
5798 if( aTolerance < 1 )
5802 aHue = (int)( 360.0 * rand() / RAND_MAX );
5805 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5806 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5807 for( ; it != itEnd; ++it )
5809 SALOMEDS::Color anAutoColor = *it;
5810 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5813 aQColor.getHsv( &h, &s, &v );
5814 if( abs( h - aHue ) < aTolerance )
5826 aColor.setHsv( aHue, 255, 255 );
5828 SALOMEDS::Color aSColor;
5829 aSColor.R = aColor.redF();
5830 aSColor.G = aColor.greenF();
5831 aSColor.B = aColor.blueF();
5836 const char* gSeparator = "_"; // character used to separate parameter names
5837 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5838 const char* gPathSep = "|"; // character used to separate paths
5841 * \brief Store visual parameters
5843 * This method is called just before the study document is saved.
5844 * Store visual parameters in AttributeParameter attribute(s)
5846 void SMESHGUI::storeVisualParameters (int savePoint)
5849 Kernel_Utils::Localizer loc;
5851 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5852 if (!appStudy || !appStudy->studyDS())
5854 _PTR(Study) studyDS = appStudy->studyDS();
5856 // componentName is used for encoding of entries when storing them in IParameters
5857 std::string componentName = myComponentSMESH->ComponentDataType();
5858 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5859 //if (!aSComponent) return;
5862 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5863 componentName.c_str(),
5865 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5867 // store custom markers
5868 if( !myMarkerMap.empty() )
5870 VTK::MarkerMap::const_iterator anIter = myMarkerMap.begin();
5871 for( ; anIter != myMarkerMap.end(); anIter++ )
5873 int anId = anIter->first;
5874 VTK::MarkerData aMarkerData = anIter->second;
5875 std::string aMarkerFileName = aMarkerData.first;
5876 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5877 if( aMarkerTexture.size() < 3 )
5878 continue; // should contain at least width, height and the first value
5880 QString aPropertyName( "texture" );
5881 aPropertyName += gSeparator;
5882 aPropertyName += QString::number( anId );
5884 QString aPropertyValue = aMarkerFileName.c_str();
5885 aPropertyValue += gPathSep;
5887 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5888 ushort aWidth = *aTextureIter++;
5889 ushort aHeight = *aTextureIter++;
5890 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5891 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5892 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5893 aPropertyValue += QString::number( *aTextureIter );
5895 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5899 // viewers counters are used for storing view_numbers in IParameters
5902 // main cycle to store parameters of displayed objects
5903 QList<SUIT_ViewManager*> lst;
5904 QList<SUIT_ViewManager*>::Iterator it;
5905 getApp()->viewManagers(lst);
5906 for (it = lst.begin(); it != lst.end(); it++)
5908 SUIT_ViewManager* vman = *it;
5909 QString vType = vman->getType();
5911 // saving VTK actors properties
5912 if (vType == SVTK_Viewer::Type())
5914 // store the clipping planes attached to the view manager
5915 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5916 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5917 if( anIter != myClippingPlaneInfoMap.end() )
5918 aClippingPlaneInfoList = anIter->second;
5920 if( !aClippingPlaneInfoList.empty() ) {
5921 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5922 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5924 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5925 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5927 QString aPropertyName( "ClippingPlane" );
5928 aPropertyName += gSeparator;
5929 aPropertyName += QString::number( vtkViewers );
5930 aPropertyName += gSeparator;
5931 aPropertyName += QString::number( anId );
5933 QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
5934 aPropertyValue += gDigitsSep;
5935 aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
5936 aPropertyValue += gDigitsSep;
5937 if ( aPlane->PlaneMode == SMESH::Absolute ) {
5938 aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
5939 aPropertyValue += gDigitsSep;
5940 aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
5941 aPropertyValue += gDigitsSep;
5942 aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
5943 aPropertyValue += gDigitsSep;
5944 aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
5945 aPropertyValue += gDigitsSep;
5946 aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
5947 aPropertyValue += gDigitsSep;
5948 aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
5949 aPropertyValue += gDigitsSep;
5950 aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
5952 else if ( aPlane->PlaneMode == SMESH::Relative ) {
5953 aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
5954 aPropertyValue += gDigitsSep;
5955 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5956 aPropertyValue += gDigitsSep;
5957 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5958 aPropertyValue += gDigitsSep;
5959 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5962 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5966 QVector<SUIT_ViewWindow*> views = vman->getViews();
5967 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5969 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5971 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5972 vtkActorCollection* allActors = aCopy.GetActors();
5973 allActors->InitTraversal();
5974 while (vtkActor* actor = allActors->GetNextActor())
5976 if (actor->GetVisibility()) // store only visible actors
5978 SMESH_Actor* aSmeshActor = 0;
5979 if (actor->IsA("SMESH_Actor"))
5980 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5981 if (aSmeshActor && aSmeshActor->hasIO())
5983 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5986 // entry is "encoded" = it does NOT contain component address,
5987 // since it is a subject to change on next component loading
5988 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5990 std::string param, vtkParam = vType.toLatin1().data();
5991 vtkParam += gSeparator;
5992 vtkParam += QString::number(vtkViewers).toLatin1().data();
5993 vtkParam += gSeparator;
5996 param = vtkParam + "Visibility";
5997 ip->setParameter(entry, param, "On");
6000 param = vtkParam + "Representation";
6001 ip->setParameter(entry, param, QString::number
6002 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
6005 param = vtkParam + "IsShrunk";
6006 ip->setParameter(entry, param, QString::number
6007 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
6009 // Displayed entities
6010 unsigned int aMode = aSmeshActor->GetEntityMode();
6011 bool isE = aMode & SMESH_Actor::eEdges;
6012 bool isF = aMode & SMESH_Actor::eFaces;
6013 bool isV = aMode & SMESH_Actor::eVolumes;
6014 bool is0d = aMode & SMESH_Actor::e0DElements;
6015 bool isB = aMode & SMESH_Actor::eBallElem;
6017 QString modeStr ("e");
6018 modeStr += gDigitsSep; modeStr += QString::number(isE);
6019 modeStr += gDigitsSep; modeStr += "f";
6020 modeStr += gDigitsSep; modeStr += QString::number(isF);
6021 modeStr += gDigitsSep; modeStr += "v";
6022 modeStr += gDigitsSep; modeStr += QString::number(isV);
6023 modeStr += gDigitsSep; modeStr += "0d";
6024 modeStr += gDigitsSep; modeStr += QString::number(is0d);
6025 modeStr += gDigitsSep; modeStr += "b";
6026 modeStr += gDigitsSep; modeStr += QString::number(isB);
6028 param = vtkParam + "Entities";
6029 ip->setParameter(entry, param, modeStr.toLatin1().data());
6035 aSmeshActor->GetSufaceColor(r, g, b, delta);
6036 QStringList colorStr;
6037 colorStr << "surface";
6038 colorStr << QString::number(r);
6039 colorStr << QString::number(g);
6040 colorStr << QString::number(b);
6042 colorStr << "backsurface";
6043 colorStr << QString::number(delta);
6045 aSmeshActor->GetVolumeColor(r, g, b, delta);
6046 colorStr << "volume";
6047 colorStr << QString::number(r);
6048 colorStr << QString::number(g);
6049 colorStr << QString::number(b);
6050 colorStr << QString::number(delta);
6052 aSmeshActor->GetEdgeColor(r, g, b);
6054 colorStr << QString::number(r);
6055 colorStr << QString::number(g);
6056 colorStr << QString::number(b);
6058 aSmeshActor->GetNodeColor(r, g, b);
6060 colorStr << QString::number(r);
6061 colorStr << QString::number(g);
6062 colorStr << QString::number(b);
6064 aSmeshActor->GetOutlineColor(r, g, b);
6065 colorStr << "outline";
6066 colorStr << QString::number(r);
6067 colorStr << QString::number(g);
6068 colorStr << QString::number(b);
6070 aSmeshActor->Get0DColor(r, g, b);
6071 colorStr << "elem0d";
6072 colorStr << QString::number(r);
6073 colorStr << QString::number(g);
6074 colorStr << QString::number(b);
6076 aSmeshActor->GetBallColor(r, g, b);
6078 colorStr << QString::number(r);
6079 colorStr << QString::number(g);
6080 colorStr << QString::number(b);
6082 aSmeshActor->GetFacesOrientationColor(r, g, b);
6083 colorStr << "orientation";
6084 colorStr << QString::number(r);
6085 colorStr << QString::number(g);
6086 colorStr << QString::number(b);
6088 param = vtkParam + "Colors";
6089 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
6092 QStringList sizeStr;
6094 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
6095 sizeStr << "outline";
6096 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
6097 sizeStr << "elem0d";
6098 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
6100 //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
6101 sizeStr << QString::number((double)aSmeshActor->GetBallSize());
6102 sizeStr << QString::number((double)aSmeshActor->GetBallScale());
6103 sizeStr << "shrink";
6104 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
6105 sizeStr << "orientation";
6106 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
6107 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
6109 param = vtkParam + "Sizes";
6110 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
6115 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
6116 if( aMarkerType == VTK::MT_USER ) {
6117 markerStr += "custom";
6118 markerStr += gDigitsSep;
6119 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
6123 markerStr += gDigitsSep;
6124 markerStr += QString::number( (int)aMarkerType );
6125 markerStr += gDigitsSep;
6126 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
6129 param = vtkParam + "PointMarker";
6130 ip->setParameter(entry, param, markerStr.toLatin1().data());
6133 param = vtkParam + "Opacity";
6134 ip->setParameter(entry, param,
6135 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
6138 param = vtkParam + "ClippingPlane";
6140 if( !aClippingPlaneInfoList.empty() ) {
6141 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
6142 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
6144 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
6145 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
6146 SMESH::TActorList::iterator anIter2 = anActorList.begin();
6147 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
6148 if( aSmeshActor == *anIter2 ) {
6149 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
6150 QString::number( anId ).toLatin1().constData() );
6157 ip->setParameter( entry, param, "Off" );
6158 } // if (io->hasEntry())
6159 } // SMESH_Actor && hasIO
6161 } // while.. actors traversal
6165 } // if (SVTK view model)
6166 } // for (viewManagers)
6169 // data structures for clipping planes processing
6173 bool isOpenGLClipping;
6174 vtkIdType RelativeOrientation;
6177 int AbsoluteOrientation;
6178 double X, Y, Z, Dx, Dy, Dz;
6180 typedef std::list<TPlaneData> TPlaneDataList;
6181 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
6183 typedef std::list<vtkActor*> TActorList;
6186 TActorList ActorList;
6187 SUIT_ViewManager* ViewManager;
6189 typedef std::list<TPlaneInfo> TPlaneInfoList;
6190 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
6193 * \brief Restore visual parameters
6195 * This method is called after the study document is opened.
6196 * Restore visual parameters from AttributeParameter attribute(s)
6198 void SMESHGUI::restoreVisualParameters (int savePoint)
6201 Kernel_Utils::Localizer loc;
6203 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6204 if (!appStudy || !appStudy->studyDS())
6206 _PTR(Study) studyDS = appStudy->studyDS();
6208 // componentName is used for encoding of entries when storing them in IParameters
6209 std::string componentName = myComponentSMESH->ComponentDataType();
6210 //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
6211 //if (!aSComponent) return;
6214 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6215 componentName.c_str(),
6217 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6219 // restore custom markers and map of clipping planes
6220 TPlaneDataMap aPlaneDataMap;
6222 std::vector<std::string> properties = ip->getProperties();
6223 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
6225 std::string property = *propIt;
6226 QString aPropertyName( property.c_str() );
6227 QString aPropertyValue( ip->getProperty( property ).c_str() );
6229 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
6230 if( aPropertyNameList.isEmpty() )
6233 QString aPropertyType = aPropertyNameList[0];
6234 if( aPropertyType == "texture" )
6236 if( aPropertyNameList.size() != 2 )
6240 int anId = aPropertyNameList[1].toInt( &ok );
6241 if( !ok || anId < 1 )
6244 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
6245 if( aPropertyValueList.size() != 2 )
6248 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
6249 QString aMarkerTextureString = aPropertyValueList[1];
6250 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
6251 if( aMarkerTextureStringList.size() != 3 )
6255 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6260 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6264 VTK::MarkerTexture aMarkerTexture;
6265 aMarkerTexture.push_back( aWidth );
6266 aMarkerTexture.push_back( aHeight );
6268 QString aMarkerTextureData = aMarkerTextureStringList[2];
6269 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6271 QChar aChar = aMarkerTextureData.at( i );
6272 if( aChar.isDigit() )
6273 aMarkerTexture.push_back( aChar.digitValue() );
6276 myMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6278 else if( aPropertyType == "ClippingPlane" )
6280 if( aPropertyNameList.size() != 3 )
6284 int aViewId = aPropertyNameList[1].toInt( &ok );
6285 if( !ok || aViewId < 0 )
6289 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6290 if( !ok || aClippingPlaneId < 0 )
6293 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6294 if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6297 TPlaneData aPlaneData;
6298 aPlaneData.AbsoluteOrientation = false;
6299 aPlaneData.RelativeOrientation = 0;
6300 aPlaneData.Distance = aPlaneData.Angle[0] = aPlaneData.Angle[1] = 0;
6301 aPlaneData.X = aPlaneData.Y = aPlaneData.Z = 0;
6302 aPlaneData.Dx = aPlaneData.Dy = aPlaneData.Dz = 0;
6304 aPlaneData.Id = aClippingPlaneId;
6307 aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6312 aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6316 if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6319 aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6324 aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6329 aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6334 aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6339 aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6344 aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6349 aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6353 else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6355 aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6360 aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6365 aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6370 aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6375 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6376 aPlaneDataList.push_back( aPlaneData );
6380 TPlaneInfoMap aPlaneInfoMap;
6382 std::vector<std::string> entries = ip->getEntries();
6384 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6386 // entry is a normal entry - it should be "decoded" (setting base address of component)
6387 QString entry (ip->decodeEntry(*entIt).c_str());
6389 // Check that the entry corresponds to a real object in the Study
6390 // as the object may be deleted or modified after the visual state is saved.
6391 _PTR(SObject) so = studyDS->FindObjectID(entry.toUtf8().data());
6392 if (!so) continue; //Skip the not existent entry
6394 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6395 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6397 std::vector<std::string>::iterator namesIt = paramNames.begin();
6398 std::vector<std::string>::iterator valuesIt = paramValues.begin();
6400 // actors are stored in a map after displaying of them for
6401 // quicker access in the future: map < viewID to actor >
6402 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6404 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6406 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6407 // '_' is used as separator and should not be used in viewer type or parameter names.
6408 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6409 if (lst.size() != 3)
6412 QString viewerTypStr = lst[0];
6413 QString viewIndexStr = lst[1];
6414 QString paramNameStr = lst[2];
6417 int viewIndex = viewIndexStr.toUInt(&ok);
6418 if (!ok) // bad conversion of view index to integer
6422 if (viewerTypStr == SVTK_Viewer::Type())
6424 SMESH_Actor* aSmeshActor = 0;
6425 if (vtkActors.IsBound(viewIndex))
6426 aSmeshActor = vtkActors.Find(viewIndex);
6428 QList<SUIT_ViewManager*> lst;
6429 getApp()->viewManagers(viewerTypStr, lst);
6431 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6432 SUIT_ViewManager* vman = NULL;
6433 if (viewIndex >= 0 && viewIndex < lst.count())
6434 vman = lst.at(viewIndex);
6436 if (paramNameStr == "Visibility")
6438 if (!aSmeshActor && displayer() && vman)
6440 SUIT_ViewModel* vmodel = vman->getViewModel();
6441 // SVTK view model can be casted to SALOME_View
6442 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6444 // store displayed actor in a temporary map for quicker
6445 // access later when restoring other parameters
6446 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6447 vtkRenderer* Renderer = vtkView->getRenderer();
6448 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6449 vtkActorCollection* theActors = aCopy.GetActors();
6450 theActors->InitTraversal();
6451 bool isFound = false;
6452 vtkActor *ac = theActors->GetNextActor();
6453 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6454 if (ac->IsA("SMESH_Actor")) {
6455 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6456 if (aGeomAc->hasIO()) {
6457 Handle(SALOME_InteractiveObject) io = aGeomAc->getIO();
6458 if (io->hasEntry() && strcmp(io->getEntry(), entry.toUtf8().data()) == 0) {
6460 vtkActors.Bind(viewIndex, aGeomAc);
6466 } // if (paramNameStr == "Visibility")
6469 // the rest properties "work" with SMESH_Actor
6472 QString val ((*valuesIt).c_str());
6475 if (paramNameStr == "Representation") {
6476 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6479 else if (paramNameStr == "IsShrunk") {
6481 if (!aSmeshActor->IsShrunk())
6482 aSmeshActor->SetShrink();
6485 if (aSmeshActor->IsShrunk())
6486 aSmeshActor->UnShrink();
6489 // Displayed entities
6490 else if (paramNameStr == "Entities") {
6491 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6492 int aEntityMode = SMESH_Actor::eAllEntity;
6493 for ( int i = 0; i < mode.count(); i+=2 ) {
6494 if ( i < mode.count()-1 ) {
6495 QString type = mode[i];
6496 bool val = mode[i+1].toInt();
6497 if ( type == "e" && !val )
6498 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6499 else if ( type == "f" && !val )
6500 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6501 else if ( type == "v" && !val )
6502 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6503 else if ( type == "0d" && !val )
6504 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6505 else if ( type == "b" && !val )
6506 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6509 aSmeshActor->SetEntityMode( aEntityMode );
6512 else if (paramNameStr == "Colors") {
6513 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6520 QColor outlineColor;
6521 QColor orientationColor;
6527 // below lines are required to get default values for delta coefficients
6528 // of backface color for faces and color of reversed volumes
6529 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
6530 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6531 for ( int i = 0; i < colors.count(); i++ ) {
6532 QString type = colors[i];
6533 if ( type == "surface" ) {
6534 // face color is set by 3 values r:g:b, where
6535 // - r,g,b - is rgb color components
6536 if ( i+1 >= colors.count() ) break; // format error
6537 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6538 if ( i+2 >= colors.count() ) break; // format error
6539 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6540 if ( i+3 >= colors.count() ) break; // format error
6541 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6542 faceColor.setRgbF( r, g, b );
6545 else if ( type == "backsurface" ) {
6546 // backface color can be defined in several ways
6547 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6548 // - in latest versions, it is set as delta coefficient
6549 bool rgbOk = false, deltaOk;
6550 if ( i+1 >= colors.count() ) break; // format error
6551 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6552 int delta = colors[i+1].toInt( &deltaOk );
6554 if ( i+1 < colors.count() ) // index is shifted to 1
6555 g = colors[i+1].toDouble( &rgbOk );
6556 if ( rgbOk ) i++; // shift index
6557 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6558 b = colors[i+1].toDouble( &rgbOk );
6560 // - as currently there's no way to set directly backsurface color as it was before,
6561 // we ignore old dump where r,g,b triple was set
6562 // - also we check that delta parameter is set properly
6563 if ( !rgbOk && deltaOk )
6566 else if ( type == "volume" ) {
6567 // volume color is set by 4 values r:g:b:delta, where
6568 // - r,g,b - is a normal volume rgb color components
6569 // - delta - is a reversed volume color delta coefficient
6570 if ( i+1 >= colors.count() ) break; // format error
6571 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6572 if ( i+2 >= colors.count() ) break; // format error
6573 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6574 if ( i+3 >= colors.count() ) break; // format error
6575 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6576 if ( i+4 >= colors.count() ) break; // format error
6577 int delta = colors[i+4].toInt( &bOk );
6578 if ( !bOk ) break; // format error
6579 volumeColor.setRgbF( r, g, b );
6583 else if ( type == "edge" ) {
6584 // edge color is set by 3 values r:g:b, where
6585 // - r,g,b - is rgb color components
6586 if ( i+1 >= colors.count() ) break; // format error
6587 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6588 if ( i+2 >= colors.count() ) break; // format error
6589 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6590 if ( i+3 >= colors.count() ) break; // format error
6591 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6592 edgeColor.setRgbF( r, g, b );
6595 else if ( type == "node" ) {
6596 // node color is set by 3 values r:g:b, where
6597 // - r,g,b - is rgb color components
6598 if ( i+1 >= colors.count() ) break; // format error
6599 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6600 if ( i+2 >= colors.count() ) break; // format error
6601 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6602 if ( i+3 >= colors.count() ) break; // format error
6603 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6604 nodeColor.setRgbF( r, g, b );
6607 else if ( type == "elem0d" ) {
6608 // 0d element color is set by 3 values r:g:b, where
6609 // - r,g,b - is rgb color components
6610 if ( i+1 >= colors.count() ) break; // format error
6611 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6612 if ( i+2 >= colors.count() ) break; // format error
6613 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6614 if ( i+3 >= colors.count() ) break; // format error
6615 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6616 elem0dColor.setRgbF( r, g, b );
6619 else if ( type == "ball" ) {
6620 // ball color is set by 3 values r:g:b, where
6621 // - r,g,b - is rgb color components
6622 if ( i+1 >= colors.count() ) break; // format error
6623 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6624 if ( i+2 >= colors.count() ) break; // format error
6625 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6626 if ( i+3 >= colors.count() ) break; // format error
6627 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6628 ballColor.setRgbF( r, g, b );
6631 else if ( type == "outline" ) {
6632 // outline color is set by 3 values r:g:b, where
6633 // - r,g,b - is rgb color components
6634 if ( i+1 >= colors.count() ) break; // format error
6635 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6636 if ( i+2 >= colors.count() ) break; // format error
6637 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6638 if ( i+3 >= colors.count() ) break; // format error
6639 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6640 outlineColor.setRgbF( r, g, b );
6643 else if ( type == "orientation" ) {
6644 // orientation color is set by 3 values r:g:b, where
6645 // - r,g,b - is rgb color components
6646 if ( i+1 >= colors.count() ) break; // format error
6647 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6648 if ( i+2 >= colors.count() ) break; // format error
6649 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6650 if ( i+3 >= colors.count() ) break; // format error
6651 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6652 orientationColor.setRgbF( r, g, b );
6657 if ( nodeColor.isValid() )
6658 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6660 if ( edgeColor.isValid() )
6661 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6663 if ( faceColor.isValid() )
6664 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6666 if ( volumeColor.isValid() )
6667 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6668 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6669 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6671 if ( elem0dColor.isValid() )
6672 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6674 if ( ballColor.isValid() )
6675 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6677 if ( outlineColor.isValid() )
6678 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6679 // orientation color
6680 if ( orientationColor.isValid() )
6681 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6684 else if (paramNameStr == "Sizes") {
6685 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6688 int outlineWidth = -1;
6689 int elem0dSize = -1;
6690 //int ballSize = -1;
6691 double ballDiameter = -1.0;
6692 double ballScale = -1.0;
6693 double shrinkSize = -1;
6694 double orientationSize = -1;
6695 bool orientation3d = false;
6696 for ( int i = 0; i < sizes.count(); i++ ) {
6697 QString type = sizes[i];
6698 if ( type == "line" ) {
6699 // line (wireframe) width is given as single integer value
6700 if ( i+1 >= sizes.count() ) break; // format error
6701 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6705 if ( type == "outline" ) {
6706 // outline width is given as single integer value
6707 if ( i+1 >= sizes.count() ) break; // format error
6708 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6712 else if ( type == "elem0d" ) {
6713 // 0d element size is given as single integer value
6714 if ( i+1 >= sizes.count() ) break; // format error
6715 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6719 else if ( type == "ball" ) {
6720 // balls are specified by two values: size:scale, where
6721 // - size - is a integer value specifying size
6722 // - scale - is a double value specifying scale factor
6723 if ( i+1 >= sizes.count() ) break; // format error
6724 //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6725 double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6726 if ( i+2 >= sizes.count() ) break; // format error
6727 double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6733 else if ( type == "shrink" ) {
6734 // shrink factor is given as single floating point value
6735 if ( i+1 >= sizes.count() ) break; // format error
6736 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6740 else if ( type == "orientation" ) {
6741 // orientation vectors are specified by two values size:3d, where
6742 // - size - is a floating point value specifying scale factor
6743 // - 3d - is a boolean
6744 if ( i+1 >= sizes.count() ) break; // format error
6745 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6746 if ( i+2 >= sizes.count() ) break; // format error
6747 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6748 orientationSize = v1;
6749 orientation3d = (bool)v2;
6753 // line (wireframe) width
6754 if ( lineWidth > 0 )
6755 aSmeshActor->SetLineWidth( lineWidth );
6757 if ( outlineWidth > 0 )
6758 aSmeshActor->SetOutlineWidth( outlineWidth );
6759 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6760 aSmeshActor->SetOutlineWidth( lineWidth );
6762 if ( elem0dSize > 0 )
6763 aSmeshActor->Set0DSize( elem0dSize );
6765 /*if ( ballSize > 0 )
6766 aSmeshActor->SetBallSize( ballSize );*/
6768 if ( ballDiameter > 0 )
6769 aSmeshActor->SetBallSize( ballDiameter );
6771 if ( ballScale > 0.0 )
6772 aSmeshActor->SetBallScale( ballScale );
6774 if ( shrinkSize > 0 )
6775 aSmeshActor->SetShrinkFactor( shrinkSize );
6776 // orientation vectors
6777 if ( orientationSize > 0 ) {
6778 aSmeshActor->SetFacesOrientationScale( orientationSize );
6779 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6783 else if (paramNameStr == "PointMarker") {
6784 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6785 if( data.count() >= 2 ) {
6787 int aParam1 = data[1].toInt( &ok );
6789 if( data[0] == "std" && data.count() == 3 ) {
6790 int aParam2 = data[2].toInt( &ok );
6791 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6793 else if( data[0] == "custom" ) {
6794 VTK::MarkerMap::const_iterator markerIt = myMarkerMap.find( aParam1 );
6795 if( markerIt != myMarkerMap.end() ) {
6796 VTK::MarkerData aMarkerData = markerIt->second;
6797 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6804 else if (paramNameStr == "Opacity") {
6805 aSmeshActor->SetOpacity(val.toFloat());
6808 else if (paramNameStr.startsWith("ClippingPlane")) {
6809 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6810 // old format - val looks like "Off" or "1:0:0:0.5:0:0"
6811 // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
6812 // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
6813 // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
6814 // new format - val looks like "Off" or "0" (plane id)
6815 // (note: in new format "Off" value is used only for consistency,
6816 // so it is processed together with values in old format)
6817 bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
6818 if( anIsOldFormat ) {
6819 if (paramNameStr == "ClippingPlane1" || val == "Off")
6820 aSmeshActor->RemoveAllClippingPlanes();
6822 QList<SUIT_ViewManager*> lst;
6823 getApp()->viewManagers(viewerTypStr, lst);
6824 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6825 if (viewIndex >= 0 && viewIndex < lst.count()) {
6826 SUIT_ViewManager* vman = lst.at(viewIndex);
6827 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6829 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6831 SMESH::TActorList anActorList;
6832 anActorList.push_back( aSmeshActor );
6833 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
6834 aPlane->myViewWindow = vtkView;
6835 SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
6836 aPlane->PlaneMode = aMode;
6837 bool isOpenGLClipping = ( bool )vals[1].toInt();
6838 aPlane->IsOpenGLClipping = isOpenGLClipping;
6839 if ( aMode == SMESH::Absolute ) {
6840 aPlane->myAbsoluteOrientation = vals[2].toInt();
6841 aPlane->X = vals[3].toFloat();
6842 aPlane->Y = vals[4].toFloat();
6843 aPlane->Z = vals[5].toFloat();
6844 aPlane->Dx = vals[6].toFloat();
6845 aPlane->Dy = vals[7].toFloat();
6846 aPlane->Dz = vals[8].toFloat();
6848 else if ( aMode == SMESH::Relative ) {
6849 aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
6850 aPlane->myDistance = vals[3].toFloat();
6851 aPlane->myAngle[0] = vals[4].toFloat();
6852 aPlane->myAngle[1] = vals[5].toFloat();
6856 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6857 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6858 aClippingPlaneInfo.Plane = aPlane;
6859 aClippingPlaneInfo.ActorList = anActorList;
6860 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6868 int aPlaneId = val.toInt( &ok );
6869 if( ok && aPlaneId >= 0 ) {
6870 bool anIsDefinedPlane = false;
6871 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6872 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6873 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6874 TPlaneInfo& aPlaneInfo = *anIter;
6875 if( aPlaneInfo.PlaneId == aPlaneId ) {
6876 aPlaneInfo.ActorList.push_back( aSmeshActor );
6877 anIsDefinedPlane = true;
6881 if( !anIsDefinedPlane ) {
6882 TPlaneInfo aPlaneInfo;
6883 aPlaneInfo.PlaneId = aPlaneId;
6884 aPlaneInfo.ActorList.push_back( aSmeshActor );
6885 aPlaneInfo.ViewManager = vman;
6887 // to make the list sorted by plane id
6888 anIter = aPlaneInfoList.begin();
6889 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6890 const TPlaneInfo& aPlaneInfoRef = *anIter;
6891 if( aPlaneInfoRef.PlaneId > aPlaneId )
6894 aPlaneInfoList.insert( anIter, aPlaneInfo );
6899 } // if (aSmeshActor)
6900 } // other parameters than Visibility
6902 } // for names/parameters iterator
6903 } // for entries iterator
6905 // take into account planes with empty list of actors referred to them
6906 QList<SUIT_ViewManager*> aVMList;
6907 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6909 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6910 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6911 int aViewId = aPlaneDataIter->first;
6912 if( aViewId >= 0 && aViewId < aVMList.count() ) {
6913 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6915 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6917 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6918 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6919 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6920 const TPlaneData& aPlaneData = *anIter2;
6921 int aPlaneId = aPlaneData.Id;
6923 bool anIsFound = false;
6924 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6925 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6926 const TPlaneInfo& aPlaneInfo = *anIter3;
6927 if( aPlaneInfo.PlaneId == aPlaneId ) {
6934 TPlaneInfo aPlaneInfo; // ActorList field is empty
6935 aPlaneInfo.PlaneId = aPlaneId;
6936 aPlaneInfo.ViewManager = aViewManager;
6938 // to make the list sorted by plane id
6939 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6940 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6941 const TPlaneInfo& aPlaneInfoRef = *anIter4;
6942 if( aPlaneInfoRef.PlaneId > aPlaneId )
6945 aPlaneInfoList.insert( anIter4, aPlaneInfo );
6951 // add clipping planes to actors according to the restored parameters
6952 // and update the clipping plane map
6953 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6954 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6955 int aViewId = anIter1->first;
6956 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6958 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6959 if( anIter2 == aPlaneDataMap.end() )
6961 const TPlaneDataList& aPlaneDataList = anIter2->second;
6963 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6964 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6965 const TPlaneInfo& aPlaneInfo = *anIter3;
6966 int aPlaneId = aPlaneInfo.PlaneId;
6967 const TActorList& anActorList = aPlaneInfo.ActorList;
6968 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6972 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6976 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6978 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6979 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6980 const TPlaneData& aPlaneData = *anIter4;
6981 if( aPlaneData.Id == aPlaneId ) {
6982 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
6983 aPlane->myViewWindow = aViewWindow;
6984 aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
6985 aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
6986 if ( aPlane->PlaneMode == SMESH::Absolute ) {
6987 aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
6988 aPlane->X = aPlaneData.X;
6989 aPlane->Y = aPlaneData.Y;
6990 aPlane->Z = aPlaneData.Z;
6991 aPlane->Dx = aPlaneData.Dx;
6992 aPlane->Dy = aPlaneData.Dy;
6993 aPlane->Dz = aPlaneData.Dz;
6995 else if ( aPlane->PlaneMode == SMESH::Relative ) {
6996 aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
6997 aPlane->myDistance = aPlaneData.Distance;
6998 aPlane->myAngle[0] = aPlaneData.Angle[0];
6999 aPlane->myAngle[1] = aPlaneData.Angle[1];
7002 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
7003 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
7004 aClippingPlaneInfo.Plane = aPlane;
7005 aClippingPlaneInfo.ActorList = anActorList;
7006 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
7017 // update all VTK views
7018 QList<SUIT_ViewManager*> lst;
7019 getApp()->viewManagers(lst);
7020 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
7021 SUIT_ViewModel* vmodel = (*it)->getViewModel();
7022 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
7023 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
7024 // set OpenGL clipping planes
7025 VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
7026 vtkActorCollection* anAllActors = aCopy.GetActors();
7027 anAllActors->InitTraversal();
7028 while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
7029 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
7030 anActor->SetOpenGLClippingPlane();
7032 vtkView->getRenderer()->ResetCameraClippingRange();
7039 \brief Adds preferences for dfont of VTK viewer
7041 \param pIf group identifier
7042 \param param parameter
7043 \return identifier of preferences
7045 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
7047 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
7049 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
7052 fam.append( tr( "SMESH_FONT_ARIAL" ) );
7053 fam.append( tr( "SMESH_FONT_COURIER" ) );
7054 fam.append( tr( "SMESH_FONT_TIMES" ) );
7056 setPreferenceProperty( tfont, "fonts", fam );
7058 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
7059 if ( needSize ) f = f | QtxFontEdit::Size;
7060 setPreferenceProperty( tfont, "features", f );
7066 \brief Actions after hypothesis edition
7067 Updates object browser after hypothesis edition
7069 void SMESHGUI::onHypothesisEdit( int result )
7072 SMESHGUI::Modified();
7073 updateObjBrowser( true );
7077 \brief Actions after choosing menu of control modes
7078 Updates control mode actions according to current selection
7080 void SMESHGUI::onUpdateControlActions()
7082 SALOME_ListIO selected;
7083 if ( LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr() )
7084 aSel->selectedObjects( selected );
7086 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
7087 if ( selected.Extent() ) {
7088 if ( selected.First()->hasEntry() ) {
7089 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( selected.First()->getEntry() )) {
7090 aControl = anActor->GetControlMode();
7091 SALOME_ListIteratorOfListIO it(selected);
7092 for ( it.Next(); it.More(); it.Next() ) {
7093 Handle(SALOME_InteractiveObject) anIO = it.Value();
7094 if ( anIO->hasEntry() ) {
7095 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
7096 if ( aControl != anActor->GetControlMode() ) {
7097 aControl = SMESH_Actor::eNone;
7107 int anAction = ActionToControl( aControl, true );
7109 action( anAction )->setChecked( true );
7111 QMenu* send = (QMenu*)sender();
7112 QList<QAction*> actions = send->actions();
7113 for ( int i = 0; i < actions.size(); i++ )
7114 actions[i]->setChecked( false );
7120 \brief Signal handler closing(SUIT_ViewWindow*) of a view
7121 \param pview view being closed
7123 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
7124 #ifndef DISABLE_PLOT2DVIEWER
7125 //Crear all Plot2d Viewers if need.
7126 SMESH::ClearPlot2Viewers(pview);
7128 EmitSignalCloseView();
7131 void SMESHGUI::message( const QString& msg )
7134 QStringList data = msg.split("/");
7135 if ( data.count() > 0 ) {
7136 if ( data.first() == "mesh_loading" ) {
7138 QString entry = data.count() > 1 ? data[1] : QString();
7139 if ( entry.isEmpty() )
7142 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
7144 _PTR(SObject) obj = study->FindObjectID( entry.toUtf8().constData() );
7147 name = SMESH::fromUtf8(obj->GetName());
7148 if ( name.isEmpty() )
7151 if ( data.last() == "stop" )
7152 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
7154 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
7155 QApplication::processEvents();
7161 \brief Connects or disconnects signals about activating and cloning view on the module slots
7162 \param pview view which is connected/disconnected
7164 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
7168 SUIT_ViewManager* viewMgr = pview->getViewManager();
7170 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7171 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7173 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7174 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7179 \brief Return \c true if object can be renamed
7181 bool SMESHGUI::renameAllowed( const QString& entry) const {
7182 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7186 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7190 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
7195 if(appStudy->isComponent(entry) || obj->isReference())
7198 // check type to prevent renaming of inappropriate objects
7199 int aType = SMESHGUI_Selection::type(qPrintable(entry));
7200 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7201 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7202 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7203 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7204 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
7211 Rename object by entry.
7212 \param entry entry of the object
7213 \param name new name of the object
7214 \brief Return \c true if rename operation finished successfully, \c false otherwise.
7216 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
7218 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7222 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7227 _PTR(Study) aStudy = appStudy->studyDS();
7232 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
7234 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
7239 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
7240 _PTR(GenericAttribute) anAttr;
7241 _PTR(AttributeName) aName;
7243 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
7245 // check type to prevent renaming of inappropriate objects
7246 int aType = SMESHGUI_Selection::type( qPrintable(entry));
7247 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7248 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7249 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7250 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7251 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
7252 if ( !name.isEmpty() ) {
7253 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qUtf8Printable(name) );
7255 // update name of group object and its actor
7256 Handle(SALOME_InteractiveObject) IObject =
7257 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
7259 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
7260 if( !aGroupObject->_is_nil() ) {
7261 aGroupObject->SetName( qUtf8Printable(name) );
7262 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
7263 anActor->setName( qUtf8Printable(name) );
7273 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
7275 static QList<QColor> colors;
7277 if ( colors.isEmpty() ) {
7279 for (int s = 0; s < 2 ; s++)
7281 for (int v = 100; v >= 40; v = v - 20)
7283 for (int h = 0; h < 359 ; h = h + 60)
7285 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
7290 static int currentColor = randomize( colors.size() );
7292 SALOMEDS::Color color;
7293 color.R = (double)colors[currentColor].red() / 255.0;
7294 color.G = (double)colors[currentColor].green() / 255.0;
7295 color.B = (double)colors[currentColor].blue() / 255.0;
7297 currentColor = (currentColor+1) % colors.count();