1 // Copyright (C) 2007-2016 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_Displayer.h"
44 #include "SMESHGUI_DuplicateNodesDlg.h"
45 #include "SMESHGUI_ExtrusionAlongPathDlg.h"
46 #include "SMESHGUI_ExtrusionDlg.h"
47 #include "SMESHGUI_FieldSelectorWdg.h"
48 #include "SMESHGUI_FileInfoDlg.h"
49 #include "SMESHGUI_FileValidator.h"
50 #include "SMESHGUI_FilterDlg.h"
51 #include "SMESHGUI_FilterLibraryDlg.h"
52 #include "SMESHGUI_FindElemByPointDlg.h"
53 #include "SMESHGUI_GroupDlg.h"
54 #include "SMESHGUI_GroupOnShapeDlg.h"
55 #include "SMESHGUI_GroupOpDlg.h"
56 #include "SMESHGUI_Hypotheses.h"
57 #include "SMESHGUI_Make2DFrom3DOp.h"
58 #include "SMESHGUI_MakeNodeAtPointDlg.h"
59 #include "SMESHGUI_Measurements.h"
60 #include "SMESHGUI_MergeDlg.h"
61 #include "SMESHGUI_MeshInfo.h"
62 #include "SMESHGUI_MeshOp.h"
63 #include "SMESHGUI_MeshOrderOp.h"
64 #include "SMESHGUI_MeshPatternDlg.h"
65 #include "SMESHGUI_MultiEditDlg.h"
66 #include "SMESHGUI_NodesDlg.h"
67 #include "SMESHGUI_Operations.h"
68 #include "SMESHGUI_Preferences_ScalarBarDlg.h"
69 #include "SMESHGUI_PropertiesDlg.h"
70 #include "SMESHGUI_RemoveElementsDlg.h"
71 #include "SMESHGUI_RemoveNodesDlg.h"
72 #include "SMESHGUI_RenumberingDlg.h"
73 #include "SMESHGUI_ReorientFacesDlg.h"
74 #include "SMESHGUI_RevolutionDlg.h"
75 #include "SMESHGUI_RotationDlg.h"
76 #include "SMESHGUI_ScaleDlg.h"
77 #include "SMESHGUI_Selection.h"
78 #include "SMESHGUI_SewingDlg.h"
79 #include "SMESHGUI_SingleEditDlg.h"
80 #include "SMESHGUI_SmoothingDlg.h"
81 #include "SMESHGUI_SymmetryDlg.h"
82 #include "SMESHGUI_TranslationDlg.h"
83 #include "SMESHGUI_TransparencyDlg.h"
84 #include "SMESHGUI_DisplayEntitiesDlg.h"
85 #include "SMESHGUI_SplitBiQuad.h"
87 #include "SMESHGUI_FilterUtils.h"
88 #include "SMESHGUI_GEOMGenUtils.h"
89 #include "SMESHGUI_GroupUtils.h"
90 #include "SMESHGUI_HypothesesUtils.h"
91 #include "SMESHGUI_MeshUtils.h"
92 #include "SMESHGUI_PatternUtils.h"
93 #include "SMESHGUI_Utils.h"
94 #include "SMESHGUI_VTKUtils.h"
96 #include "SMESH_version.h"
98 #include "SMESH_ControlsDef.hxx"
99 #include "SMESH_Actor.h"
100 #include "SMESH_ActorUtils.h"
101 #include "SMESH_Client.hxx"
102 #include "SMESH_ScalarBarActor.h"
103 #include "SMESH_TypeFilter.hxx"
105 // SALOME GUI includes
106 #include <SalomeApp_Application.h>
107 #include <SalomeApp_CheckFileDlg.h>
108 #include <SalomeApp_DataObject.h>
109 #include <SalomeApp_Study.h>
110 #include <SalomeApp_Tools.h>
112 #include <LightApp_DataOwner.h>
113 #include <LightApp_NameDlg.h>
114 #include <LightApp_Preferences.h>
115 #include <LightApp_SelectionMgr.h>
116 #include <LightApp_UpdateFlags.h>
118 #include <SVTK_ViewManager.h>
119 #include <SVTK_ViewModel.h>
120 #include <SVTK_ViewWindow.h>
122 #include <VTKViewer_Algorithm.h>
124 #include <SUIT_Desktop.h>
125 #include <SUIT_FileDlg.h>
126 #include <SUIT_MessageBox.h>
127 #include <SUIT_OverrideCursor.h>
128 #include <SUIT_ResourceMgr.h>
129 #include <SUIT_Session.h>
131 #include <QtxPopupMgr.h>
132 #include <QtxFontEdit.h>
134 #include <SALOME_ListIO.hxx>
136 #ifndef DISABLE_PLOT2DVIEWER
137 #include <SPlot2d_ViewModel.h>
138 #include <SPlot2d_Histogram.h>
142 #include <SALOMEconfig.h>
143 #include CORBA_CLIENT_HEADER(SALOMEDS_Attributes)
144 #include CORBA_CLIENT_HEADER(SMESH_MeshEditor)
145 #include CORBA_CLIENT_HEADER(SMESH_Measurements)
148 // #define INCLUDE_MENUITEM_DEF // VSR commented ????????
149 #include <QApplication>
151 #include <QTextStream>
156 #include <QDialogButtonBox>
159 #include <boost/shared_ptr.hpp>
162 #include <vtkCallbackCommand.h>
163 #include <vtkCamera.h>
164 #include <vtkLookupTable.h>
165 #include <vtkPlane.h>
166 #include <vtkRenderer.h>
168 // SALOME KERNEL includes
169 #include <SALOMEDSClient_ClientFactory.hxx>
170 #include <SALOMEDSClient_IParameters.hxx>
171 #include <SALOMEDSClient_SComponent.hxx>
172 #include <SALOMEDSClient_StudyBuilder.hxx>
173 #include <SALOMEDS_Study.hxx>
174 #include <SALOMEDS_SObject.hxx>
175 #include "utilities.h"
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, SMESHGUI_StudyId2MarkerMap& 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 (*.sauv*)" ) );
242 filter.append( QObject::tr( "All files (*)" ) );
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::GetActiveStudyDocument();
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)
494 if(dontShowCheckBox.checkState() == Qt::Checked)
497 resMgr->setValue( "SMESH", "show_warning", false);
505 QString aMeshName = anIObject->getName();
507 // check for name duplications
508 if ( !hasDuplicatedMeshNames )
509 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
510 if( aMeshName == (*aMeshIter).second ) {
511 hasDuplicatedMeshNames = true;
516 aMeshList.append( QPair< SMESH::SMESH_IDSource_var, QString >( aMeshItem, aMeshName ) );
519 if( hasDuplicatedMeshNames && isMED ) {
520 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
521 QObject::tr("SMESH_WRN_WARNING"),
522 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_MESH_NAMES"),
523 QObject::tr("SMESH_BUT_YES"),
524 QObject::tr("SMESH_BUT_NO"), 0, 1);
529 aMeshIter = aMeshList.begin();
530 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
531 SMESH::SMESH_Mesh_var aMesh = aMeshOrGroup->GetMesh();
532 QString aMeshName = (*aMeshIter).second;
534 if ( isMED || isCGNS || isSAUV ) // formats where group names must be unique
536 // check for equal group names within each mesh
537 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
538 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
539 if ( !aMeshItem->_is_nil() && aMeshItem->HasDuplicatedGroupNamesMED()) {
540 int aRet = SUIT_MessageBox::warning
541 (SMESHGUI::desktop(),
542 QObject::tr("SMESH_WRN_WARNING"),
543 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_GRP").arg((*aMeshIter).second),
544 QObject::tr("SMESH_BUT_YES"),
545 QObject::tr("SMESH_BUT_NO"), 0, 1);
552 // Warn the user about presence of not supported elements
554 std::vector< SMESH::EntityType > notSupportedElemTypes, presentNotSupported;
558 notSupportedElemTypes.push_back( SMESH::Entity_0D );
559 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
564 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
565 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
566 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
567 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
568 notSupportedElemTypes.push_back( SMESH::Entity_Pyramid );
569 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
570 notSupportedElemTypes.push_back( SMESH::Entity_0D );
571 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
576 notSupportedElemTypes.push_back( SMESH::Entity_Edge );
577 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Edge );
578 notSupportedElemTypes.push_back( SMESH::Entity_0D );
579 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
584 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
589 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
590 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Triangle );
591 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Quadrangle );
592 notSupportedElemTypes.push_back( SMESH::Entity_TriQuad_Hexa );
593 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
594 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
595 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
596 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
601 notSupportedElemTypes.push_back( SMESH::Entity_0D );
602 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
603 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
604 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Pyramid );
605 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Penta );
606 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
607 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
608 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
609 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
611 if ( ! notSupportedElemTypes.empty() )
613 SMESH::long_array_var nbElems = aMeshOrGroup->GetMeshInfo();
614 for ( size_t iType = 0; iType < notSupportedElemTypes.size(); ++iType )
615 if ( nbElems[ notSupportedElemTypes[ iType ]] > 0 )
616 presentNotSupported.push_back( notSupportedElemTypes[ iType ]);
618 if ( !presentNotSupported.empty() )
621 const char* typeMsg[] = {
622 "SMESH_NODES", "SMESH_ELEMS0D","SMESH_EDGES","SMESH_QUADRATIC_EDGES",
623 "SMESH_TRIANGLES", "SMESH_QUADRATIC_TRIANGLES", "SMESH_BIQUADRATIC_TRIANGLES",
624 "SMESH_QUADRANGLES","SMESH_QUADRATIC_QUADRANGLES", "SMESH_BIQUADRATIC_QUADRANGLES",
625 "SMESH_POLYGONS","SMESH_QUADRATIC_POLYGONS",
626 "SMESH_TETRAHEDRA","SMESH_QUADRATIC_TETRAHEDRONS","SMESH_PYRAMIDS",
627 "SMESH_QUADRATIC_PYRAMIDS","SMESH_HEXAHEDRA","SMESH_QUADRATIC_HEXAHEDRONS",
628 "SMESH_TRIQUADRATIC_HEXAHEDRONS","SMESH_PENTAHEDRA","SMESH_QUADRATIC_PENTAHEDRONS",
629 "SMESH_OCTAHEDRA","SMESH_POLYEDRONS","SMESH_QUADRATIC_POLYEDRONS","SMESH_BALLS"
631 // is typeMsg complete? (compilation failure mains that enum SMDSAbs_EntityType changed)
632 const int nbTypes = sizeof( typeMsg ) / sizeof( const char* );
633 int _assert[( nbTypes == SMESH::Entity_Last ) ? 2 : -1 ]; _assert[0]=_assert[1];
635 QString andStr = " " + QObject::tr("SMESH_AND") + " ", comma(", ");
636 for ( size_t iType = 0; iType < presentNotSupported.size(); ++iType ) {
637 typeNames += QObject::tr( typeMsg[ presentNotSupported[ iType ]]);
638 if ( iType != presentNotSupported.size() - 1 )
639 typeNames += ( iType == presentNotSupported.size() - 2 ) ? andStr : comma;
641 int aRet = SUIT_MessageBox::warning
642 (SMESHGUI::desktop(),
643 QObject::tr("SMESH_WRN_WARNING"),
644 QObject::tr("EXPORT_NOT_SUPPORTED").arg(aMeshName).arg(format).arg(typeNames),
645 QObject::tr("SMESH_BUT_YES"),
646 QObject::tr("SMESH_BUT_NO"), 0, 1);
651 // Get parameters of export operation
654 SMESH::MED_VERSION aFormat = SMESH::MED_V2_2;
655 // Init the parameters with the default values
656 bool aIsASCII_STL = true;
657 bool toCreateGroups = false;
659 toCreateGroups = resMgr->booleanValue( "SMESH", "auto_groups", false );
660 bool toOverwrite = true;
661 bool toFindOutDim = true;
663 QString aFilter, aTitle = QObject::tr("SMESH_EXPORT_MESH");
664 QString anInitialPath = "";
665 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
666 anInitialPath = QDir::currentPath();
668 QList< QPair< GEOM::ListOfFields_var, QString > > aFieldList;
670 // Get a file name to write in and additional otions
671 if ( isUNV || isDAT || isGMF ) // Export w/o options
674 aFilter = QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)";
676 aFilter = QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)";
678 aFilter = QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" +
679 ";;" + QObject::tr( "GMF_BINARY_FILES_FILTER" ) + " (*.meshb)";
680 if ( anInitialPath.isEmpty() ) anInitialPath = SUIT_FileDlg::getLastVisitedPath();
681 aFilename = SUIT_FileDlg::getFileName(SMESHGUI::desktop(),
682 anInitialPath + QString("/") + aMeshName,
683 aFilter, aTitle, false);
685 else if ( isCGNS )// Export to CGNS
687 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
688 fd->setWindowTitle( aTitle );
689 fd->setNameFilter( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
690 if ( !anInitialPath.isEmpty() )
691 fd->setDirectory( anInitialPath );
692 fd->selectFile(aMeshName);
693 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
694 fd->setValidator( fv );
697 aFilename = fd->selectedFile();
698 toOverwrite = fv->isOverwrite();
702 else if ( isSTL ) // Export to STL
704 QMap<QString, int> aFilterMap;
705 aFilterMap.insert( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)", 1 );
706 aFilterMap.insert( QObject::tr( "STL_BIN_FILES_FILTER" ) + " (*.stl)", 0 );
709 QMap<QString, int>::const_iterator it = aFilterMap.begin();
710 for ( ; it != aFilterMap.end(); ++it )
711 filters.push_back( it.key() );
713 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
714 fd->setWindowTitle( aTitle );
715 fd->setNameFilters( filters );
716 fd->selectNameFilter( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
717 if ( !anInitialPath.isEmpty() )
718 fd->setDirectory( anInitialPath );
719 fd->selectFile(aMeshName);
723 aFilename = fd->selectedFile();
724 aIsASCII_STL = (aFilterMap[fd->selectedNameFilter()]) == 1 ? true: false;
729 else if ( isMED || isSAUV ) // Export to MED or SAUV
731 QMap<QString, SMESH::MED_VERSION> aFilterMap;
732 //QString v21 (aMesh->GetVersionString(SMESH::MED_V2_1, 2));
734 QString v22 (aMesh->GetVersionString(SMESH::MED_V2_2, 2));
735 //aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v21 ) + " (*.med)", SMESH::MED_V2_1 );
736 aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v22 ) + " (*.med)", SMESH::MED_V2_2 );
739 aFilterMap.insert("All files (*)", SMESH::MED_V2_1 );
740 aFilterMap.insert("SAUV files (*.sauv)", SMESH::MED_V2_2 );
741 aFilterMap.insert("SAUV files (*.sauve)", SMESH::MED_V2_1 );
745 QString aDefaultFilter;
746 QMap<QString, SMESH::MED_VERSION>::const_iterator it = aFilterMap.begin();
747 for ( ; it != aFilterMap.end(); ++it ) {
748 filters.push_back( it.key() );
749 if (it.value() == SMESH::MED_V2_2)
750 aDefaultFilter = it.key();
752 QStringList checkBoxes;
753 checkBoxes << QObject::tr("SMESH_AUTO_GROUPS") << QObject::tr("SMESH_AUTO_DIM");
755 SMESHGUI_FieldSelectorWdg* fieldSelWdg = new SMESHGUI_FieldSelectorWdg();
756 QList< QWidget* > wdgList;
757 if ( fieldSelWdg->GetAllFeilds( aMeshList, aFieldList ))
758 wdgList.append( fieldSelWdg );
760 SalomeApp_CheckFileDlg* fd =
761 new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true, wdgList );
762 fd->setWindowTitle( aTitle );
763 fd->setNameFilters( filters );
764 fd->selectNameFilter( aDefaultFilter );
765 fd->SetChecked( toCreateGroups, 0 );
766 fd->SetChecked( toFindOutDim, 1 );
767 if ( !anInitialPath.isEmpty() )
768 fd->setDirectory( anInitialPath );
769 fd->selectFile(aMeshName);
772 QListView *lview = fd->findChild<QListView*>("listView");
774 lview->setMinimumHeight(200);
776 QTreeView *tview = fd->findChild<QTreeView*>("treeView");
778 tview->setMinimumHeight(200);
781 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
782 fd->setValidator( fv );
787 aFilename = fd->selectedFile();
789 aFilename = QString::null;
792 aFormat = aFilterMap[fd->selectedNameFilter()];
793 toOverwrite = fv->isOverwrite();
795 if ( !aFilename.isEmpty() ) {
796 // med-2.1 does not support poly elements
797 if ( aFormat==SMESH::MED_V2_1 )
798 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
799 SMESH::SMESH_IDSource_var aMeshItem = (*aMeshIter).first;
800 SMESH::long_array_var nbElems = aMeshItem->GetMeshInfo();
801 if ( nbElems[ SMESH::Entity_Polygon ] + nbElems[ SMESH::Entity_Quad_Polygon ] +
802 nbElems[ SMESH::Entity_Polyhedra ] + nbElems[ SMESH::Entity_Quad_Polyhedra ])
804 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
805 QObject::tr("SMESH_WRN_WARNING"),
806 QObject::tr("SMESH_EXPORT_MED_V2_1").arg((*aMeshIter).second),
807 QObject::tr("SMESH_BUT_YES"),
808 QObject::tr("SMESH_BUT_NO"), 0, 1);
816 // can't append to an existing using other format
817 SMESH::MED_VERSION aVersion = SMESH::MED_V2_1;
818 bool isVersionOk = SMESHGUI::GetSMESHGen()->GetMEDVersion( aFilename.toUtf8().constData(), aVersion );
819 if( !isVersionOk || aVersion != aFormat ) {
820 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
821 QObject::tr("SMESH_WRN_WARNING"),
822 QObject::tr("SMESH_EXPORT_MED_VERSION_COLLISION").arg(aFilename),
823 QObject::tr("SMESH_BUT_YES"),
824 QObject::tr("SMESH_BUT_NO"), 0, 1);
831 QStringList aMeshNamesCollisionList;
832 SMESH::string_array_var aMeshNames = SMESHGUI::GetSMESHGen()->GetMeshNames( aFilename.toUtf8().constData() );
833 for( int i = 0, n = aMeshNames->length(); i < n; i++ ) {
834 QString anExistingMeshName( aMeshNames[ i ] );
835 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
836 QString anExportMeshName = (*aMeshIter).second;
837 if( anExportMeshName == anExistingMeshName ) {
838 aMeshNamesCollisionList.append( anExportMeshName );
843 if( !aMeshNamesCollisionList.isEmpty() ) {
844 QString aMeshNamesCollisionString = aMeshNamesCollisionList.join( ", " );
845 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
846 QObject::tr("SMESH_WRN_WARNING"),
847 QObject::tr("SMESH_EXPORT_MED_MESH_NAMES_COLLISION").arg(aMeshNamesCollisionString),
848 QObject::tr("SMESH_BUT_YES"),
849 QObject::tr("SMESH_BUT_NO"),
850 QObject::tr("SMESH_BUT_CANCEL"), 0, 2);
859 toCreateGroups = fd->IsChecked(0);
860 toFindOutDim = fd->IsChecked(1);
861 fieldSelWdg->GetSelectedFeilds();
862 if ( !fieldSelWdg->parent() )
873 if ( !aFilename.isEmpty() ) {
874 // Check whether the file already exists and delete it if yes
875 QFile aFile( aFilename );
876 if ( aFile.exists() && toOverwrite )
878 SUIT_OverrideCursor wc;
881 // Renumbering is not needed since SMDS redesign in V6.2.0 (Nov 2010)
882 // bool Renumber = false;
883 // // PAL 14172 : Check of we have to renumber or not from the preferences before export
885 // Renumber= resMgr->booleanValue("renumbering");
887 // SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
888 // aMeshEditor->RenumberNodes();
889 // aMeshEditor->RenumberElements();
890 // if ( SMESHGUI::automaticUpdate() )
891 // SMESH::UpdateView();
895 aMeshIter = aMeshList.begin();
896 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
898 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
899 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
900 const GEOM::ListOfFields& fields = aFieldList[ aMeshIndex ].first.in();
901 const QString& geoAssFields = aFieldList[ aMeshIndex ].second;
902 const bool hasFields = ( fields.length() || !geoAssFields.isEmpty() );
903 if ( !hasFields && aMeshOrGroup->_is_equivalent( aMeshItem ))
904 aMeshItem->ExportToMEDX( aFilename.toUtf8().data(), toCreateGroups,
905 aFormat, toOverwrite && aMeshIndex == 0, toFindOutDim );
907 aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups,
908 aFormat, toOverwrite && aMeshIndex == 0, toFindOutDim,
909 fields, geoAssFields.toLatin1().data() );
914 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ )
916 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
917 if( !aMeshItem->_is_nil() )
918 aMeshItem->ExportSAUV( aFilename.toUtf8().data(), toCreateGroups );
923 if ( aMeshOrGroup->_is_equivalent( aMesh ))
924 aMesh->ExportDAT( aFilename.toUtf8().data() );
926 aMesh->ExportPartToDAT( aMeshOrGroup, aFilename.toUtf8().data() );
930 if ( aMeshOrGroup->_is_equivalent( aMesh ))
931 aMesh->ExportUNV( aFilename.toUtf8().data() );
933 aMesh->ExportPartToUNV( aMeshOrGroup, aFilename.toUtf8().data() );
937 if ( aMeshOrGroup->_is_equivalent( aMesh ))
938 aMesh->ExportSTL( aFilename.toUtf8().data(), aIsASCII_STL );
940 aMesh->ExportPartToSTL( aMeshOrGroup, aFilename.toUtf8().data(), aIsASCII_STL );
944 aMeshIter = aMeshList.begin();
945 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
947 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
948 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
949 aMeshItem->ExportCGNS( aMeshOrGroup,
950 aFilename.toUtf8().data(),
951 toOverwrite && aMeshIndex == 0 );
956 toCreateGroups = true;
957 aMesh->ExportGMF( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups );
960 catch (const SALOME::SALOME_Exception& S_ex){
962 SUIT_MessageBox::warning(SMESHGUI::desktop(),
963 QObject::tr("SMESH_WRN_WARNING"),
964 QObject::tr("SMESH_EXPORT_FAILED"));
970 inline void InverseEntityMode(unsigned int& theOutputMode,
971 unsigned int theMode)
973 bool anIsNotPresent = ~theOutputMode & theMode;
975 theOutputMode |= theMode;
977 theOutputMode &= ~theMode;
980 void SetDisplayEntity(int theCommandID)
982 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
983 SALOME_ListIO selected;
985 aSel->selectedObjects( selected );
987 if ( selected.Extent() >= 1 ) {
988 SUIT_OverrideCursor wc;
989 SALOME_ListIteratorOfListIO It( selected );
990 for( ; It.More(); It.Next()){
991 Handle(SALOME_InteractiveObject) IObject = It.Value();
992 if(IObject->hasEntry()){
993 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
994 unsigned int aMode = anActor->GetEntityMode();
995 switch(theCommandID){
996 case SMESHOp::OpDE0DElements: InverseEntityMode(aMode,SMESH_Actor::e0DElements); break;
997 case SMESHOp::OpDEEdges: InverseEntityMode(aMode,SMESH_Actor::eEdges); break;
998 case SMESHOp::OpDEFaces: InverseEntityMode(aMode,SMESH_Actor::eFaces); break;
999 case SMESHOp::OpDEVolumes: InverseEntityMode(aMode,SMESH_Actor::eVolumes); break;
1000 case SMESHOp::OpDEBalls: InverseEntityMode(aMode,SMESH_Actor::eBallElem); break;
1001 case SMESHOp::OpDEAllEntity: aMode = SMESH_Actor::eAllEntity; break;
1004 anActor->SetEntityMode(aMode);
1013 SalomeApp_Application* app =
1014 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1018 LightApp_SelectionMgr* aSel = app->selectionMgr();
1019 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1020 if ( !aSel || !appStudy )
1023 SALOME_ListIO selected;
1024 aSel->selectedObjects( selected );
1025 if ( selected.IsEmpty() )
1028 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1030 _PTR(Study) aStudy = appStudy->studyDS();
1031 _PTR(SObject) aMainSObject = aStudy->FindObjectID( anIObject->getEntry() );
1032 SMESH::SMESH_Mesh_var aMainObject = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1033 if ( aMainObject->_is_nil() )
1036 SUIT_OverrideCursor wc;
1038 aMainObject->SetAutoColor( true ); // mesh groups are re-colored here
1040 QList<SALOMEDS::Color> aReservedColors;
1042 SMESH::ListOfGroups aListOfGroups = *aMainObject->GetGroups();
1043 for ( int i = 0, n = aListOfGroups.length(); i < n; i++ )
1045 SMESH::SMESH_GroupBase_var aGroupObject = aListOfGroups[i];
1047 #ifdef SIMPLE_AUTOCOLOR // simplified algorithm for auto-colors
1048 SALOMEDS::Color aColor = SMESHGUI::getPredefinedUniqueColor();
1049 #else // old algorithm for auto-colors
1050 SALOMEDS::Color aColor = SMESHGUI::getUniqueColor( aReservedColors );
1051 aReservedColors.append( aColor );
1052 #endif // SIMPLE_AUTOCOLOR
1053 aGroupObject->SetColor( aColor );
1055 _PTR(SObject) aGroupSObject = SMESH::FindSObject(aGroupObject);
1056 if ( aGroupSObject ) {
1059 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry(aGroupSObject->GetID().c_str())) {
1060 switch ( aGroupObject->GetType ()) {
1062 anActor->SetNodeColor( aColor.R, aColor.G, aColor.B ); break;
1064 anActor->SetEdgeColor( aColor.R, aColor.G, aColor.B ); break;
1066 anActor->Set0DColor( aColor.R, aColor.G, aColor.B ); break;
1068 anActor->SetBallColor( aColor.R, aColor.G, aColor.B ); break;
1070 SMESH::GetColor("SMESH", "volume_color", c, delta, "255,0,170|-100");
1071 anActor->SetVolumeColor( aColor.R, aColor.G, aColor.B, delta ); break;
1074 SMESH::GetColor("SMESH", "fill_color", c, delta, "0,170,255|-100");
1075 anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B, delta );
1081 SMESH::RepaintCurrentView();
1084 void OverallMeshQuality()
1086 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1087 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1088 SALOME_ListIO selected;
1090 aSel->selectedObjects( selected );
1092 if ( selected.IsEmpty() ) return;
1093 SALOME_ListIteratorOfListIO It( selected );
1094 for ( ; It.More(); It.Next() ) {
1095 SMESHGUI_CtrlInfoDlg* ctrlDlg = new SMESHGUI_CtrlInfoDlg( SMESHGUI::desktop() );
1096 ctrlDlg->showInfo( It.Value() );
1101 QString functorToString( SMESH::Controls::FunctorPtr f )
1103 QString type = QObject::tr( "UNKNOWN_CONTROL" );
1104 if ( dynamic_cast< SMESH::Controls::Volume* >( f.get() ) )
1105 type = QObject::tr( "VOLUME_3D_ELEMENTS" );
1106 else if ( dynamic_cast< SMESH::Controls::MaxElementLength2D* >( f.get() ) )
1107 type = QObject::tr( "MAX_ELEMENT_LENGTH_2D" );
1108 else if ( dynamic_cast< SMESH::Controls::MaxElementLength3D* >( f.get() ) )
1109 type = QObject::tr( "MAX_ELEMENT_LENGTH_3D" );
1110 else if ( dynamic_cast< SMESH::Controls::MinimumAngle* >( f.get() ) )
1111 type = QObject::tr( "MINIMUMANGLE_ELEMENTS" );
1112 else if ( dynamic_cast< SMESH::Controls::AspectRatio* >( f.get() ) )
1113 type = QObject::tr( "ASPECTRATIO_ELEMENTS" );
1114 else if ( dynamic_cast< SMESH::Controls::AspectRatio3D* >( f.get() ) )
1115 type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" );
1116 else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) )
1117 type = QObject::tr( "WARP_ELEMENTS" );
1118 else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) )
1119 type = QObject::tr( "TAPER_ELEMENTS" );
1120 else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) )
1121 type = QObject::tr( "SKEW_ELEMENTS" );
1122 else if ( dynamic_cast< SMESH::Controls::Area* >( f.get() ) )
1123 type = QObject::tr( "AREA_ELEMENTS" );
1124 else if ( dynamic_cast< SMESH::Controls::Length* >( f.get() ) )
1125 type = QObject::tr( "LENGTH_EDGES" );
1126 else if ( dynamic_cast< SMESH::Controls::Length2D* >( f.get() ) )
1127 type = QObject::tr( "LENGTH2D_EDGES" );
1128 else if ( dynamic_cast< SMESH::Controls::MultiConnection* >( f.get() ) )
1129 type = QObject::tr( "MULTI_BORDERS" );
1130 else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) )
1131 type = QObject::tr( "MULTI2D_BORDERS" );
1132 else if ( dynamic_cast< SMESH::Controls::FreeNodes* >( f.get() ) )
1133 type = QObject::tr( "FREE_NODES" );
1134 else if ( dynamic_cast< SMESH::Controls::FreeEdges* >( f.get() ) )
1135 type = QObject::tr( "FREE_EDGES" );
1136 else if ( dynamic_cast< SMESH::Controls::FreeBorders* >( f.get() ) )
1137 type = QObject::tr( "FREE_BORDERS" );
1138 else if ( dynamic_cast< SMESH::Controls::FreeFaces* >( f.get() ) )
1139 type = QObject::tr( "FREE_FACES" );
1140 else if ( dynamic_cast< SMESH::Controls::BareBorderVolume* >( f.get() ) )
1141 type = QObject::tr( "BARE_BORDER_VOLUME" );
1142 else if ( dynamic_cast< SMESH::Controls::BareBorderFace* >( f.get() ) )
1143 type = QObject::tr( "BARE_BORDER_FACE" );
1144 else if ( dynamic_cast< SMESH::Controls::OverConstrainedVolume* >( f.get() ) )
1145 type = QObject::tr( "OVER_CONSTRAINED_VOLUME" );
1146 else if ( dynamic_cast< SMESH::Controls::OverConstrainedFace* >( f.get() ) )
1147 type = QObject::tr( "OVER_CONSTRAINED_FACE" );
1148 else if ( dynamic_cast< SMESH::Controls::CoincidentNodes* >( f.get() ) )
1149 type = QObject::tr( "EQUAL_NODE" );
1150 else if ( dynamic_cast< SMESH::Controls::CoincidentElements1D* >( f.get() ) )
1151 type = QObject::tr( "EQUAL_EDGE" );
1152 else if ( dynamic_cast< SMESH::Controls::CoincidentElements2D* >( f.get() ) )
1153 type = QObject::tr( "EQUAL_FACE" );
1154 else if ( dynamic_cast< SMESH::Controls::CoincidentElements3D* >( f.get() ) )
1155 type = QObject::tr( "EQUAL_VOLUME" );
1156 else if ( dynamic_cast< SMESH::Controls::NodeConnectivityNumber* >( f.get() ) )
1157 type = QObject::tr( "NODE_CONNECTIVITY_NB" );
1161 void SaveDistribution()
1163 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1164 SALOME_ListIO selected;
1166 aSel->selectedObjects( selected );
1168 if ( selected.Extent() == 1 ) {
1169 Handle(SALOME_InteractiveObject) anIO = selected.First();
1170 if ( anIO->hasEntry() ) {
1171 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1173 anActor->GetScalarBarActor() &&
1174 anActor->GetControlMode() != SMESH_Actor::eNone )
1176 SMESH_ScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor();
1177 SMESH::Controls::FunctorPtr aFunctor = anActor->GetFunctor();
1178 if ( aScalarBarActor && aFunctor ) {
1179 SMESH::Controls::NumericalFunctor* aNumFun =
1180 dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
1182 std::vector<int> elements;
1183 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
1184 if ( mesh->_is_nil() ) {
1185 SMESH::SMESH_IDSource_var idSource =
1186 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
1187 if ( !idSource->_is_nil() )
1189 SMESH::long_array_var ids = idSource->GetIDs();
1190 elements.resize( ids->length() );
1191 for ( unsigned i = 0; i < elements.size(); ++i )
1192 elements[i] = ids[i];
1195 int nbIntervals = aScalarBarActor->GetMaximumNumberOfColors();
1196 vtkLookupTable* lookupTable =
1197 static_cast<vtkLookupTable*>(aScalarBarActor->GetLookupTable());
1198 double * minmax = lookupTable->GetRange();
1199 bool isLogarithmic = lookupTable->GetScale() == VTK_SCALE_LOG10;
1200 std::vector<int> nbEvents;
1201 std::vector<double> funValues;
1202 aNumFun->GetHistogram( nbIntervals, nbEvents, funValues,
1203 elements, minmax, isLogarithmic );
1204 QString anInitialPath = "";
1205 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
1206 anInitialPath = QDir::currentPath();
1207 QString aMeshName = anIO->getName();
1209 filter.append( QObject::tr( "TEXT_FILES_FILTER" ) + " (*.txt)" );
1210 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
1211 QString aFilename = anInitialPath + "/" + aMeshName + "_" +
1212 functorToString( aFunctor ).toLower().simplified().replace( QRegExp( " |-" ), "_" ) + ".txt";
1213 aFilename = SUIT_FileDlg::getFileName( SMESHGUI::desktop(),
1216 QObject::tr( "SMESH_SAVE_DISTRIBUTION" ),
1218 if ( !aFilename.isEmpty() ) {
1219 QFile f( aFilename );
1220 if ( f.open( QFile::WriteOnly | QFile::Truncate ) ) {
1221 QTextStream out( &f );
1222 out << "# Mesh: " << aMeshName << endl;
1223 out << "# Control: " << functorToString( aFunctor ) << endl;
1225 out.setFieldWidth( 10 );
1226 for ( int i = 0; i < (int)qMin( nbEvents.size(), funValues.size()-1 ); i++ )
1227 out << funValues[i] << "\t" << funValues[i+1] << "\t" << nbEvents[i] << endl;
1238 void ShowElement( int theCommandID )
1240 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1241 SALOME_ListIO selected;
1243 aSel->selectedObjects( selected );
1245 if ( selected.Extent() == 1 ) {
1246 Handle(SALOME_InteractiveObject) anIO = selected.First();
1247 if ( anIO->hasEntry() ) {
1248 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1250 anActor->GetScalarBarActor() &&
1251 anActor->GetControlMode() != SMESH_Actor::eNone )
1253 SMESH_ScalarBarActor *aScalarBarActor = anActor->GetScalarBarActor();
1254 if ( theCommandID == SMESHOp::OpShowDistribution ) {
1255 aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility());
1257 else if ( theCommandID == SMESHOp::OpShowScalarBar ) {
1258 aScalarBarActor->SetVisibility( !aScalarBarActor->GetVisibility());
1265 #ifndef DISABLE_PLOT2DVIEWER
1266 void PlotDistribution()
1268 SalomeApp_Application* app =
1269 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1273 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1274 SALOME_ListIO selected;
1276 aSel->selectedObjects( selected );
1278 if ( selected.Extent() == 1 ) {
1279 Handle(SALOME_InteractiveObject) anIO = selected.First();
1280 if ( anIO->hasEntry() ) {
1281 //Find Actor by entry before getting Plot2d viewer,
1282 //because after call getViewManager( Plot2d_Viewer::Type(), true ) active window is Plot2d Viewer
1283 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1285 SUIT_ViewManager* aViewManager =
1286 app->getViewManager( Plot2d_Viewer::Type(), true ); // create if necessary
1290 SPlot2d_Viewer* aView = dynamic_cast<SPlot2d_Viewer*>(aViewManager->getViewModel());
1294 Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
1298 if ( anActor && anActor->GetControlMode() != SMESH_Actor::eNone )
1300 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1301 QString functorName = functorToString( anActor->GetFunctor());
1302 QString aHistogramName("%1 : %2");
1303 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1304 aHistogram->setName(aHistogramName);
1305 aHistogram->setHorTitle(functorName);
1306 aHistogram->setVerTitle(QObject::tr("DISTRIBUTION_NB_ENT"));
1307 aPlot->displayObject(aHistogram, true);
1312 #endif //DISABLE_PLOT2DVIEWER
1314 void DisableAutoColor()
1316 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1317 SALOME_ListIO selected;
1319 aSel->selectedObjects( selected );
1321 if ( selected.Extent() ) {
1322 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1323 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1324 if ( !aMesh->_is_nil() ) {
1325 aMesh->SetAutoColor( false );
1332 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1333 SALOME_ListIO selected;
1335 aSel->selectedObjects( selected );
1336 if ( selected.Extent() )
1338 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1339 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1340 _PTR(SObject) aSObj = aStudy->FindObjectID(anIObject->getEntry());
1342 if ( aStudy->GetUseCaseBuilder()->SortChildren( aSObj, true/*AscendingOrder*/ ) ) {
1343 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1350 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap)
1352 SALOME_ListIO selected;
1353 SalomeApp_Application* app =
1354 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1358 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1359 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1360 if ( !aSel || !appStudy )
1363 if ( theCommandID == SMESHOp::OpClipping ) { // Clipping dialog can be activated without selection
1364 if ( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
1365 aModule->EmitSignalDeactivateDialog();
1366 if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
1367 (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
1372 _PTR(Study) aStudy = appStudy->studyDS();
1374 aSel->selectedObjects( selected );
1376 if ( selected.Extent() >= 1 )
1378 switch ( theCommandID ) {
1379 case SMESHOp::OpTransparency:
1381 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1382 (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
1385 case SMESHOp::OpProperties:
1388 QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
1389 QColor orientationColor, outlineColor, volumeColor;
1390 int deltaF = 0, deltaV = 0;
1393 double ballScale = 1.0;
1395 int outlineWidth = 1;
1396 double shrinkCoef = 0.0;
1397 double orientationScale = 0.0;
1398 bool orientation3d = false;
1399 VTK::MarkerType markerType = VTK::MT_NONE;
1400 VTK::MarkerScale markerScale = VTK::MS_NONE;
1402 bool hasNodes = false;
1403 int presentEntities = 0;
1404 bool firstTime = true;
1406 SALOME_ListIteratorOfListIO It( selected );
1407 for ( ; It.More(); It.Next() ) {
1408 Handle(SALOME_InteractiveObject) IObject = It.Value();
1409 if ( !IObject->hasEntry() ) continue;
1410 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1411 if ( !anActor || !anActor->GetObject() ) continue;
1414 // nodes: color, marker
1415 anActor->GetNodeColor( color[0], color[1], color[2] );
1416 nodeColor.setRgbF( color[0], color[1], color[2] );
1417 markerType = anActor->GetMarkerType();
1418 markerScale = anActor->GetMarkerScale();
1419 markerId = anActor->GetMarkerTexture();
1420 // edges: color, width
1421 anActor->GetEdgeColor( color[0], color[1], color[2] );
1422 edgeColor.setRgbF( color[0], color[1], color[2] );
1423 edgeWidth = qMax( (int)anActor->GetLineWidth(), 1 ); // minimum allowed width is 1
1424 // faces: front color, back color (delta)
1425 anActor->GetSufaceColor( color[0], color[1], color[2], deltaF );
1426 faceColor.setRgbF( color[0], color[1], color[2] );
1427 // faces: front color, back color (delta)
1428 anActor->GetVolumeColor( color[0], color[1], color[2], deltaV );
1429 volumeColor.setRgbF( color[0], color[1], color[2] );
1430 // 0d elements: color, size
1431 anActor->Get0DColor( color[0], color[1], color[2] );
1432 elem0dColor.setRgbF( color[0], color[1], color[2] );
1433 elem0dSize = qMax( (int)anActor->Get0DSize(), 1 ); // minimum allowed size is 1
1434 // balls: color, size
1435 anActor->GetBallColor( color[0], color[1], color[2] );
1436 ballColor.setRgbF( color[0], color[1], color[2] );
1437 //ballSize = qMax( (int)anActor->GetBallSize(), 1 ); // minimum allowed size is 1
1438 ballScale = qMax( (double)anActor->GetBallScale(), 1e-2 ); // minimum allowed scale is 1e-2
1440 anActor->GetOutlineColor( color[0], color[1], color[2] );
1441 outlineColor.setRgbF( color[0], color[1], color[2] );
1442 outlineWidth = qMax( (int)anActor->GetOutlineWidth(), 1 ); // minimum allowed width is 1
1443 // orientation vectors: color, scale, 3d flag
1444 anActor->GetFacesOrientationColor( color[0], color[1], color[2] );
1445 orientationColor.setRgbF( color[0], color[1], color[2] );
1446 orientationScale = anActor->GetFacesOrientationScale();
1447 orientation3d = anActor->GetFacesOrientation3DVectors();
1449 shrinkCoef = anActor->GetShrinkFactor();
1452 firstTime = false; // we only take properties from first object (for performance reasons)
1455 hasNodes = anActor->GetObject()->GetNbEntities( SMDSAbs_Node );
1456 if ( !(presentEntities & SMESH_Actor::eEdges) && anActor->GetObject()->GetNbEntities( SMDSAbs_Edge ) )
1457 presentEntities = presentEntities | SMESH_Actor::eEdges;
1458 if ( !(presentEntities & SMESH_Actor::eFaces) && anActor->GetObject()->GetNbEntities( SMDSAbs_Face ) )
1459 presentEntities = presentEntities | SMESH_Actor::eFaces;
1460 if ( !(presentEntities & SMESH_Actor::eVolumes) && anActor->GetObject()->GetNbEntities( SMDSAbs_Volume ) )
1461 presentEntities = presentEntities | SMESH_Actor::eVolumes;
1462 if ( !(presentEntities & SMESH_Actor::e0DElements) && anActor->GetObject()->GetNbEntities( SMDSAbs_0DElement ) )
1463 presentEntities = presentEntities | SMESH_Actor::e0DElements;
1464 if ( !(presentEntities & SMESH_Actor::eBallElem) && anActor->GetObject()->GetNbEntities( SMDSAbs_Ball ) )
1465 presentEntities = presentEntities | SMESH_Actor::eBallElem;
1467 // as we know that all types of elements are present, we can exit the loop
1468 if ( presentEntities == SMESH_Actor::eAllEntity )
1472 SMESHGUI_PropertiesDlg dlg( theMarkerMap[ aStudy->StudyId() ], SMESHGUI::desktop() );
1473 // nodes: color, marker
1474 dlg.setNodeColor( nodeColor );
1475 if( markerType != VTK::MT_USER )
1476 dlg.setNodeMarker( markerType, markerScale );
1478 dlg.setNodeCustomMarker( markerId );
1479 // edges: color, line width
1480 dlg.setEdgeColor( edgeColor );
1481 dlg.setEdgeWidth( edgeWidth );
1482 // faces: front color, back color
1483 dlg.setFaceColor( faceColor, deltaF );
1484 // volumes: normal color, reversed color
1485 dlg.setVolumeColor( volumeColor, deltaV );
1486 // outlines: color, line width
1487 dlg.setOutlineColor( outlineColor );
1488 dlg.setOutlineWidth( outlineWidth );
1489 // 0d elements: color, size
1490 dlg.setElem0dColor( elem0dColor );
1491 dlg.setElem0dSize( elem0dSize );
1492 // balls: color, size
1493 dlg.setBallColor( ballColor );
1494 //dlg.setBallSize( ballSize );
1495 dlg.setBallScale( ballScale );
1496 // orientation: color, scale, 3d flag
1497 dlg.setOrientationColor( orientationColor );
1498 dlg.setOrientationSize( int( orientationScale * 100. ) );
1499 dlg.setOrientation3d( orientation3d );
1500 // shrink: scale factor
1501 dlg.setShrinkCoef( int( shrinkCoef * 100. ) );
1502 // hide unused controls
1503 dlg.showControls( presentEntities, hasNodes );
1506 nodeColor = dlg.nodeColor();
1507 markerType = dlg.nodeMarkerType();
1508 markerScale = dlg.nodeMarkerScale();
1509 markerId = dlg.nodeMarkerId();
1510 edgeColor = dlg.edgeColor();
1511 edgeWidth = dlg.edgeWidth();
1512 faceColor = dlg.faceColor();
1513 deltaF = dlg.faceColorDelta();
1514 volumeColor = dlg.volumeColor();
1515 deltaV = dlg.volumeColorDelta();
1516 outlineColor = dlg.outlineColor();
1517 outlineWidth = dlg.outlineWidth();
1518 elem0dColor = dlg.elem0dColor();
1519 elem0dSize = dlg.elem0dSize();
1520 ballColor = dlg.ballColor();
1521 // ballSize = dlg.ballSize();
1522 ballScale = dlg.ballScale();
1523 orientationColor = dlg.orientationColor();
1524 orientationScale = dlg.orientationSize() / 100.;
1525 orientation3d = dlg.orientation3d();
1526 shrinkCoef = dlg.shrinkCoef() / 100.;
1528 // store point markers map that might be changed by the user
1529 theMarkerMap[ aStudy->StudyId() ] = dlg.customMarkers();
1531 // set properties from dialog box to the presentations
1532 SALOME_ListIteratorOfListIO It( selected );
1533 for ( ; It.More(); It.Next() ) {
1534 Handle(SALOME_InteractiveObject) IObject = It.Value();
1535 if ( !IObject->hasEntry() ) continue;
1536 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1537 if ( !anActor ) continue;
1539 // nodes: color, marker
1540 anActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
1541 if ( markerType != VTK::MT_USER ) {
1542 anActor->SetMarkerStd( markerType, markerScale );
1545 const VTK::MarkerMap& markerMap = theMarkerMap[ aStudy->StudyId() ];
1546 VTK::MarkerMap::const_iterator iter = markerMap.find( markerId );
1547 if ( iter != markerMap.end() )
1548 anActor->SetMarkerTexture( markerId, iter->second.second );
1550 // volumes: normal color, reversed color (delta)
1551 anActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
1552 // faces: front color, back color (delta)
1553 anActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
1554 // edges: color, width
1555 anActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
1556 anActor->SetLineWidth( edgeWidth );
1558 anActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
1559 anActor->SetOutlineWidth( outlineWidth );
1560 // 0D elements: color, size
1561 anActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
1562 anActor->Set0DSize( elem0dSize );
1563 // balls: color, size
1564 anActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
1565 // anActor->SetBallSize( ballSize );
1566 anActor->SetBallScale( ballScale );
1567 // orientation: color, scale, 3d flag
1568 anActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
1569 anActor->SetFacesOrientationScale( orientationScale );
1570 anActor->SetFacesOrientation3DVectors( orientation3d );
1572 anActor->SetShrinkFactor( shrinkCoef );
1574 // for groups, set also proper color
1575 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1576 if ( !aGroupObject->_is_nil() ) {
1577 SMESH::ElementType anElementType = aGroupObject->GetType();
1579 switch( anElementType ) {
1581 aColor = nodeColor; break;
1583 aColor = edgeColor; break;
1585 aColor = faceColor; break;
1587 aColor = volumeColor; break;
1589 aColor = elem0dColor; break;
1591 aColor = ballColor; break;
1595 if ( aColor.isValid() ) {
1596 SALOMEDS::Color aGroupColor;
1597 aGroupColor.R = aColor.redF();
1598 aGroupColor.G = aColor.greenF();
1599 aGroupColor.B = aColor.blueF();
1600 aGroupObject->SetColor( aGroupColor );
1602 } // if ( !aGroupObject->_is_nil() )
1603 } // for ( ; It.More(); It.Next() )
1604 SMESH::RepaintCurrentView();
1605 } // if ( dlg.exec() )
1607 } // case SMESHOp::OpProperties:
1608 } // switch(theCommandID)
1609 SUIT_OverrideCursor wc;
1610 SALOME_ListIteratorOfListIO It( selected );
1611 for( ; It.More(); It.Next()){
1612 Handle(SALOME_InteractiveObject) IObject = It.Value();
1613 if(IObject->hasEntry()){
1614 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1615 switch(theCommandID){
1616 case SMESHOp::OpDMWireframe:
1617 anActor->SetRepresentation(SMESH_Actor::eEdge);
1619 case SMESHOp::OpDMShading:
1620 anActor->SetRepresentation(SMESH_Actor::eSurface);
1622 case SMESHOp::OpDMShrink:
1623 if(anActor->IsShrunk())
1624 anActor->UnShrink();
1626 anActor->SetShrink();
1628 case SMESHOp::OpDMNodes:
1629 anActor->SetRepresentation(SMESH_Actor::ePoint);
1631 case SMESHOp::OpRepresentationLines:
1632 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1633 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1635 case SMESHOp::OpRepresentationArcs:
1636 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1637 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1643 SMESH::RepaintCurrentView();
1647 int ActionToControl( int theID, bool theReversed )
1649 NCollection_DoubleMap<int,int> ActionControl;
1650 ActionControl.Bind( 0, SMESH_Actor::eNone );
1651 ActionControl.Bind( SMESHOp::OpFreeNode, SMESH_Actor::eFreeNodes );
1652 ActionControl.Bind( SMESHOp::OpEqualNode, SMESH_Actor::eCoincidentNodes );
1653 ActionControl.Bind( SMESHOp::OpNodeConnectivityNb, SMESH_Actor::eNodeConnectivityNb );
1654 ActionControl.Bind( SMESHOp::OpFreeEdge, SMESH_Actor::eFreeEdges );
1655 ActionControl.Bind( SMESHOp::OpFreeBorder, SMESH_Actor::eFreeBorders );
1656 ActionControl.Bind( SMESHOp::OpLength, SMESH_Actor::eLength );
1657 ActionControl.Bind( SMESHOp::OpConnection, SMESH_Actor::eMultiConnection );
1658 ActionControl.Bind( SMESHOp::OpEqualEdge, SMESH_Actor::eCoincidentElems1D );
1659 ActionControl.Bind( SMESHOp::OpFreeFace, SMESH_Actor::eFreeFaces );
1660 ActionControl.Bind( SMESHOp::OpBareBorderFace, SMESH_Actor::eBareBorderFace );
1661 ActionControl.Bind( SMESHOp::OpOverConstrainedFace, SMESH_Actor::eOverConstrainedFace );
1662 ActionControl.Bind( SMESHOp::OpLength2D, SMESH_Actor::eLength2D );
1663 ActionControl.Bind( SMESHOp::OpConnection2D, SMESH_Actor::eMultiConnection2D );
1664 ActionControl.Bind( SMESHOp::OpArea, SMESH_Actor::eArea );
1665 ActionControl.Bind( SMESHOp::OpTaper, SMESH_Actor::eTaper );
1666 ActionControl.Bind( SMESHOp::OpAspectRatio, SMESH_Actor::eAspectRatio );
1667 ActionControl.Bind( SMESHOp::OpMinimumAngle, SMESH_Actor::eMinimumAngle );
1668 ActionControl.Bind( SMESHOp::OpWarpingAngle, SMESH_Actor::eWarping );
1669 ActionControl.Bind( SMESHOp::OpSkew, SMESH_Actor::eSkew );
1670 ActionControl.Bind( SMESHOp::OpMaxElementLength2D, SMESH_Actor::eMaxElementLength2D );
1671 ActionControl.Bind( SMESHOp::OpEqualFace, SMESH_Actor::eCoincidentElems2D );
1672 ActionControl.Bind( SMESHOp::OpAspectRatio3D, SMESH_Actor::eAspectRatio3D );
1673 ActionControl.Bind( SMESHOp::OpVolume, SMESH_Actor::eVolume3D );
1674 ActionControl.Bind( SMESHOp::OpMaxElementLength3D, SMESH_Actor::eMaxElementLength3D );
1675 ActionControl.Bind( SMESHOp::OpBareBorderVolume, SMESH_Actor::eBareBorderVolume );
1676 ActionControl.Bind( SMESHOp::OpOverConstrainedVolume, SMESH_Actor::eOverConstrainedVolume );
1677 ActionControl.Bind( SMESHOp::OpEqualVolume, SMESH_Actor::eCoincidentElems3D );
1679 return theReversed ? ActionControl.Find2( theID ) : ActionControl.Find1( theID );
1682 void Control( int theCommandID )
1684 SMESH_Actor::eControl aControl = SMESH_Actor::eControl( ActionToControl( theCommandID ));
1685 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1687 SALOME_ListIO selected;
1688 if ( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
1689 aSel->selectedObjects( selected );
1691 if ( !selected.IsEmpty() ) {
1692 SALOME_ListIteratorOfListIO It(selected);
1693 for ( ; It.More(); It.Next())
1695 Handle(SALOME_InteractiveObject) anIO = It.Value();
1696 if ( !anIO.IsNull() ) {
1697 _PTR(SObject) SO = aStudy->FindObjectID( It.Value()->getEntry() );
1699 CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
1700 SMESH::SMESH_IDSource_var anIDSrc = SMESH::SMESH_IDSource::_narrow( aObject );
1701 if ( !anIDSrc->_is_nil() ) {
1702 SMESH_Actor *anActor = SMESH::FindActorByEntry( anIO->getEntry());
1703 if (( !anActor && selected.Extent() == 1 ) &&
1704 ( anActor = SMESH::CreateActor( aStudy, anIO->getEntry() )))
1706 anActor->SetControlMode( aControl );
1707 SMESH::DisplayActor( SMESH::GetCurrentVtkView(), anActor );
1708 SMESH::UpdateView ( SMESH::eDisplay, anIO->getEntry() );
1712 if ( anActor->GetControlMode() != aControl )
1713 anActor->SetControlMode( aControl );
1714 QString functorName = functorToString( anActor->GetFunctor() );
1715 int anEntitiesCount = anActor->GetNumberControlEntities();
1716 if (anEntitiesCount >= 0)
1717 functorName = functorName + ": " + QString::number(anEntitiesCount);
1718 anActor->GetScalarBarActor()->SetTitle( functorName.toLatin1().constData() );
1719 SMESH::RepaintCurrentView();
1720 #ifndef DISABLE_PLOT2DVIEWER
1721 if ( anActor->GetPlot2Histogram() ) {
1722 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1723 QString aHistogramName("%1 : %2");
1724 aHistogramName = aHistogramName.arg( anIO->getName() ).arg( functorName );
1725 aHistogram->setName( aHistogramName );
1726 aHistogram->setHorTitle( functorName );
1727 SMESH::ProcessIn2DViewers( anActor );
1739 bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1740 SMESH::MeshObjectType theType,
1741 const QString theInTypeName,
1742 QString & theOutTypeName)
1744 SMESH_TypeFilter aTypeFilter( theType );
1746 if ( !theIO.IsNull() )
1748 entry = theIO->getEntry();
1749 LightApp_DataOwner owner( entry );
1750 if ( aTypeFilter.isOk( &owner )) {
1751 theOutTypeName = theInTypeName;
1759 QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1761 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1762 _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1764 _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1765 CORBA::String_var anID = aSComp->GetID().c_str();
1766 if ( !strcmp(anID.in(),theIO->getEntry()) )
1772 CheckOIType ( theIO, SMESH::HYPOTHESIS, "Hypothesis", aTypeName ) ||
1773 CheckOIType ( theIO, SMESH::ALGORITHM, "Algorithm", aTypeName ) ||
1774 CheckOIType ( theIO, SMESH::MESH, "Mesh", aTypeName ) ||
1775 CheckOIType ( theIO, SMESH::SUBMESH, "SubMesh", aTypeName ) ||
1776 CheckOIType ( theIO, SMESH::GROUP, "Group", aTypeName )
1784 // QString CheckHomogeneousSelection()
1786 // LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1787 // SALOME_ListIO selected;
1789 // aSel->selectedObjects( selected );
1791 // QString RefType = CheckTypeObject(selected.First());
1792 // SALOME_ListIteratorOfListIO It(selected);
1793 // for ( ; It.More(); It.Next())
1795 // Handle(SALOME_InteractiveObject) IObject = It.Value();
1796 // QString Type = CheckTypeObject(IObject);
1797 // if ( Type.compare(RefType) != 0 )
1798 // return "Heterogeneous Selection";
1804 uint randomize( uint size )
1806 static bool initialized = false;
1807 if ( !initialized ) {
1808 qsrand( QDateTime::currentDateTime().toTime_t() );
1812 v = uint( (double)( v ) / RAND_MAX * size );
1813 v = qMax( uint(0), qMin ( v, size-1 ) );
1819 void SMESHGUI::OnEditDelete()
1821 // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1822 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1823 SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1825 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1826 _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1827 _PTR(GenericAttribute) anAttr;
1828 _PTR(AttributeIOR) anIOR;
1830 int objectCount = 0;
1832 QString aParentComponent = QString::null;
1834 for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1836 Handle(SALOME_InteractiveObject) anIO = anIt.Value();
1837 if ( anIO.IsNull() ) continue;
1839 QString father = "unknown";
1841 _PTR(SObject) aSO = aStudy->FindObjectID( anIO->getEntry() );
1843 father = QString::fromStdString( aSO->GetFatherComponent()->ComponentDataType() );
1844 // check if object is reference
1845 _PTR(SObject) aRefSObj;
1846 aNameList.append("\n - ");
1847 if ( aSO->ReferencedObject( aRefSObj ) ) {
1848 QString aRefName = QString::fromStdString ( aRefSObj->GetName() );
1849 aNameList.append( aRefName );
1850 father = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1853 aNameList.append(anIO->getName());
1857 if( aParentComponent.isNull() )
1858 aParentComponent = father;
1859 else if( !aParentComponent.isEmpty() && aParentComponent!=father )
1860 aParentComponent = "";
1863 if ( objectCount == 0 )
1864 return; // No Valid Objects Selected
1866 if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
1867 SUIT_MessageBox::warning( SMESHGUI::desktop(),
1868 QObject::tr("ERR_ERROR"),
1869 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
1872 // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
1873 if (SUIT_MessageBox::warning
1874 (SMESHGUI::desktop(),
1875 QObject::tr("SMESH_WRN_WARNING"),
1876 QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
1877 SUIT_MessageBox::Yes | SUIT_MessageBox::No,
1878 SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
1881 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1883 // Put the whole hierarchy of sub-objects of the selected SO's into a list and
1884 // then treat them all starting from the deepest objects (at list back)
1885 std::list< _PTR(SObject) > listSO;
1886 SALOME_ListIteratorOfListIO It(selected);
1887 for( ; It.More(); It.Next()) // loop on selected IO's
1889 Handle(SALOME_InteractiveObject) IObject = It.Value();
1890 if(IObject->hasEntry()) {
1891 _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
1893 // disable removal of "SMESH" component object
1894 if(aSO->FindAttribute(anAttr, "AttributeIOR")){
1896 if ( engineIOR() == anIOR->Value().c_str() )
1899 //Check the referenced object
1900 _PTR(SObject) aRefSObject;
1901 if ( aSO && aSO->ReferencedObject( aRefSObject ) )
1902 aSO = aRefSObject; // Delete main Object instead of reference
1904 listSO.push_back( aSO );
1905 std::list< _PTR(SObject) >::iterator itSO = --listSO.end();
1906 for ( ; itSO != listSO.end(); ++itSO ) {
1907 _PTR(ChildIterator) it = aStudy->NewChildIterator( *itSO );
1908 for (it->InitEx(false); it->More(); it->Next())
1909 listSO.push_back( it->Value() );
1913 // Check if none of objects to delete is referred from outside
1914 std::list< _PTR(SObject) >::reverse_iterator ritSO;
1915 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1917 _PTR(SObject) SO = *ritSO;
1918 if ( !SO ) continue;
1919 std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( *ritSO );
1920 for (size_t i = 0; i < aReferences.size(); i++) {
1921 _PTR(SComponent) aComponent = aReferences[i]->GetFatherComponent();
1922 std::string type = aComponent->ComponentDataType();
1923 if ( type != "SMESH" )
1925 SUIT_MessageBox::warning( anApp->desktop(),
1926 QObject::tr("WRN_WARNING"),
1927 QObject::tr("DEP_OBJECT") );
1928 return; // outside SMESH, there is an object depending on a SMESH object
1933 // Call mesh->Clear() to prevent loading mesh from file caused by hypotheses removal
1934 for( It.Initialize( selected ); It.More(); It.Next()) // loop on selected IO's
1936 Handle(SALOME_InteractiveObject) IObject = It.Value();
1937 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface< SMESH::SMESH_Mesh >( IObject );
1938 if ( !mesh->_is_nil() )
1942 // Treat SO's in the list starting from the back
1943 aStudyBuilder->NewCommand(); // There is a transaction
1944 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1946 _PTR(SObject) SO = *ritSO;
1947 if ( !SO ) continue;
1948 std::string anEntry = SO->GetID();
1950 /** Erase graphical object and remove all its data **/
1951 if(SO->FindAttribute(anAttr, "AttributeIOR")) {
1952 SMESH::RemoveVisualObjectWithActors( anEntry.c_str(), true);
1954 /** Remove an object from data structures **/
1955 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
1956 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
1957 if ( !aGroup->_is_nil() ) { // DELETE GROUP
1958 SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
1959 aMesh->RemoveGroup( aGroup );
1961 else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
1962 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
1963 aMesh->RemoveSubMesh( aSubMesh );
1965 _PTR(SObject) aMeshSO = SMESH::FindSObject(aMesh);
1967 SMESH::ModifiedMesh(aMeshSO, false, aMesh->NbNodes()==0);
1970 Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
1971 ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
1972 QString objType = CheckTypeObject(IObject);
1973 if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
1974 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
1975 aStudyBuilder->RemoveObjectWithChildren( SO );
1977 else {// default action: remove SObject from the study
1978 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
1979 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
1981 aStudyBuilder->RemoveObjectWithChildren( SO );
1985 } /* listSO back loop */
1987 aStudyBuilder->CommitCommand();
1989 /* Clear any previous selection */
1991 aSel->setSelectedObjects( l1 );
1993 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1997 SMESHGUI_EXPORT CAM_Module* createModule()
1999 return new SMESHGUI();
2002 SMESHGUI_EXPORT char* getModuleVersion() {
2003 return (char*)SMESH_VERSION_STR;
2007 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
2009 //=============================================================================
2013 //=============================================================================
2014 SMESHGUI::SMESHGUI() :
2015 SalomeApp_Module( "SMESH" )
2017 if ( CORBA::is_nil( myComponentSMESH ) )
2019 CORBA::Boolean anIsEmbeddedMode;
2020 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
2021 //MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
2023 // 0019923: EDF 765 SMESH : default values of hypothesis
2024 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
2025 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
2026 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
2027 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
2028 myComponentSMESH->SetDefaultNbSegments( nbSeg );
2030 const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif", "default_grp_color" };
2031 for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
2032 if ( aResourceMgr->hasValue( "SMESH", options[i] ))
2034 QString val = aResourceMgr->stringValue( "SMESH", options[i] );
2035 myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
2039 myActiveDialogBox = 0;
2040 myFilterLibraryDlg = 0;
2044 myEventCallbackCommand = vtkCallbackCommand::New();
2045 myEventCallbackCommand->Delete();
2046 myEventCallbackCommand->SetClientData( this );
2047 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
2050 /* load resources for all available meshers */
2051 SMESH::InitAvailableHypotheses();
2054 //=============================================================================
2058 //=============================================================================
2059 SMESHGUI::~SMESHGUI()
2063 //=============================================================================
2067 //=============================================================================
2068 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
2070 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2072 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
2077 //=============================================================================
2081 //=============================================================================
2082 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
2084 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2088 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2089 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2090 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2091 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2092 return autoUpdate && !exceeded;
2095 //=============================================================================
2099 //=============================================================================
2100 bool SMESHGUI::automaticUpdate( SMESH::SMESH_IDSource_ptr theMesh,
2101 int* entities, bool* limitExceeded, int* hidden, long* nbElements )
2103 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2107 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2108 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2109 bool incrementalLimit = resMgr->booleanValue( "SMESH", "incremental_limit", false );
2111 SMESH::long_array_var info = theMesh->GetMeshInfo();
2112 long nbOdElems = info[SMDSEntity_0D];
2113 long nbEdges = info[SMDSEntity_Edge] + info[SMDSEntity_Quad_Edge];
2114 long nbFaces = info[SMDSEntity_Triangle] + info[SMDSEntity_Quad_Triangle] + info[SMDSEntity_BiQuad_Triangle] +
2115 info[SMDSEntity_Quadrangle] + info[SMDSEntity_Quad_Quadrangle] + info[SMDSEntity_BiQuad_Quadrangle] +
2116 info[SMDSEntity_Polygon] + info[SMDSEntity_Quad_Polygon];
2117 long nbVolumes = info[SMDSEntity_Tetra] + info[SMDSEntity_Quad_Tetra] +
2118 info[SMDSEntity_Hexa] + info[SMDSEntity_Quad_Hexa] + info[SMDSEntity_TriQuad_Hexa] +
2119 info[SMDSEntity_Pyramid] + info[SMDSEntity_Quad_Pyramid] +
2120 info[SMDSEntity_Penta] + info[SMDSEntity_Quad_Penta] +
2121 info[SMDSEntity_Polyhedra] +
2122 info[SMDSEntity_Hexagonal_Prism];
2123 long nbBalls = info[SMDSEntity_Ball];
2125 long requestedSize = nbOdElems + nbBalls + nbEdges + nbFaces + nbVolumes;
2126 *nbElements = requestedSize;
2128 *entities = SMESH_Actor::eAllEntity;
2131 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2133 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2135 if ( incrementalLimit ) {
2138 if ( nbOdElems > 0 ) {
2139 if ( total + nbOdElems > updateLimit ) {
2140 *entities = *entities & ~SMESH_Actor::e0DElements;
2141 *hidden = *hidden | SMESH_Actor::e0DElements;
2148 if ( nbEdges > 0 ) {
2149 if ( total + nbEdges > updateLimit ) {
2150 *entities = *entities & ~SMESH_Actor::eEdges;
2151 *hidden = *hidden | SMESH_Actor::eEdges;
2158 if ( nbFaces > 0 ) {
2159 if ( total + nbFaces > updateLimit ) {
2160 *entities = *entities & ~SMESH_Actor::eFaces;
2161 *hidden = *hidden | SMESH_Actor::eFaces;
2168 if ( nbVolumes > 0 ) {
2169 if ( total + nbVolumes > updateLimit ) {
2170 *entities = *entities & ~SMESH_Actor::eVolumes;
2171 *hidden = *hidden | SMESH_Actor::eVolumes;
2178 if ( nbBalls > 0 ) {
2179 if ( total + nbBalls > updateLimit ) {
2180 *entities = *entities & ~SMESH_Actor::eBallElem;
2181 *hidden = *hidden | SMESH_Actor::eBallElem;
2189 return autoUpdate && !exceeded;
2192 //=============================================================================
2196 //=============================================================================
2197 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
2199 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
2202 //=============================================================================
2206 //=============================================================================
2207 SMESHGUI* SMESHGUI::GetSMESHGUI()
2209 SMESHGUI* smeshMod = 0;
2210 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
2213 CAM_Module* module = app->module( "Mesh" );
2214 smeshMod = dynamic_cast<SMESHGUI*>( module );
2217 if ( smeshMod && smeshMod->application() && smeshMod->application()->activeStudy() )
2219 SalomeApp_Study* study = dynamic_cast<SalomeApp_Study*>( smeshMod->application()->activeStudy() );
2222 _PTR(Study) aStudy = study->studyDS();
2224 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
2233 Standard_EXPORT SMESHGUI* GetComponentGUI()
2235 return SMESHGUI::GetSMESHGUI();
2239 //=============================================================================
2243 //=============================================================================
2244 void SMESHGUI::SetState(int aState)
2249 //=============================================================================
2253 //=============================================================================
2254 void SMESHGUI::ResetState()
2259 //=============================================================================
2263 //=============================================================================
2264 void SMESHGUI::EmitSignalDeactivateDialog()
2266 emit SignalDeactivateActiveDialog();
2269 //=============================================================================
2273 //=============================================================================
2274 void SMESHGUI::EmitSignalStudyFrameChanged()
2276 emit SignalStudyFrameChanged();
2279 //=============================================================================
2283 //=============================================================================
2284 void SMESHGUI::EmitSignalCloseAllDialogs()
2286 emit SignalCloseAllDialogs();
2289 //=============================================================================
2293 //=============================================================================
2294 void SMESHGUI::EmitSignalVisibilityChanged()
2296 emit SignalVisibilityChanged();
2299 //=============================================================================
2303 //=============================================================================
2304 void SMESHGUI::EmitSignalCloseView()
2306 emit SignalCloseView();
2309 //=============================================================================
2313 //=============================================================================
2314 void SMESHGUI::EmitSignalActivatedViewManager()
2316 emit SignalActivatedViewManager();
2319 //=============================================================================
2323 //=============================================================================
2324 QDialog *SMESHGUI::GetActiveDialogBox()
2326 return myActiveDialogBox;
2329 //=============================================================================
2333 //=============================================================================
2334 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2336 myActiveDialogBox = (QDialog *) aDlg;
2340 //=============================================================================
2344 //=============================================================================
2345 SUIT_Desktop* SMESHGUI::desktop()
2347 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2349 return app->desktop();
2354 //=============================================================================
2358 //=============================================================================
2359 SalomeApp_Study* SMESHGUI::activeStudy()
2361 SUIT_Application* app = SUIT_Session::session()->activeApplication();
2363 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2368 //=============================================================================
2372 //=============================================================================
2373 void SMESHGUI::Modified( bool theIsUpdateActions )
2375 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2376 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2377 appStudy->Modified();
2378 if( theIsUpdateActions )
2379 app->updateActions();
2384 //=============================================================================
2388 //=============================================================================
2389 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2391 /* Here the position is on the bottom right corner - 10 */
2392 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2394 SUIT_Desktop *PP = desktop();
2395 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2396 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2400 //=============================================================================
2404 //=============================================================================
2405 static int isStudyLocked(_PTR(Study) theStudy){
2406 return theStudy->GetProperties()->IsLocked();
2409 static bool checkLock(_PTR(Study) theStudy) {
2410 if (isStudyLocked(theStudy)) {
2411 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2412 QObject::tr("WRN_WARNING"),
2413 QObject::tr("WRN_STUDY_LOCKED") );
2419 //=======================================================================
2420 //function : CheckActiveStudyLocked
2422 //=======================================================================
2424 bool SMESHGUI::isActiveStudyLocked()
2426 _PTR(Study) aStudy = activeStudy()->studyDS();
2427 return checkLock( aStudy );
2430 //=============================================================================
2434 //=============================================================================
2435 bool SMESHGUI::OnGUIEvent( int theCommandID )
2437 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2441 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
2442 SUIT_ResourceMgr* mgr = resourceMgr();
2446 if (CORBA::is_nil(GetSMESHGen()->GetCurrentStudy())) {
2447 GetSMESHGen()->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
2450 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2451 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2453 //QAction* act = action( theCommandID );
2455 switch (theCommandID) {
2456 case SMESHOp::OpDelete:
2457 if(checkLock(aStudy)) break;
2460 case SMESHOp::OpImportDAT:
2461 case SMESHOp::OpImportUNV:
2462 case SMESHOp::OpImportMED:
2463 case SMESHOp::OpImportSTL:
2464 case SMESHOp::OpImportCGNS:
2465 case SMESHOp::OpImportSAUV:
2466 case SMESHOp::OpImportGMF:
2467 case SMESHOp::OpPopupImportDAT:
2468 case SMESHOp::OpPopupImportUNV:
2469 case SMESHOp::OpPopupImportMED:
2470 case SMESHOp::OpPopupImportSTL:
2471 case SMESHOp::OpPopupImportCGNS:
2472 case SMESHOp::OpPopupImportSAUV:
2473 case SMESHOp::OpPopupImportGMF:
2475 if(checkLock(aStudy)) break;
2476 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2480 case SMESHOp::OpFileInformation:
2482 SALOME_ListIO selected;
2483 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2485 aSel->selectedObjects( selected );
2486 if( selected.Extent() )
2488 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2489 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2490 if ( !aMesh->_is_nil() )
2492 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2498 case SMESHOp::OpExportDAT:
2499 case SMESHOp::OpExportMED:
2500 case SMESHOp::OpExportUNV:
2501 case SMESHOp::OpExportSTL:
2502 case SMESHOp::OpExportCGNS:
2503 case SMESHOp::OpExportSAUV:
2504 case SMESHOp::OpExportGMF:
2505 case SMESHOp::OpPopupExportDAT:
2506 case SMESHOp::OpPopupExportMED:
2507 case SMESHOp::OpPopupExportUNV:
2508 case SMESHOp::OpPopupExportSTL:
2509 case SMESHOp::OpPopupExportCGNS:
2510 case SMESHOp::OpPopupExportSAUV:
2511 case SMESHOp::OpPopupExportGMF:
2513 ::ExportMeshToFile(theCommandID);
2517 case SMESHOp::OpReset: // SCALAR BAR
2519 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2520 SALOME_ListIO selected;
2522 aSel->selectedObjects( selected );
2524 SALOME_ListIteratorOfListIO it(selected);
2525 for( ; it.More(); it.Next()) {
2526 Handle(SALOME_InteractiveObject) anIO = it.Value();
2527 if( anIO->hasEntry() ) {
2528 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2529 anActor->SetControlMode( SMESH_Actor::eNone );
2530 #ifndef DISABLE_PLOT2DVIEWER
2531 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2536 SMESH::UpdateView();
2539 case SMESHOp::OpScalarBarProperties:
2541 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2544 case SMESHOp::OpShowScalarBar:
2546 // show/hide scalar bar
2547 ::ShowElement(theCommandID);
2550 case SMESHOp::OpSaveDistribution:
2552 // dump control distribution data to the text file
2553 ::SaveDistribution();
2557 case SMESHOp::OpShowDistribution:
2559 // show/hide distribution
2560 ::ShowElement(theCommandID);
2564 #ifndef DISABLE_PLOT2DVIEWER
2565 case SMESHOp::OpPlotDistribution:
2567 // plot distribution
2568 ::PlotDistribution();
2574 case SMESHOp::OpAutoColor:
2578 case SMESHOp::OpDisableAutoColor:
2579 ::DisableAutoColor();
2582 case SMESHOp::OpClipping:
2583 case SMESHOp::OpTransparency:
2584 case SMESHOp::OpProperties: // Display preferences (colors, shrink size, line width, ...)
2587 case SMESHOp::OpDMWireframe:
2588 case SMESHOp::OpDMShading:
2589 case SMESHOp::OpDMNodes:
2590 case SMESHOp::OpDMShrink:
2591 ::SetDisplayMode(theCommandID, myMarkerMap);
2594 //2D quadratic representation
2595 case SMESHOp::OpRepresentationLines:
2596 case SMESHOp::OpRepresentationArcs:
2597 ::SetDisplayMode(theCommandID, myMarkerMap);
2601 case SMESHOp::OpDE0DElements:
2602 case SMESHOp::OpDEEdges:
2603 case SMESHOp::OpDEFaces:
2604 case SMESHOp::OpDEVolumes:
2605 case SMESHOp::OpDEBalls:
2606 case SMESHOp::OpDEAllEntity:
2607 ::SetDisplayEntity(theCommandID);
2610 // Choose entities to be displayed
2611 case SMESHOp::OpDEChoose:
2613 ( new SMESHGUI_DisplayEntitiesDlg( SMESHGUI::desktop() ) )->exec();
2617 case SMESHOp::OpOrientationOnFaces:
2619 SUIT_OverrideCursor wc;
2620 LightApp_SelectionMgr* mgr = selectionMgr();
2621 SALOME_ListIO selected; mgr->selectedObjects( selected );
2623 SALOME_ListIteratorOfListIO it(selected);
2624 for( ; it.More(); it.Next()) {
2625 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2626 if(anIObject->hasEntry()) {
2627 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2628 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2635 case SMESHOp::OpUpdate:
2637 if(checkLock(aStudy)) break;
2638 SUIT_OverrideCursor wc;
2640 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2643 SMESH::UpdateView();
2645 catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2646 SMESH::OnVisuException();
2648 catch (...) { // PAL16774 (Crash after display of many groups)
2649 SMESH::OnVisuException();
2653 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2654 aSel->selectedObjects( l );
2655 aSel->setSelectedObjects( l );
2659 case SMESHOp::OpHide:
2660 case SMESHOp::OpShow:
2661 case SMESHOp::OpShowOnly:
2663 SUIT_OverrideCursor wc;
2664 SMESH::EDisplaing anAction;
2665 switch (theCommandID) {
2666 case SMESHOp::OpHide: anAction = SMESH::eErase; break;
2667 case SMESHOp::OpShow: anAction = SMESH::eDisplay; break;
2668 case SMESHOp::OpShowOnly: anAction = SMESH::eDisplayOnly; break;
2671 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2672 SALOME_ListIO sel_objects, to_process;
2674 aSel->selectedObjects( sel_objects );
2676 if ( theCommandID==SMESHOp::OpShowOnly )
2678 //MESSAGE("anAction = SMESH::eDisplayOnly");
2679 startOperation( myEraseAll );
2682 extractContainers( sel_objects, to_process );
2687 SALOME_ListIteratorOfListIO It( to_process );
2688 for ( ; It.More(); It.Next())
2690 Handle(SALOME_InteractiveObject) IOS = It.Value();
2691 if ( IOS->hasEntry() )
2693 if ( !SMESH::UpdateView( anAction, IOS->getEntry() )) {
2694 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2695 break; // PAL16774 (Crash after display of many groups)
2697 if (anAction == SMESH::eDisplayOnly)
2698 anAction = SMESH::eDisplay;
2703 // PAL13338 + PAL15161 -->
2704 if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !checkLock(aStudy)) {
2705 SMESH::UpdateView();
2706 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2708 // PAL13338 + PAL15161 <--
2710 catch (...) { // PAL16774 (Crash after display of many groups)
2711 SMESH::OnVisuException();
2714 if (anAction == SMESH::eErase) {
2716 aSel->setSelectedObjects( l1 );
2719 aSel->setSelectedObjects( to_process );
2724 case SMESHOp::OpNode:
2726 if(checkLock(aStudy)) break;
2729 EmitSignalDeactivateDialog();
2731 ( new SMESHGUI_NodesDlg( this ) )->show();
2734 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"),tr("SMESH_WRN_VIEWER_VTK"));
2739 case SMESHOp::OpCreateMesh:
2740 case SMESHOp::OpCreateSubMesh:
2741 case SMESHOp::OpEditMeshOrSubMesh:
2742 case SMESHOp::OpEditMesh:
2743 case SMESHOp::OpEditSubMesh:
2744 case SMESHOp::OpCompute:
2745 case SMESHOp::OpComputeSubMesh:
2746 case SMESHOp::OpPreCompute:
2747 case SMESHOp::OpEvaluate:
2748 case SMESHOp::OpMeshOrder:
2749 startOperation( theCommandID );
2751 case SMESHOp::OpCopyMesh:
2753 if (checkLock(aStudy)) break;
2754 EmitSignalDeactivateDialog();
2755 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2758 case SMESHOp::OpBuildCompoundMesh:
2760 if (checkLock(aStudy)) break;
2761 EmitSignalDeactivateDialog();
2762 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2766 case SMESHOp::OpDiagonalInversion:
2767 case SMESHOp::OpUnionOfTwoTriangle:
2771 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2775 if ( checkLock( aStudy ) )
2778 /*Standard_Boolean aRes;
2779 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2780 if ( aMesh->_is_nil() )
2782 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2783 tr( "SMESH_BAD_SELECTION" ) );
2787 EmitSignalDeactivateDialog();
2788 if ( theCommandID == SMESHOp::OpDiagonalInversion )
2789 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2791 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2794 case SMESHOp::OpOrientation:
2795 case SMESHOp::OpUnionOfTriangles:
2796 case SMESHOp::OpCuttingOfQuadrangles:
2797 case SMESHOp::OpSplitVolumes:
2801 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2805 if ( checkLock( aStudy ) )
2808 EmitSignalDeactivateDialog();
2809 SMESHGUI_MultiEditDlg* aDlg = NULL;
2810 if ( theCommandID == SMESHOp::OpOrientation )
2811 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2812 else if ( theCommandID == SMESHOp::OpUnionOfTriangles )
2813 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2814 else if ( theCommandID == SMESHOp::OpSplitVolumes )
2815 aDlg = new SMESHGUI_SplitVolumesDlg(this);
2817 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2822 case SMESHOp::OpSmoothing:
2824 if(checkLock(aStudy)) break;
2826 EmitSignalDeactivateDialog();
2827 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2830 SUIT_MessageBox::warning(desktop(), tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2834 case SMESHOp::OpExtrusion:
2836 if (checkLock(aStudy)) break;
2838 EmitSignalDeactivateDialog();
2839 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2841 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2845 case SMESHOp::OpExtrusionAlongAPath:
2847 if (checkLock(aStudy)) break;
2849 EmitSignalDeactivateDialog();
2850 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2852 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2856 case SMESHOp::OpRevolution:
2858 if(checkLock(aStudy)) break;
2860 EmitSignalDeactivateDialog();
2861 ( new SMESHGUI_RevolutionDlg( this ) )->show();
2864 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2868 case SMESHOp::OpPatternMapping:
2870 if ( checkLock( aStudy ) )
2874 EmitSignalDeactivateDialog();
2875 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2878 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2882 case SMESHOp::OpSplitBiQuadratic:
2883 case SMESHOp::OpConvertMeshToQuadratic:
2884 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
2885 case SMESHOp::OpReorientFaces:
2886 case SMESHOp::OpCreateGeometryGroup:
2888 startOperation( theCommandID );
2891 case SMESHOp::OpCreateGroup:
2895 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2899 if(checkLock(aStudy)) break;
2900 EmitSignalDeactivateDialog();
2901 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2903 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2904 SALOME_ListIO selected;
2906 aSel->selectedObjects( selected );
2908 int nbSel = selected.Extent();
2910 // check if mesh is selected
2911 aMesh = SMESH::GetMeshByIO( selected.First() );
2913 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2918 case SMESHOp::OpConstructGroup:
2922 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2926 if(checkLock(aStudy)) break;
2927 EmitSignalDeactivateDialog();
2929 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2930 SALOME_ListIO selected;
2932 aSel->selectedObjects( selected );
2934 int nbSel = selected.Extent();
2936 // check if submesh is selected
2937 Handle(SALOME_InteractiveObject) IObject = selected.First();
2938 if (IObject->hasEntry()) {
2939 _PTR(SObject) aSObj = aStudy->FindObjectID(IObject->getEntry());
2941 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2942 if (!aSubMesh->_is_nil()) {
2944 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2945 // get submesh elements list by types
2946 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2947 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2948 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2949 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2950 // create group for each type o elements
2951 QString aName = IObject->getName();
2952 QStringList anEntryList;
2953 if (aNodes->length() > 0) {
2954 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2955 aGroup->Add(aNodes.inout());
2956 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2957 anEntryList.append( aSObject->GetID().c_str() );
2959 if (aEdges->length() > 0) {
2960 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2961 aGroup->Add(aEdges.inout());
2962 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2963 anEntryList.append( aSObject->GetID().c_str() );
2965 if (aFaces->length() > 0) {
2966 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2967 aGroup->Add(aFaces.inout());
2968 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2969 anEntryList.append( aSObject->GetID().c_str() );
2971 if (aVolumes->length() > 0) {
2972 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2973 aGroup->Add(aVolumes.inout());
2974 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2975 anEntryList.append( aSObject->GetID().c_str() );
2978 anApp->browseObjects( anEntryList );
2980 catch(const SALOME::SALOME_Exception & S_ex){
2981 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2988 SUIT_MessageBox::warning(desktop(),
2989 tr("SMESH_WRN_WARNING"),
2990 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
2995 case SMESHOp::OpEditGroup:
2999 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3003 if(checkLock(aStudy)) break;
3004 EmitSignalDeactivateDialog();
3006 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3007 SALOME_ListIO selected;
3009 aSel->selectedObjects( selected );
3011 SALOME_ListIteratorOfListIO It (selected);
3012 int nbSelectedGroups = 0;
3013 for ( ; It.More(); It.Next() )
3015 SMESH::SMESH_GroupBase_var aGroup =
3016 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
3017 if (!aGroup->_is_nil()) {
3019 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
3023 if (nbSelectedGroups == 0)
3025 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
3031 case SMESHOp::OpAddElemGroupPopup: // Add elements to group
3033 if(checkLock(aStudy)) break;
3034 if (myState == 800) {
3035 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3036 if (aDlg) aDlg->onAdd();
3041 case SMESHOp::OpRemoveElemGroupPopup: // Remove elements from group
3043 if(checkLock(aStudy)) break;
3044 if (myState == 800) {
3045 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3046 if (aDlg) aDlg->onRemove();
3051 case SMESHOp::OpEditGeomGroupAsGroup:
3055 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3059 if(checkLock(aStudy)) break;
3060 EmitSignalDeactivateDialog();
3062 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3063 SALOME_ListIO selected;
3065 aSel->selectedObjects( selected );
3067 SALOME_ListIteratorOfListIO It (selected);
3068 for ( ; It.More(); It.Next() )
3070 SMESH::SMESH_GroupOnGeom_var aGroup =
3071 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
3072 if (!aGroup->_is_nil()) {
3073 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3078 SMESH::SMESH_GroupOnFilter_var aGroup =
3079 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
3080 if (!aGroup->_is_nil()) {
3081 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3089 case SMESHOp::OpUnionGroups:
3090 case SMESHOp::OpIntersectGroups:
3091 case SMESHOp::OpCutGroups:
3095 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3099 if ( checkLock( aStudy ) )
3102 EmitSignalDeactivateDialog();
3104 SMESHGUI_GroupOpDlg* aDlg = 0;
3105 if ( theCommandID == SMESHOp::OpUnionGroups )
3106 aDlg = new SMESHGUI_UnionGroupsDlg( this );
3107 else if ( theCommandID == SMESHOp::OpIntersectGroups )
3108 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3110 aDlg = new SMESHGUI_CutGroupsDlg( this );
3117 case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
3119 if ( checkLock( aStudy ) )
3122 EmitSignalDeactivateDialog();
3123 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3129 case SMESHOp::OpDeleteGroup: // Delete groups with their contents
3133 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3137 if ( checkLock( aStudy ) )
3140 EmitSignalDeactivateDialog();
3142 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3146 case SMESHOp::OpMeshInformation:
3147 case SMESHOp::OpWhatIs:
3149 int page = theCommandID == SMESHOp::OpMeshInformation ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3150 EmitSignalDeactivateDialog();
3151 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3152 SALOME_ListIO selected;
3154 aSel->selectedObjects( selected );
3156 if ( selected.Extent() > 1 ) { // a dlg for each IO
3157 SALOME_ListIteratorOfListIO It( selected );
3158 for ( ; It.More(); It.Next() ) {
3159 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3160 dlg->showInfo( It.Value() );
3165 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3171 case SMESHOp::OpFindElementByPoint:
3173 startOperation( theCommandID );
3177 case SMESHOp::OpEditHypothesis:
3179 if(checkLock(aStudy)) break;
3181 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3182 SALOME_ListIO selected;
3184 aSel->selectedObjects( selected );
3186 int nbSel = selected.Extent();
3189 Handle(SALOME_InteractiveObject) anIObject = selected.First();
3190 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3192 if ( !aHypothesis->_is_nil() )
3194 SMESHGUI_GenericHypothesisCreator* aCreator =
3195 SMESH::GetHypothesisCreator( SMESH::toQStr( aHypothesis->GetName() ));
3198 // set geometry of mesh and sub-mesh to aCreator
3199 aSel->selectedObjects( selected, "", /*convertReferences=*/false);
3200 if ( selected.Extent() == 1 )
3202 QString subGeomID, meshGeomID;
3203 Handle(SALOME_InteractiveObject) hypIO = selected.First();
3204 if ( SMESH::GetGeomEntries( hypIO, subGeomID, meshGeomID ))
3206 if ( subGeomID.isEmpty() ) subGeomID = meshGeomID;
3207 aCreator->setShapeEntry( subGeomID );
3208 aCreator->setMainShapeEntry( meshGeomID );
3212 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3222 case SMESHOp::OpUnassign: // REMOVE HYPOTHESIS / ALGORITHMS
3224 if(checkLock(aStudy)) break;
3225 SUIT_OverrideCursor wc;
3227 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3228 SALOME_ListIO selected;
3230 aSel->selectedObjects( selected, QString::null, false );
3232 SALOME_ListIteratorOfListIO It(selected);
3233 for (int i = 0; It.More(); It.Next(), i++) {
3234 Handle(SALOME_InteractiveObject) IObject = It.Value();
3235 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3238 aSel->setSelectedObjects( l1 );
3243 case SMESHOp::OpElem0D:
3244 case SMESHOp::OpBall:
3245 case SMESHOp::OpEdge:
3246 case SMESHOp::OpTriangle:
3247 case SMESHOp::OpQuadrangle:
3248 case SMESHOp::OpPolygon:
3249 case SMESHOp::OpTetrahedron:
3250 case SMESHOp::OpHexahedron:
3251 case SMESHOp::OpPentahedron:
3252 case SMESHOp::OpPyramid:
3253 case SMESHOp::OpHexagonalPrism:
3255 if(checkLock(aStudy)) break;
3257 EmitSignalDeactivateDialog();
3258 SMDSAbs_EntityType type = SMDSEntity_Edge;
3259 switch (theCommandID) {
3260 case SMESHOp::OpElem0D: type = SMDSEntity_0D; break;
3261 case SMESHOp::OpBall: type = SMDSEntity_Ball; break;
3262 case SMESHOp::OpTriangle: type = SMDSEntity_Triangle; break;
3263 case SMESHOp::OpQuadrangle: type = SMDSEntity_Quadrangle; break;
3264 case SMESHOp::OpTetrahedron: type = SMDSEntity_Tetra; break;
3265 case SMESHOp::OpPolygon: type = SMDSEntity_Polygon; break;
3266 case SMESHOp::OpHexahedron: type = SMDSEntity_Hexa; break;
3267 case SMESHOp::OpPentahedron: type = SMDSEntity_Penta; break;
3268 case SMESHOp::OpPyramid: type = SMDSEntity_Pyramid; break;
3269 case SMESHOp::OpHexagonalPrism: type = SMDSEntity_Hexagonal_Prism; break;
3272 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3275 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3279 case SMESHOp::OpPolyhedron:
3281 if(checkLock(aStudy)) break;
3283 EmitSignalDeactivateDialog();
3284 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3287 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3291 case SMESHOp::OpQuadraticEdge:
3292 case SMESHOp::OpQuadraticTriangle:
3293 case SMESHOp::OpBiQuadraticTriangle:
3294 case SMESHOp::OpQuadraticQuadrangle:
3295 case SMESHOp::OpBiQuadraticQuadrangle:
3296 case SMESHOp::OpQuadraticPolygon:
3297 case SMESHOp::OpQuadraticTetrahedron:
3298 case SMESHOp::OpQuadraticPyramid:
3299 case SMESHOp::OpQuadraticPentahedron:
3300 case SMESHOp::OpQuadraticHexahedron:
3301 case SMESHOp::OpTriQuadraticHexahedron:
3303 if(checkLock(aStudy)) break;
3305 EmitSignalDeactivateDialog();
3306 SMDSAbs_EntityType type = SMDSEntity_Last;
3308 switch (theCommandID) {
3309 case SMESHOp::OpQuadraticEdge: type = SMDSEntity_Quad_Edge; break;
3310 case SMESHOp::OpQuadraticTriangle: type = SMDSEntity_Quad_Triangle; break;
3311 case SMESHOp::OpBiQuadraticTriangle: type = SMDSEntity_BiQuad_Triangle; break;
3312 case SMESHOp::OpQuadraticQuadrangle: type = SMDSEntity_Quad_Quadrangle; break;
3313 case SMESHOp::OpBiQuadraticQuadrangle: type = SMDSEntity_BiQuad_Quadrangle; break;
3314 case SMESHOp::OpQuadraticPolygon: type = SMDSEntity_Quad_Polygon; break;
3315 case SMESHOp::OpQuadraticTetrahedron: type = SMDSEntity_Quad_Tetra; break;
3316 case SMESHOp::OpQuadraticPyramid: type = SMDSEntity_Quad_Pyramid; break;
3317 case SMESHOp::OpQuadraticPentahedron: type = SMDSEntity_Quad_Penta; break;
3318 case SMESHOp::OpQuadraticHexahedron: type = SMDSEntity_Quad_Hexa; break;
3319 case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
3322 if ( type != SMDSEntity_Last )
3323 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3326 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3327 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3331 case SMESHOp::OpRemoveNodes:
3333 if(checkLock(aStudy)) break;
3335 EmitSignalDeactivateDialog();
3336 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3339 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3340 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3344 case SMESHOp::OpRemoveElements: // REMOVES ELEMENTS
3346 if(checkLock(aStudy)) break;
3348 EmitSignalDeactivateDialog();
3349 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3353 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3354 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3358 case SMESHOp::OpClearMesh: {
3360 if(checkLock(aStudy)) break;
3362 SALOME_ListIO selected;
3363 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3364 aSel->selectedObjects( selected );
3366 SUIT_OverrideCursor wc;
3367 SALOME_ListIteratorOfListIO It (selected);
3368 for ( ; It.More(); It.Next() )
3370 Handle(SALOME_InteractiveObject) IOS = It.Value();
3371 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3372 if ( aMesh->_is_nil()) continue;
3375 if ( aMesh->NbNodes() == 0 ) // imported mesh is not empty
3376 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3377 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3378 SMESH::ModifiedMesh( aMeshSObj, false, true);
3379 // hide groups and submeshes
3380 _PTR(ChildIterator) anIter =
3381 SMESH::GetActiveStudyDocument()->NewChildIterator( aMeshSObj );
3382 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3384 _PTR(SObject) so = anIter->Value();
3385 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3388 catch (const SALOME::SALOME_Exception& S_ex){
3390 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3394 SMESH::UpdateView();
3398 case SMESHOp::OpRemoveOrphanNodes:
3400 if(checkLock(aStudy)) break;
3401 SALOME_ListIO selected;
3402 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3403 aSel->selectedObjects( selected );
3404 if ( selected.Extent() == 1 ) {
3405 Handle(SALOME_InteractiveObject) anIO = selected.First();
3406 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3407 if ( !aMesh->_is_nil() ) {
3408 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3409 tr( "SMESH_WARNING" ),
3410 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3411 SUIT_MessageBox::Yes |
3412 SUIT_MessageBox::No,
3413 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3416 SUIT_OverrideCursor wc;
3417 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3418 int removed = aMeshEditor->RemoveOrphanNodes();
3419 SUIT_MessageBox::information(SMESHGUI::desktop(),
3420 tr("SMESH_INFORMATION"),
3421 tr("NB_NODES_REMOVED").arg(removed));
3422 if ( removed > 0 ) {
3423 SMESH::UpdateView();
3424 SMESHGUI::Modified();
3427 catch (const SALOME::SALOME_Exception& S_ex) {
3428 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3437 case SMESHOp::OpRenumberingNodes:
3439 if(checkLock(aStudy)) break;
3441 EmitSignalDeactivateDialog();
3442 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3446 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3447 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3451 case SMESHOp::OpRenumberingElements:
3453 if(checkLock(aStudy)) break;
3455 EmitSignalDeactivateDialog();
3456 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3460 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3461 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3465 case SMESHOp::OpTranslation:
3467 if(checkLock(aStudy)) break;
3469 EmitSignalDeactivateDialog();
3470 ( new SMESHGUI_TranslationDlg( this ) )->show();
3473 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3474 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3478 case SMESHOp::OpRotation:
3480 if(checkLock(aStudy)) break;
3482 EmitSignalDeactivateDialog();
3483 ( new SMESHGUI_RotationDlg( this ) )->show();
3486 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3487 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3491 case SMESHOp::OpSymmetry:
3493 if(checkLock(aStudy)) break;
3495 EmitSignalDeactivateDialog();
3496 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3499 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3500 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3504 case SMESHOp::OpScale:
3506 if(checkLock(aStudy)) break;
3508 EmitSignalDeactivateDialog();
3509 ( new SMESHGUI_ScaleDlg( this ) )->show();
3512 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3513 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3518 case SMESHOp::OpSewing:
3520 if(checkLock(aStudy)) break;
3522 EmitSignalDeactivateDialog();
3523 ( new SMESHGUI_SewingDlg( this ) )->show();
3526 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3527 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3531 case SMESHOp::OpMergeNodes:
3533 if(checkLock(aStudy)) break;
3535 EmitSignalDeactivateDialog();
3536 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3539 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3540 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3544 case SMESHOp::OpMergeElements:
3546 if (checkLock(aStudy)) break;
3548 EmitSignalDeactivateDialog();
3549 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3551 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3552 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3557 case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
3558 startOperation( SMESHOp::OpMoveNode );
3561 case SMESHOp::OpDuplicateNodes:
3563 if(checkLock(aStudy)) break;
3565 EmitSignalDeactivateDialog();
3566 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3569 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3570 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3575 case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
3576 startOperation( SMESHOp::OpElem0DOnElemNodes );
3579 case SMESHOp::OpSelectFiltersLibrary: // Library of selection filters
3581 static QList<int> aTypes;
3582 if ( aTypes.isEmpty() )
3584 aTypes.append( SMESH::NODE );
3585 aTypes.append( SMESH::EDGE );
3586 aTypes.append( SMESH::FACE );
3587 aTypes.append( SMESH::VOLUME );
3589 if (!myFilterLibraryDlg)
3590 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3591 else if (myFilterLibraryDlg->isHidden())
3592 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3593 myFilterLibraryDlg->raise();
3597 case SMESHOp::OpFreeNode:
3598 case SMESHOp::OpEqualNode:
3599 case SMESHOp::OpNodeConnectivityNb:
3600 case SMESHOp::OpFreeEdge:
3601 case SMESHOp::OpFreeBorder:
3602 case SMESHOp::OpLength:
3603 case SMESHOp::OpConnection:
3604 case SMESHOp::OpEqualEdge:
3605 case SMESHOp::OpFreeFace:
3606 case SMESHOp::OpBareBorderFace:
3607 case SMESHOp::OpOverConstrainedFace:
3608 case SMESHOp::OpLength2D:
3609 case SMESHOp::OpConnection2D:
3610 case SMESHOp::OpArea:
3611 case SMESHOp::OpTaper:
3612 case SMESHOp::OpAspectRatio:
3613 case SMESHOp::OpMinimumAngle:
3614 case SMESHOp::OpWarpingAngle:
3615 case SMESHOp::OpSkew:
3616 case SMESHOp::OpMaxElementLength2D:
3617 case SMESHOp::OpEqualFace:
3618 case SMESHOp::OpAspectRatio3D:
3619 case SMESHOp::OpVolume:
3620 case SMESHOp::OpMaxElementLength3D:
3621 case SMESHOp::OpBareBorderVolume:
3622 case SMESHOp::OpOverConstrainedVolume:
3623 case SMESHOp::OpEqualVolume:
3626 LightApp_SelectionMgr* mgr = selectionMgr();
3627 SALOME_ListIO selected; mgr->selectedObjects( selected );
3629 if( !selected.IsEmpty() ) {
3630 SUIT_OverrideCursor wc;
3631 ::Control( theCommandID );
3634 SUIT_MessageBox::warning(desktop(),
3635 tr( "SMESH_WRN_WARNING" ),
3636 tr( "SMESH_BAD_SELECTION" ) );
3640 SUIT_MessageBox::warning(desktop(),
3641 tr( "SMESH_WRN_WARNING" ),
3642 tr( "NOT_A_VTK_VIEWER" ) );
3645 case SMESHOp::OpOverallMeshQuality:
3646 OverallMeshQuality();
3648 case SMESHOp::OpNumberingNodes:
3650 SUIT_OverrideCursor wc;
3651 LightApp_SelectionMgr* mgr = selectionMgr();
3652 SALOME_ListIO selected; mgr->selectedObjects( selected );
3654 SALOME_ListIteratorOfListIO it(selected);
3655 for( ; it.More(); it.Next()) {
3656 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3657 if(anIObject->hasEntry()) {
3658 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3659 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3665 case SMESHOp::OpNumberingElements:
3667 SUIT_OverrideCursor wc;
3668 LightApp_SelectionMgr* mgr = selectionMgr();
3669 SALOME_ListIO selected; mgr->selectedObjects( selected );
3671 SALOME_ListIteratorOfListIO it(selected);
3672 for( ; it.More(); it.Next()) {
3673 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3674 if(anIObject->hasEntry())
3675 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3676 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3681 case SMESHOp::OpPropertiesLength:
3682 case SMESHOp::OpPropertiesArea:
3683 case SMESHOp::OpPropertiesVolume:
3684 case SMESHOp::OpMinimumDistance:
3685 case SMESHOp::OpBoundingBox:
3687 int page = SMESHGUI_MeasureDlg::MinDistance;
3688 if ( theCommandID == SMESHOp::OpBoundingBox )
3689 page = SMESHGUI_MeasureDlg::BoundingBox;
3690 else if ( theCommandID == SMESHOp::OpPropertiesLength )
3691 page = SMESHGUI_MeasureDlg::Length;
3692 else if ( theCommandID == SMESHOp::OpPropertiesArea )
3693 page = SMESHGUI_MeasureDlg::Area;
3694 else if ( theCommandID == SMESHOp::OpPropertiesVolume )
3695 page = SMESHGUI_MeasureDlg::Volume;
3697 EmitSignalDeactivateDialog();
3698 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3702 case SMESHOp::OpSortChild:
3708 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3709 //updateObjBrowser();
3713 //=============================================================================
3717 //=============================================================================
3718 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3723 //=============================================================================
3727 //=============================================================================
3728 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3733 //=============================================================================
3737 //=============================================================================
3738 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3743 //=============================================================================
3744 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3745 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3747 //=============================================================================
3748 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3749 SUIT_ViewWindow* wnd )
3751 if(theIO->hasEntry()){
3752 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3753 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3757 //=======================================================================
3758 // function : createSMESHAction
3760 //=======================================================================
3761 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3762 const int key, const bool toggle, const QString& shortcutAction )
3765 QWidget* parent = application()->desktop();
3766 SUIT_ResourceMgr* resMgr = resourceMgr();
3768 if ( !icon_id.isEmpty() )
3769 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3771 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3772 if ( !pix.isNull() )
3773 icon = QIcon( pix );
3775 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3776 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3777 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3779 createAction( id, tooltip, icon, menu, status_bar, key, parent,
3780 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3783 //=======================================================================
3784 // function : createPopupItem
3786 //=======================================================================
3787 void SMESHGUI::createPopupItem( const int id,
3788 const QString& clients,
3789 const QString& types,
3790 const QString& theRule,
3793 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3794 popupMgr()->insert( action( id ), pId, 0 );
3796 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3797 QString dc = "selcount"; // VSR : insetad of QtxPopupSelection::defSelCountParam()
3798 QString rule = "(%1) and (%2) and (%3)";
3799 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3800 if( clients.isEmpty() )
3801 rule = rule.arg( QString( "true" ) );
3803 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3804 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3807 bool cont = myRules.contains( id );
3809 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3811 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3812 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3815 //=======================================================================
3816 // function : initialize
3818 //=======================================================================
3819 void SMESHGUI::initialize( CAM_Application* app )
3821 SalomeApp_Module::initialize( app );
3823 // SUIT_ResourceMgr* mgr = app->resourceMgr();
3825 /* Automatic Update flag */
3826 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3828 // ----- create actions --------------
3830 //createSMESHAction( SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
3831 createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_I) );
3832 createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
3833 createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL" );
3835 createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
3837 createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
3838 createSMESHAction( SMESHOp::OpImportGMF, "IMPORT_GMF" );
3839 createSMESHAction( SMESHOp::OpPopupImportUNV, "IMPORT_UNV");
3840 createSMESHAction( SMESHOp::OpPopupImportMED, "IMPORT_MED");
3841 createSMESHAction( SMESHOp::OpPopupImportSTL, "IMPORT_STL" );
3843 createSMESHAction( SMESHOp::OpPopupImportCGNS, "IMPORT_CGNS" );
3845 createSMESHAction( SMESHOp::OpPopupImportSAUV, "IMPORT_SAUV" );
3846 createSMESHAction( SMESHOp::OpPopupImportGMF, "IMPORT_GMF" );
3848 createSMESHAction( SMESHOp::OpExportDAT, "DAT" );
3849 createSMESHAction( SMESHOp::OpExportMED, "MED" );
3850 createSMESHAction( SMESHOp::OpExportUNV, "UNV" );
3851 createSMESHAction( SMESHOp::OpExportSTL, "STL" );
3853 createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
3855 createSMESHAction( SMESHOp::OpExportSAUV, "SAUV");
3856 createSMESHAction( SMESHOp::OpExportGMF, "GMF" );
3857 createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
3858 createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
3859 createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
3860 createSMESHAction( SMESHOp::OpPopupExportSTL, "STL" );
3862 createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
3864 createSMESHAction( SMESHOp::OpPopupExportSAUV, "SAUV");
3865 createSMESHAction( SMESHOp::OpPopupExportGMF, "GMF" );
3866 createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
3867 createSMESHAction( SMESHOp::OpDelete, "DELETE", "ICON_DELETE", Qt::Key_Delete );
3868 createSMESHAction( SMESHOp::OpSelectFiltersLibrary, "SEL_FILTER_LIB" );
3869 createSMESHAction( SMESHOp::OpCreateMesh, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
3870 createSMESHAction( SMESHOp::OpCreateSubMesh, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
3871 createSMESHAction( SMESHOp::OpEditMeshOrSubMesh, "EDIT_MESHSUBMESH", "ICON_DLG_EDIT_MESH" );
3872 createSMESHAction( SMESHOp::OpEditMesh, "EDIT_MESH", "ICON_DLG_EDIT_MESH" );
3873 createSMESHAction( SMESHOp::OpEditSubMesh, "EDIT_SUBMESH", "ICON_DLG_EDIT_MESH" );
3874 createSMESHAction( SMESHOp::OpBuildCompoundMesh, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
3875 createSMESHAction( SMESHOp::OpCopyMesh, "COPY_MESH", "ICON_COPY_MESH" );
3876 createSMESHAction( SMESHOp::OpCompute, "COMPUTE", "ICON_COMPUTE" );
3877 createSMESHAction( SMESHOp::OpComputeSubMesh, "COMPUTE_SUBMESH", "ICON_COMPUTE" );
3878 createSMESHAction( SMESHOp::OpPreCompute, "PRECOMPUTE", "ICON_PRECOMPUTE" );
3879 createSMESHAction( SMESHOp::OpEvaluate, "EVALUATE", "ICON_EVALUATE" );
3880 createSMESHAction( SMESHOp::OpMeshOrder, "MESH_ORDER", "ICON_MESH_ORDER");
3881 createSMESHAction( SMESHOp::OpCreateGroup, "CREATE_GROUP", "ICON_CREATE_GROUP" );
3882 createSMESHAction( SMESHOp::OpCreateGeometryGroup, "CREATE_GEO_GROUP", "ICON_CREATE_GEO_GROUP" );
3883 createSMESHAction( SMESHOp::OpConstructGroup, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
3884 createSMESHAction( SMESHOp::OpEditGroup, "EDIT_GROUP", "ICON_EDIT_GROUP" );
3885 createSMESHAction( SMESHOp::OpEditGeomGroupAsGroup, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3886 createSMESHAction( SMESHOp::OpUnionGroups, "UN_GROUP", "ICON_UNION" );
3887 createSMESHAction( SMESHOp::OpIntersectGroups, "INT_GROUP", "ICON_INTERSECT" );
3888 createSMESHAction( SMESHOp::OpCutGroups, "CUT_GROUP", "ICON_CUT" );
3889 createSMESHAction( SMESHOp::OpGroupUnderlyingElem, "UNDERLYING_ELEMS", "ICON_UNDERLYING_ELEMS" );
3890 createSMESHAction( SMESHOp::OpAddElemGroupPopup, "ADD_TO_GROUP" );
3891 createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE_FROM_GROUP" );
3892 createSMESHAction( SMESHOp::OpDeleteGroup, "DEL_GROUP", "ICON_DEL_GROUP" );
3893 createSMESHAction( SMESHOp::OpMeshInformation , "ADV_INFO", "ICON_ADV_INFO" );
3894 //createSMESHAction( SMESHOp::OpStdInfo, "STD_INFO", "ICON_STD_INFO" );
3895 //createSMESHAction( SMESHOp::OpWhatIs, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3896 createSMESHAction( SMESHOp::OpFindElementByPoint, "FIND_ELEM", "ICON_FIND_ELEM" );
3898 createSMESHAction( SMESHOp::OpFreeNode, "FREE_NODE", "ICON_FREE_NODE", 0, true );
3899 createSMESHAction( SMESHOp::OpEqualNode, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
3900 createSMESHAction( SMESHOp::OpNodeConnectivityNb, "NODE_CONNECTIVITY_NB", "ICON_NODE_CONN_NB", 0, true );
3901 createSMESHAction( SMESHOp::OpFreeEdge, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
3902 createSMESHAction( SMESHOp::OpFreeBorder, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
3903 createSMESHAction( SMESHOp::OpLength, "LENGTH", "ICON_LENGTH", 0, true );
3904 createSMESHAction( SMESHOp::OpConnection, "CONNECTION", "ICON_CONNECTION", 0, true );
3905 createSMESHAction( SMESHOp::OpEqualEdge, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
3906 createSMESHAction( SMESHOp::OpFreeFace, "FREE_FACES", "ICON_FREE_FACES", 0, true );
3907 createSMESHAction( SMESHOp::OpBareBorderFace, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
3908 createSMESHAction( SMESHOp::OpOverConstrainedFace, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
3909 createSMESHAction( SMESHOp::OpLength2D, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
3910 createSMESHAction( SMESHOp::OpConnection2D, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
3911 createSMESHAction( SMESHOp::OpArea, "AREA", "ICON_AREA", 0, true );
3912 createSMESHAction( SMESHOp::OpTaper, "TAPER", "ICON_TAPER", 0, true );
3913 createSMESHAction( SMESHOp::OpAspectRatio, "ASPECT", "ICON_ASPECT", 0, true );
3914 createSMESHAction( SMESHOp::OpMinimumAngle, "MIN_ANG", "ICON_ANGLE", 0, true );
3915 createSMESHAction( SMESHOp::OpWarpingAngle, "WARP", "ICON_WARP", 0, true );
3916 createSMESHAction( SMESHOp::OpSkew, "SKEW", "ICON_SKEW", 0, true );
3917 createSMESHAction( SMESHOp::OpMaxElementLength2D, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
3918 createSMESHAction( SMESHOp::OpEqualFace, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
3919 createSMESHAction( SMESHOp::OpAspectRatio3D, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
3920 createSMESHAction( SMESHOp::OpVolume, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
3921 createSMESHAction( SMESHOp::OpMaxElementLength3D, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
3922 createSMESHAction( SMESHOp::OpBareBorderVolume, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
3923 createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
3924 createSMESHAction( SMESHOp::OpEqualVolume, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
3925 createSMESHAction( SMESHOp::OpOverallMeshQuality, "OVERALL_MESH_QUALITY", "ICON_OVL_MESH_QUALITY" );
3927 createSMESHAction( SMESHOp::OpNode, "NODE", "ICON_DLG_NODE" );
3928 createSMESHAction( SMESHOp::OpElem0D, "ELEM0D", "ICON_DLG_ELEM0D" );
3929 createSMESHAction( SMESHOp::OpElem0DOnElemNodes, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
3930 createSMESHAction( SMESHOp::OpBall, "BALL", "ICON_DLG_BALL" );
3931 createSMESHAction( SMESHOp::OpEdge, "EDGE", "ICON_DLG_EDGE" );
3932 createSMESHAction( SMESHOp::OpTriangle, "TRIANGLE", "ICON_DLG_TRIANGLE" );
3933 createSMESHAction( SMESHOp::OpQuadrangle, "QUAD", "ICON_DLG_QUADRANGLE" );
3934 createSMESHAction( SMESHOp::OpPolygon, "POLYGON", "ICON_DLG_POLYGON" );
3935 createSMESHAction( SMESHOp::OpTetrahedron, "TETRA", "ICON_DLG_TETRAS" );
3936 createSMESHAction( SMESHOp::OpHexahedron, "HEXA", "ICON_DLG_HEXAS" );
3937 createSMESHAction( SMESHOp::OpPentahedron, "PENTA", "ICON_DLG_PENTA" );
3938 createSMESHAction( SMESHOp::OpPyramid , "PYRAMID", "ICON_DLG_PYRAMID" );
3939 createSMESHAction( SMESHOp::OpHexagonalPrism, "OCTA", "ICON_DLG_OCTA" );
3940 createSMESHAction( SMESHOp::OpPolyhedron, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
3941 createSMESHAction( SMESHOp::OpQuadraticEdge, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
3942 createSMESHAction( SMESHOp::OpQuadraticTriangle, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
3943 createSMESHAction( SMESHOp::OpBiQuadraticTriangle, "BIQUADRATIC_TRIANGLE", "ICON_DLG_BIQUADRATIC_TRIANGLE" );
3944 createSMESHAction( SMESHOp::OpQuadraticQuadrangle, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
3945 createSMESHAction( SMESHOp::OpBiQuadraticQuadrangle, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
3946 createSMESHAction( SMESHOp::OpQuadraticPolygon, "QUADRATIC_POLYGON", "ICON_DLG_QUADRATIC_POLYGON" );
3947 createSMESHAction( SMESHOp::OpQuadraticTetrahedron, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
3948 createSMESHAction( SMESHOp::OpQuadraticPyramid, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
3949 createSMESHAction( SMESHOp::OpQuadraticPentahedron, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
3950 createSMESHAction( SMESHOp::OpQuadraticHexahedron, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
3951 createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
3953 createSMESHAction( SMESHOp::OpRemoveNodes, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
3954 createSMESHAction( SMESHOp::OpRemoveElements, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
3955 createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
3956 createSMESHAction( SMESHOp::OpClearMesh, "CLEAR_MESH", "ICON_CLEAR_MESH" );
3958 //createSMESHAction( SMESHOp::OpRenumberingNodes, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
3959 //createSMESHAction( SMESHOp::OpRenumberingElements, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
3961 createSMESHAction( SMESHOp::OpTranslation, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
3962 createSMESHAction( SMESHOp::OpRotation, "ROT", "ICON_DLG_MESH_ROTATION" );
3963 createSMESHAction( SMESHOp::OpSymmetry, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
3964 createSMESHAction( SMESHOp::OpScale, "SCALE", "ICON_DLG_MESH_SCALE" );
3965 createSMESHAction( SMESHOp::OpSewing, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
3966 createSMESHAction( SMESHOp::OpMergeNodes, "MERGE", "ICON_SMESH_MERGE_NODES" );
3967 createSMESHAction( SMESHOp::OpMergeElements, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
3968 createSMESHAction( SMESHOp::OpMoveNode, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
3969 createSMESHAction( SMESHOp::OpDuplicateNodes, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
3970 createSMESHAction( SMESHOp::OpDiagonalInversion, "INV", "ICON_DLG_MESH_DIAGONAL" );
3971 createSMESHAction( SMESHOp::OpUnionOfTwoTriangle, "UNION2", "ICON_UNION2TRI" );
3972 createSMESHAction( SMESHOp::OpOrientation, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
3973 createSMESHAction( SMESHOp::OpReorientFaces, "REORIENT_2D", "ICON_REORIENT_2D" );
3974 createSMESHAction( SMESHOp::OpUnionOfTriangles, "UNION", "ICON_UNIONTRI" );
3975 createSMESHAction( SMESHOp::OpCuttingOfQuadrangles, "CUT", "ICON_CUTQUAD" );
3976 createSMESHAction( SMESHOp::OpSplitVolumes, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
3977 createSMESHAction( SMESHOp::OpSplitBiQuadratic, "SPLIT_BIQUAD", "ICON_SPLIT_BIQUAD" );
3978 createSMESHAction( SMESHOp::OpSmoothing, "SMOOTH", "ICON_DLG_SMOOTHING" );
3979 createSMESHAction( SMESHOp::OpExtrusion, "EXTRUSION", "ICON_EXTRUSION" );
3980 createSMESHAction( SMESHOp::OpExtrusionAlongAPath, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
3981 createSMESHAction( SMESHOp::OpRevolution, "REVOLUTION", "ICON_REVOLUTION" );
3982 createSMESHAction( SMESHOp::OpPatternMapping, "MAP", "ICON_MAP" );
3983 createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
3984 createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D", "ICON_2D_FROM_3D" );
3986 createSMESHAction( SMESHOp::OpReset, "RESET" );
3987 createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
3988 createSMESHAction( SMESHOp::OpShowScalarBar, "SHOW_SCALAR_BAR","",0, true );
3989 createSMESHAction( SMESHOp::OpSaveDistribution, "SAVE_DISTRIBUTION" );
3990 createSMESHAction( SMESHOp::OpShowDistribution, "SHOW_DISTRIBUTION","",0, true );
3991 #ifndef DISABLE_PLOT2DVIEWER
3992 createSMESHAction( SMESHOp::OpPlotDistribution, "PLOT_DISTRIBUTION" );
3994 createSMESHAction( SMESHOp::OpDMWireframe, "WIRE", "ICON_WIRE", 0, true );
3995 createSMESHAction( SMESHOp::OpDMShading, "SHADE", "ICON_SHADE", 0, true );
3996 createSMESHAction( SMESHOp::OpDMNodes, "NODES", "ICON_POINTS", 0, true );
3997 createSMESHAction( SMESHOp::OpDMShrink, "SHRINK", "ICON_SHRINK", 0, true );
3998 createSMESHAction( SMESHOp::OpUpdate, "UPDATE", "ICON_UPDATE" );
3999 createSMESHAction( SMESHOp::OpDE0DElements, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
4000 createSMESHAction( SMESHOp::OpDEEdges, "EDGES", "ICON_DLG_EDGE", 0, true );
4001 createSMESHAction( SMESHOp::OpDEFaces, "FACES", "ICON_DLG_TRIANGLE", 0, true );
4002 createSMESHAction( SMESHOp::OpDEVolumes, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
4003 createSMESHAction( SMESHOp::OpDEBalls, "BALLS", "ICON_DLG_BALL", 0, true );
4004 createSMESHAction( SMESHOp::OpDEChoose, "CHOOSE", "ICON_DLG_CHOOSE", 0, false );
4005 createSMESHAction( SMESHOp::OpDEAllEntity, "ALL", "ICON_DLG_CHOOSE_ALL", 0, false );
4006 createSMESHAction( SMESHOp::OpOrientationOnFaces, "FACE_ORIENTATION", "", 0, true );
4008 createSMESHAction( SMESHOp::OpRepresentationLines, "LINE_REPRESENTATION", "", 0, true );
4009 createSMESHAction( SMESHOp::OpRepresentationArcs, "ARC_REPRESENTATION", "", 0, true );
4011 createSMESHAction( SMESHOp::OpEditHypothesis, "EDIT_HYPO" );
4012 createSMESHAction( SMESHOp::OpUnassign, "UNASSIGN" );
4013 createSMESHAction( SMESHOp::OpNumberingNodes, "NUM_NODES", "", 0, true );
4014 createSMESHAction( SMESHOp::OpNumberingElements, "NUM_ELEMENTS", "", 0, true );
4015 createSMESHAction( SMESHOp::OpProperties, "COLORS" );
4016 createSMESHAction( SMESHOp::OpTransparency, "TRANSP" );
4017 createSMESHAction( SMESHOp::OpClipping, "CLIP" );
4018 createSMESHAction( SMESHOp::OpAutoColor, "AUTO_COLOR" );
4019 createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
4021 createSMESHAction( SMESHOp::OpMinimumDistance, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
4022 createSMESHAction( SMESHOp::OpBoundingBox, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
4023 createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH", "ICON_MEASURE_LENGTH" );
4024 createSMESHAction( SMESHOp::OpPropertiesArea, "MEASURE_AREA", "ICON_MEASURE_AREA" );
4025 createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME", "ICON_MEASURE_VOLUME" );
4027 createSMESHAction( SMESHOp::OpHide, "HIDE", "ICON_HIDE" );
4028 createSMESHAction( SMESHOp::OpShow, "SHOW", "ICON_SHOW" );
4029 createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
4031 createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
4033 QList<int> aCtrlActions;
4034 aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode
4035 << SMESHOp::OpNodeConnectivityNb // node controls
4036 << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
4037 << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge // edge controls
4038 << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
4039 << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
4040 << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
4041 << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
4042 << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace // face controls
4043 << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
4044 << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
4045 << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume; // volume controls
4046 QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
4047 aCtrlGroup->setExclusive( true );
4048 for( int i = 0; i < aCtrlActions.size(); i++ )
4049 aCtrlGroup->addAction( action( aCtrlActions[i] ) );
4051 // ----- create menu --------------
4052 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
4053 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
4054 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
4055 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
4056 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
4057 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
4058 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
4059 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
4061 createMenu( separator(), fileId );
4063 QMenu* nodeMenu = new QMenu(); QMenu* edgeMenu = new QMenu();
4064 QMenu* faceMenu = new QMenu(); QMenu* volumeMenu = new QMenu();
4065 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
4066 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
4067 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10, -1, nodeMenu ),
4068 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10, -1, edgeMenu ),
4069 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10, -1, faceMenu ),
4070 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10, -1, volumeMenu ),
4071 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
4072 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
4073 //renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
4074 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
4075 basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
4077 //createMenu( SMESHOp::OpImportDAT, importId, -1 );
4078 createMenu( SMESHOp::OpImportUNV, importId, -1 );
4079 createMenu( SMESHOp::OpImportMED, importId, -1 );
4080 createMenu( SMESHOp::OpImportSTL, importId, -1 );
4082 createMenu( SMESHOp::OpImportCGNS, importId, -1 );
4084 createMenu( SMESHOp::OpImportSAUV, importId, -1 );
4085 createMenu( SMESHOp::OpImportGMF, importId, -1 );
4086 createMenu( SMESHOp::OpExportDAT, exportId, -1 );
4087 createMenu( SMESHOp::OpExportMED, exportId, -1 );
4088 createMenu( SMESHOp::OpExportUNV, exportId, -1 );
4089 createMenu( SMESHOp::OpExportSTL, exportId, -1 );
4091 createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
4093 createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
4094 createMenu( SMESHOp::OpExportGMF, exportId, -1 );
4095 createMenu( separator(), fileId, 10 );
4097 createMenu( SMESHOp::OpDelete, editId, -1 );
4099 createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
4101 createMenu( SMESHOp::OpCreateMesh, meshId, -1 ); // "Mesh" menu
4102 createMenu( SMESHOp::OpCreateSubMesh, meshId, -1 );
4103 createMenu( SMESHOp::OpEditMeshOrSubMesh, meshId, -1 );
4104 createMenu( SMESHOp::OpBuildCompoundMesh, meshId, -1 );
4105 createMenu( SMESHOp::OpCopyMesh, meshId, -1 );
4106 createMenu( separator(), meshId, -1 );
4107 createMenu( SMESHOp::OpCompute, meshId, -1 );
4108 createMenu( SMESHOp::OpPreCompute, meshId, -1 );
4109 createMenu( SMESHOp::OpEvaluate, meshId, -1 );
4110 createMenu( SMESHOp::OpMeshOrder, meshId, -1 );
4111 createMenu( separator(), meshId, -1 );
4112 createMenu( SMESHOp::OpCreateGroup, meshId, -1 );
4113 createMenu( SMESHOp::OpCreateGeometryGroup, meshId, -1 );
4114 createMenu( SMESHOp::OpConstructGroup, meshId, -1 );
4115 createMenu( SMESHOp::OpEditGroup, meshId, -1 );
4116 createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4117 createMenu( separator(), meshId, -1 );
4118 createMenu( SMESHOp::OpUnionGroups, meshId, -1 );
4119 createMenu( SMESHOp::OpIntersectGroups, meshId, -1 );
4120 createMenu( SMESHOp::OpCutGroups, meshId, -1 );
4121 createMenu( separator(), meshId, -1 );
4122 createMenu( SMESHOp::OpGroupUnderlyingElem, meshId, -1 );
4123 createMenu( separator(), meshId, -1 );
4124 createMenu( SMESHOp::OpMeshInformation, meshId, -1 );
4125 //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4126 //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4127 createMenu( SMESHOp::OpFindElementByPoint, meshId, -1 );
4128 createMenu( separator(), meshId, -1 );
4130 createMenu( SMESHOp::OpFreeNode, nodeId, -1 );
4131 createMenu( SMESHOp::OpEqualNode, nodeId, -1 );
4132 //createMenu( SMESHOp::OpNodeConnectivityNb, nodeId, -1 );
4133 createMenu( SMESHOp::OpFreeBorder, edgeId, -1 );
4134 createMenu( SMESHOp::OpLength, edgeId, -1 );
4135 createMenu( SMESHOp::OpConnection, edgeId, -1 );
4136 createMenu( SMESHOp::OpEqualEdge, edgeId, -1 );
4137 createMenu( SMESHOp::OpFreeEdge, faceId, -1 );
4138 createMenu( SMESHOp::OpFreeFace, faceId, -1 );
4139 createMenu( SMESHOp::OpBareBorderFace, faceId, -1 );
4140 createMenu( SMESHOp::OpOverConstrainedFace, faceId, -1 );
4141 createMenu( SMESHOp::OpLength2D, faceId, -1 );
4142 createMenu( SMESHOp::OpConnection2D, faceId, -1 );
4143 createMenu( SMESHOp::OpArea, faceId, -1 );
4144 createMenu( SMESHOp::OpTaper, faceId, -1 );
4145 createMenu( SMESHOp::OpAspectRatio, faceId, -1 );
4146 createMenu( SMESHOp::OpMinimumAngle, faceId, -1 );
4147 createMenu( SMESHOp::OpWarpingAngle, faceId, -1 );
4148 createMenu( SMESHOp::OpSkew, faceId, -1 );
4149 createMenu( SMESHOp::OpMaxElementLength2D, faceId, -1 );
4150 createMenu( SMESHOp::OpEqualFace, faceId, -1 );
4151 createMenu( SMESHOp::OpAspectRatio3D, volumeId, -1 );
4152 createMenu( SMESHOp::OpVolume, volumeId, -1 );
4153 createMenu( SMESHOp::OpMaxElementLength3D, volumeId, -1 );
4154 createMenu( SMESHOp::OpBareBorderVolume, volumeId, -1 );
4155 createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4156 createMenu( SMESHOp::OpEqualVolume, volumeId, -1 );
4157 createMenu( separator(), ctrlId, -1 );
4158 createMenu( SMESHOp::OpReset, ctrlId, -1 );
4159 createMenu( separator(), ctrlId, -1 );
4160 createMenu( SMESHOp::OpOverallMeshQuality, ctrlId, -1 );
4162 createMenu( SMESHOp::OpNode, addId, -1 );
4163 createMenu( SMESHOp::OpElem0D, addId, -1 );
4164 createMenu( SMESHOp::OpElem0DOnElemNodes, addId, -1 );
4165 createMenu( SMESHOp::OpBall, addId, -1 );
4166 createMenu( SMESHOp::OpEdge, addId, -1 );
4167 createMenu( SMESHOp::OpTriangle, addId, -1 );
4168 createMenu( SMESHOp::OpQuadrangle, addId, -1 );
4169 createMenu( SMESHOp::OpPolygon, addId, -1 );
4170 createMenu( SMESHOp::OpTetrahedron, addId, -1 );
4171 createMenu( SMESHOp::OpHexahedron, addId, -1 );
4172 createMenu( SMESHOp::OpPentahedron, addId, -1 );
4173 createMenu( SMESHOp::OpPyramid, addId, -1 );
4174 createMenu( SMESHOp::OpHexagonalPrism, addId, -1 );
4175 createMenu( SMESHOp::OpPolyhedron, addId, -1 );
4176 createMenu( separator(), addId, -1 );
4177 createMenu( SMESHOp::OpQuadraticEdge, addId, -1 );
4178 createMenu( SMESHOp::OpQuadraticTriangle, addId, -1 );
4179 createMenu( SMESHOp::OpBiQuadraticTriangle , addId, -1 );
4180 createMenu( SMESHOp::OpQuadraticQuadrangle, addId, -1 );
4181 createMenu( SMESHOp::OpBiQuadraticQuadrangle, addId, -1 );
4182 createMenu( SMESHOp::OpQuadraticPolygon, addId, -1 );
4183 createMenu( SMESHOp::OpQuadraticTetrahedron, addId, -1 );
4184 createMenu( SMESHOp::OpQuadraticPyramid, addId, -1 );
4185 createMenu( SMESHOp::OpQuadraticPentahedron, addId, -1 );
4186 createMenu( SMESHOp::OpQuadraticHexahedron, addId, -1 );
4187 createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4189 createMenu( SMESHOp::OpRemoveNodes, removeId, -1 );
4190 createMenu( SMESHOp::OpRemoveElements, removeId, -1 );
4191 createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4192 createMenu( separator(), removeId, -1 );
4193 createMenu( SMESHOp::OpDeleteGroup, removeId, -1 );
4194 createMenu( separator(), removeId, -1 );
4195 createMenu( SMESHOp::OpClearMesh, removeId, -1 );
4197 //createMenu( SMESHOp::OpRenumberingNodes, renumId, -1 );
4198 //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4200 createMenu( SMESHOp::OpTranslation, transfId, -1 );
4201 createMenu( SMESHOp::OpRotation, transfId, -1 );
4202 createMenu( SMESHOp::OpSymmetry, transfId, -1 );
4203 createMenu( SMESHOp::OpScale, transfId, -1 );
4204 createMenu( SMESHOp::OpSewing, transfId, -1 );
4205 createMenu( SMESHOp::OpMergeNodes, transfId, -1 );
4206 createMenu( SMESHOp::OpMergeElements, transfId, -1 );
4207 createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4209 createMenu( SMESHOp::OpMoveNode, modifyId, -1 );
4210 createMenu( SMESHOp::OpDiagonalInversion, modifyId, -1 );
4211 createMenu( SMESHOp::OpUnionOfTwoTriangle, modifyId, -1 );
4212 createMenu( SMESHOp::OpOrientation, modifyId, -1 );
4213 createMenu( SMESHOp::OpReorientFaces, modifyId, -1 );
4214 createMenu( SMESHOp::OpUnionOfTriangles, modifyId, -1 );
4215 createMenu( SMESHOp::OpCuttingOfQuadrangles, modifyId, -1 );
4216 createMenu( SMESHOp::OpSplitVolumes, modifyId, -1 );
4217 createMenu( SMESHOp::OpSplitBiQuadratic, modifyId, -1 );
4218 createMenu( SMESHOp::OpSmoothing, modifyId, -1 );
4219 createMenu( SMESHOp::OpExtrusion, modifyId, -1 );
4220 createMenu( SMESHOp::OpExtrusionAlongAPath , modifyId, -1 );
4221 createMenu( SMESHOp::OpRevolution, modifyId, -1 );
4222 createMenu( SMESHOp::OpPatternMapping, modifyId, -1 );
4223 createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4224 createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4226 createMenu( SMESHOp::OpMinimumDistance, measureId, -1 );
4227 createMenu( SMESHOp::OpBoundingBox, measureId, -1 );
4228 createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4229 createMenu( SMESHOp::OpPropertiesArea, basicPropId, -1 );
4230 createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4231 createMenu( SMESHOp::OpUpdate, viewId, -1 );
4233 connect( nodeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4234 connect( edgeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4235 connect( faceMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4236 connect( volumeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4238 // ----- create toolbars --------------
4239 int meshTb = createTool( tr( "TB_MESH" ), QString( "SMESHMeshToolbar" ) ),
4240 info = createTool( tr( "TB_INFO" ), QString( "SMESHInformationToolbar" ) ),
4241 groupTb = createTool( tr( "TB_GROUP" ), QString( "SMESHGroupToolbar" ) ),
4242 ctrl0dTb = createTool( tr( "TB_CTRL0D" ), QString( "SMESHNodeControlsToolbar" ) ),
4243 ctrl1dTb = createTool( tr( "TB_CTRL1D" ), QString( "SMESHEdgeControlsToolbar" ) ),
4244 ctrl2dTb = createTool( tr( "TB_CTRL2D" ), QString( "SMESHFaceControlsToolbar" ) ),
4245 ctrl3dTb = createTool( tr( "TB_CTRL3D" ), QString( "SMESHVolumeControlsToolbar" ) ),
4246 addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ),
4247 addNonElemTb = createTool( tr( "TB_ADDNON" ), QString( "SMESHAddElementToolbar" ) ),
4248 remTb = createTool( tr( "TB_REM" ), QString( "SMESHRemoveToolbar" ) ),
4249 //renumbTb = createTool( tr( "TB_RENUMBER" ), QString( "SMESHRenumberingToolbar" ) ),
4250 transformTb = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ),
4251 modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ),
4252 measuremTb = createTool( tr( "TB_MEASUREM" ), QString( "SMESHMeasurementsToolbar" ) ),
4253 dispModeTb = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4255 createTool( SMESHOp::OpCreateMesh, meshTb );
4256 createTool( SMESHOp::OpCreateSubMesh, meshTb );
4257 createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4258 createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4259 createTool( SMESHOp::OpCopyMesh, meshTb );
4260 createTool( separator(), meshTb );
4261 createTool( SMESHOp::OpCompute, meshTb );
4262 createTool( SMESHOp::OpPreCompute, meshTb );
4263 createTool( SMESHOp::OpEvaluate, meshTb );
4264 createTool( SMESHOp::OpMeshOrder, meshTb );
4266 createTool( SMESHOp::OpCreateGroup, groupTb );
4267 createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4268 createTool( SMESHOp::OpConstructGroup, groupTb );
4269 createTool( SMESHOp::OpEditGroup, groupTb );
4271 createTool( SMESHOp::OpMeshInformation, info );
4272 //createTool( SMESHOp::OpStdInfo, meshTb );
4273 //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4274 createTool( SMESHOp::OpFindElementByPoint, info );
4276 createTool( SMESHOp::OpFreeNode, ctrl0dTb );
4277 createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4278 //createTool( SMESHOp::OpNodeConnectivityNb, ctrl0dTb );
4280 createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4281 createTool( SMESHOp::OpLength, ctrl1dTb );
4282 createTool( SMESHOp::OpConnection, ctrl1dTb );
4283 createTool( SMESHOp::OpEqualEdge, ctrl1dTb );
4285 createTool( SMESHOp::OpFreeEdge, ctrl2dTb );
4286 createTool( SMESHOp::OpFreeFace, ctrl2dTb );
4287 createTool( SMESHOp::OpBareBorderFace, ctrl2dTb );
4288 createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4289 createTool( SMESHOp::OpLength2D, ctrl2dTb );
4290 createTool( SMESHOp::OpConnection2D, ctrl2dTb );
4291 createTool( SMESHOp::OpArea, ctrl2dTb );
4292 createTool( SMESHOp::OpTaper, ctrl2dTb );
4293 createTool( SMESHOp::OpAspectRatio, ctrl2dTb );
4294 createTool( SMESHOp::OpMinimumAngle, ctrl2dTb );
4295 createTool( SMESHOp::OpWarpingAngle, ctrl2dTb );
4296 createTool( SMESHOp::OpSkew, ctrl2dTb );
4297 createTool( SMESHOp::OpMaxElementLength2D, ctrl2dTb );
4298 createTool( SMESHOp::OpEqualFace, ctrl2dTb );
4300 createTool( SMESHOp::OpAspectRatio3D, ctrl3dTb );
4301 createTool( SMESHOp::OpVolume, ctrl3dTb );
4302 createTool( SMESHOp::OpMaxElementLength3D, ctrl3dTb );
4303 createTool( SMESHOp::OpBareBorderVolume, ctrl3dTb );
4304 createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
4305 createTool( SMESHOp::OpEqualVolume, ctrl3dTb );
4307 createTool( SMESHOp::OpNode, addElemTb );
4308 createTool( SMESHOp::OpElem0D, addElemTb );
4309 createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4310 createTool( SMESHOp::OpBall, addElemTb );
4311 createTool( SMESHOp::OpEdge, addElemTb );
4312 createTool( SMESHOp::OpTriangle, addElemTb );
4313 createTool( SMESHOp::OpQuadrangle, addElemTb );
4314 createTool( SMESHOp::OpPolygon, addElemTb );
4315 createTool( SMESHOp::OpTetrahedron, addElemTb );
4316 createTool( SMESHOp::OpHexahedron, addElemTb );
4317 createTool( SMESHOp::OpPentahedron, addElemTb );
4318 createTool( SMESHOp::OpPyramid, addElemTb );
4319 createTool( SMESHOp::OpHexagonalPrism, addElemTb );
4320 createTool( SMESHOp::OpPolyhedron, addElemTb );
4322 createTool( SMESHOp::OpQuadraticEdge, addNonElemTb );
4323 createTool( SMESHOp::OpQuadraticTriangle, addNonElemTb );
4324 createTool( SMESHOp::OpBiQuadraticTriangle, addNonElemTb );
4325 createTool( SMESHOp::OpQuadraticQuadrangle, addNonElemTb );
4326 createTool( SMESHOp::OpBiQuadraticQuadrangle, addNonElemTb );
4327 createTool( SMESHOp::OpQuadraticPolygon, addNonElemTb );
4328 createTool( SMESHOp::OpQuadraticTetrahedron, addNonElemTb );
4329 createTool( SMESHOp::OpQuadraticPyramid, addNonElemTb );
4330 createTool( SMESHOp::OpQuadraticPentahedron, addNonElemTb );
4331 createTool( SMESHOp::OpQuadraticHexahedron, addNonElemTb );
4332 createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4334 createTool( SMESHOp::OpRemoveNodes, remTb );
4335 createTool( SMESHOp::OpRemoveElements, remTb );
4336 createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4337 createTool( SMESHOp::OpClearMesh, remTb );
4339 //createTool( SMESHOp::OpRenumberingNodes, renumbTb );
4340 //createTool( SMESHOp::OpRenumberingElements, renumbTb );
4342 createTool( SMESHOp::OpTranslation, transformTb );
4343 createTool( SMESHOp::OpRotation, transformTb );
4344 createTool( SMESHOp::OpSymmetry, transformTb );
4345 createTool( SMESHOp::OpScale, transformTb );
4346 createTool( SMESHOp::OpSewing, transformTb );
4347 createTool( SMESHOp::OpMergeNodes, transformTb );
4348 createTool( SMESHOp::OpMergeElements, transformTb );
4349 createTool( SMESHOp::OpDuplicateNodes, transformTb );
4351 createTool( SMESHOp::OpMoveNode, modifyTb );
4352 createTool( SMESHOp::OpDiagonalInversion, modifyTb );
4353 createTool( SMESHOp::OpUnionOfTwoTriangle, modifyTb );
4354 createTool( SMESHOp::OpOrientation, modifyTb );
4355 createTool( SMESHOp::OpReorientFaces, modifyTb );
4356 createTool( SMESHOp::OpUnionOfTriangles, modifyTb );
4357 createTool( SMESHOp::OpCuttingOfQuadrangles, modifyTb );
4358 createTool( SMESHOp::OpSplitVolumes, modifyTb );
4359 createTool( SMESHOp::OpSplitBiQuadratic, modifyTb );
4360 createTool( SMESHOp::OpSmoothing, modifyTb );
4361 createTool( SMESHOp::OpExtrusion, modifyTb );
4362 createTool( SMESHOp::OpExtrusionAlongAPath, modifyTb );
4363 createTool( SMESHOp::OpRevolution, modifyTb );
4364 createTool( SMESHOp::OpPatternMapping, modifyTb );
4365 createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4366 createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4368 createTool( SMESHOp::OpMinimumDistance, measuremTb );
4370 createTool( SMESHOp::OpUpdate, dispModeTb );
4372 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4373 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4377 OB = "'ObjectBrowser'",
4378 View = "'" + SVTK_Viewer::Type() + "'",
4380 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4381 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4382 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4383 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4384 smesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::COMPONENT ) ),
4385 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4386 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4387 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4388 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4389 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4390 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4391 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4393 mesh_part = mesh + " " + subMesh + " " + group,
4394 mesh_group = mesh + " " + group,
4395 mesh_submesh = mesh + " " + subMesh,
4396 hyp_alg = hypo + " " + algo;
4398 // popup for object browser
4400 isInvisible("not( isVisible )"),
4401 isEmpty("numberOfNodes = 0"),
4402 isNotEmpty("numberOfNodes <> 0"),
4404 // has nodes, edges, etc in VISIBLE! actor
4405 hasNodes("(numberOfNodes > 0 ) && hasActor"),
4406 hasElems("(count( elemTypes ) > 0)"),
4407 hasDifferentElems("(count( elemTypes ) > 1)"),
4408 hasDifferentObjElems("(count( objElemTypes ) > 1)"),
4409 hasBalls("({'BallElem'} in elemTypes)"),
4410 hasElems0d("({'Elem0d'} in elemTypes)"),
4411 hasEdges("({'Edge'} in elemTypes)"),
4412 hasFaces("({'Face'} in elemTypes)"),
4413 hasVolumes("({'Volume'} in elemTypes)"),
4414 hasFacesOrVolumes("(({'Face'} in elemTypes) || ({'Volume'} in elemTypes)) ");
4416 createPopupItem( SMESHOp::OpFileInformation, OB, mesh, "&& selcount=1 && isImported" );
4417 createPopupItem( SMESHOp::OpCreateSubMesh, OB, mesh, "&& hasGeomReference");
4418 createPopupItem( SMESHOp::OpEditMesh, OB, mesh, "&& selcount=1" );
4419 createPopupItem( SMESHOp::OpEditSubMesh, OB, subMesh, "&& selcount=1 && hasGeomReference" );
4420 createPopupItem( SMESHOp::OpEditGroup, OB, group );
4421 createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4423 popupMgr()->insert( separator(), -1, 0 );
4424 createPopupItem( SMESHOp::OpCompute, OB, mesh, "&& selcount=1 && isComputable" );
4425 createPopupItem( SMESHOp::OpComputeSubMesh, OB, subMesh, "&& selcount=1 && isComputable" );
4426 createPopupItem( SMESHOp::OpPreCompute, OB, mesh, "&& selcount=1 && isPreComputable" );
4427 createPopupItem( SMESHOp::OpEvaluate, OB, mesh, "&& selcount=1 && isComputable" );
4428 createPopupItem( SMESHOp::OpMeshOrder, OB, mesh, "&& selcount=1 && isComputable && hasGeomReference" );
4429 createPopupItem( SMESHOp::OpUpdate, OB, mesh_part );
4430 createPopupItem( SMESHOp::OpMeshInformation, OB, mesh_part );
4431 createPopupItem( SMESHOp::OpFindElementByPoint,OB, mesh_group, "&& selcount=1" );
4432 createPopupItem( SMESHOp::OpOverallMeshQuality,OB, mesh_part );
4433 popupMgr()->insert( separator(), -1, 0 );
4434 createPopupItem( SMESHOp::OpCreateGroup, OB, mesh, "&& selcount=1" );
4435 createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh, "&& selcount=1 && hasGeomReference" );
4436 createPopupItem( SMESHOp::OpConstructGroup, OB, subMesh );
4437 popupMgr()->insert( separator(), -1, 0 );
4438 createPopupItem( SMESHOp::OpEditHypothesis, OB, hypo, "&& isEditableHyp");
4439 createPopupItem( SMESHOp::OpUnassign, OB, hyp_alg );
4440 popupMgr()->insert( separator(), -1, 0 );
4441 createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh_submesh );
4442 createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh_group, "&& selcount=1 && dim>=2");
4443 popupMgr()->insert( separator(), -1, 0 );
4444 createPopupItem( SMESHOp::OpClearMesh, OB, mesh );
4445 //popupMgr()->insert( separator(), -1, 0 );
4447 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4448 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4449 QString only_one_2D = only_one_non_empty + " && dim>1";
4451 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4452 createPopupItem( SMESHOp::OpPopupExportMED, OB, mesh_group, multiple_non_empty, anId );
4453 createPopupItem( SMESHOp::OpPopupExportUNV, OB, mesh_group, only_one_non_empty, anId );
4454 createPopupItem( SMESHOp::OpPopupExportSTL, OB, mesh_group, only_one_2D, anId );
4456 createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4458 createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, only_one_non_empty, anId );
4459 createPopupItem( SMESHOp::OpPopupExportGMF, OB, mesh_group, only_one_non_empty, anId );
4460 createPopupItem( SMESHOp::OpPopupExportDAT, OB, mesh_group, only_one_non_empty, anId );
4461 createPopupItem( SMESHOp::OpDelete, OB, mesh_part + " " + hyp_alg );
4462 createPopupItem( SMESHOp::OpDeleteGroup, OB, group );
4464 anId = popupMgr()->insert( tr( "MEN_IMPORT" ), -1, -1 ); // IMPORT submenu
4465 createPopupItem( SMESHOp::OpPopupImportMED, OB, smesh, "", anId );
4466 createPopupItem( SMESHOp::OpPopupImportUNV, OB, smesh, "", anId );
4467 createPopupItem( SMESHOp::OpPopupImportSTL, OB, smesh, "", anId );
4469 createPopupItem( SMESHOp::OpPopupImportCGNS, OB, smesh, "", anId );
4471 createPopupItem( SMESHOp::OpPopupImportSAUV, OB, smesh, "", anId );
4472 createPopupItem( SMESHOp::OpPopupImportGMF, OB, smesh, "", anId );
4473 createPopupItem( SMESHOp::OpPopupImportDAT, OB, smesh, "", anId );
4474 popupMgr()->insert( separator(), -1, 0 );
4477 createPopupItem( SMESHOp::OpEditGroup, View, group );
4478 createPopupItem( SMESHOp::OpAddElemGroupPopup, View, elems, "&& guiState = 800" );
4479 createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems, "&& guiState = 800" );
4481 popupMgr()->insert( separator(), -1, 0 );
4482 createPopupItem( SMESHOp::OpUpdate, View, mesh_part );
4483 createPopupItem( SMESHOp::OpMeshInformation, View, mesh_part );
4484 createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4485 createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh );
4486 popupMgr()->insert( separator(), -1, 0 );
4488 createPopupItem( SMESHOp::OpAutoColor, OB + " " + View, mesh, "&& (not isAutoColor)" );
4489 createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4490 popupMgr()->insert( separator(), -1, 0 );
4492 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4493 QString aType = QString( "%1type in {%2}" ).arg( lc );
4494 aType = aType.arg( mesh_part );
4495 QString aMeshInVTK = aClient + "&&" + aType;
4497 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4498 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4499 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4501 //-------------------------------------------------
4503 //-------------------------------------------------
4504 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4506 popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4507 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4508 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4510 popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4511 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4512 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4514 popupMgr()->insert( separator(), -1, -1 );
4516 //-------------------------------------------------
4518 //-------------------------------------------------
4519 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4521 popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4522 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4523 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4525 popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4526 popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4527 popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4529 popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4530 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4531 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4533 popupMgr()->insert( separator(), anId, -1 );
4535 popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4536 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4537 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4539 //-------------------------------------------------
4541 //-------------------------------------------------
4542 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4544 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4546 popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4547 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4548 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4550 popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4551 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4552 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4554 popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4555 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4556 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4558 popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4559 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4560 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4562 popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4563 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4564 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4566 popupMgr()->insert( separator(), anId, -1 );
4568 popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4569 popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&& $type in {" + mesh + "} &&" + hasDifferentObjElems, QtxPopupMgr::VisibleRule );
4571 popupMgr()->insert( separator(), anId, -1 );
4573 popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4574 popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4577 //-------------------------------------------------
4578 // Representation of the 2D Quadratic elements
4579 //-------------------------------------------------
4580 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4581 popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4582 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "&& isVisible && isQuadratic",QtxPopupMgr::VisibleRule );
4583 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4585 popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4586 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "&& isVisible && isQuadratic", QtxPopupMgr::VisibleRule );
4587 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4589 //-------------------------------------------------
4590 // Orientation of faces
4591 //-------------------------------------------------
4592 popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4593 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4594 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4596 //-------------------------------------------------
4598 //-------------------------------------------------
4599 popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4600 popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4602 //-------------------------------------------------
4604 //-------------------------------------------------
4605 popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4606 popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4608 //-------------------------------------------------
4610 //-------------------------------------------------
4612 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4613 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4614 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4615 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4617 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4619 popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4620 popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4622 popupMgr()->insert( separator(), anId, -1 );
4624 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4626 popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4627 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4628 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4630 popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4631 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4632 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4634 // popupMgr()->insert( action( SMESHOp::OpNodeConnectivityNb ), aSubId, -1 );
4635 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4636 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), "controlMode = 'eNodeConnectivityNb'", QtxPopupMgr::ToggleRule );
4638 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4640 popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4641 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVTK + "&&" + hasEdges + "&&" + hasFacesOrVolumes, QtxPopupMgr::VisibleRule );
4642 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4644 popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4645 popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4646 popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4648 popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4649 popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4650 popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4651 popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4652 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4653 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4655 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4657 popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4658 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4659 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4661 popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4662 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4663 QtxPopupMgr::VisibleRule );
4664 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4666 popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4667 popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4668 popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4670 popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4671 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4672 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4674 popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
4675 popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4676 popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4678 popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
4679 popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4680 popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4682 popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
4683 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4684 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4686 popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
4687 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4688 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4690 popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
4691 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4692 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4694 popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
4695 popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4696 popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4698 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
4699 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4700 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4702 popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
4703 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4704 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4706 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
4707 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4708 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4709 popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
4710 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4711 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4713 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4715 popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D ), aSubId, -1 );
4716 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4717 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4719 popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
4720 popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4721 popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4723 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
4724 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4725 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4727 popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
4728 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4729 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4731 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
4732 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4733 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4735 popupMgr()->insert ( action( SMESHOp::OpEqualVolume ), aSubId, -1 );
4736 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4737 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4739 popupMgr()->insert( separator(), anId, -1 );
4741 popupMgr()->insert( action( SMESHOp::OpShowScalarBar ), anId, -1 );
4742 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4743 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone' && isScalarBarVisible", QtxPopupMgr::ToggleRule );
4744 popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
4745 popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4747 popupMgr()->insert( separator(), anId, -1 );
4749 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4751 popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
4752 popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4754 popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
4755 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4756 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isScalarBarVisible && isDistributionVisible", QtxPopupMgr::ToggleRule);
4758 #ifndef DISABLE_PLOT2DVIEWER
4759 popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
4760 popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4763 //-------------------------------------------------
4765 //-------------------------------------------------
4766 popupMgr()->insert( separator(), -1, -1 );
4767 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4768 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4769 popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
4770 popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4772 popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
4773 popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4775 popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
4776 popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4778 popupMgr()->insert( separator(), -1, -1 );
4780 //-------------------------------------------------
4782 //-------------------------------------------------
4783 popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
4784 popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4786 popupMgr()->insert( separator(), -1, -1 );
4788 popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
4789 popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
4790 popupMgr()->insert( separator(), -1, -1 );
4792 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4793 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4795 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4796 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4799 //================================================================================
4801 * \brief Return true if SMESH or GEOM objects are selected.
4802 * Is called form LightApp_Module::activateModule() which clear selection if
4803 * not isSelectionCompatible()
4805 //================================================================================
4807 bool SMESHGUI::isSelectionCompatible()
4809 bool isCompatible = true;
4810 SALOME_ListIO selected;
4811 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4812 Sel->selectedObjects( selected );
4814 SALOME_ListIteratorOfListIO It( selected );
4815 for ( ; isCompatible && It.More(); It.Next())
4817 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4818 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4820 return isCompatible;
4824 bool SMESHGUI::reusableOperation( const int id )
4826 // compute, evaluate and precompute are not reusable operations
4827 return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate ) ? false : SalomeApp_Module::reusableOperation( id );
4830 bool SMESHGUI::activateModule( SUIT_Study* study )
4832 bool res = SalomeApp_Module::activateModule( study );
4834 setMenuShown( true );
4835 setToolShown( true );
4837 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4838 PyGILState_STATE gstate = PyGILState_Ensure();
4839 PyObject* pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4840 if ( !pluginsmanager ) {
4844 PyObject* result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toUtf8().data(),tr("SMESH_PLUGINS_OTHER").toUtf8().data());
4849 PyGILState_Release(gstate);
4850 // end of SMESH plugins loading
4852 // Reset actions accelerator keys
4853 action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
4855 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4856 GetSMESHGen()->SetCurrentStudy(SALOMEDS::Study::_nil());
4857 if ( SalomeApp_Study* s = dynamic_cast<SalomeApp_Study*>( study )) {
4858 if ( _PTR(Study) aStudy = s->studyDS() )
4859 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
4862 // get all view currently opened in the study and connect their signals to
4863 // the corresponding slots of the class.
4864 SUIT_Desktop* aDesk = study->application()->desktop();
4866 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4867 SUIT_ViewWindow* wnd;
4868 foreach ( wnd, wndList )
4872 Py_XDECREF(pluginsmanager);
4876 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4878 setMenuShown( false );
4879 setToolShown( false );
4881 EmitSignalCloseAllDialogs();
4883 // Unset actions accelerator keys
4884 action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
4886 return SalomeApp_Module::deactivateModule( study );
4889 void SMESHGUI::studyClosed( SUIT_Study* s )
4893 SMESH::RemoveVisuData( s->id() );
4894 SalomeApp_Module::studyClosed( s );
4897 void SMESHGUI::OnGUIEvent()
4899 const QObject* obj = sender();
4900 if ( !obj || !obj->inherits( "QAction" ) )
4902 int id = actionId((QAction*)obj);
4907 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4909 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
4910 if ( CORBA::is_nil( myComponentSMESH ) )
4912 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4914 aGUI.myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4915 return aGUI.myComponentSMESH;
4918 myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4919 return myComponentSMESH;
4922 QString SMESHGUI::engineIOR() const
4924 CORBA::ORB_var anORB = getApp()->orb();
4925 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4926 return QString( anIOR.in() );
4929 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4931 SalomeApp_Module::contextMenuPopup( client, menu, title );
4933 selectionMgr()->selectedObjects( lst );
4934 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4935 Handle(SALOME_InteractiveObject) io = lst.First();
4936 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4937 _PTR(Study) study = appStudy->studyDS();
4938 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4940 QString aName = QString( SMESH::fromUtf8(obj->GetName()) );
4941 while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4942 aName.remove( (aName.length() - 1), 1 );
4948 LightApp_Selection* SMESHGUI::createSelection() const
4950 return new SMESHGUI_Selection();
4953 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4955 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4956 aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
4957 #ifndef DISABLE_PYCONSOLE
4958 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4962 void SMESHGUI::viewManagers( QStringList& list ) const
4964 list.append( SVTK_Viewer::Type() );
4967 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4969 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4970 SMESH::UpdateSelectionProp( this );
4972 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
4973 for(int i = 0; i < aViews.count() ; i++){
4974 SUIT_ViewWindow *sf = aViews[i];
4977 EmitSignalActivatedViewManager();
4981 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
4983 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
4984 myClippingPlaneInfoMap.erase( theViewManager );
4987 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
4989 theActor->AddObserver( SMESH::DeleteActorEvent,
4990 myEventCallbackCommand.GetPointer(),
4994 void SMESHGUI::ProcessEvents( vtkObject* theObject,
4995 unsigned long theEvent,
4996 void* theClientData,
4999 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
5000 if( theObject && (int) theEvent == SMESH::DeleteActorEvent ) {
5001 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
5002 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
5003 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
5004 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
5005 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
5006 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
5007 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
5008 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
5009 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
5010 SMESH::TActorList::iterator anIter3 = anActorList.begin();
5011 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
5012 if( anActor == *anIter3 ) {
5013 anActorList.erase( anIter3 );
5024 void SMESHGUI::createPreferences()
5026 // General tab ------------------------------------------------------------------------
5027 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
5029 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
5030 setPreferenceProperty( autoUpdate, "columns", 2 );
5031 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
5032 setPreferenceProperty( lim, "min", 0 );
5033 setPreferenceProperty( lim, "max", 100000000 );
5034 setPreferenceProperty( lim, "step", 1000 );
5035 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5036 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
5038 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
5039 setPreferenceProperty( dispgroup, "columns", 2 );
5040 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
5042 modes.append( tr("MEN_WIRE") );
5043 modes.append( tr("MEN_SHADE") );
5044 modes.append( tr("MEN_NODES") );
5045 modes.append( tr("MEN_SHRINK") );
5046 QList<QVariant> indices;
5047 indices.append( 0 );
5048 indices.append( 1 );
5049 indices.append( 2 );
5050 indices.append( 3 );
5051 setPreferenceProperty( dispmode, "strings", modes );
5052 setPreferenceProperty( dispmode, "indexes", indices );
5054 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
5055 setPreferenceProperty( arcgroup, "columns", 2 );
5056 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
5057 QStringList quadraticModes;
5058 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
5059 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
5061 indices.append( 0 );
5062 indices.append( 1 );
5063 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
5064 setPreferenceProperty( quadraticmode, "indexes", indices );
5066 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
5067 "SMESH", "max_angle" );
5068 setPreferenceProperty( maxAngle, "min", 1 );
5069 setPreferenceProperty( maxAngle, "max", 90 );
5071 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
5072 setPreferenceProperty( qaGroup, "columns", 2 );
5073 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
5074 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
5075 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
5076 setPreferenceProperty( prec, "min", 0 );
5077 setPreferenceProperty( prec, "max", 100 );
5078 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
5079 setPreferenceProperty( doubleNodesTol, "precision", 10 );
5080 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
5081 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
5082 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
5085 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
5086 setPreferenceProperty( exportgroup, "columns", 2 );
5087 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
5088 addPreference( tr( "PREF_SHOW_WARN" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "show_warning" );
5089 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
5091 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
5092 setPreferenceProperty( computeGroup, "columns", 2 );
5093 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
5095 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5096 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5097 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5099 indices.append( 0 );
5100 indices.append( 1 );
5101 indices.append( 2 );
5102 setPreferenceProperty( notifyMode, "strings", modes );
5103 setPreferenceProperty( notifyMode, "indexes", indices );
5105 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5106 setPreferenceProperty( infoGroup, "columns", 2 );
5107 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5109 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5110 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5112 indices.append( 0 );
5113 indices.append( 1 );
5114 setPreferenceProperty( elemInfo, "strings", modes );
5115 setPreferenceProperty( elemInfo, "indexes", indices );
5116 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5117 setPreferenceProperty( nodesLim, "min", 0 );
5118 setPreferenceProperty( nodesLim, "max", 10000000 );
5119 setPreferenceProperty( nodesLim, "step", 10000 );
5120 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5121 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5122 setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5123 setPreferenceProperty( ctrlLim, "min", 0 );
5124 setPreferenceProperty( ctrlLim, "max", 10000000 );
5125 setPreferenceProperty( ctrlLim, "step", 1000 );
5126 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5127 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5128 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5129 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5130 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5132 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5133 setPreferenceProperty( segGroup, "columns", 2 );
5134 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5135 "SMESH", "segmentation" );
5136 setPreferenceProperty( segLen, "min", 1 );
5137 setPreferenceProperty( segLen, "max", 10000000 );
5138 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5139 "SMESH", "nb_segments_per_edge" );
5140 setPreferenceProperty( nbSeg, "min", 1 );
5141 setPreferenceProperty( nbSeg, "max", 10000000 );
5143 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5144 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5145 "SMESH", "forget_mesh_on_hyp_modif" );
5148 // Quantities with individual precision settings
5149 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5150 setPreferenceProperty( precGroup, "columns", 2 );
5152 const int nbQuantities = 6;
5153 int precs[nbQuantities], ii = 0;
5154 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5155 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5156 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5157 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5158 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5159 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5160 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5161 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5162 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5163 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5164 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5165 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5167 // Set property for precision value for spinboxes
5168 for ( ii = 0; ii < nbQuantities; ii++ ){
5169 setPreferenceProperty( precs[ii], "min", -14 );
5170 setPreferenceProperty( precs[ii], "max", 14 );
5171 setPreferenceProperty( precs[ii], "precision", 2 );
5174 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5175 setPreferenceProperty( previewGroup, "columns", 2 );
5176 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5177 setPreferenceProperty( chunkSize, "min", 1 );
5178 setPreferenceProperty( chunkSize, "max", 1000 );
5179 setPreferenceProperty( chunkSize, "step", 50 );
5181 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5182 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5184 // Mesh tab ------------------------------------------------------------------------
5185 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5186 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5187 setPreferenceProperty( nodeGroup, "columns", 3 );
5189 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5191 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5193 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5194 QList<QVariant> aMarkerTypeIndicesList;
5195 QList<QVariant> aMarkerTypeIconsList;
5196 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5197 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5198 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5199 aMarkerTypeIndicesList << i;
5200 aMarkerTypeIconsList << pixmap;
5202 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5203 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
5205 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5207 QList<QVariant> aMarkerScaleIndicesList;
5208 QStringList aMarkerScaleValuesList;
5209 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5210 aMarkerScaleIndicesList << i;
5211 //aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5212 aMarkerScaleValuesList << QString::number( i );
5214 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5215 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5217 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5218 //setPreferenceProperty( elemGroup, "columns", 2 );
5220 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5221 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5222 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5223 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5224 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5225 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5226 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5227 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5228 addPreference( tr( "PREF_PREVIEW_COLOR" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5231 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5232 setPreferenceProperty( grpGroup, "columns", 2 );
5234 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5235 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5237 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5238 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5239 /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5240 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5241 double ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5242 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5243 double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5244 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5245 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
5246 LightApp_Preferences::IntSpin, "SMESH", "element_width");
5247 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5248 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5249 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5250 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5252 setPreferenceProperty( size0d, "min", 1 );
5253 setPreferenceProperty( size0d, "max", 10 );
5255 // setPreferenceProperty( ballSize, "min", 1 );
5256 // setPreferenceProperty( ballSize, "max", 10 );
5258 setPreferenceProperty( ballDiameter, "min", 1e-7 );
5259 setPreferenceProperty( ballDiameter, "max", 1e9 );
5260 setPreferenceProperty( ballDiameter, "step", 0.1 );
5262 setPreferenceProperty( ballScale, "min", 1e-2 );
5263 setPreferenceProperty( ballScale, "max", 1e7 );
5264 setPreferenceProperty( ballScale, "step", 0.5 );
5266 setPreferenceProperty( elemW, "min", 1 );
5267 setPreferenceProperty( elemW, "max", 5 );
5269 setPreferenceProperty( outW, "min", 1 );
5270 setPreferenceProperty( outW, "max", 5 );
5272 setPreferenceProperty( shrink, "min", 0 );
5273 setPreferenceProperty( shrink, "max", 100 );
5275 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5276 setPreferenceProperty( numGroup, "columns", 2 );
5278 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5279 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5281 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5282 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5284 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5285 setPreferenceProperty( orientGroup, "columns", 1 );
5287 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5288 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5290 setPreferenceProperty( orientScale, "min", 0.05 );
5291 setPreferenceProperty( orientScale, "max", 0.5 );
5292 setPreferenceProperty( orientScale, "step", 0.05 );
5294 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5296 // Selection tab ------------------------------------------------------------------------
5297 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5299 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5300 setPreferenceProperty( selGroup, "columns", 2 );
5302 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5303 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5305 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5306 setPreferenceProperty( preGroup, "columns", 2 );
5308 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5310 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5311 setPreferenceProperty( precSelGroup, "columns", 2 );
5313 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5314 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5315 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5317 // Scalar Bar tab ------------------------------------------------------------------------
5318 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5319 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5320 setPreferenceProperty( fontGr, "columns", 2 );
5322 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5323 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5325 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5326 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5328 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5329 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5331 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5332 setPreferenceProperty( numcol, "min", 2 );
5333 setPreferenceProperty( numcol, "max", 256 );
5335 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5336 setPreferenceProperty( numlab, "min", 2 );
5337 setPreferenceProperty( numlab, "max", 65 );
5339 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5340 setPreferenceProperty( orientGr, "columns", 2 );
5341 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5342 QStringList orients;
5343 orients.append( tr( "SMESH_VERTICAL" ) );
5344 orients.append( tr( "SMESH_HORIZONTAL" ) );
5345 indices.clear(); indices.append( 0 ); indices.append( 1 );
5346 setPreferenceProperty( orient, "strings", orients );
5347 setPreferenceProperty( orient, "indexes", indices );
5349 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5350 setPreferenceProperty( posVSizeGr, "columns", 2 );
5351 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5352 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5353 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5354 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5355 setPreferenceProperty( xv, "step", 0.1 );
5356 setPreferenceProperty( xv, "min", 0.0 );
5357 setPreferenceProperty( xv, "max", 1.0 );
5358 setPreferenceProperty( yv, "step", 0.1 );
5359 setPreferenceProperty( yv, "min", 0.0 );
5360 setPreferenceProperty( yv, "max", 1.0 );
5361 setPreferenceProperty( wv, "step", 0.1 );
5362 setPreferenceProperty( wv, "min", 0.0 );
5363 setPreferenceProperty( wv, "max", 1.0 );
5364 setPreferenceProperty( hv, "min", 0.0 );
5365 setPreferenceProperty( hv, "max", 1.0 );
5366 setPreferenceProperty( hv, "step", 0.1 );
5368 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5369 setPreferenceProperty( posHSizeGr, "columns", 2 );
5370 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5371 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5372 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5373 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5374 setPreferenceProperty( xv, "min", 0.0 );
5375 setPreferenceProperty( xv, "max", 1.0 );
5376 setPreferenceProperty( xv, "step", 0.1 );
5377 setPreferenceProperty( xh, "min", 0.0 );
5378 setPreferenceProperty( xh, "max", 1.0 );
5379 setPreferenceProperty( xh, "step", 0.1 );
5380 setPreferenceProperty( yh, "min", 0.0 );
5381 setPreferenceProperty( yh, "max", 1.0 );
5382 setPreferenceProperty( yh, "step", 0.1 );
5383 setPreferenceProperty( wh, "min", 0.0 );
5384 setPreferenceProperty( wh, "max", 1.0 );
5385 setPreferenceProperty( wh, "step", 0.1 );
5386 setPreferenceProperty( hh, "min", 0.0 );
5387 setPreferenceProperty( hh, "max", 1.0 );
5388 setPreferenceProperty( hh, "step", 0.1 );
5390 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5391 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5392 setPreferenceProperty( distributionGr, "columns", 3 );
5394 types.append( tr( "SMESH_MONOCOLOR" ) );
5395 types.append( tr( "SMESH_MULTICOLOR" ) );
5396 indices.clear(); indices.append( 0 ); indices.append( 1 );
5397 setPreferenceProperty( coloringType, "strings", types );
5398 setPreferenceProperty( coloringType, "indexes", indices );
5399 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5403 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5405 if ( sect=="SMESH" ) {
5406 float sbX1 = 0.01, sbY1 = 0.01, sbW = 0.08, sbH = 0.08;
5407 float aTol = 1.00000009999999;
5408 std::string aWarning;
5409 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5411 if ( name== "selection_object_color" ||
5412 name=="selection_element_color" ||
5413 name== "highlight_color" ||
5414 name=="selection_precision_node" ||
5415 name=="selection_precision_element" ||
5416 name=="selection_precision_object" )
5418 SMESH::UpdateSelectionProp( this );
5420 else if (name == "scalar_bar_vertical_x" || name == "scalar_bar_vertical_width")
5422 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5423 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5424 if ( sbX1+sbW > aTol ) {
5425 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5428 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5429 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5432 else if (name == "scalar_bar_vertical_y" || name == "scalar_bar_vertical_height" )
5434 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5435 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5436 if ( sbY1 + sbH > aTol ) {
5437 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5438 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5439 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5442 else if (name == "scalar_bar_horizontal_x" || name == "scalar_bar_horizontal_width")
5444 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5445 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5446 if ( sbX1 + sbW > aTol ) {
5447 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5450 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5451 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5454 else if (name == "scalar_bar_horizontal_y" || name == "scalar_bar_horizontal_height")
5456 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5457 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5458 if ( sbY1 + sbH > aTol ) {
5459 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5462 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5463 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5466 else if ( name == "segmentation" )
5468 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5469 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5471 else if ( name == "nb_segments_per_edge" )
5473 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5474 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5476 else if ( name == "historical_python_dump" || name == "forget_mesh_on_hyp_modif" || name == "default_grp_color" )
5478 QString val = aResourceMgr->stringValue( "SMESH", name );
5479 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5481 else if ( name == "numbering_node_color" || name == "numbering_node_font" )
5483 SMESH::UpdateFontProp( this );
5485 else if ( name == "numbering_elem_color" || name == "numbering_elem_font" )
5487 SMESH::UpdateFontProp( this );
5490 if ( aWarning.size() != 0 ) {
5491 aWarning += "The default values are applied instead.";
5492 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5493 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5494 QObject::tr(aWarning.c_str()));
5499 //================================================================================
5501 * \brief Update something in accordance with update flags
5502 * \param theFlags - update flags
5504 * Update viewer or/and object browser etc. in accordance with update flags ( see
5505 * LightApp_UpdateFlags enumeration ).
5507 //================================================================================
5508 void SMESHGUI::update( const int flags )
5510 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5511 SMESH::UpdateView();
5513 SalomeApp_Module::update( flags );
5516 //================================================================================
5518 * \brief Set default selection mode
5520 * SLOT called when operation committed. Sets default selection mode
5522 //================================================================================
5523 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5525 SVTK_ViewWindow* vtkWnd =
5526 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5528 vtkWnd->SetSelectionMode( ActorSelection );
5531 //================================================================================
5533 * \brief Set default selection mode
5535 * SLOT called when operation aborted. Sets default selection mode
5537 //================================================================================
5538 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5540 SVTK_ViewWindow* vtkWnd =
5541 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5543 vtkWnd->SetSelectionMode( ActorSelection );
5546 //================================================================================
5548 * \brief Creates operation with given identifier
5549 * \param id - identifier of operation to be started
5550 * \return Pointer on created operation or NULL if operation is not created
5552 * Virtual method redefined from the base class creates operation with given id.
5553 * It is called called automatically from startOperation method of base class.
5555 //================================================================================
5556 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5558 LightApp_Operation* op = 0;
5559 // to do : create operation here
5562 case SMESHOp::OpSplitBiQuadratic:
5563 op = new SMESHGUI_SplitBiQuadOp();
5565 case SMESHOp::OpConvertMeshToQuadratic:
5566 op = new SMESHGUI_ConvToQuadOp();
5568 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5569 op = new SMESHGUI_Make2DFrom3DOp();
5571 case SMESHOp::OpReorientFaces:
5572 op = new SMESHGUI_ReorientFacesOp();
5574 case SMESHOp::OpCreateMesh:
5575 op = new SMESHGUI_MeshOp( true, true );
5577 case SMESHOp::OpCreateSubMesh:
5578 op = new SMESHGUI_MeshOp( true, false );
5580 case SMESHOp::OpEditMeshOrSubMesh:
5581 case SMESHOp::OpEditMesh:
5582 case SMESHOp::OpEditSubMesh:
5583 op = new SMESHGUI_MeshOp( false );
5585 case SMESHOp::OpCompute:
5586 case SMESHOp::OpComputeSubMesh:
5587 op = new SMESHGUI_ComputeOp();
5589 case SMESHOp::OpPreCompute:
5590 op = new SMESHGUI_PrecomputeOp();
5592 case SMESHOp::OpEvaluate:
5593 op = new SMESHGUI_EvaluateOp();
5595 case SMESHOp::OpMeshOrder:
5596 op = new SMESHGUI_MeshOrderOp();
5598 case SMESHOp::OpCreateGeometryGroup:
5599 op = new SMESHGUI_GroupOnShapeOp();
5601 case SMESHOp::OpFindElementByPoint:
5602 op = new SMESHGUI_FindElemByPointOp();
5604 case SMESHOp::OpMoveNode: // Make mesh pass through point
5605 op = new SMESHGUI_MakeNodeAtPointOp();
5607 case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
5608 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5615 op = SalomeApp_Module::createOperation( id );
5619 //================================================================================
5621 * \brief Stops current operations and starts a given one
5622 * \param id - The id of the operation to start
5624 //================================================================================
5626 void SMESHGUI::switchToOperation(int id)
5628 if ( _PTR(Study) aStudy = SMESH::GetActiveStudyDocument() )
5629 activeStudy()->abortAllOperations();
5630 startOperation( id );
5633 LightApp_Displayer* SMESHGUI::displayer()
5636 myDisplayer = new SMESHGUI_Displayer( getApp() );
5640 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5643 int aTolerance = 64;
5644 int anIterations = 0;
5650 if( anIterations % aPeriod == 0 )
5653 if( aTolerance < 1 )
5657 aHue = (int)( 360.0 * rand() / RAND_MAX );
5660 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5661 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5662 for( ; it != itEnd; ++it )
5664 SALOMEDS::Color anAutoColor = *it;
5665 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5668 aQColor.getHsv( &h, &s, &v );
5669 if( abs( h - aHue ) < aTolerance )
5681 aColor.setHsv( aHue, 255, 255 );
5683 SALOMEDS::Color aSColor;
5684 aSColor.R = aColor.redF();
5685 aSColor.G = aColor.greenF();
5686 aSColor.B = aColor.blueF();
5691 const char* gSeparator = "_"; // character used to separate parameter names
5692 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5693 const char* gPathSep = "|"; // character used to separate paths
5696 * \brief Store visual parameters
5698 * This method is called just before the study document is saved.
5699 * Store visual parameters in AttributeParameter attribue(s)
5701 void SMESHGUI::storeVisualParameters (int savePoint)
5704 Kernel_Utils::Localizer loc;
5706 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5707 if (!appStudy || !appStudy->studyDS())
5709 _PTR(Study) studyDS = appStudy->studyDS();
5711 // componentName is used for encoding of entries when storing them in IParameters
5712 std::string componentName = myComponentSMESH->ComponentDataType();
5713 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5714 //if (!aSComponent) return;
5717 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5718 componentName.c_str(),
5720 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5722 // store map of custom markers
5723 const VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5724 if( !aMarkerMap.empty() )
5726 VTK::MarkerMap::const_iterator anIter = aMarkerMap.begin();
5727 for( ; anIter != aMarkerMap.end(); anIter++ )
5729 int anId = anIter->first;
5730 VTK::MarkerData aMarkerData = anIter->second;
5731 std::string aMarkerFileName = aMarkerData.first;
5732 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5733 if( aMarkerTexture.size() < 3 )
5734 continue; // should contain at least width, height and the first value
5736 QString aPropertyName( "texture" );
5737 aPropertyName += gSeparator;
5738 aPropertyName += QString::number( anId );
5740 QString aPropertyValue = aMarkerFileName.c_str();
5741 aPropertyValue += gPathSep;
5743 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5744 ushort aWidth = *aTextureIter++;
5745 ushort aHeight = *aTextureIter++;
5746 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5747 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5748 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5749 aPropertyValue += QString::number( *aTextureIter );
5751 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5755 // viewers counters are used for storing view_numbers in IParameters
5758 // main cycle to store parameters of displayed objects
5759 QList<SUIT_ViewManager*> lst;
5760 QList<SUIT_ViewManager*>::Iterator it;
5761 getApp()->viewManagers(lst);
5762 for (it = lst.begin(); it != lst.end(); it++)
5764 SUIT_ViewManager* vman = *it;
5765 QString vType = vman->getType();
5767 // saving VTK actors properties
5768 if (vType == SVTK_Viewer::Type())
5770 // store the clipping planes attached to the view manager
5771 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5772 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5773 if( anIter != myClippingPlaneInfoMap.end() )
5774 aClippingPlaneInfoList = anIter->second;
5776 if( !aClippingPlaneInfoList.empty() ) {
5777 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5778 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5780 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5781 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5783 QString aPropertyName( "ClippingPlane" );
5784 aPropertyName += gSeparator;
5785 aPropertyName += QString::number( vtkViewers );
5786 aPropertyName += gSeparator;
5787 aPropertyName += QString::number( anId );
5789 QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
5790 aPropertyValue += gDigitsSep;
5791 aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
5792 aPropertyValue += gDigitsSep;
5793 if ( aPlane->PlaneMode == SMESH::Absolute ) {
5794 aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
5795 aPropertyValue += gDigitsSep;
5796 aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
5797 aPropertyValue += gDigitsSep;
5798 aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
5799 aPropertyValue += gDigitsSep;
5800 aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
5801 aPropertyValue += gDigitsSep;
5802 aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
5803 aPropertyValue += gDigitsSep;
5804 aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
5805 aPropertyValue += gDigitsSep;
5806 aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
5808 else if ( aPlane->PlaneMode == SMESH::Relative ) {
5809 aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
5810 aPropertyValue += gDigitsSep;
5811 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5812 aPropertyValue += gDigitsSep;
5813 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5814 aPropertyValue += gDigitsSep;
5815 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5818 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5822 QVector<SUIT_ViewWindow*> views = vman->getViews();
5823 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5825 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5827 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5828 vtkActorCollection* allActors = aCopy.GetActors();
5829 allActors->InitTraversal();
5830 while (vtkActor* actor = allActors->GetNextActor())
5832 if (actor->GetVisibility()) // store only visible actors
5834 SMESH_Actor* aSmeshActor = 0;
5835 if (actor->IsA("SMESH_Actor"))
5836 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5837 if (aSmeshActor && aSmeshActor->hasIO())
5839 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5842 // entry is "encoded" = it does NOT contain component address,
5843 // since it is a subject to change on next component loading
5844 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5846 std::string param, vtkParam = vType.toLatin1().data();
5847 vtkParam += gSeparator;
5848 vtkParam += QString::number(vtkViewers).toLatin1().data();
5849 vtkParam += gSeparator;
5852 param = vtkParam + "Visibility";
5853 ip->setParameter(entry, param, "On");
5856 param = vtkParam + "Representation";
5857 ip->setParameter(entry, param, QString::number
5858 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5861 param = vtkParam + "IsShrunk";
5862 ip->setParameter(entry, param, QString::number
5863 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5865 // Displayed entities
5866 unsigned int aMode = aSmeshActor->GetEntityMode();
5867 bool isE = aMode & SMESH_Actor::eEdges;
5868 bool isF = aMode & SMESH_Actor::eFaces;
5869 bool isV = aMode & SMESH_Actor::eVolumes;
5870 bool is0d = aMode & SMESH_Actor::e0DElements;
5871 bool isB = aMode & SMESH_Actor::eBallElem;
5873 QString modeStr ("e");
5874 modeStr += gDigitsSep; modeStr += QString::number(isE);
5875 modeStr += gDigitsSep; modeStr += "f";
5876 modeStr += gDigitsSep; modeStr += QString::number(isF);
5877 modeStr += gDigitsSep; modeStr += "v";
5878 modeStr += gDigitsSep; modeStr += QString::number(isV);
5879 modeStr += gDigitsSep; modeStr += "0d";
5880 modeStr += gDigitsSep; modeStr += QString::number(is0d);
5881 modeStr += gDigitsSep; modeStr += "b";
5882 modeStr += gDigitsSep; modeStr += QString::number(isB);
5884 param = vtkParam + "Entities";
5885 ip->setParameter(entry, param, modeStr.toLatin1().data());
5891 aSmeshActor->GetSufaceColor(r, g, b, delta);
5892 QStringList colorStr;
5893 colorStr << "surface";
5894 colorStr << QString::number(r);
5895 colorStr << QString::number(g);
5896 colorStr << QString::number(b);
5898 colorStr << "backsurface";
5899 colorStr << QString::number(delta);
5901 aSmeshActor->GetVolumeColor(r, g, b, delta);
5902 colorStr << "volume";
5903 colorStr << QString::number(r);
5904 colorStr << QString::number(g);
5905 colorStr << QString::number(b);
5906 colorStr << QString::number(delta);
5908 aSmeshActor->GetEdgeColor(r, g, b);
5910 colorStr << QString::number(r);
5911 colorStr << QString::number(g);
5912 colorStr << QString::number(b);
5914 aSmeshActor->GetNodeColor(r, g, b);
5916 colorStr << QString::number(r);
5917 colorStr << QString::number(g);
5918 colorStr << QString::number(b);
5920 aSmeshActor->GetOutlineColor(r, g, b);
5921 colorStr << "outline";
5922 colorStr << QString::number(r);
5923 colorStr << QString::number(g);
5924 colorStr << QString::number(b);
5926 aSmeshActor->Get0DColor(r, g, b);
5927 colorStr << "elem0d";
5928 colorStr << QString::number(r);
5929 colorStr << QString::number(g);
5930 colorStr << QString::number(b);
5932 aSmeshActor->GetBallColor(r, g, b);
5934 colorStr << QString::number(r);
5935 colorStr << QString::number(g);
5936 colorStr << QString::number(b);
5938 aSmeshActor->GetFacesOrientationColor(r, g, b);
5939 colorStr << "orientation";
5940 colorStr << QString::number(r);
5941 colorStr << QString::number(g);
5942 colorStr << QString::number(b);
5944 param = vtkParam + "Colors";
5945 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
5948 QStringList sizeStr;
5950 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
5951 sizeStr << "outline";
5952 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
5953 sizeStr << "elem0d";
5954 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
5956 //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
5957 sizeStr << QString::number((double)aSmeshActor->GetBallSize());
5958 sizeStr << QString::number((double)aSmeshActor->GetBallScale());
5959 sizeStr << "shrink";
5960 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
5961 sizeStr << "orientation";
5962 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
5963 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
5965 param = vtkParam + "Sizes";
5966 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
5971 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5972 if( aMarkerType == VTK::MT_USER ) {
5973 markerStr += "custom";
5974 markerStr += gDigitsSep;
5975 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
5979 markerStr += gDigitsSep;
5980 markerStr += QString::number( (int)aMarkerType );
5981 markerStr += gDigitsSep;
5982 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
5985 param = vtkParam + "PointMarker";
5986 ip->setParameter(entry, param, markerStr.toLatin1().data());
5989 param = vtkParam + "Opacity";
5990 ip->setParameter(entry, param,
5991 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
5994 param = vtkParam + "ClippingPlane";
5996 if( !aClippingPlaneInfoList.empty() ) {
5997 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
5998 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
6000 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
6001 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
6002 SMESH::TActorList::iterator anIter2 = anActorList.begin();
6003 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
6004 if( aSmeshActor == *anIter2 ) {
6005 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
6006 QString::number( anId ).toLatin1().constData() );
6013 ip->setParameter( entry, param, "Off" );
6014 } // if (io->hasEntry())
6015 } // SMESH_Actor && hasIO
6017 } // while.. actors traversal
6021 } // if (SVTK view model)
6022 } // for (viewManagers)
6025 // data structures for clipping planes processing
6029 bool isOpenGLClipping;
6030 vtkIdType RelativeOrientation;
6033 int AbsoluteOrientation;
6034 double X, Y, Z, Dx, Dy, Dz;
6036 typedef std::list<TPlaneData> TPlaneDataList;
6037 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
6039 typedef std::list<vtkActor*> TActorList;
6042 TActorList ActorList;
6043 SUIT_ViewManager* ViewManager;
6045 typedef std::list<TPlaneInfo> TPlaneInfoList;
6046 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
6049 * \brief Restore visual parameters
6051 * This method is called after the study document is opened.
6052 * Restore visual parameters from AttributeParameter attribue(s)
6054 void SMESHGUI::restoreVisualParameters (int savePoint)
6057 Kernel_Utils::Localizer loc;
6059 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6060 if (!appStudy || !appStudy->studyDS())
6062 _PTR(Study) studyDS = appStudy->studyDS();
6064 // componentName is used for encoding of entries when storing them in IParameters
6065 std::string componentName = myComponentSMESH->ComponentDataType();
6066 //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
6067 //if (!aSComponent) return;
6070 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6071 componentName.c_str(),
6073 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6075 // restore map of custom markers and map of clipping planes
6076 VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
6077 TPlaneDataMap aPlaneDataMap;
6079 std::vector<std::string> properties = ip->getProperties();
6080 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
6082 std::string property = *propIt;
6083 QString aPropertyName( property.c_str() );
6084 QString aPropertyValue( ip->getProperty( property ).c_str() );
6086 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
6087 if( aPropertyNameList.isEmpty() )
6090 QString aPropertyType = aPropertyNameList[0];
6091 if( aPropertyType == "texture" )
6093 if( aPropertyNameList.size() != 2 )
6097 int anId = aPropertyNameList[1].toInt( &ok );
6098 if( !ok || anId < 1 )
6101 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
6102 if( aPropertyValueList.size() != 2 )
6105 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
6106 QString aMarkerTextureString = aPropertyValueList[1];
6107 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
6108 if( aMarkerTextureStringList.size() != 3 )
6112 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6117 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6121 VTK::MarkerTexture aMarkerTexture;
6122 aMarkerTexture.push_back( aWidth );
6123 aMarkerTexture.push_back( aHeight );
6125 QString aMarkerTextureData = aMarkerTextureStringList[2];
6126 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6128 QChar aChar = aMarkerTextureData.at( i );
6129 if( aChar.isDigit() )
6130 aMarkerTexture.push_back( aChar.digitValue() );
6133 aMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6135 else if( aPropertyType == "ClippingPlane" )
6137 if( aPropertyNameList.size() != 3 )
6141 int aViewId = aPropertyNameList[1].toInt( &ok );
6142 if( !ok || aViewId < 0 )
6146 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6147 if( !ok || aClippingPlaneId < 0 )
6150 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6151 if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6154 TPlaneData aPlaneData;
6155 aPlaneData.AbsoluteOrientation = false;
6156 aPlaneData.RelativeOrientation = 0;
6157 aPlaneData.Distance = aPlaneData.Angle[0] = aPlaneData.Angle[1] = 0;
6158 aPlaneData.X = aPlaneData.Y = aPlaneData.Z = 0;
6159 aPlaneData.Dx = aPlaneData.Dy = aPlaneData.Dz = 0;
6161 aPlaneData.Id = aClippingPlaneId;
6164 aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6169 aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6173 if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6176 aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6181 aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6186 aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6191 aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6196 aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6201 aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6206 aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6210 else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6212 aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6217 aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6222 aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6227 aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6232 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6233 aPlaneDataList.push_back( aPlaneData );
6237 TPlaneInfoMap aPlaneInfoMap;
6239 std::vector<std::string> entries = ip->getEntries();
6241 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6243 // entry is a normal entry - it should be "decoded" (setting base address of component)
6244 QString entry (ip->decodeEntry(*entIt).c_str());
6246 // Check that the entry corresponds to a real object in the Study
6247 // as the object may be deleted or modified after the visual state is saved.
6248 _PTR(SObject) so = studyDS->FindObjectID(entry.toLatin1().data());
6249 if (!so) continue; //Skip the not existent entry
6251 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6252 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6254 std::vector<std::string>::iterator namesIt = paramNames.begin();
6255 std::vector<std::string>::iterator valuesIt = paramValues.begin();
6257 // actors are stored in a map after displaying of them for
6258 // quicker access in the future: map < viewID to actor >
6259 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6261 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6263 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6264 // '_' is used as separator and should not be used in viewer type or parameter names.
6265 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6266 if (lst.size() != 3)
6269 QString viewerTypStr = lst[0];
6270 QString viewIndexStr = lst[1];
6271 QString paramNameStr = lst[2];
6274 int viewIndex = viewIndexStr.toUInt(&ok);
6275 if (!ok) // bad conversion of view index to integer
6279 if (viewerTypStr == SVTK_Viewer::Type())
6281 SMESH_Actor* aSmeshActor = 0;
6282 if (vtkActors.IsBound(viewIndex))
6283 aSmeshActor = vtkActors.Find(viewIndex);
6285 QList<SUIT_ViewManager*> lst;
6286 getApp()->viewManagers(viewerTypStr, lst);
6288 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6289 SUIT_ViewManager* vman = NULL;
6290 if (viewIndex >= 0 && viewIndex < lst.count())
6291 vman = lst.at(viewIndex);
6293 if (paramNameStr == "Visibility")
6295 if (!aSmeshActor && displayer() && vman)
6297 SUIT_ViewModel* vmodel = vman->getViewModel();
6298 // SVTK view model can be casted to SALOME_View
6299 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6301 // store displayed actor in a temporary map for quicker
6302 // access later when restoring other parameters
6303 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6304 vtkRenderer* Renderer = vtkView->getRenderer();
6305 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6306 vtkActorCollection* theActors = aCopy.GetActors();
6307 theActors->InitTraversal();
6308 bool isFound = false;
6309 vtkActor *ac = theActors->GetNextActor();
6310 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6311 if (ac->IsA("SMESH_Actor")) {
6312 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6313 if (aGeomAc->hasIO()) {
6314 Handle(SALOME_InteractiveObject) io = aGeomAc->getIO();
6315 if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) {
6317 vtkActors.Bind(viewIndex, aGeomAc);
6323 } // if (paramNameStr == "Visibility")
6326 // the rest properties "work" with SMESH_Actor
6329 QString val ((*valuesIt).c_str());
6332 if (paramNameStr == "Representation") {
6333 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6336 else if (paramNameStr == "IsShrunk") {
6338 if (!aSmeshActor->IsShrunk())
6339 aSmeshActor->SetShrink();
6342 if (aSmeshActor->IsShrunk())
6343 aSmeshActor->UnShrink();
6346 // Displayed entities
6347 else if (paramNameStr == "Entities") {
6348 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6349 int aEntityMode = SMESH_Actor::eAllEntity;
6350 for ( int i = 0; i < mode.count(); i+=2 ) {
6351 if ( i < mode.count()-1 ) {
6352 QString type = mode[i];
6353 bool val = mode[i+1].toInt();
6354 if ( type == "e" && !val )
6355 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6356 else if ( type == "f" && !val )
6357 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6358 else if ( type == "v" && !val )
6359 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6360 else if ( type == "0d" && !val )
6361 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6362 else if ( type == "b" && !val )
6363 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6366 aSmeshActor->SetEntityMode( aEntityMode );
6369 else if (paramNameStr == "Colors") {
6370 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6377 QColor outlineColor;
6378 QColor orientationColor;
6384 // below lines are required to get default values for delta coefficients
6385 // of backface color for faces and color of reversed volumes
6386 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
6387 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6388 for ( int i = 0; i < colors.count(); i++ ) {
6389 QString type = colors[i];
6390 if ( type == "surface" ) {
6391 // face color is set by 3 values r:g:b, where
6392 // - r,g,b - is rgb color components
6393 if ( i+1 >= colors.count() ) break; // format error
6394 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6395 if ( i+2 >= colors.count() ) break; // format error
6396 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6397 if ( i+3 >= colors.count() ) break; // format error
6398 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6399 faceColor.setRgbF( r, g, b );
6402 else if ( type == "backsurface" ) {
6403 // backface color can be defined in several ways
6404 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6405 // - in latest versions, it is set as delta coefficient
6406 bool rgbOk = false, deltaOk;
6407 if ( i+1 >= colors.count() ) break; // format error
6408 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6409 int delta = colors[i+1].toInt( &deltaOk );
6411 if ( i+1 < colors.count() ) // index is shifted to 1
6412 g = colors[i+1].toDouble( &rgbOk );
6413 if ( rgbOk ) i++; // shift index
6414 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6415 b = colors[i+1].toDouble( &rgbOk );
6417 // - as currently there's no way to set directly backsurface color as it was before,
6418 // we ignore old dump where r,g,b triple was set
6419 // - also we check that delta parameter is set properly
6420 if ( !rgbOk && deltaOk )
6423 else if ( type == "volume" ) {
6424 // volume color is set by 4 values r:g:b:delta, where
6425 // - r,g,b - is a normal volume rgb color components
6426 // - delta - is a reversed volume color delta coefficient
6427 if ( i+1 >= colors.count() ) break; // format error
6428 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6429 if ( i+2 >= colors.count() ) break; // format error
6430 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6431 if ( i+3 >= colors.count() ) break; // format error
6432 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6433 if ( i+4 >= colors.count() ) break; // format error
6434 int delta = colors[i+4].toInt( &bOk );
6435 if ( !bOk ) break; // format error
6436 volumeColor.setRgbF( r, g, b );
6440 else if ( type == "edge" ) {
6441 // edge color is set by 3 values r:g:b, where
6442 // - r,g,b - is rgb color components
6443 if ( i+1 >= colors.count() ) break; // format error
6444 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6445 if ( i+2 >= colors.count() ) break; // format error
6446 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6447 if ( i+3 >= colors.count() ) break; // format error
6448 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6449 edgeColor.setRgbF( r, g, b );
6452 else if ( type == "node" ) {
6453 // node color is set by 3 values r:g:b, where
6454 // - r,g,b - is rgb color components
6455 if ( i+1 >= colors.count() ) break; // format error
6456 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6457 if ( i+2 >= colors.count() ) break; // format error
6458 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6459 if ( i+3 >= colors.count() ) break; // format error
6460 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6461 nodeColor.setRgbF( r, g, b );
6464 else if ( type == "elem0d" ) {
6465 // 0d element color is set by 3 values r:g:b, where
6466 // - r,g,b - is rgb color components
6467 if ( i+1 >= colors.count() ) break; // format error
6468 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6469 if ( i+2 >= colors.count() ) break; // format error
6470 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6471 if ( i+3 >= colors.count() ) break; // format error
6472 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6473 elem0dColor.setRgbF( r, g, b );
6476 else if ( type == "ball" ) {
6477 // ball color is set by 3 values r:g:b, where
6478 // - r,g,b - is rgb color components
6479 if ( i+1 >= colors.count() ) break; // format error
6480 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6481 if ( i+2 >= colors.count() ) break; // format error
6482 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6483 if ( i+3 >= colors.count() ) break; // format error
6484 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6485 ballColor.setRgbF( r, g, b );
6488 else if ( type == "outline" ) {
6489 // outline color is set by 3 values r:g:b, where
6490 // - r,g,b - is rgb color components
6491 if ( i+1 >= colors.count() ) break; // format error
6492 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6493 if ( i+2 >= colors.count() ) break; // format error
6494 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6495 if ( i+3 >= colors.count() ) break; // format error
6496 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6497 outlineColor.setRgbF( r, g, b );
6500 else if ( type == "orientation" ) {
6501 // orientation color is set by 3 values r:g:b, where
6502 // - r,g,b - is rgb color components
6503 if ( i+1 >= colors.count() ) break; // format error
6504 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6505 if ( i+2 >= colors.count() ) break; // format error
6506 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6507 if ( i+3 >= colors.count() ) break; // format error
6508 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6509 orientationColor.setRgbF( r, g, b );
6514 if ( nodeColor.isValid() )
6515 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6517 if ( edgeColor.isValid() )
6518 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6520 if ( faceColor.isValid() )
6521 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6523 if ( volumeColor.isValid() )
6524 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6525 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6526 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6528 if ( elem0dColor.isValid() )
6529 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6531 if ( ballColor.isValid() )
6532 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6534 if ( outlineColor.isValid() )
6535 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6536 // orientation color
6537 if ( orientationColor.isValid() )
6538 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6541 else if (paramNameStr == "Sizes") {
6542 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6545 int outlineWidth = -1;
6546 int elem0dSize = -1;
6547 //int ballSize = -1;
6548 double ballDiameter = -1.0;
6549 double ballScale = -1.0;
6550 double shrinkSize = -1;
6551 double orientationSize = -1;
6552 bool orientation3d = false;
6553 for ( int i = 0; i < sizes.count(); i++ ) {
6554 QString type = sizes[i];
6555 if ( type == "line" ) {
6556 // line (wireframe) width is given as single integer value
6557 if ( i+1 >= sizes.count() ) break; // format error
6558 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6562 if ( type == "outline" ) {
6563 // outline width is given as single integer value
6564 if ( i+1 >= sizes.count() ) break; // format error
6565 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6569 else if ( type == "elem0d" ) {
6570 // 0d element size is given as single integer value
6571 if ( i+1 >= sizes.count() ) break; // format error
6572 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6576 else if ( type == "ball" ) {
6577 // balls are specified by two values: size:scale, where
6578 // - size - is a integer value specifying size
6579 // - scale - is a double value specifying scale factor
6580 if ( i+1 >= sizes.count() ) break; // format error
6581 //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6582 double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6583 if ( i+2 >= sizes.count() ) break; // format error
6584 double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6590 else if ( type == "shrink" ) {
6591 // shrink factor is given as single floating point value
6592 if ( i+1 >= sizes.count() ) break; // format error
6593 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6597 else if ( type == "orientation" ) {
6598 // orientation vectors are specified by two values size:3d, where
6599 // - size - is a floating point value specifying scale factor
6600 // - 3d - is a boolean
6601 if ( i+1 >= sizes.count() ) break; // format error
6602 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6603 if ( i+2 >= sizes.count() ) break; // format error
6604 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6605 orientationSize = v1;
6606 orientation3d = (bool)v2;
6610 // line (wireframe) width
6611 if ( lineWidth > 0 )
6612 aSmeshActor->SetLineWidth( lineWidth );
6614 if ( outlineWidth > 0 )
6615 aSmeshActor->SetOutlineWidth( outlineWidth );
6616 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6617 aSmeshActor->SetOutlineWidth( lineWidth );
6619 if ( elem0dSize > 0 )
6620 aSmeshActor->Set0DSize( elem0dSize );
6622 /*if ( ballSize > 0 )
6623 aSmeshActor->SetBallSize( ballSize );*/
6625 if ( ballDiameter > 0 )
6626 aSmeshActor->SetBallSize( ballDiameter );
6628 if ( ballScale > 0.0 )
6629 aSmeshActor->SetBallScale( ballScale );
6631 if ( shrinkSize > 0 )
6632 aSmeshActor->SetShrinkFactor( shrinkSize );
6633 // orientation vectors
6634 if ( orientationSize > 0 ) {
6635 aSmeshActor->SetFacesOrientationScale( orientationSize );
6636 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6640 else if (paramNameStr == "PointMarker") {
6641 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6642 if( data.count() >= 2 ) {
6644 int aParam1 = data[1].toInt( &ok );
6646 if( data[0] == "std" && data.count() == 3 ) {
6647 int aParam2 = data[2].toInt( &ok );
6648 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6650 else if( data[0] == "custom" ) {
6651 VTK::MarkerMap::const_iterator markerIt = aMarkerMap.find( aParam1 );
6652 if( markerIt != aMarkerMap.end() ) {
6653 VTK::MarkerData aMarkerData = markerIt->second;
6654 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6661 else if (paramNameStr == "Opacity") {
6662 aSmeshActor->SetOpacity(val.toFloat());
6665 else if (paramNameStr.startsWith("ClippingPlane")) {
6666 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6667 // old format - val looks like "Off" or "1:0:0:0.5:0:0"
6668 // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
6669 // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
6670 // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
6671 // new format - val looks like "Off" or "0" (plane id)
6672 // (note: in new format "Off" value is used only for consistency,
6673 // so it is processed together with values in old format)
6674 bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
6675 if( anIsOldFormat ) {
6676 if (paramNameStr == "ClippingPlane1" || val == "Off")
6677 aSmeshActor->RemoveAllClippingPlanes();
6679 QList<SUIT_ViewManager*> lst;
6680 getApp()->viewManagers(viewerTypStr, lst);
6681 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6682 if (viewIndex >= 0 && viewIndex < lst.count()) {
6683 SUIT_ViewManager* vman = lst.at(viewIndex);
6684 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6686 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6688 SMESH::TActorList anActorList;
6689 anActorList.push_back( aSmeshActor );
6690 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
6691 aPlane->myViewWindow = vtkView;
6692 SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
6693 aPlane->PlaneMode = aMode;
6694 bool isOpenGLClipping = ( bool )vals[1].toInt();
6695 aPlane->IsOpenGLClipping = isOpenGLClipping;
6696 if ( aMode == SMESH::Absolute ) {
6697 aPlane->myAbsoluteOrientation = vals[2].toInt();
6698 aPlane->X = vals[3].toFloat();
6699 aPlane->Y = vals[4].toFloat();
6700 aPlane->Z = vals[5].toFloat();
6701 aPlane->Dx = vals[6].toFloat();
6702 aPlane->Dy = vals[7].toFloat();
6703 aPlane->Dz = vals[8].toFloat();
6705 else if ( aMode == SMESH::Relative ) {
6706 aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
6707 aPlane->myDistance = vals[3].toFloat();
6708 aPlane->myAngle[0] = vals[4].toFloat();
6709 aPlane->myAngle[1] = vals[5].toFloat();
6713 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6714 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6715 aClippingPlaneInfo.Plane = aPlane;
6716 aClippingPlaneInfo.ActorList = anActorList;
6717 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6725 int aPlaneId = val.toInt( &ok );
6726 if( ok && aPlaneId >= 0 ) {
6727 bool anIsDefinedPlane = false;
6728 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6729 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6730 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6731 TPlaneInfo& aPlaneInfo = *anIter;
6732 if( aPlaneInfo.PlaneId == aPlaneId ) {
6733 aPlaneInfo.ActorList.push_back( aSmeshActor );
6734 anIsDefinedPlane = true;
6738 if( !anIsDefinedPlane ) {
6739 TPlaneInfo aPlaneInfo;
6740 aPlaneInfo.PlaneId = aPlaneId;
6741 aPlaneInfo.ActorList.push_back( aSmeshActor );
6742 aPlaneInfo.ViewManager = vman;
6744 // to make the list sorted by plane id
6745 anIter = aPlaneInfoList.begin();
6746 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6747 const TPlaneInfo& aPlaneInfoRef = *anIter;
6748 if( aPlaneInfoRef.PlaneId > aPlaneId )
6751 aPlaneInfoList.insert( anIter, aPlaneInfo );
6756 } // if (aSmeshActor)
6757 } // other parameters than Visibility
6759 } // for names/parameters iterator
6760 } // for entries iterator
6762 // take into account planes with empty list of actors referred to them
6763 QList<SUIT_ViewManager*> aVMList;
6764 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6766 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6767 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6768 int aViewId = aPlaneDataIter->first;
6769 if( aViewId >= 0 && aViewId < aVMList.count() ) {
6770 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6772 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6774 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6775 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6776 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6777 const TPlaneData& aPlaneData = *anIter2;
6778 int aPlaneId = aPlaneData.Id;
6780 bool anIsFound = false;
6781 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6782 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6783 const TPlaneInfo& aPlaneInfo = *anIter3;
6784 if( aPlaneInfo.PlaneId == aPlaneId ) {
6791 TPlaneInfo aPlaneInfo; // ActorList field is empty
6792 aPlaneInfo.PlaneId = aPlaneId;
6793 aPlaneInfo.ViewManager = aViewManager;
6795 // to make the list sorted by plane id
6796 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6797 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6798 const TPlaneInfo& aPlaneInfoRef = *anIter4;
6799 if( aPlaneInfoRef.PlaneId > aPlaneId )
6802 aPlaneInfoList.insert( anIter4, aPlaneInfo );
6808 // add clipping planes to actors according to the restored parameters
6809 // and update the clipping plane map
6810 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6811 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6812 int aViewId = anIter1->first;
6813 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6815 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6816 if( anIter2 == aPlaneDataMap.end() )
6818 const TPlaneDataList& aPlaneDataList = anIter2->second;
6820 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6821 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6822 const TPlaneInfo& aPlaneInfo = *anIter3;
6823 int aPlaneId = aPlaneInfo.PlaneId;
6824 const TActorList& anActorList = aPlaneInfo.ActorList;
6825 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6829 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6833 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6835 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6836 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6837 const TPlaneData& aPlaneData = *anIter4;
6838 if( aPlaneData.Id == aPlaneId ) {
6839 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
6840 aPlane->myViewWindow = aViewWindow;
6841 aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
6842 aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
6843 if ( aPlane->PlaneMode == SMESH::Absolute ) {
6844 aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
6845 aPlane->X = aPlaneData.X;
6846 aPlane->Y = aPlaneData.Y;
6847 aPlane->Z = aPlaneData.Z;
6848 aPlane->Dx = aPlaneData.Dx;
6849 aPlane->Dy = aPlaneData.Dy;
6850 aPlane->Dz = aPlaneData.Dz;
6852 else if ( aPlane->PlaneMode == SMESH::Relative ) {
6853 aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
6854 aPlane->myDistance = aPlaneData.Distance;
6855 aPlane->myAngle[0] = aPlaneData.Angle[0];
6856 aPlane->myAngle[1] = aPlaneData.Angle[1];
6859 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6860 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6861 aClippingPlaneInfo.Plane = aPlane;
6862 aClippingPlaneInfo.ActorList = anActorList;
6863 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6874 // update all VTK views
6875 QList<SUIT_ViewManager*> lst;
6876 getApp()->viewManagers(lst);
6877 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6878 SUIT_ViewModel* vmodel = (*it)->getViewModel();
6879 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6880 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6881 // set OpenGL clipping planes
6882 VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
6883 vtkActorCollection* anAllActors = aCopy.GetActors();
6884 anAllActors->InitTraversal();
6885 while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
6886 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
6887 anActor->SetOpenGLClippingPlane();
6889 vtkView->getRenderer()->ResetCameraClippingRange();
6896 \brief Adds preferences for dfont of VTK viewer
6898 \param pIf group identifier
6899 \param param parameter
6900 \return identifier of preferences
6902 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
6904 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6906 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6909 fam.append( tr( "SMESH_FONT_ARIAL" ) );
6910 fam.append( tr( "SMESH_FONT_COURIER" ) );
6911 fam.append( tr( "SMESH_FONT_TIMES" ) );
6913 setPreferenceProperty( tfont, "fonts", fam );
6915 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6916 if ( needSize ) f = f | QtxFontEdit::Size;
6917 setPreferenceProperty( tfont, "features", f );
6923 \brief Actions after hypothesis edition
6924 Updates object browser after hypothesis edition
6926 void SMESHGUI::onHypothesisEdit( int result )
6929 SMESHGUI::Modified();
6930 updateObjBrowser( true );
6934 \brief Actions after choosing menu of control modes
6935 Updates control mode actions according to current selection
6937 void SMESHGUI::onUpdateControlActions()
6939 SALOME_ListIO selected;
6940 if ( LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr() )
6941 aSel->selectedObjects( selected );
6943 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
6944 if ( selected.Extent() ) {
6945 if ( selected.First()->hasEntry() ) {
6946 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( selected.First()->getEntry() )) {
6947 aControl = anActor->GetControlMode();
6948 SALOME_ListIteratorOfListIO it(selected);
6949 for ( it.Next(); it.More(); it.Next() ) {
6950 Handle(SALOME_InteractiveObject) anIO = it.Value();
6951 if ( anIO->hasEntry() ) {
6952 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
6953 if ( aControl != anActor->GetControlMode() ) {
6954 aControl = SMESH_Actor::eNone;
6964 int anAction = ActionToControl( aControl, true );
6966 action( anAction )->setChecked( true );
6968 QMenu* send = (QMenu*)sender();
6969 QList<QAction*> actions = send->actions();
6970 for ( int i = 0; i < actions.size(); i++ )
6971 actions[i]->setChecked( false );
6977 \brief Signal handler closing(SUIT_ViewWindow*) of a view
6978 \param pview view being closed
6980 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
6981 #ifndef DISABLE_PLOT2DVIEWER
6982 //Crear all Plot2d Viewers if need.
6983 SMESH::ClearPlot2Viewers(pview);
6985 EmitSignalCloseView();
6988 void SMESHGUI::message( const QString& msg )
6991 QStringList data = msg.split("/");
6992 if ( data.count() > 0 ) {
6993 if ( data.first() == "mesh_loading" ) {
6995 QString entry = data.count() > 1 ? data[1] : QString();
6996 if ( entry.isEmpty() )
6999 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
7001 _PTR(SObject) obj = study->FindObjectID( entry.toLatin1().constData() );
7004 name = SMESH::fromUtf8(obj->GetName());
7005 if ( name.isEmpty() )
7008 if ( data.last() == "stop" )
7009 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
7011 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
7012 QApplication::processEvents();
7018 \brief Connects or disconnects signals about activating and cloning view on the module slots
7019 \param pview view which is connected/disconnected
7021 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
7025 SUIT_ViewManager* viewMgr = pview->getViewManager();
7027 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7028 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7030 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7031 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7036 \brief Return \c true if object can be renamed
7038 bool SMESHGUI::renameAllowed( const QString& entry) const {
7039 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7043 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7047 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
7052 if(appStudy->isComponent(entry) || obj->isReference())
7055 // check type to prevent renaming of inappropriate objects
7056 int aType = SMESHGUI_Selection::type(qPrintable(entry), SMESH::GetActiveStudyDocument());
7057 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7058 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7059 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7060 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7061 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
7068 Rename object by entry.
7069 \param entry entry of the object
7070 \param name new name of the object
7071 \brief Return \c true if rename operation finished successfully, \c false otherwise.
7073 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
7075 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7079 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7084 _PTR(Study) aStudy = appStudy->studyDS();
7089 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
7091 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
7096 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
7097 _PTR(GenericAttribute) anAttr;
7098 _PTR(AttributeName) aName;
7100 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
7102 // check type to prevent renaming of inappropriate objects
7103 int aType = SMESHGUI_Selection::type( qPrintable(entry), SMESH::GetActiveStudyDocument() );
7104 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7105 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7106 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7107 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7108 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
7109 if ( !name.isEmpty() ) {
7110 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
7112 // update name of group object and its actor
7113 Handle(SALOME_InteractiveObject) IObject =
7114 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
7116 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
7117 if( !aGroupObject->_is_nil() ) {
7118 aGroupObject->SetName( qPrintable(name) );
7119 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
7120 anActor->setName( qPrintable(name) );
7130 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
7132 static QList<QColor> colors;
7134 if ( colors.isEmpty() ) {
7136 for (int s = 0; s < 2 ; s++)
7138 for (int v = 100; v >= 40; v = v - 20)
7140 for (int h = 0; h < 359 ; h = h + 60)
7142 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
7147 static int currentColor = randomize( colors.size() );
7149 SALOMEDS::Color color;
7150 color.R = (double)colors[currentColor].red() / 255.0;
7151 color.G = (double)colors[currentColor].green() / 255.0;
7152 color.B = (double)colors[currentColor].blue() / 255.0;
7154 currentColor = (currentColor+1) % colors.count();