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