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)) {
1423 geomGen->BreakLink(aREntry.toStdString().c_str());
1424 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1432 void SetDisplayMode(int theCommandID, VTK::MarkerMap& theMarkerMap)
1434 SALOME_ListIO selected;
1435 SalomeApp_Application* app =
1436 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1440 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1441 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1442 if ( !aSel || !appStudy )
1445 if ( theCommandID == SMESHOp::OpClipping ) { // Clipping dialog can be activated without selection
1446 if ( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
1447 aModule->EmitSignalDeactivateDialog();
1448 if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
1449 (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
1454 aSel->selectedObjects( selected );
1456 if ( selected.Extent() >= 1 )
1458 switch ( theCommandID ) {
1459 case SMESHOp::OpTransparency:
1461 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1462 (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
1465 case SMESHOp::OpProperties:
1468 QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
1469 QColor orientationColor, outlineColor, volumeColor;
1470 int deltaF = 0, deltaV = 0;
1473 double ballScale = 1.0;
1475 int outlineWidth = 1;
1476 double shrinkCoef = 0.0;
1477 double orientationScale = 0.0;
1478 bool orientation3d = false;
1479 VTK::MarkerType markerType = VTK::MT_NONE;
1480 VTK::MarkerScale markerScale = VTK::MS_NONE;
1482 bool hasNodes = false;
1483 int presentEntities = 0;
1484 bool firstTime = true;
1486 SALOME_ListIteratorOfListIO It( selected );
1487 for ( ; It.More(); It.Next() ) {
1488 Handle(SALOME_InteractiveObject) IObject = It.Value();
1489 if ( !IObject->hasEntry() ) continue;
1490 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1491 if ( !anActor || !anActor->GetObject() ) continue;
1494 // nodes: color, marker
1495 anActor->GetNodeColor( color[0], color[1], color[2] );
1496 nodeColor.setRgbF( color[0], color[1], color[2] );
1497 markerType = anActor->GetMarkerType();
1498 markerScale = anActor->GetMarkerScale();
1499 markerId = anActor->GetMarkerTexture();
1500 // edges: color, width
1501 anActor->GetEdgeColor( color[0], color[1], color[2] );
1502 edgeColor.setRgbF( color[0], color[1], color[2] );
1503 edgeWidth = qMax( (int)anActor->GetLineWidth(), 1 ); // minimum allowed width is 1
1504 // faces: front color, back color (delta)
1505 anActor->GetSufaceColor( color[0], color[1], color[2], deltaF );
1506 faceColor.setRgbF( color[0], color[1], color[2] );
1507 // faces: front color, back color (delta)
1508 anActor->GetVolumeColor( color[0], color[1], color[2], deltaV );
1509 volumeColor.setRgbF( color[0], color[1], color[2] );
1510 // 0d elements: color, size
1511 anActor->Get0DColor( color[0], color[1], color[2] );
1512 elem0dColor.setRgbF( color[0], color[1], color[2] );
1513 elem0dSize = qMax( (int)anActor->Get0DSize(), 1 ); // minimum allowed size is 1
1514 // balls: color, size
1515 anActor->GetBallColor( color[0], color[1], color[2] );
1516 ballColor.setRgbF( color[0], color[1], color[2] );
1517 //ballSize = qMax( (int)anActor->GetBallSize(), 1 ); // minimum allowed size is 1
1518 ballScale = qMax( (double)anActor->GetBallScale(), 1e-2 ); // minimum allowed scale is 1e-2
1520 anActor->GetOutlineColor( color[0], color[1], color[2] );
1521 outlineColor.setRgbF( color[0], color[1], color[2] );
1522 outlineWidth = qMax( (int)anActor->GetOutlineWidth(), 1 ); // minimum allowed width is 1
1523 // orientation vectors: color, scale, 3d flag
1524 anActor->GetFacesOrientationColor( color[0], color[1], color[2] );
1525 orientationColor.setRgbF( color[0], color[1], color[2] );
1526 orientationScale = anActor->GetFacesOrientationScale();
1527 orientation3d = anActor->GetFacesOrientation3DVectors();
1529 shrinkCoef = anActor->GetShrinkFactor();
1532 firstTime = false; // we only take properties from first object (for performance reasons)
1535 hasNodes = anActor->GetObject()->GetNbEntities( SMDSAbs_Node );
1536 if ( !(presentEntities & SMESH_Actor::eEdges) && anActor->GetObject()->GetNbEntities( SMDSAbs_Edge ) )
1537 presentEntities = presentEntities | SMESH_Actor::eEdges;
1538 if ( !(presentEntities & SMESH_Actor::eFaces) && anActor->GetObject()->GetNbEntities( SMDSAbs_Face ) )
1539 presentEntities = presentEntities | SMESH_Actor::eFaces;
1540 if ( !(presentEntities & SMESH_Actor::eVolumes) && anActor->GetObject()->GetNbEntities( SMDSAbs_Volume ) )
1541 presentEntities = presentEntities | SMESH_Actor::eVolumes;
1542 if ( !(presentEntities & SMESH_Actor::e0DElements) && anActor->GetObject()->GetNbEntities( SMDSAbs_0DElement ) )
1543 presentEntities = presentEntities | SMESH_Actor::e0DElements;
1544 if ( !(presentEntities & SMESH_Actor::eBallElem) && anActor->GetObject()->GetNbEntities( SMDSAbs_Ball ) )
1545 presentEntities = presentEntities | SMESH_Actor::eBallElem;
1547 // as we know that all types of elements are present, we can exit the loop
1548 if ( presentEntities == SMESH_Actor::eAllEntity )
1552 SMESHGUI_PropertiesDlg dlg( theMarkerMap, SMESHGUI::desktop() );
1553 // nodes: color, marker
1554 dlg.setNodeColor( nodeColor );
1555 if( markerType != VTK::MT_USER )
1556 dlg.setNodeMarker( markerType, markerScale );
1558 dlg.setNodeCustomMarker( markerId );
1559 // edges: color, line width
1560 dlg.setEdgeColor( edgeColor );
1561 dlg.setEdgeWidth( edgeWidth );
1562 // faces: front color, back color
1563 dlg.setFaceColor( faceColor, deltaF );
1564 // volumes: normal color, reversed color
1565 dlg.setVolumeColor( volumeColor, deltaV );
1566 // outlines: color, line width
1567 dlg.setOutlineColor( outlineColor );
1568 dlg.setOutlineWidth( outlineWidth );
1569 // 0d elements: color, size
1570 dlg.setElem0dColor( elem0dColor );
1571 dlg.setElem0dSize( elem0dSize );
1572 // balls: color, size
1573 dlg.setBallColor( ballColor );
1574 //dlg.setBallSize( ballSize );
1575 dlg.setBallScale( ballScale );
1576 // orientation: color, scale, 3d flag
1577 dlg.setOrientationColor( orientationColor );
1578 dlg.setOrientationSize( int( orientationScale * 100. ) );
1579 dlg.setOrientation3d( orientation3d );
1580 // shrink: scale factor
1581 dlg.setShrinkCoef( int( shrinkCoef * 100. ) );
1582 // hide unused controls
1583 dlg.showControls( presentEntities, hasNodes );
1586 nodeColor = dlg.nodeColor();
1587 markerType = dlg.nodeMarkerType();
1588 markerScale = dlg.nodeMarkerScale();
1589 markerId = dlg.nodeMarkerId();
1590 edgeColor = dlg.edgeColor();
1591 edgeWidth = dlg.edgeWidth();
1592 faceColor = dlg.faceColor();
1593 deltaF = dlg.faceColorDelta();
1594 volumeColor = dlg.volumeColor();
1595 deltaV = dlg.volumeColorDelta();
1596 outlineColor = dlg.outlineColor();
1597 outlineWidth = dlg.outlineWidth();
1598 elem0dColor = dlg.elem0dColor();
1599 elem0dSize = dlg.elem0dSize();
1600 ballColor = dlg.ballColor();
1601 // ballSize = dlg.ballSize();
1602 ballScale = dlg.ballScale();
1603 orientationColor = dlg.orientationColor();
1604 orientationScale = dlg.orientationSize() / 100.;
1605 orientation3d = dlg.orientation3d();
1606 shrinkCoef = dlg.shrinkCoef() / 100.;
1608 // store point markers that might be changed by the user
1609 theMarkerMap = dlg.customMarkers();
1611 // set properties from dialog box to the presentations
1612 SALOME_ListIteratorOfListIO It( selected );
1613 for ( ; It.More(); It.Next() ) {
1614 Handle(SALOME_InteractiveObject) IObject = It.Value();
1615 if ( !IObject->hasEntry() ) continue;
1616 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1617 if ( !anActor ) continue;
1619 // nodes: color, marker
1620 anActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
1621 if ( markerType != VTK::MT_USER ) {
1622 anActor->SetMarkerStd( markerType, markerScale );
1625 VTK::MarkerMap::const_iterator iter = theMarkerMap.find( markerId );
1626 if ( iter != theMarkerMap.end() )
1627 anActor->SetMarkerTexture( markerId, iter->second.second );
1629 // volumes: normal color, reversed color (delta)
1630 anActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
1631 // faces: front color, back color (delta)
1632 anActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
1633 // edges: color, width
1634 anActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
1635 anActor->SetLineWidth( edgeWidth );
1637 anActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
1638 anActor->SetOutlineWidth( outlineWidth );
1639 // 0D elements: color, size
1640 anActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
1641 anActor->Set0DSize( elem0dSize );
1642 // balls: color, size
1643 anActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
1644 // anActor->SetBallSize( ballSize );
1645 anActor->SetBallScale( ballScale );
1646 // orientation: color, scale, 3d flag
1647 anActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
1648 anActor->SetFacesOrientationScale( orientationScale );
1649 anActor->SetFacesOrientation3DVectors( orientation3d );
1651 anActor->SetShrinkFactor( shrinkCoef );
1653 // for groups, set also proper color
1654 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1655 if ( !aGroupObject->_is_nil() ) {
1656 SMESH::ElementType anElementType = aGroupObject->GetType();
1658 switch( anElementType ) {
1660 aColor = nodeColor; break;
1662 aColor = edgeColor; break;
1664 aColor = faceColor; break;
1666 aColor = volumeColor; break;
1668 aColor = elem0dColor; break;
1670 aColor = ballColor; break;
1674 if ( aColor.isValid() ) {
1675 SALOMEDS::Color aGroupColor;
1676 aGroupColor.R = aColor.redF();
1677 aGroupColor.G = aColor.greenF();
1678 aGroupColor.B = aColor.blueF();
1679 aGroupObject->SetColor( aGroupColor );
1681 } // if ( !aGroupObject->_is_nil() )
1682 } // for ( ; It.More(); It.Next() )
1683 SMESH::RepaintCurrentView();
1684 } // if ( dlg.exec() )
1686 } // case SMESHOp::OpProperties:
1687 } // switch(theCommandID)
1688 SUIT_OverrideCursor wc;
1689 SALOME_ListIteratorOfListIO It( selected );
1690 for( ; It.More(); It.Next()){
1691 Handle(SALOME_InteractiveObject) IObject = It.Value();
1692 if(IObject->hasEntry()){
1693 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1694 switch(theCommandID){
1695 case SMESHOp::OpDMWireframe:
1696 anActor->SetRepresentation(SMESH_Actor::eEdge);
1698 case SMESHOp::OpDMShading:
1699 anActor->SetRepresentation(SMESH_Actor::eSurface);
1701 case SMESHOp::OpDMShrink:
1702 if(anActor->IsShrunk())
1703 anActor->UnShrink();
1705 anActor->SetShrink();
1707 case SMESHOp::OpDMNodes:
1708 anActor->SetRepresentation(SMESH_Actor::ePoint);
1710 case SMESHOp::OpRepresentationLines:
1711 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1712 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1714 case SMESHOp::OpRepresentationArcs:
1715 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1716 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1722 SMESH::RepaintCurrentView();
1726 int ActionToControl( int theID, bool theReversed )
1728 NCollection_DoubleMap<int,int> ActionControl;
1729 ActionControl.Bind( 0, SMESH_Actor::eNone );
1730 ActionControl.Bind( SMESHOp::OpFreeNode, SMESH_Actor::eFreeNodes );
1731 ActionControl.Bind( SMESHOp::OpEqualNode, SMESH_Actor::eCoincidentNodes );
1732 ActionControl.Bind( SMESHOp::OpNodeConnectivityNb, SMESH_Actor::eNodeConnectivityNb );
1733 ActionControl.Bind( SMESHOp::OpFreeEdge, SMESH_Actor::eFreeEdges );
1734 ActionControl.Bind( SMESHOp::OpFreeBorder, SMESH_Actor::eFreeBorders );
1735 ActionControl.Bind( SMESHOp::OpLength, SMESH_Actor::eLength );
1736 ActionControl.Bind( SMESHOp::OpConnection, SMESH_Actor::eMultiConnection );
1737 ActionControl.Bind( SMESHOp::OpEqualEdge, SMESH_Actor::eCoincidentElems1D );
1738 ActionControl.Bind( SMESHOp::OpFreeFace, SMESH_Actor::eFreeFaces );
1739 ActionControl.Bind( SMESHOp::OpBareBorderFace, SMESH_Actor::eBareBorderFace );
1740 ActionControl.Bind( SMESHOp::OpOverConstrainedFace, SMESH_Actor::eOverConstrainedFace );
1741 ActionControl.Bind( SMESHOp::OpLength2D, SMESH_Actor::eLength2D );
1742 ActionControl.Bind( SMESHOp::OpDeflection2D, SMESH_Actor::eDeflection2D );
1743 ActionControl.Bind( SMESHOp::OpConnection2D, SMESH_Actor::eMultiConnection2D );
1744 ActionControl.Bind( SMESHOp::OpArea, SMESH_Actor::eArea );
1745 ActionControl.Bind( SMESHOp::OpTaper, SMESH_Actor::eTaper );
1746 ActionControl.Bind( SMESHOp::OpAspectRatio, SMESH_Actor::eAspectRatio );
1747 ActionControl.Bind( SMESHOp::OpMinimumAngle, SMESH_Actor::eMinimumAngle );
1748 ActionControl.Bind( SMESHOp::OpWarpingAngle, SMESH_Actor::eWarping );
1749 ActionControl.Bind( SMESHOp::OpSkew, SMESH_Actor::eSkew );
1750 ActionControl.Bind( SMESHOp::OpMaxElementLength2D, SMESH_Actor::eMaxElementLength2D );
1751 ActionControl.Bind( SMESHOp::OpEqualFace, SMESH_Actor::eCoincidentElems2D );
1752 ActionControl.Bind( SMESHOp::OpAspectRatio3D, SMESH_Actor::eAspectRatio3D );
1753 ActionControl.Bind( SMESHOp::OpVolume, SMESH_Actor::eVolume3D );
1754 ActionControl.Bind( SMESHOp::OpMaxElementLength3D, SMESH_Actor::eMaxElementLength3D );
1755 ActionControl.Bind( SMESHOp::OpBareBorderVolume, SMESH_Actor::eBareBorderVolume );
1756 ActionControl.Bind( SMESHOp::OpOverConstrainedVolume, SMESH_Actor::eOverConstrainedVolume );
1757 ActionControl.Bind( SMESHOp::OpEqualVolume, SMESH_Actor::eCoincidentElems3D );
1760 return ActionControl.IsBound2( theID ) ? ActionControl.Find2( theID ) : 0;
1761 return ActionControl.IsBound1( theID ) ? ActionControl.Find1( theID ) : 0;
1764 void Control( int theCommandID )
1766 SMESH_Actor::eControl aControl = SMESH_Actor::eControl( ActionToControl( theCommandID ));
1767 _PTR(Study) aStudy = SMESH::getStudy();
1769 SALOME_ListIO selected;
1770 if ( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
1771 aSel->selectedObjects( selected );
1773 if ( !selected.IsEmpty() ) {
1774 SALOME_ListIteratorOfListIO It(selected);
1775 for ( ; It.More(); It.Next())
1777 Handle(SALOME_InteractiveObject) anIO = It.Value();
1778 if ( !anIO.IsNull() ) {
1779 _PTR(SObject) SO = aStudy->FindObjectID( It.Value()->getEntry() );
1781 CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
1782 SMESH::SMESH_IDSource_var anIDSrc = SMESH::SMESH_IDSource::_narrow( aObject );
1783 if ( !anIDSrc->_is_nil() ) {
1784 SMESH_Actor *anActor = SMESH::FindActorByEntry( anIO->getEntry());
1785 if (( !anActor && selected.Extent() == 1 ) &&
1786 ( anActor = SMESH::CreateActor( anIO->getEntry() )))
1788 anActor->SetControlMode( aControl );
1789 SMESH::DisplayActor( SMESH::GetCurrentVtkView(), anActor );
1790 SMESH::UpdateView ( SMESH::eDisplay, anIO->getEntry() );
1794 if ( anActor->GetControlMode() != aControl )
1795 anActor->SetControlMode( aControl );
1796 QString functorName = functorToString( anActor->GetFunctor() );
1797 int anEntitiesCount = anActor->GetNumberControlEntities();
1798 if (anEntitiesCount >= 0)
1799 functorName = functorName + ": " + QString::number(anEntitiesCount);
1800 anActor->GetScalarBarActor()->SetTitle( functorName.toUtf8().constData() );
1801 SMESH::RepaintCurrentView();
1802 #ifndef DISABLE_PLOT2DVIEWER
1803 if ( anActor->GetPlot2Histogram() ) {
1804 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1805 QString aHistogramName("%1 : %2");
1806 aHistogramName = aHistogramName.arg( anIO->getName() ).arg( functorName );
1807 aHistogram->setName( aHistogramName );
1808 aHistogram->setHorTitle( functorName );
1809 SMESH::ProcessIn2DViewers( anActor );
1821 bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1822 SMESH::MeshObjectType theType,
1823 const QString theInTypeName,
1824 QString & theOutTypeName)
1826 SMESH_TypeFilter aTypeFilter( theType );
1828 if ( !theIO.IsNull() )
1830 entry = theIO->getEntry();
1831 LightApp_DataOwner owner( entry );
1832 if ( aTypeFilter.isOk( &owner )) {
1833 theOutTypeName = theInTypeName;
1841 QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1843 _PTR(Study) aStudy = SMESH::getStudy();
1844 _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1846 _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1847 CORBA::String_var anID = aSComp->GetID().c_str();
1848 if ( !strcmp(anID.in(),theIO->getEntry()) )
1854 CheckOIType ( theIO, SMESH::HYPOTHESIS, "Hypothesis", aTypeName ) ||
1855 CheckOIType ( theIO, SMESH::ALGORITHM, "Algorithm", aTypeName ) ||
1856 CheckOIType ( theIO, SMESH::MESH, "Mesh", aTypeName ) ||
1857 CheckOIType ( theIO, SMESH::SUBMESH, "SubMesh", aTypeName ) ||
1858 CheckOIType ( theIO, SMESH::GROUP, "Group", aTypeName )
1866 // QString CheckHomogeneousSelection()
1868 // LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1869 // SALOME_ListIO selected;
1871 // aSel->selectedObjects( selected );
1873 // QString RefType = CheckTypeObject(selected.First());
1874 // SALOME_ListIteratorOfListIO It(selected);
1875 // for ( ; It.More(); It.Next())
1877 // Handle(SALOME_InteractiveObject) IObject = It.Value();
1878 // QString Type = CheckTypeObject(IObject);
1879 // if ( Type.compare(RefType) != 0 )
1880 // return "Heterogeneous Selection";
1886 uint randomize( uint size )
1888 static bool initialized = false;
1889 if ( !initialized ) {
1890 qsrand( QDateTime::currentDateTime().toTime_t() );
1894 v = uint( (double)( v ) / RAND_MAX * size );
1895 v = qMax( uint(0), qMin ( v, size-1 ) );
1901 void SMESHGUI::OnEditDelete()
1903 // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1904 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1905 SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1907 _PTR(Study) aStudy = SMESH::getStudy();
1908 _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1909 _PTR(GenericAttribute) anAttr;
1910 _PTR(AttributeIOR) anIOR;
1912 const int objectCountLimit = 30; // PAL23599
1913 int objectCount = 0;
1915 QString aParentComponent = QString::null;
1917 for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1919 Handle(SALOME_InteractiveObject) anIO = anIt.Value();
1920 if ( anIO.IsNull() ) continue;
1922 QString father = "unknown", name;
1924 _PTR(SObject) aSO = aStudy->FindObjectID( anIO->getEntry() );
1926 father = QString::fromStdString( aSO->GetFatherComponent()->ComponentDataType() );
1927 // check if object is reference
1928 _PTR(SObject) aRefSObj;
1929 if ( aSO->ReferencedObject( aRefSObj ) ) {
1930 name = QString::fromStdString ( aRefSObj->GetName() );
1931 father = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1934 name = anIO->getName();
1937 if ( objectCount < objectCountLimit ) { // avoid occupying the whole screen
1938 aNameList.append("\n - ");
1939 aNameList.append( name );
1942 if( aParentComponent.isNull() )
1943 aParentComponent = father;
1944 else if( !aParentComponent.isEmpty() && aParentComponent!=father )
1945 aParentComponent = "";
1947 if ( objectCount >= objectCountLimit )
1948 aNameList.append("\n - ...");
1950 if ( objectCount == 0 )
1951 return; // No Valid Objects Selected
1953 if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
1954 SUIT_MessageBox::warning( SMESHGUI::desktop(),
1955 QObject::tr("ERR_ERROR"),
1956 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
1959 // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
1960 if (SUIT_MessageBox::warning
1961 (SMESHGUI::desktop(),
1962 QObject::tr("SMESH_WRN_WARNING"),
1963 QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
1964 SUIT_MessageBox::Yes | SUIT_MessageBox::No,
1965 SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
1968 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1970 // Put one level of sub-objects of the selected SO's into a list
1971 // in order to get objects inside folders like "Assigned Algorithms"
1972 std::list< _PTR(SObject) > listSO;
1973 SALOME_ListIteratorOfListIO It(selected);
1974 for( ; It.More(); It.Next()) // loop on selected IO's
1976 Handle(SALOME_InteractiveObject) IObject = It.Value();
1977 if(IObject->hasEntry()) {
1978 _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
1980 // disable removal of "SMESH" component object
1981 if(aSO->FindAttribute(anAttr, "AttributeIOR")){
1983 if ( engineIOR() == anIOR->Value().c_str() )
1986 //Check the referenced object
1987 _PTR(SObject) aRefSObject;
1988 if ( aSO && aSO->ReferencedObject( aRefSObject ) )
1989 aSO = aRefSObject; // Delete main Object instead of reference
1991 listSO.push_back( aSO );
1993 _PTR(ChildIterator) it = aStudy->NewChildIterator( aSO );
1994 for (it->InitEx(false); it->More(); it->Next())
1995 listSO.push_back( it->Value() );
1998 // Check if none of objects to delete is referred from outside
1999 std::list< _PTR(SObject) >::reverse_iterator ritSO;
2000 std::vector< _PTR(SObject) > subSO;
2001 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
2003 _PTR(SObject) SO = *ritSO;
2004 if ( !SO ) continue;
2006 int nbChildren = SO->GetLastChildTag();
2008 subSO.reserve( 1 + nbChildren );
2009 subSO.push_back( SO );
2010 if ( nbChildren > 0 )
2012 _PTR(ChildIterator) it = aStudy->NewChildIterator( SO );
2013 for ( it->InitEx( true ); it->More(); it->Next() )
2014 subSO.push_back( it->Value() );
2016 for ( size_t i = 0; i < subSO.size(); ++i )
2018 std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( subSO[i] );
2019 for ( size_t j = 0; j < aReferences.size(); j++ ) {
2020 _PTR(SComponent) aComponent = aReferences[j]->GetFatherComponent();
2021 std::string type = aComponent->ComponentDataType();
2022 if ( type != "SMESH" )
2024 SUIT_MessageBox::warning( anApp->desktop(),
2025 QObject::tr("WRN_WARNING"),
2026 QObject::tr("DEP_OBJECT") );
2027 return; // outside SMESH, there is an object depending on a SMESH object
2033 // Treat SO's in the list starting from the back
2034 aStudyBuilder->NewCommand(); // There is a transaction
2035 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
2037 _PTR(SObject) SO = *ritSO;
2038 if ( !SO ) continue;
2039 std::string anEntry = SO->GetID();
2041 /** Erase graphical object and remove all its data **/
2042 if ( SO->FindAttribute( anAttr, "AttributeIOR" )) {
2043 SMESH::RemoveVisualObjectWithActors( anEntry.c_str(), true);
2045 /** Remove an object from data structures **/
2046 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
2047 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
2048 if ( !aGroup->_is_nil() ) { // DELETE GROUP
2049 SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
2050 aMesh->RemoveGroup( aGroup );
2052 else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
2053 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2054 aMesh->RemoveSubMesh( aSubMesh );
2057 Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
2058 ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
2059 QString objType = CheckTypeObject(IObject);
2060 if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
2061 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
2062 aStudyBuilder->RemoveObjectWithChildren( SO );
2064 else {// default action: remove SObject from the study
2065 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
2066 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
2068 aStudyBuilder->RemoveObjectWithChildren( SO );
2072 } /* listSO back loop */
2074 aStudyBuilder->CommitCommand();
2076 /* Clear any previous selection */
2078 aSel->setSelectedObjects( l1 );
2080 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
2084 SMESHGUI_EXPORT CAM_Module* createModule()
2086 return new SMESHGUI();
2089 SMESHGUI_EXPORT char* getModuleVersion() {
2090 return (char*)SMESH_VERSION_STR;
2094 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
2096 //=============================================================================
2100 //=============================================================================
2101 SMESHGUI::SMESHGUI() :
2102 SalomeApp_Module( "SMESH" )
2104 if ( CORBA::is_nil( myComponentSMESH ) )
2106 CORBA::Boolean anIsEmbeddedMode;
2107 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
2108 //MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
2110 // 0019923: EDF 765 SMESH : default values of hypothesis
2111 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
2112 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
2113 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
2114 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
2115 myComponentSMESH->SetDefaultNbSegments( nbSeg );
2117 const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif", "default_grp_color" };
2118 for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
2119 if ( aResourceMgr->hasValue( "SMESH", options[i] ))
2121 QString val = aResourceMgr->stringValue( "SMESH", options[i] );
2122 myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
2126 myActiveDialogBox = 0;
2127 myFilterLibraryDlg = 0;
2131 myEventCallbackCommand = vtkCallbackCommand::New();
2132 myEventCallbackCommand->Delete();
2133 myEventCallbackCommand->SetClientData( this );
2134 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
2137 /* load resources for all available meshers */
2138 SMESH::InitAvailableHypotheses();
2141 //=============================================================================
2145 //=============================================================================
2146 SMESHGUI::~SMESHGUI()
2150 //=============================================================================
2154 //=============================================================================
2155 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
2157 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2159 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
2164 //=============================================================================
2168 //=============================================================================
2169 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
2171 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2175 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2176 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2177 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2178 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2179 return autoUpdate && !exceeded;
2182 //=============================================================================
2186 //=============================================================================
2187 bool SMESHGUI::automaticUpdate( SMESH::SMESH_IDSource_ptr theMesh,
2188 int* entities, bool* limitExceeded, int* hidden, long* nbElements )
2190 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2194 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2195 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2196 bool incrementalLimit = resMgr->booleanValue( "SMESH", "incremental_limit", false );
2198 SMESH::long_array_var info = theMesh->GetMeshInfo();
2199 long nbOdElems = info[SMDSEntity_0D];
2200 long nbEdges = info[SMDSEntity_Edge] + info[SMDSEntity_Quad_Edge];
2201 long nbFaces = info[SMDSEntity_Triangle] + info[SMDSEntity_Quad_Triangle] + info[SMDSEntity_BiQuad_Triangle] +
2202 info[SMDSEntity_Quadrangle] + info[SMDSEntity_Quad_Quadrangle] + info[SMDSEntity_BiQuad_Quadrangle] +
2203 info[SMDSEntity_Polygon] + info[SMDSEntity_Quad_Polygon];
2204 long nbVolumes = info[SMDSEntity_Tetra] + info[SMDSEntity_Quad_Tetra] +
2205 info[SMDSEntity_Hexa] + info[SMDSEntity_Quad_Hexa] + info[SMDSEntity_TriQuad_Hexa] +
2206 info[SMDSEntity_Pyramid] + info[SMDSEntity_Quad_Pyramid] +
2207 info[SMDSEntity_Penta] + info[SMDSEntity_Quad_Penta] + info[SMDSEntity_BiQuad_Penta] +
2208 info[SMDSEntity_Polyhedra] +
2209 info[SMDSEntity_Hexagonal_Prism];
2210 long nbBalls = info[SMDSEntity_Ball];
2212 long requestedSize = nbOdElems + nbBalls + nbEdges + nbFaces + nbVolumes;
2213 *nbElements = requestedSize;
2215 *entities = SMESH_Actor::eAllEntity;
2218 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2220 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2222 if ( incrementalLimit ) {
2225 if ( nbOdElems > 0 ) {
2226 if ( total + nbOdElems > updateLimit ) {
2227 *entities = *entities & ~SMESH_Actor::e0DElements;
2228 *hidden = *hidden | SMESH_Actor::e0DElements;
2235 if ( nbEdges > 0 ) {
2236 if ( total + nbEdges > updateLimit ) {
2237 *entities = *entities & ~SMESH_Actor::eEdges;
2238 *hidden = *hidden | SMESH_Actor::eEdges;
2245 if ( nbFaces > 0 ) {
2246 if ( total + nbFaces > updateLimit ) {
2247 *entities = *entities & ~SMESH_Actor::eFaces;
2248 *hidden = *hidden | SMESH_Actor::eFaces;
2255 if ( nbVolumes > 0 ) {
2256 if ( total + nbVolumes > updateLimit ) {
2257 *entities = *entities & ~SMESH_Actor::eVolumes;
2258 *hidden = *hidden | SMESH_Actor::eVolumes;
2265 if ( nbBalls > 0 ) {
2266 if ( total + nbBalls > updateLimit ) {
2267 *entities = *entities & ~SMESH_Actor::eBallElem;
2268 *hidden = *hidden | SMESH_Actor::eBallElem;
2276 return autoUpdate && !exceeded;
2279 //=============================================================================
2283 //=============================================================================
2284 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
2286 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
2289 //=============================================================================
2293 //=============================================================================
2294 SMESHGUI* SMESHGUI::GetSMESHGUI()
2296 SMESHGUI* smeshMod = 0;
2297 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
2300 CAM_Module* module = app->module( "Mesh" );
2301 smeshMod = dynamic_cast<SMESHGUI*>( module );
2309 Standard_EXPORT SMESHGUI* GetComponentGUI()
2311 return SMESHGUI::GetSMESHGUI();
2315 //=============================================================================
2319 //=============================================================================
2320 void SMESHGUI::SetState(int aState)
2325 //=============================================================================
2329 //=============================================================================
2330 void SMESHGUI::ResetState()
2335 //=============================================================================
2339 //=============================================================================
2340 void SMESHGUI::EmitSignalDeactivateDialog()
2342 emit SignalDeactivateActiveDialog();
2345 //=============================================================================
2349 //=============================================================================
2350 void SMESHGUI::EmitSignalStudyFrameChanged()
2352 emit SignalStudyFrameChanged();
2355 //=============================================================================
2359 //=============================================================================
2360 void SMESHGUI::EmitSignalCloseAllDialogs()
2362 emit SignalCloseAllDialogs();
2365 //=============================================================================
2369 //=============================================================================
2370 void SMESHGUI::EmitSignalVisibilityChanged()
2372 emit SignalVisibilityChanged();
2375 //=============================================================================
2379 //=============================================================================
2380 void SMESHGUI::EmitSignalCloseView()
2382 emit SignalCloseView();
2385 //=============================================================================
2389 //=============================================================================
2390 void SMESHGUI::EmitSignalActivatedViewManager()
2392 emit SignalActivatedViewManager();
2395 //=============================================================================
2399 //=============================================================================
2400 QDialog *SMESHGUI::GetActiveDialogBox()
2402 return myActiveDialogBox;
2405 //=============================================================================
2409 //=============================================================================
2410 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2412 myActiveDialogBox = (QDialog *) aDlg;
2416 //=============================================================================
2420 //=============================================================================
2421 SUIT_Desktop* SMESHGUI::desktop()
2423 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2425 return app->desktop();
2430 //=============================================================================
2434 //=============================================================================
2435 SalomeApp_Study* SMESHGUI::activeStudy()
2437 SUIT_Application* app = SUIT_Session::session()->activeApplication();
2439 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2444 //=============================================================================
2448 //=============================================================================
2449 void SMESHGUI::Modified( bool theIsUpdateActions )
2451 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2452 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2453 appStudy->Modified();
2454 if( theIsUpdateActions )
2455 app->updateActions();
2460 //=============================================================================
2464 //=============================================================================
2465 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2467 /* Here the position is on the bottom right corner - 10 */
2468 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2470 SUIT_Desktop *PP = desktop();
2471 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2472 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2477 * \brief Verifies whether study of operation is locked
2478 * \param theMess - specifies whether message box must be shown if study is locked
2479 * \return State of study.
2481 * Verifies whether study of operation is locked. If second parameter is TRUE and study
2482 * is locked when corresponding message box appears
2484 bool SMESHGUI::isStudyLocked( bool theMessage )
2486 if ( SMESH::getStudy()->GetProperties()->IsLocked() )
2489 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2490 QObject::tr( "WRN_WARNING" ),
2491 QObject::tr( "WRN_STUDY_LOCKED" ) );
2497 //=============================================================================
2501 //=============================================================================
2502 bool SMESHGUI::OnGUIEvent( int theCommandID )
2504 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2508 SUIT_ResourceMgr* mgr = resourceMgr();
2512 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2513 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2515 //QAction* act = action( theCommandID );
2517 switch (theCommandID) {
2518 case SMESHOp::OpDelete:
2519 if(isStudyLocked()) break;
2522 case SMESHOp::OpImportDAT:
2523 case SMESHOp::OpImportUNV:
2524 case SMESHOp::OpImportMED:
2525 case SMESHOp::OpImportSTL:
2526 case SMESHOp::OpImportCGNS:
2527 case SMESHOp::OpImportSAUV:
2528 case SMESHOp::OpImportGMF:
2529 case SMESHOp::OpPopupImportDAT:
2530 case SMESHOp::OpPopupImportUNV:
2531 case SMESHOp::OpPopupImportMED:
2532 case SMESHOp::OpPopupImportSTL:
2533 case SMESHOp::OpPopupImportCGNS:
2534 case SMESHOp::OpPopupImportSAUV:
2535 case SMESHOp::OpPopupImportGMF:
2537 if(isStudyLocked()) break;
2538 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2542 case SMESHOp::OpFileInformation:
2544 SALOME_ListIO selected;
2545 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2547 aSel->selectedObjects( selected );
2548 if( selected.Extent() )
2550 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2551 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2552 if ( !aMesh->_is_nil() )
2554 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2560 case SMESHOp::OpExportDAT:
2561 case SMESHOp::OpExportMED:
2562 case SMESHOp::OpExportUNV:
2563 case SMESHOp::OpExportSTL:
2564 case SMESHOp::OpExportCGNS:
2565 case SMESHOp::OpExportSAUV:
2566 case SMESHOp::OpExportGMF:
2567 case SMESHOp::OpPopupExportDAT:
2568 case SMESHOp::OpPopupExportMED:
2569 case SMESHOp::OpPopupExportUNV:
2570 case SMESHOp::OpPopupExportSTL:
2571 case SMESHOp::OpPopupExportCGNS:
2572 case SMESHOp::OpPopupExportSAUV:
2573 case SMESHOp::OpPopupExportGMF:
2575 ::ExportMeshToFile(theCommandID);
2579 case SMESHOp::OpReset: // SCALAR BAR
2581 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2582 SALOME_ListIO selected;
2584 aSel->selectedObjects( selected );
2586 SALOME_ListIteratorOfListIO it(selected);
2587 for( ; it.More(); it.Next()) {
2588 Handle(SALOME_InteractiveObject) anIO = it.Value();
2589 if( anIO->hasEntry() ) {
2590 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2591 anActor->SetControlMode( SMESH_Actor::eNone );
2592 #ifndef DISABLE_PLOT2DVIEWER
2593 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2595 anActor->UpdateFilter();
2599 SMESH::UpdateView();
2602 case SMESHOp::OpScalarBarProperties:
2604 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2607 case SMESHOp::OpShowScalarBar:
2609 // show/hide scalar bar
2610 ::ShowElement(theCommandID);
2613 case SMESHOp::OpSaveDistribution:
2615 // dump control distribution data to the text file
2616 ::SaveDistribution();
2620 case SMESHOp::OpShowDistribution:
2622 // show/hide distribution
2623 ::ShowElement(theCommandID);
2627 #ifndef DISABLE_PLOT2DVIEWER
2628 case SMESHOp::OpPlotDistribution:
2630 // plot distribution
2631 ::PlotDistribution();
2637 case SMESHOp::OpAutoColor:
2641 case SMESHOp::OpDisableAutoColor:
2642 ::DisableAutoColor();
2645 case SMESHOp::OpClipping:
2646 case SMESHOp::OpTransparency:
2647 case SMESHOp::OpProperties: // Display preferences (colors, shrink size, line width, ...)
2650 case SMESHOp::OpDMWireframe:
2651 case SMESHOp::OpDMShading:
2652 case SMESHOp::OpDMNodes:
2653 case SMESHOp::OpDMShrink:
2654 ::SetDisplayMode(theCommandID, myMarkerMap);
2657 //2D quadratic representation
2658 case SMESHOp::OpRepresentationLines:
2659 case SMESHOp::OpRepresentationArcs:
2660 ::SetDisplayMode(theCommandID, myMarkerMap);
2664 case SMESHOp::OpDE0DElements:
2665 case SMESHOp::OpDEEdges:
2666 case SMESHOp::OpDEFaces:
2667 case SMESHOp::OpDEVolumes:
2668 case SMESHOp::OpDEBalls:
2669 case SMESHOp::OpDEAllEntity:
2670 ::SetDisplayEntity(theCommandID);
2673 // Choose entities to be displayed
2674 case SMESHOp::OpDEChoose:
2676 ( new SMESHGUI_DisplayEntitiesDlg( SMESHGUI::desktop() ) )->exec();
2680 case SMESHOp::OpOrientationOnFaces:
2682 SUIT_OverrideCursor wc;
2683 LightApp_SelectionMgr* mgr = selectionMgr();
2684 SALOME_ListIO selected; mgr->selectedObjects( selected );
2686 SALOME_ListIteratorOfListIO it(selected);
2687 for( ; it.More(); it.Next()) {
2688 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2689 if(anIObject->hasEntry()) {
2690 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2691 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2698 case SMESHOp::OpUpdate:
2700 if(isStudyLocked()) break;
2701 SUIT_OverrideCursor wc;
2704 SMESH::UpdateView();
2706 catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2707 SMESH::OnVisuException();
2709 catch (...) { // PAL16774 (Crash after display of many groups)
2710 SMESH::OnVisuException();
2714 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2715 aSel->selectedObjects( l );
2716 aSel->setSelectedObjects( l );
2720 case SMESHOp::OpHide:
2721 case SMESHOp::OpShow:
2722 case SMESHOp::OpShowOnly:
2724 SUIT_OverrideCursor wc;
2725 SMESH::EDisplaing anAction;
2726 switch (theCommandID) {
2727 case SMESHOp::OpHide: anAction = SMESH::eErase; break;
2728 case SMESHOp::OpShow: anAction = SMESH::eDisplay; break;
2729 case SMESHOp::OpShowOnly: anAction = SMESH::eDisplayOnly; break;
2732 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2733 SALOME_ListIO sel_objects, to_process;
2735 aSel->selectedObjects( sel_objects );
2737 if ( theCommandID==SMESHOp::OpShowOnly )
2739 //MESSAGE("anAction = SMESH::eDisplayOnly");
2740 startOperation( myEraseAll );
2743 extractContainers( sel_objects, to_process );
2748 SALOME_ListIteratorOfListIO It( to_process );
2749 for ( ; It.More(); It.Next())
2751 Handle(SALOME_InteractiveObject) IOS = It.Value();
2752 if ( IOS->hasEntry() )
2754 if ( !SMESH::UpdateView( anAction, IOS->getEntry() )) {
2755 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2756 break; // PAL16774 (Crash after display of many groups)
2758 if (anAction == SMESH::eDisplayOnly)
2759 anAction = SMESH::eDisplay;
2764 // PAL13338 + PAL15161 -->
2765 if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !isStudyLocked()) {
2766 SMESH::UpdateView();
2767 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2769 // PAL13338 + PAL15161 <--
2771 catch (...) { // PAL16774 (Crash after display of many groups)
2772 SMESH::OnVisuException();
2775 if (anAction == SMESH::eErase) {
2777 aSel->setSelectedObjects( l1 );
2780 aSel->setSelectedObjects( to_process );
2782 if ( vtkwnd && vtkwnd->GetRenderer() && !isStudyLocked() &&
2783 ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) )
2784 vtkwnd->GetRenderer()->AdjustActors();
2789 case SMESHOp::OpNode:
2791 if(isStudyLocked()) break;
2794 EmitSignalDeactivateDialog();
2796 ( new SMESHGUI_NodesDlg( this ) )->show();
2799 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"),tr("SMESH_WRN_VIEWER_VTK"));
2804 case SMESHOp::OpCreateMesh:
2805 case SMESHOp::OpCreateSubMesh:
2806 case SMESHOp::OpEditMeshOrSubMesh:
2807 case SMESHOp::OpEditMesh:
2808 case SMESHOp::OpEditSubMesh:
2809 case SMESHOp::OpCompute:
2810 case SMESHOp::OpComputeSubMesh:
2811 case SMESHOp::OpPreCompute:
2812 case SMESHOp::OpEvaluate:
2813 case SMESHOp::OpMeshOrder:
2814 startOperation( theCommandID );
2816 case SMESHOp::OpCopyMesh:
2818 if (isStudyLocked()) break;
2819 EmitSignalDeactivateDialog();
2820 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2823 case SMESHOp::OpBuildCompoundMesh:
2825 if (isStudyLocked()) break;
2826 EmitSignalDeactivateDialog();
2827 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2831 case SMESHOp::OpDiagonalInversion:
2832 case SMESHOp::OpUnionOfTwoTriangle:
2836 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2840 if ( isStudyLocked() )
2843 /*Standard_Boolean aRes;
2844 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2845 if ( aMesh->_is_nil() )
2847 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2848 tr( "SMESH_BAD_SELECTION" ) );
2852 EmitSignalDeactivateDialog();
2853 if ( theCommandID == SMESHOp::OpDiagonalInversion )
2854 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2856 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2859 case SMESHOp::OpOrientation:
2860 case SMESHOp::OpUnionOfTriangles:
2861 case SMESHOp::OpCuttingOfQuadrangles:
2862 case SMESHOp::OpSplitVolumes:
2866 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2870 if ( isStudyLocked() )
2873 EmitSignalDeactivateDialog();
2874 SMESHGUI_MultiEditDlg* aDlg = NULL;
2875 if ( theCommandID == SMESHOp::OpOrientation )
2876 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2877 else if ( theCommandID == SMESHOp::OpUnionOfTriangles )
2878 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2879 else if ( theCommandID == SMESHOp::OpSplitVolumes )
2880 aDlg = new SMESHGUI_SplitVolumesDlg(this);
2882 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2887 case SMESHOp::OpSmoothing:
2889 if(isStudyLocked()) break;
2891 EmitSignalDeactivateDialog();
2892 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2895 SUIT_MessageBox::warning(desktop(), tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2899 case SMESHOp::OpExtrusion:
2901 if (isStudyLocked()) break;
2903 EmitSignalDeactivateDialog();
2904 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2906 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2910 case SMESHOp::OpExtrusionAlongAPath:
2912 if (isStudyLocked()) break;
2914 EmitSignalDeactivateDialog();
2915 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2917 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2921 case SMESHOp::OpRevolution:
2923 if(isStudyLocked()) break;
2925 EmitSignalDeactivateDialog();
2926 ( new SMESHGUI_RevolutionDlg( this ) )->show();
2929 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2933 case SMESHOp::OpPatternMapping:
2935 if ( isStudyLocked() )
2939 EmitSignalDeactivateDialog();
2940 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2943 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2947 case SMESHOp::OpSplitBiQuadratic:
2948 case SMESHOp::OpConvertMeshToQuadratic:
2949 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
2950 case SMESHOp::OpReorientFaces:
2951 case SMESHOp::OpCreateGeometryGroup:
2953 startOperation( theCommandID );
2956 case SMESHOp::OpCreateGroup:
2960 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2964 if(isStudyLocked()) break;
2965 EmitSignalDeactivateDialog();
2966 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2968 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2969 SALOME_ListIO selected;
2971 aSel->selectedObjects( selected );
2973 int nbSel = selected.Extent();
2975 // check if mesh is selected
2976 aMesh = SMESH::GetMeshByIO( selected.First() );
2978 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2983 case SMESHOp::OpConstructGroup:
2987 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2991 if(isStudyLocked()) break;
2992 EmitSignalDeactivateDialog();
2994 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2995 SALOME_ListIO selected;
2997 aSel->selectedObjects( selected );
2999 int nbSel = selected.Extent();
3001 // check if submesh is selected
3002 Handle(SALOME_InteractiveObject) IObject = selected.First();
3003 if (IObject->hasEntry()) {
3004 _PTR(SObject) aSObj = SMESH::getStudy()->FindObjectID(IObject->getEntry());
3006 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
3007 if (!aSubMesh->_is_nil()) {
3009 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
3010 // get submesh elements list by types
3011 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
3012 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
3013 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
3014 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
3015 // create group for each type o elements
3016 QString aName = IObject->getName();
3017 QStringList anEntryList;
3018 if (aNodes->length() > 0) {
3019 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
3020 aGroup->Add(aNodes.inout());
3021 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3022 anEntryList.append( aSObject->GetID().c_str() );
3024 if (aEdges->length() > 0) {
3025 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
3026 aGroup->Add(aEdges.inout());
3027 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3028 anEntryList.append( aSObject->GetID().c_str() );
3030 if (aFaces->length() > 0) {
3031 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
3032 aGroup->Add(aFaces.inout());
3033 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3034 anEntryList.append( aSObject->GetID().c_str() );
3036 if (aVolumes->length() > 0) {
3037 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
3038 aGroup->Add(aVolumes.inout());
3039 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3040 anEntryList.append( aSObject->GetID().c_str() );
3043 anApp->browseObjects( anEntryList );
3045 catch(const SALOME::SALOME_Exception & S_ex){
3046 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3053 SUIT_MessageBox::warning(desktop(),
3054 tr("SMESH_WRN_WARNING"),
3055 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
3060 case SMESHOp::OpEditGroup:
3064 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3068 if(isStudyLocked()) break;
3069 EmitSignalDeactivateDialog();
3071 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3072 SALOME_ListIO selected;
3074 aSel->selectedObjects( selected );
3076 SALOME_ListIteratorOfListIO It (selected);
3077 int nbSelectedGroups = 0;
3078 for ( ; It.More(); It.Next() )
3080 SMESH::SMESH_GroupBase_var aGroup =
3081 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
3082 if (!aGroup->_is_nil()) {
3084 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
3088 if (nbSelectedGroups == 0)
3090 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
3096 case SMESHOp::OpAddElemGroupPopup: // Add elements to group
3098 if(isStudyLocked()) break;
3099 if (myState == 800) {
3100 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3101 if (aDlg) aDlg->onAdd();
3106 case SMESHOp::OpRemoveElemGroupPopup: // Remove elements from group
3108 if(isStudyLocked()) break;
3109 if (myState == 800) {
3110 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3111 if (aDlg) aDlg->onRemove();
3116 case SMESHOp::OpEditGeomGroupAsGroup:
3120 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3124 if(isStudyLocked()) break;
3125 EmitSignalDeactivateDialog();
3127 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3128 SALOME_ListIO selected;
3130 aSel->selectedObjects( selected );
3132 SALOME_ListIteratorOfListIO It (selected);
3133 for ( ; It.More(); It.Next() )
3135 SMESH::SMESH_GroupOnGeom_var aGroup =
3136 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
3137 if (!aGroup->_is_nil()) {
3138 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3143 SMESH::SMESH_GroupOnFilter_var aGroup =
3144 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
3145 if (!aGroup->_is_nil()) {
3146 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3154 case SMESHOp::OpUnionGroups:
3155 case SMESHOp::OpIntersectGroups:
3156 case SMESHOp::OpCutGroups:
3160 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3164 if ( isStudyLocked() )
3167 EmitSignalDeactivateDialog();
3169 SMESHGUI_GroupOpDlg* aDlg = 0;
3170 if ( theCommandID == SMESHOp::OpUnionGroups )
3171 aDlg = new SMESHGUI_UnionGroupsDlg( this );
3172 else if ( theCommandID == SMESHOp::OpIntersectGroups )
3173 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3175 aDlg = new SMESHGUI_CutGroupsDlg( this );
3182 case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
3184 if ( isStudyLocked() )
3187 EmitSignalDeactivateDialog();
3188 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3194 case SMESHOp::OpFaceGroupsByEdges: // Create face groups separated by sharp edges
3196 if ( isStudyLocked() )
3199 EmitSignalDeactivateDialog();
3200 SMESHGUI_FaceGroupsSeparatedByEdgesDlg* aDlg = new SMESHGUI_FaceGroupsSeparatedByEdgesDlg( this );
3206 case SMESHOp::OpDeleteGroup: // Delete groups with their contents
3210 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3214 if ( isStudyLocked() )
3217 EmitSignalDeactivateDialog();
3219 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3223 case SMESHOp::OpMeshInformation:
3224 case SMESHOp::OpWhatIs:
3226 int page = theCommandID == SMESHOp::OpMeshInformation ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3227 EmitSignalDeactivateDialog();
3228 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3229 SALOME_ListIO selected;
3231 aSel->selectedObjects( selected );
3233 if ( selected.Extent() > 1 ) { // a dlg for each IO
3234 SALOME_ListIteratorOfListIO It( selected );
3235 for ( ; It.More(); It.Next() ) {
3236 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3237 dlg->showInfo( It.Value() );
3242 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3248 case SMESHOp::OpFindElementByPoint:
3250 startOperation( theCommandID );
3254 case SMESHOp::OpEditHypothesis:
3256 if(isStudyLocked()) break;
3258 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3259 SALOME_ListIO selected;
3261 aSel->selectedObjects( selected );
3263 int nbSel = selected.Extent();
3266 Handle(SALOME_InteractiveObject) anIObject = selected.First();
3267 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3269 if ( !aHypothesis->_is_nil() )
3271 SMESHGUI_GenericHypothesisCreator* aCreator =
3272 SMESH::GetHypothesisCreator( SMESH::toQStr( aHypothesis->GetName() ));
3275 // set geometry of mesh and sub-mesh to aCreator
3276 aSel->selectedObjects( selected, "", /*convertReferences=*/false);
3277 if ( selected.Extent() == 1 )
3279 QString subGeomID, meshGeomID;
3280 Handle(SALOME_InteractiveObject) hypIO = selected.First();
3281 if ( SMESH::GetGeomEntries( hypIO, subGeomID, meshGeomID ))
3283 if ( subGeomID.isEmpty() ) subGeomID = meshGeomID;
3284 aCreator->setShapeEntry( subGeomID );
3285 aCreator->setMainShapeEntry( meshGeomID );
3289 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3299 case SMESHOp::OpUnassign: // REMOVE HYPOTHESIS / ALGORITHMS
3301 if(isStudyLocked()) break;
3302 SUIT_OverrideCursor wc;
3304 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3305 SALOME_ListIO selected;
3307 aSel->selectedObjects( selected, QString::null, false );
3309 SALOME_ListIteratorOfListIO It(selected);
3310 for (int i = 0; It.More(); It.Next(), i++) {
3311 Handle(SALOME_InteractiveObject) IObject = It.Value();
3312 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3315 aSel->setSelectedObjects( l1 );
3320 case SMESHOp::OpElem0D:
3321 case SMESHOp::OpBall:
3322 case SMESHOp::OpEdge:
3323 case SMESHOp::OpTriangle:
3324 case SMESHOp::OpQuadrangle:
3325 case SMESHOp::OpPolygon:
3326 case SMESHOp::OpTetrahedron:
3327 case SMESHOp::OpHexahedron:
3328 case SMESHOp::OpPentahedron:
3329 case SMESHOp::OpPyramid:
3330 case SMESHOp::OpHexagonalPrism:
3332 if(isStudyLocked()) break;
3334 EmitSignalDeactivateDialog();
3335 SMDSAbs_EntityType type = SMDSEntity_Edge;
3336 switch (theCommandID) {
3337 case SMESHOp::OpElem0D: type = SMDSEntity_0D; break;
3338 case SMESHOp::OpBall: type = SMDSEntity_Ball; break;
3339 case SMESHOp::OpTriangle: type = SMDSEntity_Triangle; break;
3340 case SMESHOp::OpQuadrangle: type = SMDSEntity_Quadrangle; break;
3341 case SMESHOp::OpTetrahedron: type = SMDSEntity_Tetra; break;
3342 case SMESHOp::OpPolygon: type = SMDSEntity_Polygon; break;
3343 case SMESHOp::OpHexahedron: type = SMDSEntity_Hexa; break;
3344 case SMESHOp::OpPentahedron: type = SMDSEntity_Penta; break;
3345 case SMESHOp::OpPyramid: type = SMDSEntity_Pyramid; break;
3346 case SMESHOp::OpHexagonalPrism: type = SMDSEntity_Hexagonal_Prism; break;
3349 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3352 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3356 case SMESHOp::OpPolyhedron:
3358 if(isStudyLocked()) break;
3360 EmitSignalDeactivateDialog();
3361 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3364 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3368 case SMESHOp::OpQuadraticEdge:
3369 case SMESHOp::OpQuadraticTriangle:
3370 case SMESHOp::OpBiQuadraticTriangle:
3371 case SMESHOp::OpQuadraticQuadrangle:
3372 case SMESHOp::OpBiQuadraticQuadrangle:
3373 case SMESHOp::OpQuadraticPolygon:
3374 case SMESHOp::OpQuadraticTetrahedron:
3375 case SMESHOp::OpQuadraticPyramid:
3376 case SMESHOp::OpQuadraticPentahedron:
3377 case SMESHOp::OpBiQuadraticPentahedron:
3378 case SMESHOp::OpQuadraticHexahedron:
3379 case SMESHOp::OpTriQuadraticHexahedron:
3381 if(isStudyLocked()) break;
3383 EmitSignalDeactivateDialog();
3384 SMDSAbs_EntityType type = SMDSEntity_Last;
3386 switch (theCommandID) {
3387 case SMESHOp::OpQuadraticEdge: type = SMDSEntity_Quad_Edge; break;
3388 case SMESHOp::OpQuadraticTriangle: type = SMDSEntity_Quad_Triangle; break;
3389 case SMESHOp::OpBiQuadraticTriangle: type = SMDSEntity_BiQuad_Triangle; break;
3390 case SMESHOp::OpQuadraticQuadrangle: type = SMDSEntity_Quad_Quadrangle; break;
3391 case SMESHOp::OpBiQuadraticQuadrangle: type = SMDSEntity_BiQuad_Quadrangle; break;
3392 case SMESHOp::OpQuadraticPolygon: type = SMDSEntity_Quad_Polygon; break;
3393 case SMESHOp::OpQuadraticTetrahedron: type = SMDSEntity_Quad_Tetra; break;
3394 case SMESHOp::OpQuadraticPyramid: type = SMDSEntity_Quad_Pyramid; break;
3395 case SMESHOp::OpQuadraticPentahedron: type = SMDSEntity_Quad_Penta; break;
3396 case SMESHOp::OpBiQuadraticPentahedron: type = SMDSEntity_BiQuad_Penta; break;
3397 case SMESHOp::OpQuadraticHexahedron: type = SMDSEntity_Quad_Hexa; break;
3398 case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
3401 if ( type != SMDSEntity_Last )
3402 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3405 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3406 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3410 case SMESHOp::OpRemoveNodes:
3412 if(isStudyLocked()) break;
3414 EmitSignalDeactivateDialog();
3415 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3418 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3419 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3423 case SMESHOp::OpRemoveElements: // REMOVES ELEMENTS
3425 if(isStudyLocked()) break;
3427 EmitSignalDeactivateDialog();
3428 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3432 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3433 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3437 case SMESHOp::OpClearMesh: {
3439 if(isStudyLocked()) break;
3441 SALOME_ListIO selected;
3442 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3443 aSel->selectedObjects( selected );
3445 SUIT_OverrideCursor wc;
3446 SALOME_ListIteratorOfListIO It (selected);
3447 for ( ; It.More(); It.Next() )
3449 Handle(SALOME_InteractiveObject) IOS = It.Value();
3450 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3451 if ( aMesh->_is_nil()) continue;
3454 if ( aMesh->NbNodes() == 0 ) // imported mesh is not empty
3455 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3456 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3457 // hide groups and submeshes
3458 _PTR(ChildIterator) anIter =
3459 SMESH::getStudy()->NewChildIterator( aMeshSObj );
3460 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3462 _PTR(SObject) so = anIter->Value();
3463 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3466 catch (const SALOME::SALOME_Exception& S_ex){
3468 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3472 SMESH::UpdateView();
3476 case SMESHOp::OpRemoveOrphanNodes:
3478 if(isStudyLocked()) break;
3479 SALOME_ListIO selected;
3480 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3481 aSel->selectedObjects( selected );
3482 if ( selected.Extent() == 1 ) {
3483 Handle(SALOME_InteractiveObject) anIO = selected.First();
3484 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3485 if ( !aMesh->_is_nil() ) {
3486 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3487 tr( "SMESH_WARNING" ),
3488 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3489 SUIT_MessageBox::Yes |
3490 SUIT_MessageBox::No,
3491 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3494 SUIT_OverrideCursor wc;
3495 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3496 int removed = aMeshEditor->RemoveOrphanNodes();
3497 SUIT_MessageBox::information(SMESHGUI::desktop(),
3498 tr("SMESH_INFORMATION"),
3499 tr("NB_NODES_REMOVED").arg(removed));
3500 if ( removed > 0 ) {
3501 SMESH::UpdateView();
3502 SMESHGUI::Modified();
3505 catch (const SALOME::SALOME_Exception& S_ex) {
3506 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3515 case SMESHOp::OpRenumberingNodes:
3517 if(isStudyLocked()) break;
3519 EmitSignalDeactivateDialog();
3520 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3524 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3525 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3529 case SMESHOp::OpRenumberingElements:
3531 if(isStudyLocked()) break;
3533 EmitSignalDeactivateDialog();
3534 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3538 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3539 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3543 case SMESHOp::OpTranslation:
3545 if(isStudyLocked()) break;
3547 EmitSignalDeactivateDialog();
3548 ( new SMESHGUI_TranslationDlg( this ) )->show();
3551 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3552 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3556 case SMESHOp::OpRotation:
3558 if(isStudyLocked()) break;
3560 EmitSignalDeactivateDialog();
3561 ( new SMESHGUI_RotationDlg( this ) )->show();
3564 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3565 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3569 case SMESHOp::OpSymmetry:
3571 if(isStudyLocked()) break;
3573 EmitSignalDeactivateDialog();
3574 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3577 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3578 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3582 case SMESHOp::OpScale:
3584 if(isStudyLocked()) break;
3586 EmitSignalDeactivateDialog();
3587 ( new SMESHGUI_ScaleDlg( this ) )->show();
3590 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3591 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3596 case SMESHOp::OpOffset:
3598 if(isStudyLocked()) break;
3600 EmitSignalDeactivateDialog();
3601 ( new SMESHGUI_OffsetDlg( this ) )->show();
3604 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3605 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3610 case SMESHOp::OpSewing:
3612 if(isStudyLocked()) break;
3614 EmitSignalDeactivateDialog();
3615 ( new SMESHGUI_SewingDlg( this ) )->show();
3618 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3619 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3623 case SMESHOp::OpMergeNodes:
3625 if(isStudyLocked()) break;
3627 EmitSignalDeactivateDialog();
3628 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3631 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3632 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3636 case SMESHOp::OpMergeElements:
3638 if (isStudyLocked()) break;
3640 EmitSignalDeactivateDialog();
3641 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3643 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3644 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3649 case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
3650 startOperation( SMESHOp::OpMoveNode );
3653 case SMESHOp::OpDuplicateNodes:
3655 if(isStudyLocked()) break;
3657 EmitSignalDeactivateDialog();
3658 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3661 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3662 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3667 case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
3668 startOperation( SMESHOp::OpElem0DOnElemNodes );
3671 case SMESHOp::OpSelectFiltersLibrary: // Library of selection filters
3673 static QList<int> aTypes;
3674 if ( aTypes.isEmpty() )
3676 aTypes.append( SMESH::NODE );
3677 aTypes.append( SMESH::EDGE );
3678 aTypes.append( SMESH::FACE );
3679 aTypes.append( SMESH::VOLUME );
3681 if (!myFilterLibraryDlg)
3682 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3683 else if (myFilterLibraryDlg->isHidden())
3684 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3685 myFilterLibraryDlg->raise();
3689 case SMESHOp::OpFreeNode:
3690 case SMESHOp::OpEqualNode:
3691 case SMESHOp::OpNodeConnectivityNb:
3692 case SMESHOp::OpFreeEdge:
3693 case SMESHOp::OpFreeBorder:
3694 case SMESHOp::OpLength:
3695 case SMESHOp::OpConnection:
3696 case SMESHOp::OpEqualEdge:
3697 case SMESHOp::OpFreeFace:
3698 case SMESHOp::OpBareBorderFace:
3699 case SMESHOp::OpOverConstrainedFace:
3700 case SMESHOp::OpLength2D:
3701 case SMESHOp::OpDeflection2D:
3702 case SMESHOp::OpConnection2D:
3703 case SMESHOp::OpArea:
3704 case SMESHOp::OpTaper:
3705 case SMESHOp::OpAspectRatio:
3706 case SMESHOp::OpMinimumAngle:
3707 case SMESHOp::OpWarpingAngle:
3708 case SMESHOp::OpSkew:
3709 case SMESHOp::OpMaxElementLength2D:
3710 case SMESHOp::OpEqualFace:
3711 case SMESHOp::OpAspectRatio3D:
3712 case SMESHOp::OpVolume:
3713 case SMESHOp::OpMaxElementLength3D:
3714 case SMESHOp::OpBareBorderVolume:
3715 case SMESHOp::OpOverConstrainedVolume:
3716 case SMESHOp::OpEqualVolume:
3719 LightApp_SelectionMgr* mgr = selectionMgr();
3720 SALOME_ListIO selected; mgr->selectedObjects( selected );
3722 if( !selected.IsEmpty() ) {
3723 SUIT_OverrideCursor wc;
3724 ::Control( theCommandID );
3727 SUIT_MessageBox::warning(desktop(),
3728 tr( "SMESH_WRN_WARNING" ),
3729 tr( "SMESH_BAD_SELECTION" ) );
3733 SUIT_MessageBox::warning(desktop(),
3734 tr( "SMESH_WRN_WARNING" ),
3735 tr( "NOT_A_VTK_VIEWER" ) );
3738 case SMESHOp::OpOverallMeshQuality:
3739 OverallMeshQuality();
3741 case SMESHOp::OpNumberingNodes:
3743 SUIT_OverrideCursor wc;
3744 LightApp_SelectionMgr* mgr = selectionMgr();
3745 SALOME_ListIO selected; mgr->selectedObjects( selected );
3747 SALOME_ListIteratorOfListIO it(selected);
3748 for( ; it.More(); it.Next()) {
3749 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3750 if(anIObject->hasEntry()) {
3751 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3752 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3758 case SMESHOp::OpNumberingElements:
3760 SUIT_OverrideCursor wc;
3761 LightApp_SelectionMgr* mgr = selectionMgr();
3762 SALOME_ListIO selected; mgr->selectedObjects( selected );
3764 SALOME_ListIteratorOfListIO it(selected);
3765 for( ; it.More(); it.Next()) {
3766 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3767 if(anIObject->hasEntry())
3768 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3769 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3774 case SMESHOp::OpPropertiesLength:
3775 case SMESHOp::OpPropertiesArea:
3776 case SMESHOp::OpPropertiesVolume:
3777 case SMESHOp::OpMinimumDistance:
3778 case SMESHOp::OpBoundingBox:
3779 case SMESHOp::OpAngle:
3781 int page = SMESHGUI_MeasureDlg::MinDistance;
3782 if ( theCommandID == SMESHOp::OpBoundingBox )
3783 page = SMESHGUI_MeasureDlg::BoundingBox;
3784 else if ( theCommandID == SMESHOp::OpPropertiesLength )
3785 page = SMESHGUI_MeasureDlg::Length;
3786 else if ( theCommandID == SMESHOp::OpPropertiesArea )
3787 page = SMESHGUI_MeasureDlg::Area;
3788 else if ( theCommandID == SMESHOp::OpPropertiesVolume )
3789 page = SMESHGUI_MeasureDlg::Volume;
3790 else if ( theCommandID == SMESHOp::OpAngle )
3791 page = SMESHGUI_MeasureDlg::Angle;
3793 EmitSignalDeactivateDialog();
3794 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3798 case SMESHOp::OpSortChild:
3801 case SMESHOp::OpBreakLink:
3802 ::breakShaperLink();
3807 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3808 //updateObjBrowser();
3812 //=============================================================================
3816 //=============================================================================
3817 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3822 //=============================================================================
3826 //=============================================================================
3827 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3832 //=============================================================================
3836 //=============================================================================
3837 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3842 //=============================================================================
3843 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3844 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3846 //=============================================================================
3847 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3848 SUIT_ViewWindow* wnd )
3850 if(theIO->hasEntry()){
3851 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3852 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3856 //=======================================================================
3857 // function : createSMESHAction
3859 //=======================================================================
3860 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3861 const int key, const bool toggle, const QString& shortcutAction )
3864 QWidget* parent = application()->desktop();
3865 SUIT_ResourceMgr* resMgr = resourceMgr();
3867 if ( !icon_id.isEmpty() )
3868 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3870 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3871 if ( !pix.isNull() )
3872 icon = QIcon( pix );
3874 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3875 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3876 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3878 createAction( id, tooltip, icon, menu, status_bar, key, parent,
3879 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3882 //=======================================================================
3883 // function : createPopupItem
3885 //=======================================================================
3886 void SMESHGUI::createPopupItem( const int id,
3887 const QString& clients,
3888 const QString& types,
3889 const QString& theRule,
3892 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3893 popupMgr()->insert( action( id ), pId, 0 );
3895 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3896 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
3897 QString rule = "(%1) and (%2) and (%3)";
3898 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3899 if( clients.isEmpty() )
3900 rule = rule.arg( QString( "true" ) );
3902 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3903 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3906 bool cont = myRules.contains( id );
3908 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3910 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3911 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3914 //=======================================================================
3915 // function : initialize
3917 //=======================================================================
3918 void SMESHGUI::initialize( CAM_Application* app )
3920 SalomeApp_Module::initialize( app );
3922 // SUIT_ResourceMgr* mgr = app->resourceMgr();
3924 /* Automatic Update flag */
3925 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3927 // ----- create actions --------------
3929 //createSMESHAction( SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
3930 createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_I) );
3931 createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
3932 createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL" );
3934 createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
3936 createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
3937 createSMESHAction( SMESHOp::OpImportGMF, "IMPORT_GMF" );
3938 createSMESHAction( SMESHOp::OpPopupImportUNV, "IMPORT_UNV");
3939 createSMESHAction( SMESHOp::OpPopupImportMED, "IMPORT_MED");
3940 createSMESHAction( SMESHOp::OpPopupImportSTL, "IMPORT_STL" );
3942 createSMESHAction( SMESHOp::OpPopupImportCGNS, "IMPORT_CGNS" );
3944 createSMESHAction( SMESHOp::OpPopupImportSAUV, "IMPORT_SAUV" );
3945 createSMESHAction( SMESHOp::OpPopupImportGMF, "IMPORT_GMF" );
3947 createSMESHAction( SMESHOp::OpExportDAT, "DAT" );
3948 createSMESHAction( SMESHOp::OpExportMED, "MED" );
3949 createSMESHAction( SMESHOp::OpExportUNV, "UNV" );
3950 createSMESHAction( SMESHOp::OpExportSTL, "STL" );
3952 createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
3954 createSMESHAction( SMESHOp::OpExportSAUV, "SAUV");
3955 createSMESHAction( SMESHOp::OpExportGMF, "GMF" );
3956 createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
3957 createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
3958 createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
3959 createSMESHAction( SMESHOp::OpPopupExportSTL, "STL" );
3961 createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
3963 createSMESHAction( SMESHOp::OpPopupExportSAUV, "SAUV");
3964 createSMESHAction( SMESHOp::OpPopupExportGMF, "GMF" );
3965 createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
3966 createSMESHAction( SMESHOp::OpDelete, "DELETE", "ICON_DELETE", Qt::Key_Delete );
3967 createSMESHAction( SMESHOp::OpSelectFiltersLibrary, "SEL_FILTER_LIB" );
3968 createSMESHAction( SMESHOp::OpCreateMesh, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
3969 createSMESHAction( SMESHOp::OpCreateSubMesh, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
3970 createSMESHAction( SMESHOp::OpEditMeshOrSubMesh, "EDIT_MESHSUBMESH", "ICON_DLG_EDIT_MESH" );
3971 createSMESHAction( SMESHOp::OpEditMesh, "EDIT_MESH", "ICON_DLG_EDIT_MESH" );
3972 createSMESHAction( SMESHOp::OpEditSubMesh, "EDIT_SUBMESH", "ICON_DLG_EDIT_MESH" );
3973 createSMESHAction( SMESHOp::OpBuildCompoundMesh, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
3974 createSMESHAction( SMESHOp::OpCopyMesh, "COPY_MESH", "ICON_COPY_MESH" );
3975 createSMESHAction( SMESHOp::OpCompute, "COMPUTE", "ICON_COMPUTE" );
3976 createSMESHAction( SMESHOp::OpComputeSubMesh, "COMPUTE_SUBMESH", "ICON_COMPUTE" );
3977 createSMESHAction( SMESHOp::OpPreCompute, "PRECOMPUTE", "ICON_PRECOMPUTE" );
3978 createSMESHAction( SMESHOp::OpEvaluate, "EVALUATE", "ICON_EVALUATE" );
3979 createSMESHAction( SMESHOp::OpMeshOrder, "MESH_ORDER", "ICON_MESH_ORDER");
3980 createSMESHAction( SMESHOp::OpCreateGroup, "CREATE_GROUP", "ICON_CREATE_GROUP" );
3981 createSMESHAction( SMESHOp::OpCreateGeometryGroup, "CREATE_GEO_GROUP", "ICON_CREATE_GEO_GROUP" );
3982 createSMESHAction( SMESHOp::OpConstructGroup, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
3983 createSMESHAction( SMESHOp::OpEditGroup, "EDIT_GROUP", "ICON_EDIT_GROUP" );
3984 createSMESHAction( SMESHOp::OpEditGeomGroupAsGroup, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3985 createSMESHAction( SMESHOp::OpUnionGroups, "UN_GROUP", "ICON_UNION" );
3986 createSMESHAction( SMESHOp::OpIntersectGroups, "INT_GROUP", "ICON_INTERSECT" );
3987 createSMESHAction( SMESHOp::OpCutGroups, "CUT_GROUP", "ICON_CUT" );
3988 createSMESHAction( SMESHOp::OpGroupUnderlyingElem, "UNDERLYING_ELEMS", "ICON_UNDERLYING_ELEMS" );
3989 createSMESHAction( SMESHOp::OpFaceGroupsByEdges, "FACE_GROUPS_BY_EDGES", "ICON_FACE_GROUPS_BY_EDGES" );
3990 createSMESHAction( SMESHOp::OpAddElemGroupPopup, "ADD_TO_GROUP" );
3991 createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE_FROM_GROUP" );
3992 createSMESHAction( SMESHOp::OpDeleteGroup, "DEL_GROUP", "ICON_DEL_GROUP" );
3993 createSMESHAction( SMESHOp::OpMeshInformation , "ADV_INFO", "ICON_ADV_INFO" );
3994 //createSMESHAction( SMESHOp::OpStdInfo, "STD_INFO", "ICON_STD_INFO" );
3995 //createSMESHAction( SMESHOp::OpWhatIs, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3996 createSMESHAction( SMESHOp::OpFindElementByPoint, "FIND_ELEM", "ICON_FIND_ELEM" );
3998 createSMESHAction( SMESHOp::OpFreeNode, "FREE_NODE", "ICON_FREE_NODE", 0, true );
3999 createSMESHAction( SMESHOp::OpEqualNode, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
4000 createSMESHAction( SMESHOp::OpNodeConnectivityNb, "NODE_CONNECTIVITY_NB", "ICON_NODE_CONN_NB", 0, true );
4001 createSMESHAction( SMESHOp::OpFreeEdge, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
4002 createSMESHAction( SMESHOp::OpFreeBorder, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
4003 createSMESHAction( SMESHOp::OpLength, "LENGTH", "ICON_LENGTH", 0, true );
4004 createSMESHAction( SMESHOp::OpConnection, "CONNECTION", "ICON_CONNECTION", 0, true );
4005 createSMESHAction( SMESHOp::OpEqualEdge, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
4006 createSMESHAction( SMESHOp::OpFreeFace, "FREE_FACES", "ICON_FREE_FACES", 0, true );
4007 createSMESHAction( SMESHOp::OpBareBorderFace, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
4008 createSMESHAction( SMESHOp::OpOverConstrainedFace, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
4009 createSMESHAction( SMESHOp::OpLength2D, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
4010 createSMESHAction( SMESHOp::OpDeflection2D, "DEFLECTION_2D", "ICON_DEFLECTION_2D", 0, true );
4011 createSMESHAction( SMESHOp::OpConnection2D, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
4012 createSMESHAction( SMESHOp::OpArea, "AREA", "ICON_AREA", 0, true );
4013 createSMESHAction( SMESHOp::OpTaper, "TAPER", "ICON_TAPER", 0, true );
4014 createSMESHAction( SMESHOp::OpAspectRatio, "ASPECT", "ICON_ASPECT", 0, true );
4015 createSMESHAction( SMESHOp::OpMinimumAngle, "MIN_ANG", "ICON_ANGLE", 0, true );
4016 createSMESHAction( SMESHOp::OpWarpingAngle, "WARP", "ICON_WARP", 0, true );
4017 createSMESHAction( SMESHOp::OpSkew, "SKEW", "ICON_SKEW", 0, true );
4018 createSMESHAction( SMESHOp::OpMaxElementLength2D, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
4019 createSMESHAction( SMESHOp::OpEqualFace, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
4020 createSMESHAction( SMESHOp::OpAspectRatio3D, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
4021 createSMESHAction( SMESHOp::OpVolume, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
4022 createSMESHAction( SMESHOp::OpMaxElementLength3D, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
4023 createSMESHAction( SMESHOp::OpBareBorderVolume, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
4024 createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
4025 createSMESHAction( SMESHOp::OpEqualVolume, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
4026 createSMESHAction( SMESHOp::OpOverallMeshQuality, "OVERALL_MESH_QUALITY", "ICON_OVL_MESH_QUALITY" );
4028 createSMESHAction( SMESHOp::OpNode, "NODE", "ICON_DLG_NODE" );
4029 createSMESHAction( SMESHOp::OpElem0D, "ELEM0D", "ICON_DLG_ELEM0D" );
4030 createSMESHAction( SMESHOp::OpElem0DOnElemNodes, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
4031 createSMESHAction( SMESHOp::OpBall, "BALL", "ICON_DLG_BALL" );
4032 createSMESHAction( SMESHOp::OpEdge, "EDGE", "ICON_DLG_EDGE" );
4033 createSMESHAction( SMESHOp::OpTriangle, "TRIANGLE", "ICON_DLG_TRIANGLE" );
4034 createSMESHAction( SMESHOp::OpQuadrangle, "QUAD", "ICON_DLG_QUADRANGLE" );
4035 createSMESHAction( SMESHOp::OpPolygon, "POLYGON", "ICON_DLG_POLYGON" );
4036 createSMESHAction( SMESHOp::OpTetrahedron, "TETRA", "ICON_DLG_TETRAS" );
4037 createSMESHAction( SMESHOp::OpHexahedron, "HEXA", "ICON_DLG_HEXAS" );
4038 createSMESHAction( SMESHOp::OpPentahedron, "PENTA", "ICON_DLG_PENTA" );
4039 createSMESHAction( SMESHOp::OpPyramid , "PYRAMID", "ICON_DLG_PYRAMID" );
4040 createSMESHAction( SMESHOp::OpHexagonalPrism, "OCTA", "ICON_DLG_OCTA" );
4041 createSMESHAction( SMESHOp::OpPolyhedron, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
4042 createSMESHAction( SMESHOp::OpQuadraticEdge, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
4043 createSMESHAction( SMESHOp::OpQuadraticTriangle, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
4044 createSMESHAction( SMESHOp::OpBiQuadraticTriangle, "BIQUADRATIC_TRIANGLE", "ICON_DLG_BIQUADRATIC_TRIANGLE" );
4045 createSMESHAction( SMESHOp::OpQuadraticQuadrangle, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
4046 createSMESHAction( SMESHOp::OpBiQuadraticQuadrangle, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
4047 createSMESHAction( SMESHOp::OpQuadraticPolygon, "QUADRATIC_POLYGON", "ICON_DLG_QUADRATIC_POLYGON" );
4048 createSMESHAction( SMESHOp::OpQuadraticTetrahedron, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
4049 createSMESHAction( SMESHOp::OpQuadraticPyramid, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
4050 createSMESHAction( SMESHOp::OpQuadraticPentahedron, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
4051 createSMESHAction( SMESHOp::OpBiQuadraticPentahedron, "BIQUADRATIC_PENTAHEDRON", "ICON_DLG_BIQUADRATIC_PENTAHEDRON" );
4052 createSMESHAction( SMESHOp::OpQuadraticHexahedron, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
4053 createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
4055 createSMESHAction( SMESHOp::OpRemoveNodes, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
4056 createSMESHAction( SMESHOp::OpRemoveElements, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
4057 createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
4058 createSMESHAction( SMESHOp::OpClearMesh, "CLEAR_MESH", "ICON_CLEAR_MESH" );
4060 //createSMESHAction( SMESHOp::OpRenumberingNodes, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
4061 //createSMESHAction( SMESHOp::OpRenumberingElements, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
4063 createSMESHAction( SMESHOp::OpTranslation, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
4064 createSMESHAction( SMESHOp::OpRotation, "ROT", "ICON_DLG_MESH_ROTATION" );
4065 createSMESHAction( SMESHOp::OpSymmetry, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
4066 createSMESHAction( SMESHOp::OpScale, "SCALE", "ICON_DLG_MESH_SCALE" );
4067 createSMESHAction( SMESHOp::OpOffset, "OFFSET", "ICON_DLG_MESH_OFFSET" );
4068 createSMESHAction( SMESHOp::OpSewing, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
4069 createSMESHAction( SMESHOp::OpMergeNodes, "MERGE", "ICON_SMESH_MERGE_NODES" );
4070 createSMESHAction( SMESHOp::OpMergeElements, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
4071 createSMESHAction( SMESHOp::OpMoveNode, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
4072 createSMESHAction( SMESHOp::OpDuplicateNodes, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
4073 createSMESHAction( SMESHOp::OpDiagonalInversion, "INV", "ICON_DLG_MESH_DIAGONAL" );
4074 createSMESHAction( SMESHOp::OpUnionOfTwoTriangle, "UNION2", "ICON_UNION2TRI" );
4075 createSMESHAction( SMESHOp::OpOrientation, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
4076 createSMESHAction( SMESHOp::OpReorientFaces, "REORIENT_2D", "ICON_REORIENT_2D" );
4077 createSMESHAction( SMESHOp::OpUnionOfTriangles, "UNION", "ICON_UNIONTRI" );
4078 createSMESHAction( SMESHOp::OpCuttingOfQuadrangles, "CUT", "ICON_CUTQUAD" );
4079 createSMESHAction( SMESHOp::OpSplitVolumes, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
4080 createSMESHAction( SMESHOp::OpSplitBiQuadratic, "SPLIT_BIQUAD", "ICON_SPLIT_BIQUAD" );
4081 createSMESHAction( SMESHOp::OpSmoothing, "SMOOTH", "ICON_DLG_SMOOTHING" );
4082 createSMESHAction( SMESHOp::OpExtrusion, "EXTRUSION", "ICON_EXTRUSION" );
4083 createSMESHAction( SMESHOp::OpExtrusionAlongAPath, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
4084 createSMESHAction( SMESHOp::OpRevolution, "REVOLUTION", "ICON_REVOLUTION" );
4085 createSMESHAction( SMESHOp::OpPatternMapping, "MAP", "ICON_MAP" );
4086 createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
4087 createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D", "ICON_2D_FROM_3D" );
4089 createSMESHAction( SMESHOp::OpReset, "RESET" );
4090 createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
4091 createSMESHAction( SMESHOp::OpShowScalarBar, "SHOW_SCALAR_BAR","",0, true );
4092 createSMESHAction( SMESHOp::OpSaveDistribution, "SAVE_DISTRIBUTION" );
4093 createSMESHAction( SMESHOp::OpShowDistribution, "SHOW_DISTRIBUTION","",0, true );
4094 #ifndef DISABLE_PLOT2DVIEWER
4095 createSMESHAction( SMESHOp::OpPlotDistribution, "PLOT_DISTRIBUTION" );
4097 createSMESHAction( SMESHOp::OpDMWireframe, "WIRE", "ICON_WIRE", 0, true );
4098 createSMESHAction( SMESHOp::OpDMShading, "SHADE", "ICON_SHADE", 0, true );
4099 createSMESHAction( SMESHOp::OpDMNodes, "NODES", "ICON_POINTS", 0, true );
4100 createSMESHAction( SMESHOp::OpDMShrink, "SHRINK", "ICON_SHRINK", 0, true );
4101 createSMESHAction( SMESHOp::OpUpdate, "UPDATE", "ICON_UPDATE" );
4102 createSMESHAction( SMESHOp::OpDE0DElements, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
4103 createSMESHAction( SMESHOp::OpDEEdges, "EDGES", "ICON_DLG_EDGE", 0, true );
4104 createSMESHAction( SMESHOp::OpDEFaces, "FACES", "ICON_DLG_TRIANGLE", 0, true );
4105 createSMESHAction( SMESHOp::OpDEVolumes, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
4106 createSMESHAction( SMESHOp::OpDEBalls, "BALLS", "ICON_DLG_BALL", 0, true );
4107 createSMESHAction( SMESHOp::OpDEChoose, "CHOOSE", "ICON_DLG_CHOOSE", 0, false );
4108 createSMESHAction( SMESHOp::OpDEAllEntity, "ALL", "ICON_DLG_CHOOSE_ALL", 0, false );
4109 createSMESHAction( SMESHOp::OpOrientationOnFaces, "FACE_ORIENTATION", "", 0, true );
4111 createSMESHAction( SMESHOp::OpRepresentationLines, "LINE_REPRESENTATION", "", 0, true );
4112 createSMESHAction( SMESHOp::OpRepresentationArcs, "ARC_REPRESENTATION", "", 0, true );
4114 createSMESHAction( SMESHOp::OpEditHypothesis, "EDIT_HYPO" );
4115 createSMESHAction( SMESHOp::OpUnassign, "UNASSIGN" );
4116 createSMESHAction( SMESHOp::OpNumberingNodes, "NUM_NODES", "", 0, true );
4117 createSMESHAction( SMESHOp::OpNumberingElements, "NUM_ELEMENTS", "", 0, true );
4118 createSMESHAction( SMESHOp::OpProperties, "COLORS" );
4119 createSMESHAction( SMESHOp::OpTransparency, "TRANSP" );
4120 createSMESHAction( SMESHOp::OpClipping, "CLIP" );
4121 createSMESHAction( SMESHOp::OpAutoColor, "AUTO_COLOR" );
4122 createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
4124 createSMESHAction( SMESHOp::OpMinimumDistance, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
4125 createSMESHAction( SMESHOp::OpBoundingBox, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
4126 createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH", "ICON_MEASURE_LENGTH" );
4127 createSMESHAction( SMESHOp::OpPropertiesArea, "MEASURE_AREA", "ICON_MEASURE_AREA" );
4128 createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME", "ICON_MEASURE_VOLUME" );
4129 createSMESHAction( SMESHOp::OpAngle, "MEASURE_ANGLE", "ICON_MEASURE_ANGLE" );
4131 createSMESHAction( SMESHOp::OpHide, "HIDE", "ICON_HIDE" );
4132 createSMESHAction( SMESHOp::OpShow, "SHOW", "ICON_SHOW" );
4133 createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
4135 createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
4137 createSMESHAction( SMESHOp::OpBreakLink, "BREAK_SHAPER_LINK" );
4139 QList<int> aCtrlActions;
4140 aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode
4141 << SMESHOp::OpNodeConnectivityNb // node controls
4142 << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
4143 << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge // edge controls
4144 << SMESHOp::OpDeflection2D
4145 << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
4146 << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
4147 << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
4148 << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
4149 << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace // face controls
4150 << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
4151 << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
4152 << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume; // volume controls
4153 QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
4154 aCtrlGroup->setExclusive( true );
4155 for( int i = 0; i < aCtrlActions.size(); i++ )
4156 aCtrlGroup->addAction( action( aCtrlActions[i] ) );
4158 // ----- create menu --------------
4159 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
4160 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
4161 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
4162 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
4163 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
4164 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
4165 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
4166 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
4168 createMenu( separator(), fileId );
4170 QMenu* nodeMenu = new QMenu(); QMenu* edgeMenu = new QMenu();
4171 QMenu* faceMenu = new QMenu(); QMenu* volumeMenu = new QMenu();
4172 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
4173 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
4174 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10, -1, nodeMenu ),
4175 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10, -1, edgeMenu ),
4176 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10, -1, faceMenu ),
4177 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10, -1, volumeMenu ),
4178 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
4179 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
4180 //renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
4181 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
4182 basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
4184 //createMenu( SMESHOp::OpImportDAT, importId, -1 );
4185 createMenu( SMESHOp::OpImportUNV, importId, -1 );
4186 createMenu( SMESHOp::OpImportMED, importId, -1 );
4187 createMenu( SMESHOp::OpImportSTL, importId, -1 );
4189 createMenu( SMESHOp::OpImportCGNS, importId, -1 );
4191 createMenu( SMESHOp::OpImportSAUV, importId, -1 );
4192 createMenu( SMESHOp::OpImportGMF, importId, -1 );
4193 createMenu( SMESHOp::OpExportDAT, exportId, -1 );
4194 createMenu( SMESHOp::OpExportMED, exportId, -1 );
4195 createMenu( SMESHOp::OpExportUNV, exportId, -1 );
4196 createMenu( SMESHOp::OpExportSTL, exportId, -1 );
4198 createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
4200 createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
4201 createMenu( SMESHOp::OpExportGMF, exportId, -1 );
4202 createMenu( separator(), fileId, 10 );
4204 createMenu( SMESHOp::OpDelete, editId, -1 );
4206 createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
4208 createMenu( SMESHOp::OpCreateMesh, meshId, -1 ); // "Mesh" menu
4209 createMenu( SMESHOp::OpCreateSubMesh, meshId, -1 );
4210 createMenu( SMESHOp::OpEditMeshOrSubMesh, meshId, -1 );
4211 createMenu( SMESHOp::OpBuildCompoundMesh, meshId, -1 );
4212 createMenu( SMESHOp::OpCopyMesh, meshId, -1 );
4213 createMenu( separator(), meshId, -1 );
4214 createMenu( SMESHOp::OpCompute, meshId, -1 );
4215 createMenu( SMESHOp::OpPreCompute, meshId, -1 );
4216 createMenu( SMESHOp::OpEvaluate, meshId, -1 );
4217 createMenu( SMESHOp::OpMeshOrder, meshId, -1 );
4218 createMenu( separator(), meshId, -1 );
4219 createMenu( SMESHOp::OpCreateGroup, meshId, -1 );
4220 createMenu( SMESHOp::OpCreateGeometryGroup, meshId, -1 );
4221 createMenu( SMESHOp::OpConstructGroup, meshId, -1 );
4222 createMenu( SMESHOp::OpEditGroup, meshId, -1 );
4223 createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4224 createMenu( separator(), meshId, -1 );
4225 createMenu( SMESHOp::OpUnionGroups, meshId, -1 );
4226 createMenu( SMESHOp::OpIntersectGroups, meshId, -1 );
4227 createMenu( SMESHOp::OpCutGroups, meshId, -1 );
4228 createMenu( separator(), meshId, -1 );
4229 createMenu( SMESHOp::OpGroupUnderlyingElem, meshId, -1 );
4230 createMenu( SMESHOp::OpFaceGroupsByEdges, meshId, -1 );
4231 createMenu( separator(), meshId, -1 );
4232 createMenu( SMESHOp::OpMeshInformation, meshId, -1 );
4233 //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4234 //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4235 createMenu( SMESHOp::OpFindElementByPoint, meshId, -1 );
4236 createMenu( separator(), meshId, -1 );
4238 createMenu( SMESHOp::OpFreeNode, nodeId, -1 );
4239 createMenu( SMESHOp::OpEqualNode, nodeId, -1 );
4240 //createMenu( SMESHOp::OpNodeConnectivityNb, nodeId, -1 );
4241 createMenu( SMESHOp::OpFreeBorder, edgeId, -1 );
4242 createMenu( SMESHOp::OpLength, edgeId, -1 );
4243 createMenu( SMESHOp::OpConnection, edgeId, -1 );
4244 createMenu( SMESHOp::OpEqualEdge, edgeId, -1 );
4245 createMenu( SMESHOp::OpFreeEdge, faceId, -1 );
4246 createMenu( SMESHOp::OpFreeFace, faceId, -1 );
4247 createMenu( SMESHOp::OpBareBorderFace, faceId, -1 );
4248 createMenu( SMESHOp::OpOverConstrainedFace, faceId, -1 );
4249 createMenu( SMESHOp::OpLength2D, faceId, -1 );
4250 createMenu( SMESHOp::OpConnection2D, faceId, -1 );
4251 createMenu( SMESHOp::OpArea, faceId, -1 );
4252 createMenu( SMESHOp::OpTaper, faceId, -1 );
4253 createMenu( SMESHOp::OpAspectRatio, faceId, -1 );
4254 createMenu( SMESHOp::OpMinimumAngle, faceId, -1 );
4255 createMenu( SMESHOp::OpWarpingAngle, faceId, -1 );
4256 createMenu( SMESHOp::OpSkew, faceId, -1 );
4257 createMenu( SMESHOp::OpMaxElementLength2D, faceId, -1 );
4258 createMenu( SMESHOp::OpEqualFace, faceId, -1 );
4259 createMenu( SMESHOp::OpDeflection2D, faceId, -1 );
4260 createMenu( SMESHOp::OpAspectRatio3D, volumeId, -1 );
4261 createMenu( SMESHOp::OpVolume, volumeId, -1 );
4262 createMenu( SMESHOp::OpMaxElementLength3D, volumeId, -1 );
4263 createMenu( SMESHOp::OpBareBorderVolume, volumeId, -1 );
4264 createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4265 createMenu( SMESHOp::OpEqualVolume, volumeId, -1 );
4266 createMenu( separator(), ctrlId, -1 );
4267 createMenu( SMESHOp::OpReset, ctrlId, -1 );
4268 createMenu( separator(), ctrlId, -1 );
4269 createMenu( SMESHOp::OpOverallMeshQuality, ctrlId, -1 );
4271 createMenu( SMESHOp::OpNode, addId, -1 );
4272 createMenu( SMESHOp::OpElem0D, addId, -1 );
4273 createMenu( SMESHOp::OpElem0DOnElemNodes, addId, -1 );
4274 createMenu( SMESHOp::OpBall, addId, -1 );
4275 createMenu( SMESHOp::OpEdge, addId, -1 );
4276 createMenu( SMESHOp::OpTriangle, addId, -1 );
4277 createMenu( SMESHOp::OpQuadrangle, addId, -1 );
4278 createMenu( SMESHOp::OpPolygon, addId, -1 );
4279 createMenu( SMESHOp::OpTetrahedron, addId, -1 );
4280 createMenu( SMESHOp::OpHexahedron, addId, -1 );
4281 createMenu( SMESHOp::OpPentahedron, addId, -1 );
4282 createMenu( SMESHOp::OpPyramid, addId, -1 );
4283 createMenu( SMESHOp::OpHexagonalPrism, addId, -1 );
4284 createMenu( SMESHOp::OpPolyhedron, addId, -1 );
4285 createMenu( separator(), addId, -1 );
4286 createMenu( SMESHOp::OpQuadraticEdge, addId, -1 );
4287 createMenu( SMESHOp::OpQuadraticTriangle, addId, -1 );
4288 createMenu( SMESHOp::OpBiQuadraticTriangle , addId, -1 );
4289 createMenu( SMESHOp::OpQuadraticQuadrangle, addId, -1 );
4290 createMenu( SMESHOp::OpBiQuadraticQuadrangle, addId, -1 );
4291 createMenu( SMESHOp::OpQuadraticPolygon, addId, -1 );
4292 createMenu( SMESHOp::OpQuadraticTetrahedron, addId, -1 );
4293 createMenu( SMESHOp::OpQuadraticPyramid, addId, -1 );
4294 createMenu( SMESHOp::OpQuadraticPentahedron, addId, -1 );
4295 createMenu( SMESHOp::OpBiQuadraticPentahedron, addId, -1 );
4296 createMenu( SMESHOp::OpQuadraticHexahedron, addId, -1 );
4297 createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4299 createMenu( SMESHOp::OpRemoveNodes, removeId, -1 );
4300 createMenu( SMESHOp::OpRemoveElements, removeId, -1 );
4301 createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4302 createMenu( separator(), removeId, -1 );
4303 createMenu( SMESHOp::OpDeleteGroup, removeId, -1 );
4304 createMenu( separator(), removeId, -1 );
4305 createMenu( SMESHOp::OpClearMesh, removeId, -1 );
4307 //createMenu( SMESHOp::OpRenumberingNodes, renumId, -1 );
4308 //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4310 createMenu( SMESHOp::OpMergeNodes, transfId, -1 );
4311 createMenu( SMESHOp::OpMergeElements, transfId, -1 );
4312 createMenu( SMESHOp::OpTranslation, transfId, -1 );
4313 createMenu( SMESHOp::OpRotation, transfId, -1 );
4314 createMenu( SMESHOp::OpSymmetry, transfId, -1 );
4315 createMenu( SMESHOp::OpScale, transfId, -1 );
4316 createMenu( SMESHOp::OpOffset, transfId, -1 );
4317 createMenu( SMESHOp::OpSewing, transfId, -1 );
4318 createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4320 createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4321 createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4322 createMenu( SMESHOp::OpExtrusion, modifyId, -1 );
4323 createMenu( SMESHOp::OpExtrusionAlongAPath, modifyId, -1 );
4324 createMenu( SMESHOp::OpRevolution, modifyId, -1 );
4325 createMenu( SMESHOp::OpOrientation, modifyId, -1 );
4326 createMenu( SMESHOp::OpReorientFaces, modifyId, -1 );
4327 createMenu( SMESHOp::OpMoveNode, modifyId, -1 );
4328 createMenu( SMESHOp::OpDiagonalInversion, modifyId, -1 );
4329 createMenu( SMESHOp::OpUnionOfTwoTriangle, modifyId, -1 );
4330 createMenu( SMESHOp::OpUnionOfTriangles, modifyId, -1 );
4331 createMenu( SMESHOp::OpCuttingOfQuadrangles, modifyId, -1 );
4332 createMenu( SMESHOp::OpSplitVolumes, modifyId, -1 );
4333 createMenu( SMESHOp::OpSplitBiQuadratic, modifyId, -1 );
4334 createMenu( SMESHOp::OpSmoothing, modifyId, -1 );
4335 createMenu( SMESHOp::OpPatternMapping, modifyId, -1 );
4337 createMenu( SMESHOp::OpMinimumDistance, measureId, -1 );
4338 createMenu( SMESHOp::OpBoundingBox, measureId, -1 );
4339 createMenu( SMESHOp::OpAngle, measureId, -1 );
4340 createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4341 createMenu( SMESHOp::OpPropertiesArea, basicPropId, -1 );
4342 createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4343 createMenu( SMESHOp::OpUpdate, viewId, -1 );
4345 connect( nodeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4346 connect( edgeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4347 connect( faceMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4348 connect( volumeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4350 // ----- create toolbars --------------
4351 int meshTb = createTool( tr( "TB_MESH" ), QString( "SMESHMeshToolbar" ) ),
4352 info = createTool( tr( "TB_INFO" ), QString( "SMESHInformationToolbar" ) ),
4353 groupTb = createTool( tr( "TB_GROUP" ), QString( "SMESHGroupToolbar" ) ),
4354 ctrl0dTb = createTool( tr( "TB_CTRL0D" ), QString( "SMESHNodeControlsToolbar" ) ),
4355 ctrl1dTb = createTool( tr( "TB_CTRL1D" ), QString( "SMESHEdgeControlsToolbar" ) ),
4356 ctrl2dTb = createTool( tr( "TB_CTRL2D" ), QString( "SMESHFaceControlsToolbar" ) ),
4357 ctrl3dTb = createTool( tr( "TB_CTRL3D" ), QString( "SMESHVolumeControlsToolbar" ) ),
4358 addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ),
4359 addNonElemTb = createTool( tr( "TB_ADDNON" ), QString( "SMESHAddElementToolbar" ) ),
4360 remTb = createTool( tr( "TB_REM" ), QString( "SMESHRemoveToolbar" ) ),
4361 //renumbTb = createTool( tr( "TB_RENUMBER" ), QString( "SMESHRenumberingToolbar" ) ),
4362 transformTb = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ),
4363 modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ),
4364 measuremTb = createTool( tr( "TB_MEASUREM" ), QString( "SMESHMeasurementsToolbar" ) ),
4365 dispModeTb = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4367 createTool( SMESHOp::OpCreateMesh, meshTb );
4368 createTool( SMESHOp::OpCreateSubMesh, meshTb );
4369 createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4370 createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4371 createTool( SMESHOp::OpCopyMesh, meshTb );
4372 createTool( separator(), meshTb );
4373 createTool( SMESHOp::OpCompute, meshTb );
4374 createTool( SMESHOp::OpPreCompute, meshTb );
4375 createTool( SMESHOp::OpEvaluate, meshTb );
4376 createTool( SMESHOp::OpMeshOrder, meshTb );
4378 createTool( SMESHOp::OpCreateGroup, groupTb );
4379 createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4380 createTool( SMESHOp::OpConstructGroup, groupTb );
4381 createTool( SMESHOp::OpEditGroup, groupTb );
4383 createTool( SMESHOp::OpMeshInformation, info );
4384 //createTool( SMESHOp::OpStdInfo, meshTb );
4385 //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4386 createTool( SMESHOp::OpFindElementByPoint, info );
4388 createTool( SMESHOp::OpFreeNode, ctrl0dTb );
4389 createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4390 //createTool( SMESHOp::OpNodeConnectivityNb, ctrl0dTb );
4392 createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4393 createTool( SMESHOp::OpLength, ctrl1dTb );
4394 createTool( SMESHOp::OpConnection, ctrl1dTb );
4395 createTool( SMESHOp::OpEqualEdge, ctrl1dTb );
4397 createTool( SMESHOp::OpFreeEdge, ctrl2dTb );
4398 createTool( SMESHOp::OpFreeFace, ctrl2dTb );
4399 createTool( SMESHOp::OpBareBorderFace, ctrl2dTb );
4400 createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4401 createTool( SMESHOp::OpLength2D, ctrl2dTb );
4402 createTool( SMESHOp::OpConnection2D, ctrl2dTb );
4403 createTool( SMESHOp::OpArea, ctrl2dTb );
4404 createTool( SMESHOp::OpTaper, ctrl2dTb );
4405 createTool( SMESHOp::OpAspectRatio, ctrl2dTb );
4406 createTool( SMESHOp::OpMinimumAngle, ctrl2dTb );
4407 createTool( SMESHOp::OpWarpingAngle, ctrl2dTb );
4408 createTool( SMESHOp::OpSkew, ctrl2dTb );
4409 createTool( SMESHOp::OpMaxElementLength2D, ctrl2dTb );
4410 createTool( SMESHOp::OpEqualFace, ctrl2dTb );
4411 createTool( SMESHOp::OpDeflection2D, ctrl2dTb );
4413 createTool( SMESHOp::OpAspectRatio3D, ctrl3dTb );
4414 createTool( SMESHOp::OpVolume, ctrl3dTb );
4415 createTool( SMESHOp::OpMaxElementLength3D, ctrl3dTb );
4416 createTool( SMESHOp::OpBareBorderVolume, ctrl3dTb );
4417 createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
4418 createTool( SMESHOp::OpEqualVolume, ctrl3dTb );
4420 createTool( SMESHOp::OpNode, addElemTb );
4421 createTool( SMESHOp::OpElem0D, addElemTb );
4422 createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4423 createTool( SMESHOp::OpBall, addElemTb );
4424 createTool( SMESHOp::OpEdge, addElemTb );
4425 createTool( SMESHOp::OpTriangle, addElemTb );
4426 createTool( SMESHOp::OpQuadrangle, addElemTb );
4427 createTool( SMESHOp::OpPolygon, addElemTb );
4428 createTool( SMESHOp::OpTetrahedron, addElemTb );
4429 createTool( SMESHOp::OpHexahedron, addElemTb );
4430 createTool( SMESHOp::OpPentahedron, addElemTb );
4431 createTool( SMESHOp::OpPyramid, addElemTb );
4432 createTool( SMESHOp::OpHexagonalPrism, addElemTb );
4433 createTool( SMESHOp::OpPolyhedron, addElemTb );
4435 createTool( SMESHOp::OpQuadraticEdge, addNonElemTb );
4436 createTool( SMESHOp::OpQuadraticTriangle, addNonElemTb );
4437 createTool( SMESHOp::OpBiQuadraticTriangle, addNonElemTb );
4438 createTool( SMESHOp::OpQuadraticQuadrangle, addNonElemTb );
4439 createTool( SMESHOp::OpBiQuadraticQuadrangle, addNonElemTb );
4440 createTool( SMESHOp::OpQuadraticPolygon, addNonElemTb );
4441 createTool( SMESHOp::OpQuadraticTetrahedron, addNonElemTb );
4442 createTool( SMESHOp::OpQuadraticPyramid, addNonElemTb );
4443 createTool( SMESHOp::OpQuadraticPentahedron, addNonElemTb );
4444 createTool( SMESHOp::OpBiQuadraticPentahedron, addNonElemTb );
4445 createTool( SMESHOp::OpQuadraticHexahedron, addNonElemTb );
4446 createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4448 createTool( SMESHOp::OpRemoveNodes, remTb );
4449 createTool( SMESHOp::OpRemoveElements, remTb );
4450 createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4451 createTool( SMESHOp::OpClearMesh, remTb );
4453 //createTool( SMESHOp::OpRenumberingNodes, renumbTb );
4454 //createTool( SMESHOp::OpRenumberingElements, renumbTb );
4456 createTool( SMESHOp::OpMergeNodes, transformTb );
4457 createTool( SMESHOp::OpMergeElements, transformTb );
4458 createTool( SMESHOp::OpTranslation, transformTb );
4459 createTool( SMESHOp::OpRotation, transformTb );
4460 createTool( SMESHOp::OpSymmetry, transformTb );
4461 createTool( SMESHOp::OpScale, transformTb );
4462 createTool( SMESHOp::OpOffset, transformTb );
4463 createTool( SMESHOp::OpSewing, transformTb );
4464 createTool( SMESHOp::OpDuplicateNodes, transformTb );
4466 createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4467 createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4468 createTool( SMESHOp::OpExtrusion, modifyTb );
4469 createTool( SMESHOp::OpExtrusionAlongAPath, modifyTb );
4470 createTool( SMESHOp::OpRevolution, modifyTb );
4471 createTool( SMESHOp::OpOrientation, modifyTb );
4472 createTool( SMESHOp::OpReorientFaces, modifyTb );
4473 createTool( SMESHOp::OpMoveNode, modifyTb );
4474 createTool( SMESHOp::OpDiagonalInversion, modifyTb );
4475 createTool( SMESHOp::OpUnionOfTwoTriangle, modifyTb );
4476 createTool( SMESHOp::OpUnionOfTriangles, modifyTb );
4477 createTool( SMESHOp::OpCuttingOfQuadrangles, modifyTb );
4478 createTool( SMESHOp::OpSplitVolumes, modifyTb );
4479 createTool( SMESHOp::OpSplitBiQuadratic, modifyTb );
4480 createTool( SMESHOp::OpSmoothing, modifyTb );
4481 createTool( SMESHOp::OpPatternMapping, modifyTb );
4483 createTool( SMESHOp::OpMinimumDistance, measuremTb );
4485 createTool( SMESHOp::OpUpdate, dispModeTb );
4487 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4488 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4492 OB = "'ObjectBrowser'",
4493 View = "'" + SVTK_Viewer::Type() + "'",
4495 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4496 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4497 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4498 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4499 smesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::COMPONENT ) ),
4500 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4501 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4502 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4503 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4504 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4505 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4506 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4508 mesh_part = mesh + " " + subMesh + " " + group,
4509 mesh_group = mesh + " " + group,
4510 mesh_submesh = mesh + " " + subMesh,
4511 hyp_alg = hypo + " " + algo;
4513 // popup for object browser
4515 isInvisible("not( isVisible )"),
4516 isEmpty("numberOfNodes = 0"),
4517 isNotEmpty("numberOfNodes <> 0"),
4519 // has nodes, edges, etc in VISIBLE! actor
4520 hasNodes("(numberOfNodes > 0 ) && hasActor"),
4521 hasElems("(count( elemTypes ) > 0)"),
4522 hasDifferentElems("(count( elemTypes ) > 1)"),
4523 hasDifferentObjElems("(count( objElemTypes ) > 1)"),
4524 hasBalls("({'BallElem'} in elemTypes)"),
4525 hasElems0d("({'Elem0d'} in elemTypes)"),
4526 hasEdges("({'Edge'} in elemTypes)"),
4527 hasFaces("({'Face'} in elemTypes)"),
4528 hasVolumes("({'Volume'} in elemTypes)"),
4529 hasFacesOrVolumes("(({'Face'} in elemTypes) || ({'Volume'} in elemTypes)) ");
4531 createPopupItem( SMESHOp::OpFileInformation, OB, mesh, "&& selcount=1 && isImported" );
4532 createPopupItem( SMESHOp::OpCreateSubMesh, OB, mesh, "&& hasGeomReference");
4533 createPopupItem( SMESHOp::OpEditMesh, OB, mesh, "&& selcount=1" );
4534 createPopupItem( SMESHOp::OpEditSubMesh, OB, subMesh, "&& selcount=1 && hasGeomReference" );
4535 createPopupItem( SMESHOp::OpEditGroup, OB, group );
4536 createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4538 popupMgr()->insert( separator(), -1, 0 );
4539 createPopupItem( SMESHOp::OpCompute, OB, mesh, "&& selcount=1 && isComputable" );
4540 createPopupItem( SMESHOp::OpComputeSubMesh, OB, subMesh, "&& selcount=1 && isComputable" );
4541 createPopupItem( SMESHOp::OpPreCompute, OB, mesh, "&& selcount=1 && isPreComputable" );
4542 createPopupItem( SMESHOp::OpEvaluate, OB, mesh, "&& selcount=1 && isComputable" );
4543 createPopupItem( SMESHOp::OpMeshOrder, OB, mesh, "&& selcount=1 && isComputable && hasGeomReference" );
4544 createPopupItem( SMESHOp::OpUpdate, OB, mesh_part );
4545 createPopupItem( SMESHOp::OpMeshInformation, OB, mesh_part );
4546 createPopupItem( SMESHOp::OpFindElementByPoint,OB, mesh_group, "&& selcount=1" );
4547 createPopupItem( SMESHOp::OpOverallMeshQuality,OB, mesh_part );
4548 popupMgr()->insert( separator(), -1, 0 );
4549 createPopupItem( SMESHOp::OpCreateGroup, OB, mesh, "&& selcount=1" );
4550 createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh, "&& selcount=1 && hasGeomReference" );
4551 createPopupItem( SMESHOp::OpConstructGroup, OB, subMesh );
4552 popupMgr()->insert( separator(), -1, 0 );
4553 createPopupItem( SMESHOp::OpEditHypothesis, OB, hypo, "&& isEditableHyp");
4554 createPopupItem( SMESHOp::OpUnassign, OB, hyp_alg );
4555 popupMgr()->insert( separator(), -1, 0 );
4556 createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh_submesh );
4557 createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh_group, "&& selcount=1 && dim>=2");
4558 popupMgr()->insert( separator(), -1, 0 );
4559 createPopupItem( SMESHOp::OpClearMesh, OB, mesh );
4560 //popupMgr()->insert( separator(), -1, 0 );
4562 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4563 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4564 QString only_one_2D = only_one_non_empty + " && dim>1";
4566 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4567 createPopupItem( SMESHOp::OpPopupExportMED, OB, mesh_group, multiple_non_empty, anId );
4568 createPopupItem( SMESHOp::OpPopupExportUNV, OB, mesh_group, only_one_non_empty, anId );
4569 createPopupItem( SMESHOp::OpPopupExportSTL, OB, mesh_group, only_one_2D, anId );
4571 createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4573 createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, only_one_non_empty, anId );
4574 createPopupItem( SMESHOp::OpPopupExportGMF, OB, mesh_group, only_one_non_empty, anId );
4575 createPopupItem( SMESHOp::OpPopupExportDAT, OB, mesh_group, only_one_non_empty, anId );
4576 createPopupItem( SMESHOp::OpDelete, OB, mesh_part + " " + hyp_alg );
4577 createPopupItem( SMESHOp::OpDeleteGroup, OB, group );
4579 anId = popupMgr()->insert( tr( "MEN_IMPORT" ), -1, -1 ); // IMPORT submenu
4580 createPopupItem( SMESHOp::OpPopupImportMED, OB, smesh, "", anId );
4581 createPopupItem( SMESHOp::OpPopupImportUNV, OB, smesh, "", anId );
4582 createPopupItem( SMESHOp::OpPopupImportSTL, OB, smesh, "", anId );
4584 createPopupItem( SMESHOp::OpPopupImportCGNS, OB, smesh, "", anId );
4586 createPopupItem( SMESHOp::OpPopupImportSAUV, OB, smesh, "", anId );
4587 createPopupItem( SMESHOp::OpPopupImportGMF, OB, smesh, "", anId );
4588 createPopupItem( SMESHOp::OpPopupImportDAT, OB, smesh, "", anId );
4589 popupMgr()->insert( separator(), -1, 0 );
4592 createPopupItem( SMESHOp::OpEditGroup, View, group );
4593 createPopupItem( SMESHOp::OpAddElemGroupPopup, View, elems, "&& guiState = 800" );
4594 createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems, "&& guiState = 800" );
4596 popupMgr()->insert( separator(), -1, 0 );
4597 createPopupItem( SMESHOp::OpUpdate, View, mesh_part );
4598 createPopupItem( SMESHOp::OpMeshInformation, View, mesh_part );
4599 createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4600 createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh );
4601 popupMgr()->insert( separator(), -1, 0 );
4603 createPopupItem( SMESHOp::OpAutoColor, OB + " " + View, mesh, "&& (not isAutoColor)" );
4604 createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4605 popupMgr()->insert( separator(), -1, 0 );
4607 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4608 QString aType = QString( "%1type in {%2}" ).arg( lc );
4609 aType = aType.arg( mesh_part );
4610 QString aMeshInVTK = aClient + "&&" + aType;
4612 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4613 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4614 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4616 //-------------------------------------------------
4618 //-------------------------------------------------
4619 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4621 popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4622 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4623 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4625 popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4626 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4627 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4629 popupMgr()->insert( separator(), -1, -1 );
4631 //-------------------------------------------------
4633 //-------------------------------------------------
4634 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4636 popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4637 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4638 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4640 popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4641 popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4642 popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4644 popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4645 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4646 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4648 popupMgr()->insert( separator(), anId, -1 );
4650 popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4651 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4652 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4654 //-------------------------------------------------
4656 //-------------------------------------------------
4657 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4659 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4661 popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4662 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4663 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4665 popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4666 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4667 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4669 popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4670 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4671 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4673 popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4674 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4675 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4677 popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4678 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4679 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4681 popupMgr()->insert( separator(), anId, -1 );
4683 popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4684 popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&& $type in {" + mesh + "} &&" + hasDifferentObjElems, QtxPopupMgr::VisibleRule );
4686 popupMgr()->insert( separator(), anId, -1 );
4688 popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4689 popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4692 //-------------------------------------------------
4693 // Representation of the 2D Quadratic elements
4694 //-------------------------------------------------
4695 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4696 popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4697 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "&& isVisible && isQuadratic",QtxPopupMgr::VisibleRule );
4698 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4700 popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4701 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "&& isVisible && isQuadratic", QtxPopupMgr::VisibleRule );
4702 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4704 //-------------------------------------------------
4705 // Orientation of faces
4706 //-------------------------------------------------
4707 popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4708 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4709 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4711 //-------------------------------------------------
4713 //-------------------------------------------------
4714 popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4715 popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4717 //-------------------------------------------------
4719 //-------------------------------------------------
4720 popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4721 popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4723 //-------------------------------------------------
4725 //-------------------------------------------------
4727 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4728 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4729 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4730 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4732 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4734 popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4735 popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4737 popupMgr()->insert( separator(), anId, -1 );
4739 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4741 popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4742 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4743 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4745 popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4746 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4747 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4749 // popupMgr()->insert( action( SMESHOp::OpNodeConnectivityNb ), aSubId, -1 );
4750 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4751 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), "controlMode = 'eNodeConnectivityNb'", QtxPopupMgr::ToggleRule );
4753 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4755 popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4756 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVTK + "&&" + hasEdges + "&&" + hasFacesOrVolumes, QtxPopupMgr::VisibleRule );
4757 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4759 popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4760 popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4761 popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4763 popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4764 popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4765 popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4766 popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4767 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4768 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4770 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4772 popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4773 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4774 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4776 popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4777 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4778 QtxPopupMgr::VisibleRule );
4779 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4781 popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4782 popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4783 popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4785 popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4786 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4787 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4789 popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
4790 popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4791 popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4793 popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
4794 popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4795 popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4797 popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
4798 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4799 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4801 popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
4802 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4803 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4805 popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
4806 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4807 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4809 popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
4810 popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4811 popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4813 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
4814 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4815 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4817 popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
4818 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4819 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4821 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
4822 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4823 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4825 popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
4826 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4827 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4829 popupMgr()->insert ( action( SMESHOp::OpDeflection2D ), aSubId, -1 );
4830 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), aMeshInVtkHasFaces + " && hasGeomReference", QtxPopupMgr::VisibleRule );
4831 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), "controlMode = 'eDeflection2D'", QtxPopupMgr::ToggleRule );
4833 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4835 popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D ), aSubId, -1 );
4836 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4837 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4839 popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
4840 popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4841 popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4843 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
4844 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4845 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4847 popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
4848 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4849 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4851 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
4852 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4853 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4855 popupMgr()->insert ( action( SMESHOp::OpEqualVolume ), aSubId, -1 );
4856 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4857 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4859 popupMgr()->insert( separator(), anId, -1 );
4861 popupMgr()->insert( action( SMESHOp::OpShowScalarBar ), anId, -1 );
4862 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4863 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone' && isScalarBarVisible", QtxPopupMgr::ToggleRule );
4864 popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
4865 popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4867 popupMgr()->insert( separator(), anId, -1 );
4869 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4871 popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
4872 popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4874 popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
4875 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4876 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isScalarBarVisible && isDistributionVisible", QtxPopupMgr::ToggleRule);
4878 #ifndef DISABLE_PLOT2DVIEWER
4879 popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
4880 popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4883 //-------------------------------------------------
4885 //-------------------------------------------------
4886 popupMgr()->insert( separator(), -1, -1 );
4887 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4888 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4889 popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
4890 popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4892 popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
4893 popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4895 popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
4896 popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4898 popupMgr()->insert( separator(), -1, -1 );
4900 //-------------------------------------------------
4902 //-------------------------------------------------
4903 popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
4904 popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4906 popupMgr()->insert( separator(), -1, -1 );
4908 popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
4909 popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
4910 popupMgr()->insert( separator(), -1, -1 );
4912 popupMgr()->insert( action( SMESHOp::OpBreakLink), -1, -1 );
4913 popupMgr()->setRule( action( SMESHOp::OpBreakLink), "$component={'SHAPERSTUDY'} and client='ObjectBrowser' and canBreakLink", QtxPopupMgr::VisibleRule );
4915 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4916 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4918 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4919 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4922 //================================================================================
4924 * \brief Return true if SMESH or GEOM objects are selected.
4925 * Is called form LightApp_Module::activateModule() which clear selection if
4926 * not isSelectionCompatible()
4928 //================================================================================
4930 bool SMESHGUI::isSelectionCompatible()
4932 bool isCompatible = true;
4933 SALOME_ListIO selected;
4934 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4935 Sel->selectedObjects( selected );
4937 SALOME_ListIteratorOfListIO It( selected );
4938 for ( ; isCompatible && It.More(); It.Next())
4940 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4941 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4943 return isCompatible;
4947 bool SMESHGUI::reusableOperation( const int id )
4949 // compute, evaluate and precompute are not reusable operations
4950 return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate ) ? false : SalomeApp_Module::reusableOperation( id );
4953 bool SMESHGUI::activateModule( SUIT_Study* study )
4955 bool res = SalomeApp_Module::activateModule( study );
4957 setMenuShown( true );
4958 setToolShown( true );
4960 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4961 PyGILState_STATE gstate = PyGILState_Ensure();
4962 PyObject* pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4963 if ( !pluginsmanager ) {
4967 PyObject* result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toUtf8().data(),tr("SMESH_PLUGINS_OTHER").toUtf8().data());
4972 PyGILState_Release(gstate);
4973 // end of SMESH plugins loading
4975 // Reset actions accelerator keys
4976 action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
4978 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4979 GetSMESHGen()->UpdateStudy();
4981 // get all view currently opened in the study and connect their signals to
4982 // the corresponding slots of the class.
4983 SUIT_Desktop* aDesk = study->application()->desktop();
4985 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4986 SUIT_ViewWindow* wnd;
4987 foreach(wnd, wndList) {
4993 Py_XDECREF(pluginsmanager);
4997 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4999 setMenuShown( false );
5000 setToolShown( false );
5002 EmitSignalCloseAllDialogs();
5004 // Unset actions accelerator keys
5005 action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
5007 return SalomeApp_Module::deactivateModule( study );
5010 void SMESHGUI::studyClosed( SUIT_Study* s )
5014 SMESH::RemoveVisuData();
5015 SalomeApp_Module::studyClosed( s );
5018 void SMESHGUI::OnGUIEvent()
5020 const QObject* obj = sender();
5021 if ( !obj || !obj->inherits( "QAction" ) )
5023 int id = actionId((QAction*)obj);
5028 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
5030 if ( CORBA::is_nil( myComponentSMESH ) )
5032 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
5033 return aGUI.myComponentSMESH;
5035 return myComponentSMESH;
5038 QString SMESHGUI::engineIOR() const
5040 CORBA::ORB_var anORB = getApp()->orb();
5041 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
5042 return QString( anIOR.in() );
5045 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
5047 SalomeApp_Module::contextMenuPopup( client, menu, title );
5049 selectionMgr()->selectedObjects( lst );
5050 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
5051 Handle(SALOME_InteractiveObject) io = lst.First();
5052 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
5053 _PTR(Study) study = appStudy->studyDS();
5054 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
5056 QString aName = SMESH::fromUtf8( obj->GetName());
5057 while ( !aName.isEmpty() && aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
5058 aName.remove(( aName.length() - 1 ), 1 );
5064 LightApp_Selection* SMESHGUI::createSelection() const
5066 return new SMESHGUI_Selection();
5069 void SMESHGUI::windows( QMap<int, int>& aMap ) const
5071 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
5072 aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
5073 #ifndef DISABLE_PYCONSOLE
5074 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
5078 void SMESHGUI::viewManagers( QStringList& list ) const
5080 list.append( SVTK_Viewer::Type() );
5083 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
5085 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
5086 SMESH::UpdateSelectionProp( this );
5088 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
5089 for(int i = 0; i < aViews.count() ; i++){
5090 SUIT_ViewWindow *sf = aViews[i];
5093 EmitSignalActivatedViewManager();
5097 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
5099 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
5100 myClippingPlaneInfoMap.erase( theViewManager );
5103 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
5105 theActor->AddObserver( SMESH::DeleteActorEvent,
5106 myEventCallbackCommand.GetPointer(),
5110 void SMESHGUI::ProcessEvents( vtkObject* theObject,
5111 unsigned long theEvent,
5112 void* theClientData,
5115 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
5116 if( theObject && (int) theEvent == SMESH::DeleteActorEvent ) {
5117 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
5118 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
5119 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
5120 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
5121 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
5122 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
5123 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
5124 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
5125 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
5126 SMESH::TActorList::iterator anIter3 = anActorList.begin();
5127 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
5128 if( anActor == *anIter3 ) {
5129 anActorList.erase( anIter3 );
5140 void SMESHGUI::createPreferences()
5142 // General tab ------------------------------------------------------------------------
5143 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
5145 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
5146 setPreferenceProperty( autoUpdate, "columns", 2 );
5147 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
5148 setPreferenceProperty( lim, "min", 0 );
5149 setPreferenceProperty( lim, "max", 100000000 );
5150 setPreferenceProperty( lim, "step", 1000 );
5151 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5152 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
5154 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
5155 setPreferenceProperty( dispgroup, "columns", 2 );
5157 addPreference( tr( "PREF_FITALL_ON_DISPLAYONLY" ), dispgroup, LightApp_Preferences::Bool, "SMESH", "fitall_on_displayonly" );
5159 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
5161 modes.append( tr("MEN_WIRE") );
5162 modes.append( tr("MEN_SHADE") );
5163 modes.append( tr("MEN_NODES") );
5164 modes.append( tr("MEN_SHRINK") );
5165 QList<QVariant> indices;
5166 indices.append( 0 );
5167 indices.append( 1 );
5168 indices.append( 2 );
5169 indices.append( 3 );
5170 setPreferenceProperty( dispmode, "strings", modes );
5171 setPreferenceProperty( dispmode, "indexes", indices );
5173 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
5174 setPreferenceProperty( arcgroup, "columns", 2 );
5175 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
5176 QStringList quadraticModes;
5177 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
5178 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
5180 indices.append( 0 );
5181 indices.append( 1 );
5182 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
5183 setPreferenceProperty( quadraticmode, "indexes", indices );
5185 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
5186 "SMESH", "max_angle" );
5187 setPreferenceProperty( maxAngle, "min", 1 );
5188 setPreferenceProperty( maxAngle, "max", 90 );
5190 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
5191 setPreferenceProperty( qaGroup, "columns", 2 );
5192 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
5193 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
5194 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
5195 setPreferenceProperty( prec, "min", 0 );
5196 setPreferenceProperty( prec, "max", 100 );
5197 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
5198 setPreferenceProperty( doubleNodesTol, "precision", 10 );
5199 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
5200 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
5201 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
5204 int cinc = addPreference(tr("PREF_CONTROLS_INCREMENT"), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_increment");
5205 setPreferenceProperty( cinc, "min", 0 );
5206 setPreferenceProperty( cinc, "max", 5 );
5209 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
5210 setPreferenceProperty( exportgroup, "columns", 2 );
5211 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
5212 addPreference( tr( "PREF_SHOW_WARN" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "show_warning" );
5213 int zTol = addPreference( tr( "PREF_ZTOLERANCE" ), exportgroup, LightApp_Preferences::DblSpin, "SMESH", "med_ztolerance" );
5214 setPreferenceProperty( zTol, "precision", 10 );
5215 setPreferenceProperty( zTol, "min", 0.0000000001 );
5216 setPreferenceProperty( zTol, "max", 1000000.0 );
5217 setPreferenceProperty( zTol, "step", 1. );
5218 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
5220 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
5221 setPreferenceProperty( computeGroup, "columns", 2 );
5222 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
5224 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5225 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5226 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5228 indices.append( 0 );
5229 indices.append( 1 );
5230 indices.append( 2 );
5231 setPreferenceProperty( notifyMode, "strings", modes );
5232 setPreferenceProperty( notifyMode, "indexes", indices );
5234 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5235 setPreferenceProperty( infoGroup, "columns", 2 );
5236 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5238 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5239 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5241 indices.append( 0 );
5242 indices.append( 1 );
5243 setPreferenceProperty( elemInfo, "strings", modes );
5244 setPreferenceProperty( elemInfo, "indexes", indices );
5245 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5246 setPreferenceProperty( nodesLim, "min", 0 );
5247 setPreferenceProperty( nodesLim, "max", 10000000 );
5248 setPreferenceProperty( nodesLim, "step", 10000 );
5249 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5250 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5251 setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5252 setPreferenceProperty( ctrlLim, "min", 0 );
5253 setPreferenceProperty( ctrlLim, "max", 10000000 );
5254 setPreferenceProperty( ctrlLim, "step", 1000 );
5255 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5256 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5257 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5258 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5259 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5261 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5262 setPreferenceProperty( segGroup, "columns", 2 );
5263 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5264 "SMESH", "segmentation" );
5265 setPreferenceProperty( segLen, "min", 1 );
5266 setPreferenceProperty( segLen, "max", 10000000 );
5267 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5268 "SMESH", "nb_segments_per_edge" );
5269 setPreferenceProperty( nbSeg, "min", 1 );
5270 setPreferenceProperty( nbSeg, "max", 10000000 );
5272 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5273 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5274 "SMESH", "forget_mesh_on_hyp_modif" );
5277 // Quantities with individual precision settings
5278 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5279 setPreferenceProperty( precGroup, "columns", 2 );
5281 const int nbQuantities = 6;
5282 int precs[nbQuantities], ii = 0;
5283 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5284 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5285 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5286 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5287 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5288 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5289 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5290 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5291 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5292 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5293 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5294 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5296 // Set property for precision value for spinboxes
5297 for ( ii = 0; ii < nbQuantities; ii++ ){
5298 setPreferenceProperty( precs[ii], "min", -14 );
5299 setPreferenceProperty( precs[ii], "max", 14 );
5300 setPreferenceProperty( precs[ii], "precision", 2 );
5303 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5304 setPreferenceProperty( previewGroup, "columns", 2 );
5305 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5306 setPreferenceProperty( chunkSize, "min", 1 );
5307 setPreferenceProperty( chunkSize, "max", 1000 );
5308 setPreferenceProperty( chunkSize, "step", 50 );
5310 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5311 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5313 // Mesh tab ------------------------------------------------------------------------
5314 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5315 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5316 setPreferenceProperty( nodeGroup, "columns", 3 );
5318 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5320 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5322 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5323 QList<QVariant> aMarkerTypeIndicesList;
5324 QList<QVariant> aMarkerTypeIconsList;
5325 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5326 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5327 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5328 aMarkerTypeIndicesList << i;
5329 aMarkerTypeIconsList << pixmap;
5331 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5332 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
5334 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5336 QList<QVariant> aMarkerScaleIndicesList;
5337 QStringList aMarkerScaleValuesList;
5338 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5339 aMarkerScaleIndicesList << i;
5340 //aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5341 aMarkerScaleValuesList << QString::number( i );
5343 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5344 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5346 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5347 //setPreferenceProperty( elemGroup, "columns", 2 );
5349 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5350 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5351 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5352 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5353 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5354 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5355 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5356 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5357 addPreference( tr( "PREF_PREVIEW_COLOR" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5360 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5361 setPreferenceProperty( grpGroup, "columns", 2 );
5363 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5364 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5366 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5367 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5368 /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5369 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5370 double ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5371 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5372 double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5373 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5374 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
5375 LightApp_Preferences::IntSpin, "SMESH", "element_width");
5376 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5377 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5378 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5379 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5381 setPreferenceProperty( size0d, "min", 1 );
5382 setPreferenceProperty( size0d, "max", 10 );
5384 // setPreferenceProperty( ballSize, "min", 1 );
5385 // setPreferenceProperty( ballSize, "max", 10 );
5387 setPreferenceProperty( ballDiameter, "min", 1e-7 );
5388 setPreferenceProperty( ballDiameter, "max", 1e9 );
5389 setPreferenceProperty( ballDiameter, "step", 0.1 );
5391 setPreferenceProperty( ballScale, "min", 1e-2 );
5392 setPreferenceProperty( ballScale, "max", 1e7 );
5393 setPreferenceProperty( ballScale, "step", 0.5 );
5395 setPreferenceProperty( elemW, "min", 1 );
5396 setPreferenceProperty( elemW, "max", 5 );
5398 setPreferenceProperty( outW, "min", 1 );
5399 setPreferenceProperty( outW, "max", 5 );
5401 setPreferenceProperty( shrink, "min", 0 );
5402 setPreferenceProperty( shrink, "max", 100 );
5404 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5405 setPreferenceProperty( numGroup, "columns", 2 );
5407 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5408 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5410 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5411 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5413 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5414 setPreferenceProperty( orientGroup, "columns", 1 );
5416 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5417 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5419 setPreferenceProperty( orientScale, "min", 0.05 );
5420 setPreferenceProperty( orientScale, "max", 0.5 );
5421 setPreferenceProperty( orientScale, "step", 0.05 );
5423 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5425 // Selection tab ------------------------------------------------------------------------
5426 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5428 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5429 setPreferenceProperty( selGroup, "columns", 2 );
5431 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5432 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5434 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5435 setPreferenceProperty( preGroup, "columns", 2 );
5437 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5439 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5440 setPreferenceProperty( precSelGroup, "columns", 2 );
5442 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5443 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5444 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5446 int sinc = addPreference(tr("PREF_SELECTION_INCREMENT"), selTab, LightApp_Preferences::IntSpin, "SMESH", "selection_increment");
5447 setPreferenceProperty( sinc, "min", 0 );
5448 setPreferenceProperty( sinc, "max", 5 );
5450 // Scalar Bar tab ------------------------------------------------------------------------
5451 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5452 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5453 setPreferenceProperty( fontGr, "columns", 2 );
5455 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5456 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5458 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5459 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5461 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5462 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5464 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5465 setPreferenceProperty( numcol, "min", 2 );
5466 setPreferenceProperty( numcol, "max", 256 );
5468 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5469 setPreferenceProperty( numlab, "min", 2 );
5470 setPreferenceProperty( numlab, "max", 65 );
5472 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5473 setPreferenceProperty( orientGr, "columns", 2 );
5474 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5475 QStringList orients;
5476 orients.append( tr( "SMESH_VERTICAL" ) );
5477 orients.append( tr( "SMESH_HORIZONTAL" ) );
5478 indices.clear(); indices.append( 0 ); indices.append( 1 );
5479 setPreferenceProperty( orient, "strings", orients );
5480 setPreferenceProperty( orient, "indexes", indices );
5482 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5483 setPreferenceProperty( posVSizeGr, "columns", 2 );
5484 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5485 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5486 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5487 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5488 setPreferenceProperty( xv, "step", 0.1 );
5489 setPreferenceProperty( xv, "min", 0.0 );
5490 setPreferenceProperty( xv, "max", 1.0 );
5491 setPreferenceProperty( yv, "step", 0.1 );
5492 setPreferenceProperty( yv, "min", 0.0 );
5493 setPreferenceProperty( yv, "max", 1.0 );
5494 setPreferenceProperty( wv, "step", 0.1 );
5495 setPreferenceProperty( wv, "min", 0.0 );
5496 setPreferenceProperty( wv, "max", 1.0 );
5497 setPreferenceProperty( hv, "min", 0.0 );
5498 setPreferenceProperty( hv, "max", 1.0 );
5499 setPreferenceProperty( hv, "step", 0.1 );
5501 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5502 setPreferenceProperty( posHSizeGr, "columns", 2 );
5503 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5504 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5505 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5506 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5507 setPreferenceProperty( xv, "min", 0.0 );
5508 setPreferenceProperty( xv, "max", 1.0 );
5509 setPreferenceProperty( xv, "step", 0.1 );
5510 setPreferenceProperty( xh, "min", 0.0 );
5511 setPreferenceProperty( xh, "max", 1.0 );
5512 setPreferenceProperty( xh, "step", 0.1 );
5513 setPreferenceProperty( yh, "min", 0.0 );
5514 setPreferenceProperty( yh, "max", 1.0 );
5515 setPreferenceProperty( yh, "step", 0.1 );
5516 setPreferenceProperty( wh, "min", 0.0 );
5517 setPreferenceProperty( wh, "max", 1.0 );
5518 setPreferenceProperty( wh, "step", 0.1 );
5519 setPreferenceProperty( hh, "min", 0.0 );
5520 setPreferenceProperty( hh, "max", 1.0 );
5521 setPreferenceProperty( hh, "step", 0.1 );
5523 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5524 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5525 setPreferenceProperty( distributionGr, "columns", 3 );
5527 types.append( tr( "SMESH_MONOCOLOR" ) );
5528 types.append( tr( "SMESH_MULTICOLOR" ) );
5529 indices.clear(); indices.append( 0 ); indices.append( 1 );
5530 setPreferenceProperty( coloringType, "strings", types );
5531 setPreferenceProperty( coloringType, "indexes", indices );
5532 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5536 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5538 if ( sect=="SMESH" ) {
5539 float sbX1 = 0.01, sbY1 = 0.01, sbW = 0.08, sbH = 0.08;
5540 float aTol = 1.00000009999999;
5541 std::string aWarning;
5542 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5544 if ( name == "selection_object_color" ||
5545 name == "selection_element_color" ||
5546 name == "highlight_color" ||
5547 name == "selection_precision_node" ||
5548 name == "selection_precision_element" ||
5549 name == "selection_precision_object" ||
5550 name == "selection_increment")
5552 SMESH::UpdateSelectionProp( this );
5554 else if (name == "scalar_bar_vertical_x" || name == "scalar_bar_vertical_width")
5556 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5557 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5558 if ( sbX1+sbW > aTol ) {
5559 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5562 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5563 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5566 else if (name == "scalar_bar_vertical_y" || name == "scalar_bar_vertical_height" )
5568 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5569 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5570 if ( sbY1 + sbH > aTol ) {
5571 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5572 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5573 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5576 else if (name == "scalar_bar_horizontal_x" || name == "scalar_bar_horizontal_width")
5578 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5579 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5580 if ( sbX1 + sbW > aTol ) {
5581 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5584 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5585 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5588 else if (name == "scalar_bar_horizontal_y" || name == "scalar_bar_horizontal_height")
5590 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5591 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5592 if ( sbY1 + sbH > aTol ) {
5593 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5596 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5597 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5600 else if ( name == "segmentation" )
5602 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5603 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5605 else if ( name == "nb_segments_per_edge" )
5607 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5608 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5610 else if ( name == "historical_python_dump" || name == "forget_mesh_on_hyp_modif" || name == "default_grp_color" )
5612 QString val = aResourceMgr->stringValue( "SMESH", name );
5613 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5615 else if ( name == "numbering_node_color" || name == "numbering_node_font" )
5617 SMESH::UpdateFontProp( this );
5619 else if ( name == "numbering_elem_color" || name == "numbering_elem_font" )
5621 SMESH::UpdateFontProp( this );
5624 if ( aWarning.size() != 0 ) {
5625 aWarning += "The default values are applied instead.";
5626 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5627 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5628 QObject::tr(aWarning.c_str()));
5633 //================================================================================
5635 * \brief Update something in accordance with update flags
5636 * \param theFlags - update flags
5638 * Update viewer or/and object browser etc. in accordance with update flags ( see
5639 * LightApp_UpdateFlags enumeration ).
5641 //================================================================================
5642 void SMESHGUI::update( const int flags )
5644 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5645 SMESH::UpdateView();
5647 SalomeApp_Module::update( flags );
5650 //================================================================================
5652 * \brief Set default selection mode
5654 * SLOT called when operation committed. Sets default selection mode
5656 //================================================================================
5657 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5659 SVTK_ViewWindow* vtkWnd =
5660 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5662 vtkWnd->SetSelectionMode( ActorSelection );
5665 //================================================================================
5667 * \brief Set default selection mode
5669 * SLOT called when operation aborted. Sets default selection mode
5671 //================================================================================
5672 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5674 SVTK_ViewWindow* vtkWnd =
5675 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5677 vtkWnd->SetSelectionMode( ActorSelection );
5680 //================================================================================
5682 * \brief Creates operation with given identifier
5683 * \param id - identifier of operation to be started
5684 * \return Pointer on created operation or NULL if operation is not created
5686 * Virtual method redefined from the base class creates operation with given id.
5687 * It is called called automatically from startOperation method of base class.
5689 //================================================================================
5690 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5692 LightApp_Operation* op = 0;
5693 // to do : create operation here
5696 case SMESHOp::OpSplitBiQuadratic:
5697 op = new SMESHGUI_SplitBiQuadOp();
5699 case SMESHOp::OpConvertMeshToQuadratic:
5700 op = new SMESHGUI_ConvToQuadOp();
5702 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5703 op = new SMESHGUI_Make2DFrom3DOp();
5705 case SMESHOp::OpReorientFaces:
5706 op = new SMESHGUI_ReorientFacesOp();
5708 case SMESHOp::OpCreateMesh:
5709 op = new SMESHGUI_MeshOp( true, true );
5711 case SMESHOp::OpCreateSubMesh:
5712 op = new SMESHGUI_MeshOp( true, false );
5714 case SMESHOp::OpEditMeshOrSubMesh:
5715 case SMESHOp::OpEditMesh:
5716 case SMESHOp::OpEditSubMesh:
5717 op = new SMESHGUI_MeshOp( false );
5719 case SMESHOp::OpCompute:
5720 case SMESHOp::OpComputeSubMesh:
5721 op = new SMESHGUI_ComputeOp();
5723 case SMESHOp::OpPreCompute:
5724 op = new SMESHGUI_PrecomputeOp();
5726 case SMESHOp::OpEvaluate:
5727 op = new SMESHGUI_EvaluateOp();
5729 case SMESHOp::OpMeshOrder:
5730 op = new SMESHGUI_MeshOrderOp();
5732 case SMESHOp::OpCreateGeometryGroup:
5733 op = new SMESHGUI_GroupOnShapeOp();
5735 case SMESHOp::OpFindElementByPoint:
5736 op = new SMESHGUI_FindElemByPointOp();
5738 case SMESHOp::OpMoveNode: // Make mesh pass through point
5739 op = new SMESHGUI_MakeNodeAtPointOp();
5741 case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
5742 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5749 op = SalomeApp_Module::createOperation( id );
5753 //================================================================================
5755 * \brief Stops current operations and starts a given one
5756 * \param id - The id of the operation to start
5758 //================================================================================
5760 void SMESHGUI::switchToOperation(int id)
5762 activeStudy()->abortAllOperations();
5763 startOperation( id );
5766 LightApp_Displayer* SMESHGUI::displayer()
5769 myDisplayer = new SMESHGUI_Displayer( getApp() );
5773 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5776 int aTolerance = 64;
5777 int anIterations = 0;
5783 if( anIterations % aPeriod == 0 )
5786 if( aTolerance < 1 )
5790 aHue = (int)( 360.0 * rand() / RAND_MAX );
5793 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5794 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5795 for( ; it != itEnd; ++it )
5797 SALOMEDS::Color anAutoColor = *it;
5798 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5801 aQColor.getHsv( &h, &s, &v );
5802 if( abs( h - aHue ) < aTolerance )
5814 aColor.setHsv( aHue, 255, 255 );
5816 SALOMEDS::Color aSColor;
5817 aSColor.R = aColor.redF();
5818 aSColor.G = aColor.greenF();
5819 aSColor.B = aColor.blueF();
5824 const char* gSeparator = "_"; // character used to separate parameter names
5825 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5826 const char* gPathSep = "|"; // character used to separate paths
5829 * \brief Store visual parameters
5831 * This method is called just before the study document is saved.
5832 * Store visual parameters in AttributeParameter attribute(s)
5834 void SMESHGUI::storeVisualParameters (int savePoint)
5837 Kernel_Utils::Localizer loc;
5839 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5840 if (!appStudy || !appStudy->studyDS())
5842 _PTR(Study) studyDS = appStudy->studyDS();
5844 // componentName is used for encoding of entries when storing them in IParameters
5845 std::string componentName = myComponentSMESH->ComponentDataType();
5846 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5847 //if (!aSComponent) return;
5850 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5851 componentName.c_str(),
5853 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5855 // store custom markers
5856 if( !myMarkerMap.empty() )
5858 VTK::MarkerMap::const_iterator anIter = myMarkerMap.begin();
5859 for( ; anIter != myMarkerMap.end(); anIter++ )
5861 int anId = anIter->first;
5862 VTK::MarkerData aMarkerData = anIter->second;
5863 std::string aMarkerFileName = aMarkerData.first;
5864 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5865 if( aMarkerTexture.size() < 3 )
5866 continue; // should contain at least width, height and the first value
5868 QString aPropertyName( "texture" );
5869 aPropertyName += gSeparator;
5870 aPropertyName += QString::number( anId );
5872 QString aPropertyValue = aMarkerFileName.c_str();
5873 aPropertyValue += gPathSep;
5875 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5876 ushort aWidth = *aTextureIter++;
5877 ushort aHeight = *aTextureIter++;
5878 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5879 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5880 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5881 aPropertyValue += QString::number( *aTextureIter );
5883 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5887 // viewers counters are used for storing view_numbers in IParameters
5890 // main cycle to store parameters of displayed objects
5891 QList<SUIT_ViewManager*> lst;
5892 QList<SUIT_ViewManager*>::Iterator it;
5893 getApp()->viewManagers(lst);
5894 for (it = lst.begin(); it != lst.end(); it++)
5896 SUIT_ViewManager* vman = *it;
5897 QString vType = vman->getType();
5899 // saving VTK actors properties
5900 if (vType == SVTK_Viewer::Type())
5902 // store the clipping planes attached to the view manager
5903 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5904 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5905 if( anIter != myClippingPlaneInfoMap.end() )
5906 aClippingPlaneInfoList = anIter->second;
5908 if( !aClippingPlaneInfoList.empty() ) {
5909 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5910 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5912 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5913 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5915 QString aPropertyName( "ClippingPlane" );
5916 aPropertyName += gSeparator;
5917 aPropertyName += QString::number( vtkViewers );
5918 aPropertyName += gSeparator;
5919 aPropertyName += QString::number( anId );
5921 QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
5922 aPropertyValue += gDigitsSep;
5923 aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
5924 aPropertyValue += gDigitsSep;
5925 if ( aPlane->PlaneMode == SMESH::Absolute ) {
5926 aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
5927 aPropertyValue += gDigitsSep;
5928 aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
5929 aPropertyValue += gDigitsSep;
5930 aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
5931 aPropertyValue += gDigitsSep;
5932 aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
5933 aPropertyValue += gDigitsSep;
5934 aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
5935 aPropertyValue += gDigitsSep;
5936 aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
5937 aPropertyValue += gDigitsSep;
5938 aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
5940 else if ( aPlane->PlaneMode == SMESH::Relative ) {
5941 aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
5942 aPropertyValue += gDigitsSep;
5943 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5944 aPropertyValue += gDigitsSep;
5945 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5946 aPropertyValue += gDigitsSep;
5947 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5950 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5954 QVector<SUIT_ViewWindow*> views = vman->getViews();
5955 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5957 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5959 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5960 vtkActorCollection* allActors = aCopy.GetActors();
5961 allActors->InitTraversal();
5962 while (vtkActor* actor = allActors->GetNextActor())
5964 if (actor->GetVisibility()) // store only visible actors
5966 SMESH_Actor* aSmeshActor = 0;
5967 if (actor->IsA("SMESH_Actor"))
5968 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5969 if (aSmeshActor && aSmeshActor->hasIO())
5971 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5974 // entry is "encoded" = it does NOT contain component address,
5975 // since it is a subject to change on next component loading
5976 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5978 std::string param, vtkParam = vType.toLatin1().data();
5979 vtkParam += gSeparator;
5980 vtkParam += QString::number(vtkViewers).toLatin1().data();
5981 vtkParam += gSeparator;
5984 param = vtkParam + "Visibility";
5985 ip->setParameter(entry, param, "On");
5988 param = vtkParam + "Representation";
5989 ip->setParameter(entry, param, QString::number
5990 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5993 param = vtkParam + "IsShrunk";
5994 ip->setParameter(entry, param, QString::number
5995 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5997 // Displayed entities
5998 unsigned int aMode = aSmeshActor->GetEntityMode();
5999 bool isE = aMode & SMESH_Actor::eEdges;
6000 bool isF = aMode & SMESH_Actor::eFaces;
6001 bool isV = aMode & SMESH_Actor::eVolumes;
6002 bool is0d = aMode & SMESH_Actor::e0DElements;
6003 bool isB = aMode & SMESH_Actor::eBallElem;
6005 QString modeStr ("e");
6006 modeStr += gDigitsSep; modeStr += QString::number(isE);
6007 modeStr += gDigitsSep; modeStr += "f";
6008 modeStr += gDigitsSep; modeStr += QString::number(isF);
6009 modeStr += gDigitsSep; modeStr += "v";
6010 modeStr += gDigitsSep; modeStr += QString::number(isV);
6011 modeStr += gDigitsSep; modeStr += "0d";
6012 modeStr += gDigitsSep; modeStr += QString::number(is0d);
6013 modeStr += gDigitsSep; modeStr += "b";
6014 modeStr += gDigitsSep; modeStr += QString::number(isB);
6016 param = vtkParam + "Entities";
6017 ip->setParameter(entry, param, modeStr.toLatin1().data());
6023 aSmeshActor->GetSufaceColor(r, g, b, delta);
6024 QStringList colorStr;
6025 colorStr << "surface";
6026 colorStr << QString::number(r);
6027 colorStr << QString::number(g);
6028 colorStr << QString::number(b);
6030 colorStr << "backsurface";
6031 colorStr << QString::number(delta);
6033 aSmeshActor->GetVolumeColor(r, g, b, delta);
6034 colorStr << "volume";
6035 colorStr << QString::number(r);
6036 colorStr << QString::number(g);
6037 colorStr << QString::number(b);
6038 colorStr << QString::number(delta);
6040 aSmeshActor->GetEdgeColor(r, g, b);
6042 colorStr << QString::number(r);
6043 colorStr << QString::number(g);
6044 colorStr << QString::number(b);
6046 aSmeshActor->GetNodeColor(r, g, b);
6048 colorStr << QString::number(r);
6049 colorStr << QString::number(g);
6050 colorStr << QString::number(b);
6052 aSmeshActor->GetOutlineColor(r, g, b);
6053 colorStr << "outline";
6054 colorStr << QString::number(r);
6055 colorStr << QString::number(g);
6056 colorStr << QString::number(b);
6058 aSmeshActor->Get0DColor(r, g, b);
6059 colorStr << "elem0d";
6060 colorStr << QString::number(r);
6061 colorStr << QString::number(g);
6062 colorStr << QString::number(b);
6064 aSmeshActor->GetBallColor(r, g, b);
6066 colorStr << QString::number(r);
6067 colorStr << QString::number(g);
6068 colorStr << QString::number(b);
6070 aSmeshActor->GetFacesOrientationColor(r, g, b);
6071 colorStr << "orientation";
6072 colorStr << QString::number(r);
6073 colorStr << QString::number(g);
6074 colorStr << QString::number(b);
6076 param = vtkParam + "Colors";
6077 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
6080 QStringList sizeStr;
6082 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
6083 sizeStr << "outline";
6084 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
6085 sizeStr << "elem0d";
6086 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
6088 //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
6089 sizeStr << QString::number((double)aSmeshActor->GetBallSize());
6090 sizeStr << QString::number((double)aSmeshActor->GetBallScale());
6091 sizeStr << "shrink";
6092 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
6093 sizeStr << "orientation";
6094 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
6095 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
6097 param = vtkParam + "Sizes";
6098 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
6103 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
6104 if( aMarkerType == VTK::MT_USER ) {
6105 markerStr += "custom";
6106 markerStr += gDigitsSep;
6107 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
6111 markerStr += gDigitsSep;
6112 markerStr += QString::number( (int)aMarkerType );
6113 markerStr += gDigitsSep;
6114 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
6117 param = vtkParam + "PointMarker";
6118 ip->setParameter(entry, param, markerStr.toLatin1().data());
6121 param = vtkParam + "Opacity";
6122 ip->setParameter(entry, param,
6123 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
6126 param = vtkParam + "ClippingPlane";
6128 if( !aClippingPlaneInfoList.empty() ) {
6129 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
6130 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
6132 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
6133 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
6134 SMESH::TActorList::iterator anIter2 = anActorList.begin();
6135 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
6136 if( aSmeshActor == *anIter2 ) {
6137 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
6138 QString::number( anId ).toLatin1().constData() );
6145 ip->setParameter( entry, param, "Off" );
6146 } // if (io->hasEntry())
6147 } // SMESH_Actor && hasIO
6149 } // while.. actors traversal
6153 } // if (SVTK view model)
6154 } // for (viewManagers)
6157 // data structures for clipping planes processing
6161 bool isOpenGLClipping;
6162 vtkIdType RelativeOrientation;
6165 int AbsoluteOrientation;
6166 double X, Y, Z, Dx, Dy, Dz;
6168 typedef std::list<TPlaneData> TPlaneDataList;
6169 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
6171 typedef std::list<vtkActor*> TActorList;
6174 TActorList ActorList;
6175 SUIT_ViewManager* ViewManager;
6177 typedef std::list<TPlaneInfo> TPlaneInfoList;
6178 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
6181 * \brief Restore visual parameters
6183 * This method is called after the study document is opened.
6184 * Restore visual parameters from AttributeParameter attribute(s)
6186 void SMESHGUI::restoreVisualParameters (int savePoint)
6189 Kernel_Utils::Localizer loc;
6191 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6192 if (!appStudy || !appStudy->studyDS())
6194 _PTR(Study) studyDS = appStudy->studyDS();
6196 // componentName is used for encoding of entries when storing them in IParameters
6197 std::string componentName = myComponentSMESH->ComponentDataType();
6198 //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
6199 //if (!aSComponent) return;
6202 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6203 componentName.c_str(),
6205 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6207 // restore custom markers and map of clipping planes
6208 TPlaneDataMap aPlaneDataMap;
6210 std::vector<std::string> properties = ip->getProperties();
6211 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
6213 std::string property = *propIt;
6214 QString aPropertyName( property.c_str() );
6215 QString aPropertyValue( ip->getProperty( property ).c_str() );
6217 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
6218 if( aPropertyNameList.isEmpty() )
6221 QString aPropertyType = aPropertyNameList[0];
6222 if( aPropertyType == "texture" )
6224 if( aPropertyNameList.size() != 2 )
6228 int anId = aPropertyNameList[1].toInt( &ok );
6229 if( !ok || anId < 1 )
6232 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
6233 if( aPropertyValueList.size() != 2 )
6236 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
6237 QString aMarkerTextureString = aPropertyValueList[1];
6238 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
6239 if( aMarkerTextureStringList.size() != 3 )
6243 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6248 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6252 VTK::MarkerTexture aMarkerTexture;
6253 aMarkerTexture.push_back( aWidth );
6254 aMarkerTexture.push_back( aHeight );
6256 QString aMarkerTextureData = aMarkerTextureStringList[2];
6257 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6259 QChar aChar = aMarkerTextureData.at( i );
6260 if( aChar.isDigit() )
6261 aMarkerTexture.push_back( aChar.digitValue() );
6264 myMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6266 else if( aPropertyType == "ClippingPlane" )
6268 if( aPropertyNameList.size() != 3 )
6272 int aViewId = aPropertyNameList[1].toInt( &ok );
6273 if( !ok || aViewId < 0 )
6277 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6278 if( !ok || aClippingPlaneId < 0 )
6281 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6282 if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6285 TPlaneData aPlaneData;
6286 aPlaneData.AbsoluteOrientation = false;
6287 aPlaneData.RelativeOrientation = 0;
6288 aPlaneData.Distance = aPlaneData.Angle[0] = aPlaneData.Angle[1] = 0;
6289 aPlaneData.X = aPlaneData.Y = aPlaneData.Z = 0;
6290 aPlaneData.Dx = aPlaneData.Dy = aPlaneData.Dz = 0;
6292 aPlaneData.Id = aClippingPlaneId;
6295 aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6300 aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6304 if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6307 aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6312 aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6317 aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6322 aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6327 aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6332 aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6337 aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6341 else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6343 aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6348 aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6353 aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6358 aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6363 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6364 aPlaneDataList.push_back( aPlaneData );
6368 TPlaneInfoMap aPlaneInfoMap;
6370 std::vector<std::string> entries = ip->getEntries();
6372 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6374 // entry is a normal entry - it should be "decoded" (setting base address of component)
6375 QString entry (ip->decodeEntry(*entIt).c_str());
6377 // Check that the entry corresponds to a real object in the Study
6378 // as the object may be deleted or modified after the visual state is saved.
6379 _PTR(SObject) so = studyDS->FindObjectID(entry.toUtf8().data());
6380 if (!so) continue; //Skip the not existent entry
6382 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6383 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6385 std::vector<std::string>::iterator namesIt = paramNames.begin();
6386 std::vector<std::string>::iterator valuesIt = paramValues.begin();
6388 // actors are stored in a map after displaying of them for
6389 // quicker access in the future: map < viewID to actor >
6390 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6392 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6394 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6395 // '_' is used as separator and should not be used in viewer type or parameter names.
6396 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6397 if (lst.size() != 3)
6400 QString viewerTypStr = lst[0];
6401 QString viewIndexStr = lst[1];
6402 QString paramNameStr = lst[2];
6405 int viewIndex = viewIndexStr.toUInt(&ok);
6406 if (!ok) // bad conversion of view index to integer
6410 if (viewerTypStr == SVTK_Viewer::Type())
6412 SMESH_Actor* aSmeshActor = 0;
6413 if (vtkActors.IsBound(viewIndex))
6414 aSmeshActor = vtkActors.Find(viewIndex);
6416 QList<SUIT_ViewManager*> lst;
6417 getApp()->viewManagers(viewerTypStr, lst);
6419 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6420 SUIT_ViewManager* vman = NULL;
6421 if (viewIndex >= 0 && viewIndex < lst.count())
6422 vman = lst.at(viewIndex);
6424 if (paramNameStr == "Visibility")
6426 if (!aSmeshActor && displayer() && vman)
6428 SUIT_ViewModel* vmodel = vman->getViewModel();
6429 // SVTK view model can be casted to SALOME_View
6430 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6432 // store displayed actor in a temporary map for quicker
6433 // access later when restoring other parameters
6434 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6435 vtkRenderer* Renderer = vtkView->getRenderer();
6436 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6437 vtkActorCollection* theActors = aCopy.GetActors();
6438 theActors->InitTraversal();
6439 bool isFound = false;
6440 vtkActor *ac = theActors->GetNextActor();
6441 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6442 if (ac->IsA("SMESH_Actor")) {
6443 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6444 if (aGeomAc->hasIO()) {
6445 Handle(SALOME_InteractiveObject) io = aGeomAc->getIO();
6446 if (io->hasEntry() && strcmp(io->getEntry(), entry.toUtf8().data()) == 0) {
6448 vtkActors.Bind(viewIndex, aGeomAc);
6454 } // if (paramNameStr == "Visibility")
6457 // the rest properties "work" with SMESH_Actor
6460 QString val ((*valuesIt).c_str());
6463 if (paramNameStr == "Representation") {
6464 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6467 else if (paramNameStr == "IsShrunk") {
6469 if (!aSmeshActor->IsShrunk())
6470 aSmeshActor->SetShrink();
6473 if (aSmeshActor->IsShrunk())
6474 aSmeshActor->UnShrink();
6477 // Displayed entities
6478 else if (paramNameStr == "Entities") {
6479 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6480 int aEntityMode = SMESH_Actor::eAllEntity;
6481 for ( int i = 0; i < mode.count(); i+=2 ) {
6482 if ( i < mode.count()-1 ) {
6483 QString type = mode[i];
6484 bool val = mode[i+1].toInt();
6485 if ( type == "e" && !val )
6486 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6487 else if ( type == "f" && !val )
6488 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6489 else if ( type == "v" && !val )
6490 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6491 else if ( type == "0d" && !val )
6492 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6493 else if ( type == "b" && !val )
6494 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6497 aSmeshActor->SetEntityMode( aEntityMode );
6500 else if (paramNameStr == "Colors") {
6501 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6508 QColor outlineColor;
6509 QColor orientationColor;
6515 // below lines are required to get default values for delta coefficients
6516 // of backface color for faces and color of reversed volumes
6517 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
6518 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6519 for ( int i = 0; i < colors.count(); i++ ) {
6520 QString type = colors[i];
6521 if ( type == "surface" ) {
6522 // face color is set by 3 values r:g:b, where
6523 // - r,g,b - is rgb color components
6524 if ( i+1 >= colors.count() ) break; // format error
6525 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6526 if ( i+2 >= colors.count() ) break; // format error
6527 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6528 if ( i+3 >= colors.count() ) break; // format error
6529 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6530 faceColor.setRgbF( r, g, b );
6533 else if ( type == "backsurface" ) {
6534 // backface color can be defined in several ways
6535 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6536 // - in latest versions, it is set as delta coefficient
6537 bool rgbOk = false, deltaOk;
6538 if ( i+1 >= colors.count() ) break; // format error
6539 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6540 int delta = colors[i+1].toInt( &deltaOk );
6542 if ( i+1 < colors.count() ) // index is shifted to 1
6543 g = colors[i+1].toDouble( &rgbOk );
6544 if ( rgbOk ) i++; // shift index
6545 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6546 b = colors[i+1].toDouble( &rgbOk );
6548 // - as currently there's no way to set directly backsurface color as it was before,
6549 // we ignore old dump where r,g,b triple was set
6550 // - also we check that delta parameter is set properly
6551 if ( !rgbOk && deltaOk )
6554 else if ( type == "volume" ) {
6555 // volume color is set by 4 values r:g:b:delta, where
6556 // - r,g,b - is a normal volume rgb color components
6557 // - delta - is a reversed volume color delta coefficient
6558 if ( i+1 >= colors.count() ) break; // format error
6559 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6560 if ( i+2 >= colors.count() ) break; // format error
6561 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6562 if ( i+3 >= colors.count() ) break; // format error
6563 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6564 if ( i+4 >= colors.count() ) break; // format error
6565 int delta = colors[i+4].toInt( &bOk );
6566 if ( !bOk ) break; // format error
6567 volumeColor.setRgbF( r, g, b );
6571 else if ( type == "edge" ) {
6572 // edge color is set by 3 values r:g:b, where
6573 // - r,g,b - is rgb color components
6574 if ( i+1 >= colors.count() ) break; // format error
6575 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6576 if ( i+2 >= colors.count() ) break; // format error
6577 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6578 if ( i+3 >= colors.count() ) break; // format error
6579 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6580 edgeColor.setRgbF( r, g, b );
6583 else if ( type == "node" ) {
6584 // node 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 nodeColor.setRgbF( r, g, b );
6595 else if ( type == "elem0d" ) {
6596 // 0d element 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 elem0dColor.setRgbF( r, g, b );
6607 else if ( type == "ball" ) {
6608 // ball 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 ballColor.setRgbF( r, g, b );
6619 else if ( type == "outline" ) {
6620 // outline 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 outlineColor.setRgbF( r, g, b );
6631 else if ( type == "orientation" ) {
6632 // orientation 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 orientationColor.setRgbF( r, g, b );
6645 if ( nodeColor.isValid() )
6646 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6648 if ( edgeColor.isValid() )
6649 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6651 if ( faceColor.isValid() )
6652 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6654 if ( volumeColor.isValid() )
6655 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6656 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6657 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6659 if ( elem0dColor.isValid() )
6660 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6662 if ( ballColor.isValid() )
6663 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6665 if ( outlineColor.isValid() )
6666 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6667 // orientation color
6668 if ( orientationColor.isValid() )
6669 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6672 else if (paramNameStr == "Sizes") {
6673 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6676 int outlineWidth = -1;
6677 int elem0dSize = -1;
6678 //int ballSize = -1;
6679 double ballDiameter = -1.0;
6680 double ballScale = -1.0;
6681 double shrinkSize = -1;
6682 double orientationSize = -1;
6683 bool orientation3d = false;
6684 for ( int i = 0; i < sizes.count(); i++ ) {
6685 QString type = sizes[i];
6686 if ( type == "line" ) {
6687 // line (wireframe) width is given as single integer value
6688 if ( i+1 >= sizes.count() ) break; // format error
6689 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6693 if ( type == "outline" ) {
6694 // outline width is given as single integer value
6695 if ( i+1 >= sizes.count() ) break; // format error
6696 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6700 else if ( type == "elem0d" ) {
6701 // 0d element size is given as single integer value
6702 if ( i+1 >= sizes.count() ) break; // format error
6703 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6707 else if ( type == "ball" ) {
6708 // balls are specified by two values: size:scale, where
6709 // - size - is a integer value specifying size
6710 // - scale - is a double value specifying scale factor
6711 if ( i+1 >= sizes.count() ) break; // format error
6712 //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6713 double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6714 if ( i+2 >= sizes.count() ) break; // format error
6715 double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6721 else if ( type == "shrink" ) {
6722 // shrink factor is given as single floating point value
6723 if ( i+1 >= sizes.count() ) break; // format error
6724 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6728 else if ( type == "orientation" ) {
6729 // orientation vectors are specified by two values size:3d, where
6730 // - size - is a floating point value specifying scale factor
6731 // - 3d - is a boolean
6732 if ( i+1 >= sizes.count() ) break; // format error
6733 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6734 if ( i+2 >= sizes.count() ) break; // format error
6735 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6736 orientationSize = v1;
6737 orientation3d = (bool)v2;
6741 // line (wireframe) width
6742 if ( lineWidth > 0 )
6743 aSmeshActor->SetLineWidth( lineWidth );
6745 if ( outlineWidth > 0 )
6746 aSmeshActor->SetOutlineWidth( outlineWidth );
6747 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6748 aSmeshActor->SetOutlineWidth( lineWidth );
6750 if ( elem0dSize > 0 )
6751 aSmeshActor->Set0DSize( elem0dSize );
6753 /*if ( ballSize > 0 )
6754 aSmeshActor->SetBallSize( ballSize );*/
6756 if ( ballDiameter > 0 )
6757 aSmeshActor->SetBallSize( ballDiameter );
6759 if ( ballScale > 0.0 )
6760 aSmeshActor->SetBallScale( ballScale );
6762 if ( shrinkSize > 0 )
6763 aSmeshActor->SetShrinkFactor( shrinkSize );
6764 // orientation vectors
6765 if ( orientationSize > 0 ) {
6766 aSmeshActor->SetFacesOrientationScale( orientationSize );
6767 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6771 else if (paramNameStr == "PointMarker") {
6772 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6773 if( data.count() >= 2 ) {
6775 int aParam1 = data[1].toInt( &ok );
6777 if( data[0] == "std" && data.count() == 3 ) {
6778 int aParam2 = data[2].toInt( &ok );
6779 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6781 else if( data[0] == "custom" ) {
6782 VTK::MarkerMap::const_iterator markerIt = myMarkerMap.find( aParam1 );
6783 if( markerIt != myMarkerMap.end() ) {
6784 VTK::MarkerData aMarkerData = markerIt->second;
6785 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6792 else if (paramNameStr == "Opacity") {
6793 aSmeshActor->SetOpacity(val.toFloat());
6796 else if (paramNameStr.startsWith("ClippingPlane")) {
6797 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6798 // old format - val looks like "Off" or "1:0:0:0.5:0:0"
6799 // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
6800 // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
6801 // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
6802 // new format - val looks like "Off" or "0" (plane id)
6803 // (note: in new format "Off" value is used only for consistency,
6804 // so it is processed together with values in old format)
6805 bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
6806 if( anIsOldFormat ) {
6807 if (paramNameStr == "ClippingPlane1" || val == "Off")
6808 aSmeshActor->RemoveAllClippingPlanes();
6810 QList<SUIT_ViewManager*> lst;
6811 getApp()->viewManagers(viewerTypStr, lst);
6812 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6813 if (viewIndex >= 0 && viewIndex < lst.count()) {
6814 SUIT_ViewManager* vman = lst.at(viewIndex);
6815 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6817 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6819 SMESH::TActorList anActorList;
6820 anActorList.push_back( aSmeshActor );
6821 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
6822 aPlane->myViewWindow = vtkView;
6823 SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
6824 aPlane->PlaneMode = aMode;
6825 bool isOpenGLClipping = ( bool )vals[1].toInt();
6826 aPlane->IsOpenGLClipping = isOpenGLClipping;
6827 if ( aMode == SMESH::Absolute ) {
6828 aPlane->myAbsoluteOrientation = vals[2].toInt();
6829 aPlane->X = vals[3].toFloat();
6830 aPlane->Y = vals[4].toFloat();
6831 aPlane->Z = vals[5].toFloat();
6832 aPlane->Dx = vals[6].toFloat();
6833 aPlane->Dy = vals[7].toFloat();
6834 aPlane->Dz = vals[8].toFloat();
6836 else if ( aMode == SMESH::Relative ) {
6837 aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
6838 aPlane->myDistance = vals[3].toFloat();
6839 aPlane->myAngle[0] = vals[4].toFloat();
6840 aPlane->myAngle[1] = vals[5].toFloat();
6844 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6845 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6846 aClippingPlaneInfo.Plane = aPlane;
6847 aClippingPlaneInfo.ActorList = anActorList;
6848 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6856 int aPlaneId = val.toInt( &ok );
6857 if( ok && aPlaneId >= 0 ) {
6858 bool anIsDefinedPlane = false;
6859 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6860 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6861 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6862 TPlaneInfo& aPlaneInfo = *anIter;
6863 if( aPlaneInfo.PlaneId == aPlaneId ) {
6864 aPlaneInfo.ActorList.push_back( aSmeshActor );
6865 anIsDefinedPlane = true;
6869 if( !anIsDefinedPlane ) {
6870 TPlaneInfo aPlaneInfo;
6871 aPlaneInfo.PlaneId = aPlaneId;
6872 aPlaneInfo.ActorList.push_back( aSmeshActor );
6873 aPlaneInfo.ViewManager = vman;
6875 // to make the list sorted by plane id
6876 anIter = aPlaneInfoList.begin();
6877 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6878 const TPlaneInfo& aPlaneInfoRef = *anIter;
6879 if( aPlaneInfoRef.PlaneId > aPlaneId )
6882 aPlaneInfoList.insert( anIter, aPlaneInfo );
6887 } // if (aSmeshActor)
6888 } // other parameters than Visibility
6890 } // for names/parameters iterator
6891 } // for entries iterator
6893 // take into account planes with empty list of actors referred to them
6894 QList<SUIT_ViewManager*> aVMList;
6895 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6897 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6898 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6899 int aViewId = aPlaneDataIter->first;
6900 if( aViewId >= 0 && aViewId < aVMList.count() ) {
6901 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6903 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6905 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6906 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6907 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6908 const TPlaneData& aPlaneData = *anIter2;
6909 int aPlaneId = aPlaneData.Id;
6911 bool anIsFound = false;
6912 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6913 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6914 const TPlaneInfo& aPlaneInfo = *anIter3;
6915 if( aPlaneInfo.PlaneId == aPlaneId ) {
6922 TPlaneInfo aPlaneInfo; // ActorList field is empty
6923 aPlaneInfo.PlaneId = aPlaneId;
6924 aPlaneInfo.ViewManager = aViewManager;
6926 // to make the list sorted by plane id
6927 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6928 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6929 const TPlaneInfo& aPlaneInfoRef = *anIter4;
6930 if( aPlaneInfoRef.PlaneId > aPlaneId )
6933 aPlaneInfoList.insert( anIter4, aPlaneInfo );
6939 // add clipping planes to actors according to the restored parameters
6940 // and update the clipping plane map
6941 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6942 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6943 int aViewId = anIter1->first;
6944 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6946 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6947 if( anIter2 == aPlaneDataMap.end() )
6949 const TPlaneDataList& aPlaneDataList = anIter2->second;
6951 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6952 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6953 const TPlaneInfo& aPlaneInfo = *anIter3;
6954 int aPlaneId = aPlaneInfo.PlaneId;
6955 const TActorList& anActorList = aPlaneInfo.ActorList;
6956 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6960 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6964 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6966 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6967 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6968 const TPlaneData& aPlaneData = *anIter4;
6969 if( aPlaneData.Id == aPlaneId ) {
6970 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
6971 aPlane->myViewWindow = aViewWindow;
6972 aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
6973 aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
6974 if ( aPlane->PlaneMode == SMESH::Absolute ) {
6975 aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
6976 aPlane->X = aPlaneData.X;
6977 aPlane->Y = aPlaneData.Y;
6978 aPlane->Z = aPlaneData.Z;
6979 aPlane->Dx = aPlaneData.Dx;
6980 aPlane->Dy = aPlaneData.Dy;
6981 aPlane->Dz = aPlaneData.Dz;
6983 else if ( aPlane->PlaneMode == SMESH::Relative ) {
6984 aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
6985 aPlane->myDistance = aPlaneData.Distance;
6986 aPlane->myAngle[0] = aPlaneData.Angle[0];
6987 aPlane->myAngle[1] = aPlaneData.Angle[1];
6990 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6991 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6992 aClippingPlaneInfo.Plane = aPlane;
6993 aClippingPlaneInfo.ActorList = anActorList;
6994 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
7005 // update all VTK views
7006 QList<SUIT_ViewManager*> lst;
7007 getApp()->viewManagers(lst);
7008 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
7009 SUIT_ViewModel* vmodel = (*it)->getViewModel();
7010 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
7011 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
7012 // set OpenGL clipping planes
7013 VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
7014 vtkActorCollection* anAllActors = aCopy.GetActors();
7015 anAllActors->InitTraversal();
7016 while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
7017 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
7018 anActor->SetOpenGLClippingPlane();
7020 vtkView->getRenderer()->ResetCameraClippingRange();
7027 \brief Adds preferences for dfont of VTK viewer
7029 \param pIf group identifier
7030 \param param parameter
7031 \return identifier of preferences
7033 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
7035 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
7037 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
7040 fam.append( tr( "SMESH_FONT_ARIAL" ) );
7041 fam.append( tr( "SMESH_FONT_COURIER" ) );
7042 fam.append( tr( "SMESH_FONT_TIMES" ) );
7044 setPreferenceProperty( tfont, "fonts", fam );
7046 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
7047 if ( needSize ) f = f | QtxFontEdit::Size;
7048 setPreferenceProperty( tfont, "features", f );
7054 \brief Actions after hypothesis edition
7055 Updates object browser after hypothesis edition
7057 void SMESHGUI::onHypothesisEdit( int result )
7060 SMESHGUI::Modified();
7061 updateObjBrowser( true );
7065 \brief Actions after choosing menu of control modes
7066 Updates control mode actions according to current selection
7068 void SMESHGUI::onUpdateControlActions()
7070 SALOME_ListIO selected;
7071 if ( LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr() )
7072 aSel->selectedObjects( selected );
7074 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
7075 if ( selected.Extent() ) {
7076 if ( selected.First()->hasEntry() ) {
7077 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( selected.First()->getEntry() )) {
7078 aControl = anActor->GetControlMode();
7079 SALOME_ListIteratorOfListIO it(selected);
7080 for ( it.Next(); it.More(); it.Next() ) {
7081 Handle(SALOME_InteractiveObject) anIO = it.Value();
7082 if ( anIO->hasEntry() ) {
7083 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
7084 if ( aControl != anActor->GetControlMode() ) {
7085 aControl = SMESH_Actor::eNone;
7095 int anAction = ActionToControl( aControl, true );
7097 action( anAction )->setChecked( true );
7099 QMenu* send = (QMenu*)sender();
7100 QList<QAction*> actions = send->actions();
7101 for ( int i = 0; i < actions.size(); i++ )
7102 actions[i]->setChecked( false );
7108 \brief Signal handler closing(SUIT_ViewWindow*) of a view
7109 \param pview view being closed
7111 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
7112 #ifndef DISABLE_PLOT2DVIEWER
7113 //Crear all Plot2d Viewers if need.
7114 SMESH::ClearPlot2Viewers(pview);
7116 EmitSignalCloseView();
7119 void SMESHGUI::message( const QString& msg )
7122 QStringList data = msg.split("/");
7123 if ( data.count() > 0 ) {
7124 if ( data.first() == "mesh_loading" ) {
7126 QString entry = data.count() > 1 ? data[1] : QString();
7127 if ( entry.isEmpty() )
7130 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
7132 _PTR(SObject) obj = study->FindObjectID( entry.toUtf8().constData() );
7135 name = SMESH::fromUtf8(obj->GetName());
7136 if ( name.isEmpty() )
7139 if ( data.last() == "stop" )
7140 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
7142 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
7143 QApplication::processEvents();
7149 \brief Connects or disconnects signals about activating and cloning view on the module slots
7150 \param pview view which is connected/disconnected
7152 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
7156 SUIT_ViewManager* viewMgr = pview->getViewManager();
7158 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7159 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7161 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7162 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7167 \brief Return \c true if object can be renamed
7169 bool SMESHGUI::renameAllowed( const QString& entry) const {
7170 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7174 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7178 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
7183 if(appStudy->isComponent(entry) || obj->isReference())
7186 // check type to prevent renaming of inappropriate objects
7187 int aType = SMESHGUI_Selection::type(qPrintable(entry));
7188 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7189 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7190 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7191 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7192 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
7199 Rename object by entry.
7200 \param entry entry of the object
7201 \param name new name of the object
7202 \brief Return \c true if rename operation finished successfully, \c false otherwise.
7204 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
7206 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7210 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7215 _PTR(Study) aStudy = appStudy->studyDS();
7220 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
7222 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
7227 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
7228 _PTR(GenericAttribute) anAttr;
7229 _PTR(AttributeName) aName;
7231 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
7233 // check type to prevent renaming of inappropriate objects
7234 int aType = SMESHGUI_Selection::type( qPrintable(entry));
7235 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7236 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7237 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7238 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7239 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
7240 if ( !name.isEmpty() ) {
7241 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qUtf8Printable(name) );
7243 // update name of group object and its actor
7244 Handle(SALOME_InteractiveObject) IObject =
7245 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
7247 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
7248 if( !aGroupObject->_is_nil() ) {
7249 aGroupObject->SetName( qUtf8Printable(name) );
7250 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
7251 anActor->setName( qUtf8Printable(name) );
7261 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
7263 static QList<QColor> colors;
7265 if ( colors.isEmpty() ) {
7267 for (int s = 0; s < 2 ; s++)
7269 for (int v = 100; v >= 40; v = v - 20)
7271 for (int h = 0; h < 359 ; h = h + 60)
7273 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
7278 static int currentColor = randomize( colors.size() );
7280 SALOMEDS::Color color;
7281 color.R = (double)colors[currentColor].red() / 255.0;
7282 color.G = (double)colors[currentColor].green() / 255.0;
7283 color.B = (double)colors[currentColor].blue() / 255.0;
7285 currentColor = (currentColor+1) % colors.count();