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;
1833 Handle(SALOME_InteractiveObject) anIO;
1834 for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1836 anIO = anIt.Value();
1837 QString cur = anIO->getComponentDataType();
1838 _PTR(SObject) aSO = aStudy->FindObjectID(anIO->getEntry());
1840 // check if object is reference
1841 _PTR(SObject) aRefSObj;
1842 aNameList.append("\n - ");
1843 if ( aSO->ReferencedObject( aRefSObj ) ) {
1844 QString aRefName = QString::fromStdString ( aRefSObj->GetName() );
1845 aNameList.append( aRefName );
1846 cur = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1849 aNameList.append(anIO->getName());
1853 if( aParentComponent.isNull() )
1854 aParentComponent = cur;
1855 else if( !aParentComponent.isEmpty() && aParentComponent!=cur )
1856 aParentComponent = "";
1859 if ( objectCount == 0 )
1860 return; // No Valid Objects Selected
1862 if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
1863 SUIT_MessageBox::warning( SMESHGUI::desktop(),
1864 QObject::tr("ERR_ERROR"),
1865 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
1868 // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
1869 if (SUIT_MessageBox::warning
1870 (SMESHGUI::desktop(),
1871 QObject::tr("SMESH_WRN_WARNING"),
1872 QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
1873 SUIT_MessageBox::Yes | SUIT_MessageBox::No,
1874 SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
1877 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1879 // Put the whole hierarchy of sub-objects of the selected SO's into a list and
1880 // then treat them all starting from the deepest objects (at list back)
1881 std::list< _PTR(SObject) > listSO;
1882 SALOME_ListIteratorOfListIO It(selected);
1883 for( ; It.More(); It.Next()) // loop on selected IO's
1885 Handle(SALOME_InteractiveObject) IObject = It.Value();
1886 if(IObject->hasEntry()) {
1887 _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
1889 // disable removal of "SMESH" component object
1890 if(aSO->FindAttribute(anAttr, "AttributeIOR")){
1892 if ( engineIOR() == anIOR->Value().c_str() )
1895 //Check the referenced object
1896 _PTR(SObject) aRefSObject;
1897 if ( aSO && aSO->ReferencedObject( aRefSObject ) )
1898 aSO = aRefSObject; // Delete main Object instead of reference
1900 listSO.push_back( aSO );
1901 std::list< _PTR(SObject) >::iterator itSO = --listSO.end();
1902 for ( ; itSO != listSO.end(); ++itSO ) {
1903 _PTR(ChildIterator) it = aStudy->NewChildIterator( *itSO );
1904 for (it->InitEx(false); it->More(); it->Next())
1905 listSO.push_back( it->Value() );
1909 // Check if none of objects to delete is referred from outside
1910 std::list< _PTR(SObject) >::reverse_iterator ritSO;
1911 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1913 _PTR(SObject) SO = *ritSO;
1914 if ( !SO ) continue;
1915 std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( *ritSO );
1916 for (size_t i = 0; i < aReferences.size(); i++) {
1917 _PTR(SComponent) aComponent = aReferences[i]->GetFatherComponent();
1918 std::string type = aComponent->ComponentDataType();
1919 if ( type != "SMESH" )
1921 SUIT_MessageBox::warning( anApp->desktop(),
1922 QObject::tr("WRN_WARNING"),
1923 QObject::tr("DEP_OBJECT") );
1924 return; // outside SMESH, there is an object depending on a SMESH object
1929 // Call mesh->Clear() to prevent loading mesh from file caused by hypotheses removal
1930 for( It.Initialize( selected ); It.More(); It.Next()) // loop on selected IO's
1932 Handle(SALOME_InteractiveObject) IObject = It.Value();
1933 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface< SMESH::SMESH_Mesh >( IObject );
1934 if ( !mesh->_is_nil() )
1938 // Treat SO's in the list starting from the back
1939 aStudyBuilder->NewCommand(); // There is a transaction
1940 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1942 _PTR(SObject) SO = *ritSO;
1943 if ( !SO ) continue;
1944 std::string anEntry = SO->GetID();
1946 /** Erase graphical object and remove all its data **/
1947 if(SO->FindAttribute(anAttr, "AttributeIOR")) {
1948 SMESH::RemoveVisualObjectWithActors( anEntry.c_str(), true);
1950 /** Remove an object from data structures **/
1951 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
1952 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
1953 if ( !aGroup->_is_nil() ) { // DELETE GROUP
1954 SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
1955 aMesh->RemoveGroup( aGroup );
1957 else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
1958 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
1959 aMesh->RemoveSubMesh( aSubMesh );
1961 _PTR(SObject) aMeshSO = SMESH::FindSObject(aMesh);
1963 SMESH::ModifiedMesh(aMeshSO, false, aMesh->NbNodes()==0);
1966 Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
1967 ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
1968 QString objType = CheckTypeObject(IObject);
1969 if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
1970 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
1971 aStudyBuilder->RemoveObjectWithChildren( SO );
1973 else {// default action: remove SObject from the study
1974 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
1975 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
1977 aStudyBuilder->RemoveObjectWithChildren( SO );
1981 } /* listSO back loop */
1983 aStudyBuilder->CommitCommand();
1985 /* Clear any previous selection */
1987 aSel->setSelectedObjects( l1 );
1989 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1993 SMESHGUI_EXPORT CAM_Module* createModule()
1995 return new SMESHGUI();
1998 SMESHGUI_EXPORT char* getModuleVersion() {
1999 return (char*)SMESH_VERSION_STR;
2003 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
2005 //=============================================================================
2009 //=============================================================================
2010 SMESHGUI::SMESHGUI() :
2011 SalomeApp_Module( "SMESH" )
2013 if ( CORBA::is_nil( myComponentSMESH ) )
2015 CORBA::Boolean anIsEmbeddedMode;
2016 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
2017 //MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
2019 // 0019923: EDF 765 SMESH : default values of hypothesis
2020 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
2021 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
2022 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
2023 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
2024 myComponentSMESH->SetDefaultNbSegments( nbSeg );
2026 const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif", "default_grp_color" };
2027 for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
2028 if ( aResourceMgr->hasValue( "SMESH", options[i] ))
2030 QString val = aResourceMgr->stringValue( "SMESH", options[i] );
2031 myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
2035 myActiveDialogBox = 0;
2036 myFilterLibraryDlg = 0;
2040 myEventCallbackCommand = vtkCallbackCommand::New();
2041 myEventCallbackCommand->Delete();
2042 myEventCallbackCommand->SetClientData( this );
2043 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
2046 /* load resources for all available meshers */
2047 SMESH::InitAvailableHypotheses();
2050 //=============================================================================
2054 //=============================================================================
2055 SMESHGUI::~SMESHGUI()
2059 //=============================================================================
2063 //=============================================================================
2064 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
2066 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2068 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
2073 //=============================================================================
2077 //=============================================================================
2078 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
2080 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2084 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2085 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2086 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2087 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2088 return autoUpdate && !exceeded;
2091 //=============================================================================
2095 //=============================================================================
2096 bool SMESHGUI::automaticUpdate( SMESH::SMESH_IDSource_ptr theMesh,
2097 int* entities, bool* limitExceeded, int* hidden, long* nbElements )
2099 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2103 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2104 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2105 bool incrementalLimit = resMgr->booleanValue( "SMESH", "incremental_limit", false );
2107 SMESH::long_array_var info = theMesh->GetMeshInfo();
2108 long nbOdElems = info[SMDSEntity_0D];
2109 long nbEdges = info[SMDSEntity_Edge] + info[SMDSEntity_Quad_Edge];
2110 long nbFaces = info[SMDSEntity_Triangle] + info[SMDSEntity_Quad_Triangle] + info[SMDSEntity_BiQuad_Triangle] +
2111 info[SMDSEntity_Quadrangle] + info[SMDSEntity_Quad_Quadrangle] + info[SMDSEntity_BiQuad_Quadrangle] +
2112 info[SMDSEntity_Polygon] + info[SMDSEntity_Quad_Polygon];
2113 long nbVolumes = info[SMDSEntity_Tetra] + info[SMDSEntity_Quad_Tetra] +
2114 info[SMDSEntity_Hexa] + info[SMDSEntity_Quad_Hexa] + info[SMDSEntity_TriQuad_Hexa] +
2115 info[SMDSEntity_Pyramid] + info[SMDSEntity_Quad_Pyramid] +
2116 info[SMDSEntity_Penta] + info[SMDSEntity_Quad_Penta] +
2117 info[SMDSEntity_Polyhedra] +
2118 info[SMDSEntity_Hexagonal_Prism];
2119 long nbBalls = info[SMDSEntity_Ball];
2121 long requestedSize = nbOdElems + nbBalls + nbEdges + nbFaces + nbVolumes;
2122 *nbElements = requestedSize;
2124 *entities = SMESH_Actor::eAllEntity;
2127 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2129 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2131 if ( incrementalLimit ) {
2134 if ( nbOdElems > 0 ) {
2135 if ( total + nbOdElems > updateLimit ) {
2136 *entities = *entities & ~SMESH_Actor::e0DElements;
2137 *hidden = *hidden | SMESH_Actor::e0DElements;
2144 if ( nbEdges > 0 ) {
2145 if ( total + nbEdges > updateLimit ) {
2146 *entities = *entities & ~SMESH_Actor::eEdges;
2147 *hidden = *hidden | SMESH_Actor::eEdges;
2154 if ( nbFaces > 0 ) {
2155 if ( total + nbFaces > updateLimit ) {
2156 *entities = *entities & ~SMESH_Actor::eFaces;
2157 *hidden = *hidden | SMESH_Actor::eFaces;
2164 if ( nbVolumes > 0 ) {
2165 if ( total + nbVolumes > updateLimit ) {
2166 *entities = *entities & ~SMESH_Actor::eVolumes;
2167 *hidden = *hidden | SMESH_Actor::eVolumes;
2174 if ( nbBalls > 0 ) {
2175 if ( total + nbBalls > updateLimit ) {
2176 *entities = *entities & ~SMESH_Actor::eBallElem;
2177 *hidden = *hidden | SMESH_Actor::eBallElem;
2185 return autoUpdate && !exceeded;
2188 //=============================================================================
2192 //=============================================================================
2193 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
2195 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
2198 //=============================================================================
2202 //=============================================================================
2203 SMESHGUI* SMESHGUI::GetSMESHGUI()
2205 SMESHGUI* smeshMod = 0;
2206 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
2209 CAM_Module* module = app->module( "Mesh" );
2210 smeshMod = dynamic_cast<SMESHGUI*>( module );
2213 if ( smeshMod && smeshMod->application() && smeshMod->application()->activeStudy() )
2215 SalomeApp_Study* study = dynamic_cast<SalomeApp_Study*>( smeshMod->application()->activeStudy() );
2218 _PTR(Study) aStudy = study->studyDS();
2220 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
2229 Standard_EXPORT SMESHGUI* GetComponentGUI()
2231 return SMESHGUI::GetSMESHGUI();
2235 //=============================================================================
2239 //=============================================================================
2240 void SMESHGUI::SetState(int aState)
2245 //=============================================================================
2249 //=============================================================================
2250 void SMESHGUI::ResetState()
2255 //=============================================================================
2259 //=============================================================================
2260 void SMESHGUI::EmitSignalDeactivateDialog()
2262 emit SignalDeactivateActiveDialog();
2265 //=============================================================================
2269 //=============================================================================
2270 void SMESHGUI::EmitSignalStudyFrameChanged()
2272 emit SignalStudyFrameChanged();
2275 //=============================================================================
2279 //=============================================================================
2280 void SMESHGUI::EmitSignalCloseAllDialogs()
2282 emit SignalCloseAllDialogs();
2285 //=============================================================================
2289 //=============================================================================
2290 void SMESHGUI::EmitSignalVisibilityChanged()
2292 emit SignalVisibilityChanged();
2295 //=============================================================================
2299 //=============================================================================
2300 void SMESHGUI::EmitSignalCloseView()
2302 emit SignalCloseView();
2305 //=============================================================================
2309 //=============================================================================
2310 void SMESHGUI::EmitSignalActivatedViewManager()
2312 emit SignalActivatedViewManager();
2315 //=============================================================================
2319 //=============================================================================
2320 QDialog *SMESHGUI::GetActiveDialogBox()
2322 return myActiveDialogBox;
2325 //=============================================================================
2329 //=============================================================================
2330 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2332 myActiveDialogBox = (QDialog *) aDlg;
2336 //=============================================================================
2340 //=============================================================================
2341 SUIT_Desktop* SMESHGUI::desktop()
2343 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2345 return app->desktop();
2350 //=============================================================================
2354 //=============================================================================
2355 SalomeApp_Study* SMESHGUI::activeStudy()
2357 SUIT_Application* app = SUIT_Session::session()->activeApplication();
2359 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2364 //=============================================================================
2368 //=============================================================================
2369 void SMESHGUI::Modified( bool theIsUpdateActions )
2371 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2372 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2373 appStudy->Modified();
2374 if( theIsUpdateActions )
2375 app->updateActions();
2380 //=============================================================================
2384 //=============================================================================
2385 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2387 /* Here the position is on the bottom right corner - 10 */
2388 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2390 SUIT_Desktop *PP = desktop();
2391 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2392 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2396 //=============================================================================
2400 //=============================================================================
2401 static int isStudyLocked(_PTR(Study) theStudy){
2402 return theStudy->GetProperties()->IsLocked();
2405 static bool checkLock(_PTR(Study) theStudy) {
2406 if (isStudyLocked(theStudy)) {
2407 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2408 QObject::tr("WRN_WARNING"),
2409 QObject::tr("WRN_STUDY_LOCKED") );
2415 //=======================================================================
2416 //function : CheckActiveStudyLocked
2418 //=======================================================================
2420 bool SMESHGUI::isActiveStudyLocked()
2422 _PTR(Study) aStudy = activeStudy()->studyDS();
2423 return checkLock( aStudy );
2426 //=============================================================================
2430 //=============================================================================
2431 bool SMESHGUI::OnGUIEvent( int theCommandID )
2433 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2437 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
2438 SUIT_ResourceMgr* mgr = resourceMgr();
2442 if (CORBA::is_nil(GetSMESHGen()->GetCurrentStudy())) {
2443 GetSMESHGen()->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
2446 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2447 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2449 //QAction* act = action( theCommandID );
2451 switch (theCommandID) {
2452 case SMESHOp::OpDelete:
2453 if(checkLock(aStudy)) break;
2456 case SMESHOp::OpImportDAT:
2457 case SMESHOp::OpImportUNV:
2458 case SMESHOp::OpImportMED:
2459 case SMESHOp::OpImportSTL:
2460 case SMESHOp::OpImportCGNS:
2461 case SMESHOp::OpImportSAUV:
2462 case SMESHOp::OpImportGMF:
2463 case SMESHOp::OpPopupImportDAT:
2464 case SMESHOp::OpPopupImportUNV:
2465 case SMESHOp::OpPopupImportMED:
2466 case SMESHOp::OpPopupImportSTL:
2467 case SMESHOp::OpPopupImportCGNS:
2468 case SMESHOp::OpPopupImportSAUV:
2469 case SMESHOp::OpPopupImportGMF:
2471 if(checkLock(aStudy)) break;
2472 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2476 case SMESHOp::OpFileInformation:
2478 SALOME_ListIO selected;
2479 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2481 aSel->selectedObjects( selected );
2482 if( selected.Extent() )
2484 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2485 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2486 if ( !aMesh->_is_nil() )
2488 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2494 case SMESHOp::OpExportDAT:
2495 case SMESHOp::OpExportMED:
2496 case SMESHOp::OpExportUNV:
2497 case SMESHOp::OpExportSTL:
2498 case SMESHOp::OpExportCGNS:
2499 case SMESHOp::OpExportSAUV:
2500 case SMESHOp::OpExportGMF:
2501 case SMESHOp::OpPopupExportDAT:
2502 case SMESHOp::OpPopupExportMED:
2503 case SMESHOp::OpPopupExportUNV:
2504 case SMESHOp::OpPopupExportSTL:
2505 case SMESHOp::OpPopupExportCGNS:
2506 case SMESHOp::OpPopupExportSAUV:
2507 case SMESHOp::OpPopupExportGMF:
2509 ::ExportMeshToFile(theCommandID);
2513 case SMESHOp::OpReset: // SCALAR BAR
2515 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2516 SALOME_ListIO selected;
2518 aSel->selectedObjects( selected );
2520 SALOME_ListIteratorOfListIO it(selected);
2521 for( ; it.More(); it.Next()) {
2522 Handle(SALOME_InteractiveObject) anIO = it.Value();
2523 if( anIO->hasEntry() ) {
2524 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2525 anActor->SetControlMode( SMESH_Actor::eNone );
2526 #ifndef DISABLE_PLOT2DVIEWER
2527 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2532 SMESH::UpdateView();
2535 case SMESHOp::OpScalarBarProperties:
2537 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2540 case SMESHOp::OpShowScalarBar:
2542 // show/hide scalar bar
2543 ::ShowElement(theCommandID);
2546 case SMESHOp::OpSaveDistribution:
2548 // dump control distribution data to the text file
2549 ::SaveDistribution();
2553 case SMESHOp::OpShowDistribution:
2555 // show/hide distribution
2556 ::ShowElement(theCommandID);
2560 #ifndef DISABLE_PLOT2DVIEWER
2561 case SMESHOp::OpPlotDistribution:
2563 // plot distribution
2564 ::PlotDistribution();
2570 case SMESHOp::OpAutoColor:
2574 case SMESHOp::OpDisableAutoColor:
2575 ::DisableAutoColor();
2578 case SMESHOp::OpClipping:
2579 case SMESHOp::OpTransparency:
2580 case SMESHOp::OpProperties: // Display preferences (colors, shrink size, line width, ...)
2583 case SMESHOp::OpDMWireframe:
2584 case SMESHOp::OpDMShading:
2585 case SMESHOp::OpDMNodes:
2586 case SMESHOp::OpDMShrink:
2587 ::SetDisplayMode(theCommandID, myMarkerMap);
2590 //2D quadratic representation
2591 case SMESHOp::OpRepresentationLines:
2592 case SMESHOp::OpRepresentationArcs:
2593 ::SetDisplayMode(theCommandID, myMarkerMap);
2597 case SMESHOp::OpDE0DElements:
2598 case SMESHOp::OpDEEdges:
2599 case SMESHOp::OpDEFaces:
2600 case SMESHOp::OpDEVolumes:
2601 case SMESHOp::OpDEBalls:
2602 case SMESHOp::OpDEAllEntity:
2603 ::SetDisplayEntity(theCommandID);
2606 // Choose entities to be displayed
2607 case SMESHOp::OpDEChoose:
2609 ( new SMESHGUI_DisplayEntitiesDlg( SMESHGUI::desktop() ) )->exec();
2613 case SMESHOp::OpOrientationOnFaces:
2615 SUIT_OverrideCursor wc;
2616 LightApp_SelectionMgr* mgr = selectionMgr();
2617 SALOME_ListIO selected; mgr->selectedObjects( selected );
2619 SALOME_ListIteratorOfListIO it(selected);
2620 for( ; it.More(); it.Next()) {
2621 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2622 if(anIObject->hasEntry()) {
2623 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2624 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2631 case SMESHOp::OpUpdate:
2633 if(checkLock(aStudy)) break;
2634 SUIT_OverrideCursor wc;
2636 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2639 SMESH::UpdateView();
2641 catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2642 SMESH::OnVisuException();
2644 catch (...) { // PAL16774 (Crash after display of many groups)
2645 SMESH::OnVisuException();
2649 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2650 aSel->selectedObjects( l );
2651 aSel->setSelectedObjects( l );
2655 case SMESHOp::OpHide:
2656 case SMESHOp::OpShow:
2657 case SMESHOp::OpShowOnly:
2659 SUIT_OverrideCursor wc;
2660 SMESH::EDisplaing anAction;
2661 switch (theCommandID) {
2662 case SMESHOp::OpHide: anAction = SMESH::eErase; break;
2663 case SMESHOp::OpShow: anAction = SMESH::eDisplay; break;
2664 case SMESHOp::OpShowOnly: anAction = SMESH::eDisplayOnly; break;
2667 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2668 SALOME_ListIO sel_objects, to_process;
2670 aSel->selectedObjects( sel_objects );
2672 if ( theCommandID==SMESHOp::OpShowOnly )
2674 //MESSAGE("anAction = SMESH::eDisplayOnly");
2675 startOperation( myEraseAll );
2678 extractContainers( sel_objects, to_process );
2683 SALOME_ListIteratorOfListIO It( to_process );
2684 for ( ; It.More(); It.Next())
2686 Handle(SALOME_InteractiveObject) IOS = It.Value();
2687 if ( IOS->hasEntry() )
2689 if ( !SMESH::UpdateView( anAction, IOS->getEntry() )) {
2690 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2691 break; // PAL16774 (Crash after display of many groups)
2693 if (anAction == SMESH::eDisplayOnly)
2694 anAction = SMESH::eDisplay;
2699 // PAL13338 + PAL15161 -->
2700 if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !checkLock(aStudy)) {
2701 SMESH::UpdateView();
2702 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2704 // PAL13338 + PAL15161 <--
2706 catch (...) { // PAL16774 (Crash after display of many groups)
2707 SMESH::OnVisuException();
2710 if (anAction == SMESH::eErase) {
2712 aSel->setSelectedObjects( l1 );
2715 aSel->setSelectedObjects( to_process );
2720 case SMESHOp::OpNode:
2722 if(checkLock(aStudy)) break;
2725 EmitSignalDeactivateDialog();
2727 ( new SMESHGUI_NodesDlg( this ) )->show();
2730 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"),tr("SMESH_WRN_VIEWER_VTK"));
2735 case SMESHOp::OpCreateMesh:
2736 case SMESHOp::OpCreateSubMesh:
2737 case SMESHOp::OpEditMeshOrSubMesh:
2738 case SMESHOp::OpEditMesh:
2739 case SMESHOp::OpEditSubMesh:
2740 case SMESHOp::OpCompute:
2741 case SMESHOp::OpComputeSubMesh:
2742 case SMESHOp::OpPreCompute:
2743 case SMESHOp::OpEvaluate:
2744 case SMESHOp::OpMeshOrder:
2745 startOperation( theCommandID );
2747 case SMESHOp::OpCopyMesh:
2749 if (checkLock(aStudy)) break;
2750 EmitSignalDeactivateDialog();
2751 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2754 case SMESHOp::OpBuildCompoundMesh:
2756 if (checkLock(aStudy)) break;
2757 EmitSignalDeactivateDialog();
2758 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2762 case SMESHOp::OpDiagonalInversion:
2763 case SMESHOp::OpUnionOfTwoTriangle:
2767 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2771 if ( checkLock( aStudy ) )
2774 /*Standard_Boolean aRes;
2775 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2776 if ( aMesh->_is_nil() )
2778 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2779 tr( "SMESH_BAD_SELECTION" ) );
2783 EmitSignalDeactivateDialog();
2784 if ( theCommandID == SMESHOp::OpDiagonalInversion )
2785 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2787 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2790 case SMESHOp::OpOrientation:
2791 case SMESHOp::OpUnionOfTriangles:
2792 case SMESHOp::OpCuttingOfQuadrangles:
2793 case SMESHOp::OpSplitVolumes:
2797 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2801 if ( checkLock( aStudy ) )
2804 EmitSignalDeactivateDialog();
2805 SMESHGUI_MultiEditDlg* aDlg = NULL;
2806 if ( theCommandID == SMESHOp::OpOrientation )
2807 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2808 else if ( theCommandID == SMESHOp::OpUnionOfTriangles )
2809 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2810 else if ( theCommandID == SMESHOp::OpSplitVolumes )
2811 aDlg = new SMESHGUI_SplitVolumesDlg(this);
2813 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2818 case SMESHOp::OpSmoothing:
2820 if(checkLock(aStudy)) break;
2822 EmitSignalDeactivateDialog();
2823 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2826 SUIT_MessageBox::warning(desktop(), tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2830 case SMESHOp::OpExtrusion:
2832 if (checkLock(aStudy)) break;
2834 EmitSignalDeactivateDialog();
2835 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2837 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2841 case SMESHOp::OpExtrusionAlongAPath:
2843 if (checkLock(aStudy)) break;
2845 EmitSignalDeactivateDialog();
2846 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2848 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2852 case SMESHOp::OpRevolution:
2854 if(checkLock(aStudy)) break;
2856 EmitSignalDeactivateDialog();
2857 ( new SMESHGUI_RevolutionDlg( this ) )->show();
2860 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2864 case SMESHOp::OpPatternMapping:
2866 if ( checkLock( aStudy ) )
2870 EmitSignalDeactivateDialog();
2871 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2874 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2878 case SMESHOp::OpSplitBiQuadratic:
2879 case SMESHOp::OpConvertMeshToQuadratic:
2880 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
2881 case SMESHOp::OpReorientFaces:
2882 case SMESHOp::OpCreateGeometryGroup:
2884 startOperation( theCommandID );
2887 case SMESHOp::OpCreateGroup:
2891 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2895 if(checkLock(aStudy)) break;
2896 EmitSignalDeactivateDialog();
2897 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2899 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2900 SALOME_ListIO selected;
2902 aSel->selectedObjects( selected );
2904 int nbSel = selected.Extent();
2906 // check if mesh is selected
2907 aMesh = SMESH::GetMeshByIO( selected.First() );
2909 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2914 case SMESHOp::OpConstructGroup:
2918 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2922 if(checkLock(aStudy)) break;
2923 EmitSignalDeactivateDialog();
2925 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2926 SALOME_ListIO selected;
2928 aSel->selectedObjects( selected );
2930 int nbSel = selected.Extent();
2932 // check if submesh is selected
2933 Handle(SALOME_InteractiveObject) IObject = selected.First();
2934 if (IObject->hasEntry()) {
2935 _PTR(SObject) aSObj = aStudy->FindObjectID(IObject->getEntry());
2937 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2938 if (!aSubMesh->_is_nil()) {
2940 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2941 // get submesh elements list by types
2942 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2943 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2944 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2945 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2946 // create group for each type o elements
2947 QString aName = IObject->getName();
2948 QStringList anEntryList;
2949 if (aNodes->length() > 0) {
2950 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2951 aGroup->Add(aNodes.inout());
2952 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2953 anEntryList.append( aSObject->GetID().c_str() );
2955 if (aEdges->length() > 0) {
2956 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2957 aGroup->Add(aEdges.inout());
2958 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2959 anEntryList.append( aSObject->GetID().c_str() );
2961 if (aFaces->length() > 0) {
2962 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2963 aGroup->Add(aFaces.inout());
2964 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2965 anEntryList.append( aSObject->GetID().c_str() );
2967 if (aVolumes->length() > 0) {
2968 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2969 aGroup->Add(aVolumes.inout());
2970 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2971 anEntryList.append( aSObject->GetID().c_str() );
2974 anApp->browseObjects( anEntryList );
2976 catch(const SALOME::SALOME_Exception & S_ex){
2977 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2984 SUIT_MessageBox::warning(desktop(),
2985 tr("SMESH_WRN_WARNING"),
2986 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
2991 case SMESHOp::OpEditGroup:
2995 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2999 if(checkLock(aStudy)) break;
3000 EmitSignalDeactivateDialog();
3002 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3003 SALOME_ListIO selected;
3005 aSel->selectedObjects( selected );
3007 SALOME_ListIteratorOfListIO It (selected);
3008 int nbSelectedGroups = 0;
3009 for ( ; It.More(); It.Next() )
3011 SMESH::SMESH_GroupBase_var aGroup =
3012 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
3013 if (!aGroup->_is_nil()) {
3015 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
3019 if (nbSelectedGroups == 0)
3021 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
3027 case SMESHOp::OpAddElemGroupPopup: // Add elements to group
3029 if(checkLock(aStudy)) break;
3030 if (myState == 800) {
3031 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3032 if (aDlg) aDlg->onAdd();
3037 case SMESHOp::OpRemoveElemGroupPopup: // Remove elements from group
3039 if(checkLock(aStudy)) break;
3040 if (myState == 800) {
3041 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3042 if (aDlg) aDlg->onRemove();
3047 case SMESHOp::OpEditGeomGroupAsGroup:
3051 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3055 if(checkLock(aStudy)) break;
3056 EmitSignalDeactivateDialog();
3058 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3059 SALOME_ListIO selected;
3061 aSel->selectedObjects( selected );
3063 SALOME_ListIteratorOfListIO It (selected);
3064 for ( ; It.More(); It.Next() )
3066 SMESH::SMESH_GroupOnGeom_var aGroup =
3067 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
3068 if (!aGroup->_is_nil()) {
3069 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3074 SMESH::SMESH_GroupOnFilter_var aGroup =
3075 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
3076 if (!aGroup->_is_nil()) {
3077 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3085 case SMESHOp::OpUnionGroups:
3086 case SMESHOp::OpIntersectGroups:
3087 case SMESHOp::OpCutGroups:
3091 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3095 if ( checkLock( aStudy ) )
3098 EmitSignalDeactivateDialog();
3100 SMESHGUI_GroupOpDlg* aDlg = 0;
3101 if ( theCommandID == SMESHOp::OpUnionGroups )
3102 aDlg = new SMESHGUI_UnionGroupsDlg( this );
3103 else if ( theCommandID == SMESHOp::OpIntersectGroups )
3104 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3106 aDlg = new SMESHGUI_CutGroupsDlg( this );
3113 case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
3115 if ( checkLock( aStudy ) )
3118 EmitSignalDeactivateDialog();
3119 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3125 case SMESHOp::OpDeleteGroup: // Delete groups with their contents
3129 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3133 if ( checkLock( aStudy ) )
3136 EmitSignalDeactivateDialog();
3138 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3142 case SMESHOp::OpMeshInformation:
3143 case SMESHOp::OpWhatIs:
3145 int page = theCommandID == SMESHOp::OpMeshInformation ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3146 EmitSignalDeactivateDialog();
3147 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3148 SALOME_ListIO selected;
3150 aSel->selectedObjects( selected );
3152 if ( selected.Extent() > 1 ) { // a dlg for each IO
3153 SALOME_ListIteratorOfListIO It( selected );
3154 for ( ; It.More(); It.Next() ) {
3155 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3156 dlg->showInfo( It.Value() );
3161 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3167 case SMESHOp::OpFindElementByPoint:
3169 startOperation( theCommandID );
3173 case SMESHOp::OpEditHypothesis:
3175 if(checkLock(aStudy)) break;
3177 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3178 SALOME_ListIO selected;
3180 aSel->selectedObjects( selected );
3182 int nbSel = selected.Extent();
3185 Handle(SALOME_InteractiveObject) anIObject = selected.First();
3186 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3188 if ( !aHypothesis->_is_nil() )
3190 SMESHGUI_GenericHypothesisCreator* aCreator =
3191 SMESH::GetHypothesisCreator( SMESH::toQStr( aHypothesis->GetName() ));
3194 // set geometry of mesh and sub-mesh to aCreator
3195 aSel->selectedObjects( selected, "", /*convertReferences=*/false);
3196 if ( selected.Extent() == 1 )
3198 QString subGeomID, meshGeomID;
3199 Handle(SALOME_InteractiveObject) hypIO = selected.First();
3200 if ( SMESH::GetGeomEntries( hypIO, subGeomID, meshGeomID ))
3202 if ( subGeomID.isEmpty() ) subGeomID = meshGeomID;
3203 aCreator->setShapeEntry( subGeomID );
3204 aCreator->setMainShapeEntry( meshGeomID );
3208 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3218 case SMESHOp::OpUnassign: // REMOVE HYPOTHESIS / ALGORITHMS
3220 if(checkLock(aStudy)) break;
3221 SUIT_OverrideCursor wc;
3223 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3224 SALOME_ListIO selected;
3226 aSel->selectedObjects( selected, QString::null, false );
3228 SALOME_ListIteratorOfListIO It(selected);
3229 for (int i = 0; It.More(); It.Next(), i++) {
3230 Handle(SALOME_InteractiveObject) IObject = It.Value();
3231 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3234 aSel->setSelectedObjects( l1 );
3239 case SMESHOp::OpElem0D:
3240 case SMESHOp::OpBall:
3241 case SMESHOp::OpEdge:
3242 case SMESHOp::OpTriangle:
3243 case SMESHOp::OpQuadrangle:
3244 case SMESHOp::OpPolygon:
3245 case SMESHOp::OpTetrahedron:
3246 case SMESHOp::OpHexahedron:
3247 case SMESHOp::OpPentahedron:
3248 case SMESHOp::OpPyramid:
3249 case SMESHOp::OpHexagonalPrism:
3251 if(checkLock(aStudy)) break;
3253 EmitSignalDeactivateDialog();
3254 SMDSAbs_EntityType type = SMDSEntity_Edge;
3255 switch (theCommandID) {
3256 case SMESHOp::OpElem0D: type = SMDSEntity_0D; break;
3257 case SMESHOp::OpBall: type = SMDSEntity_Ball; break;
3258 case SMESHOp::OpTriangle: type = SMDSEntity_Triangle; break;
3259 case SMESHOp::OpQuadrangle: type = SMDSEntity_Quadrangle; break;
3260 case SMESHOp::OpTetrahedron: type = SMDSEntity_Tetra; break;
3261 case SMESHOp::OpPolygon: type = SMDSEntity_Polygon; break;
3262 case SMESHOp::OpHexahedron: type = SMDSEntity_Hexa; break;
3263 case SMESHOp::OpPentahedron: type = SMDSEntity_Penta; break;
3264 case SMESHOp::OpPyramid: type = SMDSEntity_Pyramid; break;
3265 case SMESHOp::OpHexagonalPrism: type = SMDSEntity_Hexagonal_Prism; break;
3268 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3271 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3275 case SMESHOp::OpPolyhedron:
3277 if(checkLock(aStudy)) break;
3279 EmitSignalDeactivateDialog();
3280 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3283 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3287 case SMESHOp::OpQuadraticEdge:
3288 case SMESHOp::OpQuadraticTriangle:
3289 case SMESHOp::OpBiQuadraticTriangle:
3290 case SMESHOp::OpQuadraticQuadrangle:
3291 case SMESHOp::OpBiQuadraticQuadrangle:
3292 case SMESHOp::OpQuadraticPolygon:
3293 case SMESHOp::OpQuadraticTetrahedron:
3294 case SMESHOp::OpQuadraticPyramid:
3295 case SMESHOp::OpQuadraticPentahedron:
3296 case SMESHOp::OpQuadraticHexahedron:
3297 case SMESHOp::OpTriQuadraticHexahedron:
3299 if(checkLock(aStudy)) break;
3301 EmitSignalDeactivateDialog();
3302 SMDSAbs_EntityType type = SMDSEntity_Last;
3304 switch (theCommandID) {
3305 case SMESHOp::OpQuadraticEdge: type = SMDSEntity_Quad_Edge; break;
3306 case SMESHOp::OpQuadraticTriangle: type = SMDSEntity_Quad_Triangle; break;
3307 case SMESHOp::OpBiQuadraticTriangle: type = SMDSEntity_BiQuad_Triangle; break;
3308 case SMESHOp::OpQuadraticQuadrangle: type = SMDSEntity_Quad_Quadrangle; break;
3309 case SMESHOp::OpBiQuadraticQuadrangle: type = SMDSEntity_BiQuad_Quadrangle; break;
3310 case SMESHOp::OpQuadraticPolygon: type = SMDSEntity_Quad_Polygon; break;
3311 case SMESHOp::OpQuadraticTetrahedron: type = SMDSEntity_Quad_Tetra; break;
3312 case SMESHOp::OpQuadraticPyramid: type = SMDSEntity_Quad_Pyramid; break;
3313 case SMESHOp::OpQuadraticPentahedron: type = SMDSEntity_Quad_Penta; break;
3314 case SMESHOp::OpQuadraticHexahedron: type = SMDSEntity_Quad_Hexa; break;
3315 case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
3318 if ( type != SMDSEntity_Last )
3319 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3322 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3323 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3327 case SMESHOp::OpRemoveNodes:
3329 if(checkLock(aStudy)) break;
3331 EmitSignalDeactivateDialog();
3332 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3335 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3336 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3340 case SMESHOp::OpRemoveElements: // REMOVES ELEMENTS
3342 if(checkLock(aStudy)) break;
3344 EmitSignalDeactivateDialog();
3345 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3349 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3350 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3354 case SMESHOp::OpClearMesh: {
3356 if(checkLock(aStudy)) break;
3358 SALOME_ListIO selected;
3359 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3360 aSel->selectedObjects( selected );
3362 SUIT_OverrideCursor wc;
3363 SALOME_ListIteratorOfListIO It (selected);
3364 for ( ; It.More(); It.Next() )
3366 Handle(SALOME_InteractiveObject) IOS = It.Value();
3367 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3368 if ( aMesh->_is_nil()) continue;
3371 if ( aMesh->NbNodes() == 0 ) // imported mesh is not empty
3372 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3373 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3374 SMESH::ModifiedMesh( aMeshSObj, false, true);
3375 // hide groups and submeshes
3376 _PTR(ChildIterator) anIter =
3377 SMESH::GetActiveStudyDocument()->NewChildIterator( aMeshSObj );
3378 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3380 _PTR(SObject) so = anIter->Value();
3381 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3384 catch (const SALOME::SALOME_Exception& S_ex){
3386 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3390 SMESH::UpdateView();
3394 case SMESHOp::OpRemoveOrphanNodes:
3396 if(checkLock(aStudy)) break;
3397 SALOME_ListIO selected;
3398 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3399 aSel->selectedObjects( selected );
3400 if ( selected.Extent() == 1 ) {
3401 Handle(SALOME_InteractiveObject) anIO = selected.First();
3402 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3403 if ( !aMesh->_is_nil() ) {
3404 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3405 tr( "SMESH_WARNING" ),
3406 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3407 SUIT_MessageBox::Yes |
3408 SUIT_MessageBox::No,
3409 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3412 SUIT_OverrideCursor wc;
3413 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3414 int removed = aMeshEditor->RemoveOrphanNodes();
3415 SUIT_MessageBox::information(SMESHGUI::desktop(),
3416 tr("SMESH_INFORMATION"),
3417 tr("NB_NODES_REMOVED").arg(removed));
3418 if ( removed > 0 ) {
3419 SMESH::UpdateView();
3420 SMESHGUI::Modified();
3423 catch (const SALOME::SALOME_Exception& S_ex) {
3424 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3433 case SMESHOp::OpRenumberingNodes:
3435 if(checkLock(aStudy)) break;
3437 EmitSignalDeactivateDialog();
3438 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3442 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3443 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3447 case SMESHOp::OpRenumberingElements:
3449 if(checkLock(aStudy)) break;
3451 EmitSignalDeactivateDialog();
3452 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3456 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3457 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3461 case SMESHOp::OpTranslation:
3463 if(checkLock(aStudy)) break;
3465 EmitSignalDeactivateDialog();
3466 ( new SMESHGUI_TranslationDlg( this ) )->show();
3469 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3470 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3474 case SMESHOp::OpRotation:
3476 if(checkLock(aStudy)) break;
3478 EmitSignalDeactivateDialog();
3479 ( new SMESHGUI_RotationDlg( this ) )->show();
3482 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3483 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3487 case SMESHOp::OpSymmetry:
3489 if(checkLock(aStudy)) break;
3491 EmitSignalDeactivateDialog();
3492 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3495 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3496 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3500 case SMESHOp::OpScale:
3502 if(checkLock(aStudy)) break;
3504 EmitSignalDeactivateDialog();
3505 ( new SMESHGUI_ScaleDlg( this ) )->show();
3508 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3509 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3514 case SMESHOp::OpSewing:
3516 if(checkLock(aStudy)) break;
3518 EmitSignalDeactivateDialog();
3519 ( new SMESHGUI_SewingDlg( this ) )->show();
3522 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3523 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3527 case SMESHOp::OpMergeNodes:
3529 if(checkLock(aStudy)) break;
3531 EmitSignalDeactivateDialog();
3532 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3535 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3536 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3540 case SMESHOp::OpMergeElements:
3542 if (checkLock(aStudy)) break;
3544 EmitSignalDeactivateDialog();
3545 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3547 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3548 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3553 case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
3554 startOperation( SMESHOp::OpMoveNode );
3557 case SMESHOp::OpDuplicateNodes:
3559 if(checkLock(aStudy)) break;
3561 EmitSignalDeactivateDialog();
3562 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3565 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3566 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3571 case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
3572 startOperation( SMESHOp::OpElem0DOnElemNodes );
3575 case SMESHOp::OpSelectFiltersLibrary: // Library of selection filters
3577 static QList<int> aTypes;
3578 if ( aTypes.isEmpty() )
3580 aTypes.append( SMESH::NODE );
3581 aTypes.append( SMESH::EDGE );
3582 aTypes.append( SMESH::FACE );
3583 aTypes.append( SMESH::VOLUME );
3585 if (!myFilterLibraryDlg)
3586 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3587 else if (myFilterLibraryDlg->isHidden())
3588 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3589 myFilterLibraryDlg->raise();
3593 case SMESHOp::OpFreeNode:
3594 case SMESHOp::OpEqualNode:
3595 case SMESHOp::OpNodeConnectivityNb:
3596 case SMESHOp::OpFreeEdge:
3597 case SMESHOp::OpFreeBorder:
3598 case SMESHOp::OpLength:
3599 case SMESHOp::OpConnection:
3600 case SMESHOp::OpEqualEdge:
3601 case SMESHOp::OpFreeFace:
3602 case SMESHOp::OpBareBorderFace:
3603 case SMESHOp::OpOverConstrainedFace:
3604 case SMESHOp::OpLength2D:
3605 case SMESHOp::OpConnection2D:
3606 case SMESHOp::OpArea:
3607 case SMESHOp::OpTaper:
3608 case SMESHOp::OpAspectRatio:
3609 case SMESHOp::OpMinimumAngle:
3610 case SMESHOp::OpWarpingAngle:
3611 case SMESHOp::OpSkew:
3612 case SMESHOp::OpMaxElementLength2D:
3613 case SMESHOp::OpEqualFace:
3614 case SMESHOp::OpAspectRatio3D:
3615 case SMESHOp::OpVolume:
3616 case SMESHOp::OpMaxElementLength3D:
3617 case SMESHOp::OpBareBorderVolume:
3618 case SMESHOp::OpOverConstrainedVolume:
3619 case SMESHOp::OpEqualVolume:
3622 LightApp_SelectionMgr* mgr = selectionMgr();
3623 SALOME_ListIO selected; mgr->selectedObjects( selected );
3625 if( !selected.IsEmpty() ) {
3626 SUIT_OverrideCursor wc;
3627 ::Control( theCommandID );
3630 SUIT_MessageBox::warning(desktop(),
3631 tr( "SMESH_WRN_WARNING" ),
3632 tr( "SMESH_BAD_SELECTION" ) );
3636 SUIT_MessageBox::warning(desktop(),
3637 tr( "SMESH_WRN_WARNING" ),
3638 tr( "NOT_A_VTK_VIEWER" ) );
3641 case SMESHOp::OpOverallMeshQuality:
3642 OverallMeshQuality();
3644 case SMESHOp::OpNumberingNodes:
3646 SUIT_OverrideCursor wc;
3647 LightApp_SelectionMgr* mgr = selectionMgr();
3648 SALOME_ListIO selected; mgr->selectedObjects( selected );
3650 SALOME_ListIteratorOfListIO it(selected);
3651 for( ; it.More(); it.Next()) {
3652 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3653 if(anIObject->hasEntry()) {
3654 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3655 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3661 case SMESHOp::OpNumberingElements:
3663 SUIT_OverrideCursor wc;
3664 LightApp_SelectionMgr* mgr = selectionMgr();
3665 SALOME_ListIO selected; mgr->selectedObjects( selected );
3667 SALOME_ListIteratorOfListIO it(selected);
3668 for( ; it.More(); it.Next()) {
3669 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3670 if(anIObject->hasEntry())
3671 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3672 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3677 case SMESHOp::OpPropertiesLength:
3678 case SMESHOp::OpPropertiesArea:
3679 case SMESHOp::OpPropertiesVolume:
3680 case SMESHOp::OpMinimumDistance:
3681 case SMESHOp::OpBoundingBox:
3683 int page = SMESHGUI_MeasureDlg::MinDistance;
3684 if ( theCommandID == SMESHOp::OpBoundingBox )
3685 page = SMESHGUI_MeasureDlg::BoundingBox;
3686 else if ( theCommandID == SMESHOp::OpPropertiesLength )
3687 page = SMESHGUI_MeasureDlg::Length;
3688 else if ( theCommandID == SMESHOp::OpPropertiesArea )
3689 page = SMESHGUI_MeasureDlg::Area;
3690 else if ( theCommandID == SMESHOp::OpPropertiesVolume )
3691 page = SMESHGUI_MeasureDlg::Volume;
3693 EmitSignalDeactivateDialog();
3694 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3698 case SMESHOp::OpSortChild:
3704 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3705 //updateObjBrowser();
3709 //=============================================================================
3713 //=============================================================================
3714 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3719 //=============================================================================
3723 //=============================================================================
3724 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3729 //=============================================================================
3733 //=============================================================================
3734 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3739 //=============================================================================
3740 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3741 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3743 //=============================================================================
3744 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3745 SUIT_ViewWindow* wnd )
3747 if(theIO->hasEntry()){
3748 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3749 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3753 //=======================================================================
3754 // function : createSMESHAction
3756 //=======================================================================
3757 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3758 const int key, const bool toggle, const QString& shortcutAction )
3761 QWidget* parent = application()->desktop();
3762 SUIT_ResourceMgr* resMgr = resourceMgr();
3764 if ( !icon_id.isEmpty() )
3765 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3767 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3768 if ( !pix.isNull() )
3769 icon = QIcon( pix );
3771 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3772 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3773 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3775 createAction( id, tooltip, icon, menu, status_bar, key, parent,
3776 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3779 //=======================================================================
3780 // function : createPopupItem
3782 //=======================================================================
3783 void SMESHGUI::createPopupItem( const int id,
3784 const QString& clients,
3785 const QString& types,
3786 const QString& theRule,
3789 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3790 popupMgr()->insert( action( id ), pId, 0 );
3792 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3793 QString dc = "selcount"; // VSR : insetad of QtxPopupSelection::defSelCountParam()
3794 QString rule = "(%1) and (%2) and (%3)";
3795 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3796 if( clients.isEmpty() )
3797 rule = rule.arg( QString( "true" ) );
3799 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3800 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3803 bool cont = myRules.contains( id );
3805 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3807 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3808 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3811 //=======================================================================
3812 // function : initialize
3814 //=======================================================================
3815 void SMESHGUI::initialize( CAM_Application* app )
3817 SalomeApp_Module::initialize( app );
3819 // SUIT_ResourceMgr* mgr = app->resourceMgr();
3821 /* Automatic Update flag */
3822 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3824 // ----- create actions --------------
3826 //createSMESHAction( SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
3827 createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_I) );
3828 createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
3829 createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL" );
3831 createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
3833 createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
3834 createSMESHAction( SMESHOp::OpImportGMF, "IMPORT_GMF" );
3835 createSMESHAction( SMESHOp::OpPopupImportUNV, "IMPORT_UNV");
3836 createSMESHAction( SMESHOp::OpPopupImportMED, "IMPORT_MED");
3837 createSMESHAction( SMESHOp::OpPopupImportSTL, "IMPORT_STL" );
3839 createSMESHAction( SMESHOp::OpPopupImportCGNS, "IMPORT_CGNS" );
3841 createSMESHAction( SMESHOp::OpPopupImportSAUV, "IMPORT_SAUV" );
3842 createSMESHAction( SMESHOp::OpPopupImportGMF, "IMPORT_GMF" );
3844 createSMESHAction( SMESHOp::OpExportDAT, "DAT" );
3845 createSMESHAction( SMESHOp::OpExportMED, "MED" );
3846 createSMESHAction( SMESHOp::OpExportUNV, "UNV" );
3847 createSMESHAction( SMESHOp::OpExportSTL, "STL" );
3849 createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
3851 createSMESHAction( SMESHOp::OpExportSAUV, "SAUV");
3852 createSMESHAction( SMESHOp::OpExportGMF, "GMF" );
3853 createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
3854 createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
3855 createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
3856 createSMESHAction( SMESHOp::OpPopupExportSTL, "STL" );
3858 createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
3860 createSMESHAction( SMESHOp::OpPopupExportSAUV, "SAUV");
3861 createSMESHAction( SMESHOp::OpPopupExportGMF, "GMF" );
3862 createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
3863 createSMESHAction( SMESHOp::OpDelete, "DELETE", "ICON_DELETE", Qt::Key_Delete );
3864 createSMESHAction( SMESHOp::OpSelectFiltersLibrary, "SEL_FILTER_LIB" );
3865 createSMESHAction( SMESHOp::OpCreateMesh, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
3866 createSMESHAction( SMESHOp::OpCreateSubMesh, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
3867 createSMESHAction( SMESHOp::OpEditMeshOrSubMesh, "EDIT_MESHSUBMESH", "ICON_DLG_EDIT_MESH" );
3868 createSMESHAction( SMESHOp::OpEditMesh, "EDIT_MESH", "ICON_DLG_EDIT_MESH" );
3869 createSMESHAction( SMESHOp::OpEditSubMesh, "EDIT_SUBMESH", "ICON_DLG_EDIT_MESH" );
3870 createSMESHAction( SMESHOp::OpBuildCompoundMesh, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
3871 createSMESHAction( SMESHOp::OpCopyMesh, "COPY_MESH", "ICON_COPY_MESH" );
3872 createSMESHAction( SMESHOp::OpCompute, "COMPUTE", "ICON_COMPUTE" );
3873 createSMESHAction( SMESHOp::OpComputeSubMesh, "COMPUTE_SUBMESH", "ICON_COMPUTE" );
3874 createSMESHAction( SMESHOp::OpPreCompute, "PRECOMPUTE", "ICON_PRECOMPUTE" );
3875 createSMESHAction( SMESHOp::OpEvaluate, "EVALUATE", "ICON_EVALUATE" );
3876 createSMESHAction( SMESHOp::OpMeshOrder, "MESH_ORDER", "ICON_MESH_ORDER");
3877 createSMESHAction( SMESHOp::OpCreateGroup, "CREATE_GROUP", "ICON_CREATE_GROUP" );
3878 createSMESHAction( SMESHOp::OpCreateGeometryGroup, "CREATE_GEO_GROUP", "ICON_CREATE_GEO_GROUP" );
3879 createSMESHAction( SMESHOp::OpConstructGroup, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
3880 createSMESHAction( SMESHOp::OpEditGroup, "EDIT_GROUP", "ICON_EDIT_GROUP" );
3881 createSMESHAction( SMESHOp::OpEditGeomGroupAsGroup, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3882 createSMESHAction( SMESHOp::OpUnionGroups, "UN_GROUP", "ICON_UNION" );
3883 createSMESHAction( SMESHOp::OpIntersectGroups, "INT_GROUP", "ICON_INTERSECT" );
3884 createSMESHAction( SMESHOp::OpCutGroups, "CUT_GROUP", "ICON_CUT" );
3885 createSMESHAction( SMESHOp::OpGroupUnderlyingElem, "UNDERLYING_ELEMS", "ICON_UNDERLYING_ELEMS" );
3886 createSMESHAction( SMESHOp::OpAddElemGroupPopup, "ADD_TO_GROUP" );
3887 createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE_FROM_GROUP" );
3888 createSMESHAction( SMESHOp::OpDeleteGroup, "DEL_GROUP", "ICON_DEL_GROUP" );
3889 createSMESHAction( SMESHOp::OpMeshInformation , "ADV_INFO", "ICON_ADV_INFO" );
3890 //createSMESHAction( SMESHOp::OpStdInfo, "STD_INFO", "ICON_STD_INFO" );
3891 //createSMESHAction( SMESHOp::OpWhatIs, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3892 createSMESHAction( SMESHOp::OpFindElementByPoint, "FIND_ELEM", "ICON_FIND_ELEM" );
3894 createSMESHAction( SMESHOp::OpFreeNode, "FREE_NODE", "ICON_FREE_NODE", 0, true );
3895 createSMESHAction( SMESHOp::OpEqualNode, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
3896 createSMESHAction( SMESHOp::OpNodeConnectivityNb, "NODE_CONNECTIVITY_NB", "ICON_NODE_CONN_NB", 0, true );
3897 createSMESHAction( SMESHOp::OpFreeEdge, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
3898 createSMESHAction( SMESHOp::OpFreeBorder, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
3899 createSMESHAction( SMESHOp::OpLength, "LENGTH", "ICON_LENGTH", 0, true );
3900 createSMESHAction( SMESHOp::OpConnection, "CONNECTION", "ICON_CONNECTION", 0, true );
3901 createSMESHAction( SMESHOp::OpEqualEdge, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
3902 createSMESHAction( SMESHOp::OpFreeFace, "FREE_FACES", "ICON_FREE_FACES", 0, true );
3903 createSMESHAction( SMESHOp::OpBareBorderFace, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
3904 createSMESHAction( SMESHOp::OpOverConstrainedFace, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
3905 createSMESHAction( SMESHOp::OpLength2D, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
3906 createSMESHAction( SMESHOp::OpConnection2D, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
3907 createSMESHAction( SMESHOp::OpArea, "AREA", "ICON_AREA", 0, true );
3908 createSMESHAction( SMESHOp::OpTaper, "TAPER", "ICON_TAPER", 0, true );
3909 createSMESHAction( SMESHOp::OpAspectRatio, "ASPECT", "ICON_ASPECT", 0, true );
3910 createSMESHAction( SMESHOp::OpMinimumAngle, "MIN_ANG", "ICON_ANGLE", 0, true );
3911 createSMESHAction( SMESHOp::OpWarpingAngle, "WARP", "ICON_WARP", 0, true );
3912 createSMESHAction( SMESHOp::OpSkew, "SKEW", "ICON_SKEW", 0, true );
3913 createSMESHAction( SMESHOp::OpMaxElementLength2D, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
3914 createSMESHAction( SMESHOp::OpEqualFace, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
3915 createSMESHAction( SMESHOp::OpAspectRatio3D, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
3916 createSMESHAction( SMESHOp::OpVolume, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
3917 createSMESHAction( SMESHOp::OpMaxElementLength3D, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
3918 createSMESHAction( SMESHOp::OpBareBorderVolume, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
3919 createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
3920 createSMESHAction( SMESHOp::OpEqualVolume, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
3921 createSMESHAction( SMESHOp::OpOverallMeshQuality, "OVERALL_MESH_QUALITY", "ICON_OVL_MESH_QUALITY" );
3923 createSMESHAction( SMESHOp::OpNode, "NODE", "ICON_DLG_NODE" );
3924 createSMESHAction( SMESHOp::OpElem0D, "ELEM0D", "ICON_DLG_ELEM0D" );
3925 createSMESHAction( SMESHOp::OpElem0DOnElemNodes, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
3926 createSMESHAction( SMESHOp::OpBall, "BALL", "ICON_DLG_BALL" );
3927 createSMESHAction( SMESHOp::OpEdge, "EDGE", "ICON_DLG_EDGE" );
3928 createSMESHAction( SMESHOp::OpTriangle, "TRIANGLE", "ICON_DLG_TRIANGLE" );
3929 createSMESHAction( SMESHOp::OpQuadrangle, "QUAD", "ICON_DLG_QUADRANGLE" );
3930 createSMESHAction( SMESHOp::OpPolygon, "POLYGON", "ICON_DLG_POLYGON" );
3931 createSMESHAction( SMESHOp::OpTetrahedron, "TETRA", "ICON_DLG_TETRAS" );
3932 createSMESHAction( SMESHOp::OpHexahedron, "HEXA", "ICON_DLG_HEXAS" );
3933 createSMESHAction( SMESHOp::OpPentahedron, "PENTA", "ICON_DLG_PENTA" );
3934 createSMESHAction( SMESHOp::OpPyramid , "PYRAMID", "ICON_DLG_PYRAMID" );
3935 createSMESHAction( SMESHOp::OpHexagonalPrism, "OCTA", "ICON_DLG_OCTA" );
3936 createSMESHAction( SMESHOp::OpPolyhedron, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
3937 createSMESHAction( SMESHOp::OpQuadraticEdge, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
3938 createSMESHAction( SMESHOp::OpQuadraticTriangle, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
3939 createSMESHAction( SMESHOp::OpBiQuadraticTriangle, "BIQUADRATIC_TRIANGLE", "ICON_DLG_BIQUADRATIC_TRIANGLE" );
3940 createSMESHAction( SMESHOp::OpQuadraticQuadrangle, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
3941 createSMESHAction( SMESHOp::OpBiQuadraticQuadrangle, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
3942 createSMESHAction( SMESHOp::OpQuadraticPolygon, "QUADRATIC_POLYGON", "ICON_DLG_QUADRATIC_POLYGON" );
3943 createSMESHAction( SMESHOp::OpQuadraticTetrahedron, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
3944 createSMESHAction( SMESHOp::OpQuadraticPyramid, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
3945 createSMESHAction( SMESHOp::OpQuadraticPentahedron, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
3946 createSMESHAction( SMESHOp::OpQuadraticHexahedron, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
3947 createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
3949 createSMESHAction( SMESHOp::OpRemoveNodes, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
3950 createSMESHAction( SMESHOp::OpRemoveElements, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
3951 createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
3952 createSMESHAction( SMESHOp::OpClearMesh, "CLEAR_MESH", "ICON_CLEAR_MESH" );
3954 //createSMESHAction( SMESHOp::OpRenumberingNodes, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
3955 //createSMESHAction( SMESHOp::OpRenumberingElements, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
3957 createSMESHAction( SMESHOp::OpTranslation, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
3958 createSMESHAction( SMESHOp::OpRotation, "ROT", "ICON_DLG_MESH_ROTATION" );
3959 createSMESHAction( SMESHOp::OpSymmetry, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
3960 createSMESHAction( SMESHOp::OpScale, "SCALE", "ICON_DLG_MESH_SCALE" );
3961 createSMESHAction( SMESHOp::OpSewing, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
3962 createSMESHAction( SMESHOp::OpMergeNodes, "MERGE", "ICON_SMESH_MERGE_NODES" );
3963 createSMESHAction( SMESHOp::OpMergeElements, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
3964 createSMESHAction( SMESHOp::OpMoveNode, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
3965 createSMESHAction( SMESHOp::OpDuplicateNodes, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
3966 createSMESHAction( SMESHOp::OpDiagonalInversion, "INV", "ICON_DLG_MESH_DIAGONAL" );
3967 createSMESHAction( SMESHOp::OpUnionOfTwoTriangle, "UNION2", "ICON_UNION2TRI" );
3968 createSMESHAction( SMESHOp::OpOrientation, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
3969 createSMESHAction( SMESHOp::OpReorientFaces, "REORIENT_2D", "ICON_REORIENT_2D" );
3970 createSMESHAction( SMESHOp::OpUnionOfTriangles, "UNION", "ICON_UNIONTRI" );
3971 createSMESHAction( SMESHOp::OpCuttingOfQuadrangles, "CUT", "ICON_CUTQUAD" );
3972 createSMESHAction( SMESHOp::OpSplitVolumes, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
3973 createSMESHAction( SMESHOp::OpSplitBiQuadratic, "SPLIT_BIQUAD", "ICON_SPLIT_BIQUAD" );
3974 createSMESHAction( SMESHOp::OpSmoothing, "SMOOTH", "ICON_DLG_SMOOTHING" );
3975 createSMESHAction( SMESHOp::OpExtrusion, "EXTRUSION", "ICON_EXTRUSION" );
3976 createSMESHAction( SMESHOp::OpExtrusionAlongAPath, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
3977 createSMESHAction( SMESHOp::OpRevolution, "REVOLUTION", "ICON_REVOLUTION" );
3978 createSMESHAction( SMESHOp::OpPatternMapping, "MAP", "ICON_MAP" );
3979 createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
3980 createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D", "ICON_2D_FROM_3D" );
3982 createSMESHAction( SMESHOp::OpReset, "RESET" );
3983 createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
3984 createSMESHAction( SMESHOp::OpShowScalarBar, "SHOW_SCALAR_BAR","",0, true );
3985 createSMESHAction( SMESHOp::OpSaveDistribution, "SAVE_DISTRIBUTION" );
3986 createSMESHAction( SMESHOp::OpShowDistribution, "SHOW_DISTRIBUTION","",0, true );
3987 #ifndef DISABLE_PLOT2DVIEWER
3988 createSMESHAction( SMESHOp::OpPlotDistribution, "PLOT_DISTRIBUTION" );
3990 createSMESHAction( SMESHOp::OpDMWireframe, "WIRE", "ICON_WIRE", 0, true );
3991 createSMESHAction( SMESHOp::OpDMShading, "SHADE", "ICON_SHADE", 0, true );
3992 createSMESHAction( SMESHOp::OpDMNodes, "NODES", "ICON_POINTS", 0, true );
3993 createSMESHAction( SMESHOp::OpDMShrink, "SHRINK", "ICON_SHRINK", 0, true );
3994 createSMESHAction( SMESHOp::OpUpdate, "UPDATE", "ICON_UPDATE" );
3995 createSMESHAction( SMESHOp::OpDE0DElements, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
3996 createSMESHAction( SMESHOp::OpDEEdges, "EDGES", "ICON_DLG_EDGE", 0, true );
3997 createSMESHAction( SMESHOp::OpDEFaces, "FACES", "ICON_DLG_TRIANGLE", 0, true );
3998 createSMESHAction( SMESHOp::OpDEVolumes, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
3999 createSMESHAction( SMESHOp::OpDEBalls, "BALLS", "ICON_DLG_BALL", 0, true );
4000 createSMESHAction( SMESHOp::OpDEChoose, "CHOOSE", "ICON_DLG_CHOOSE", 0, false );
4001 createSMESHAction( SMESHOp::OpDEAllEntity, "ALL", "ICON_DLG_CHOOSE_ALL", 0, false );
4002 createSMESHAction( SMESHOp::OpOrientationOnFaces, "FACE_ORIENTATION", "", 0, true );
4004 createSMESHAction( SMESHOp::OpRepresentationLines, "LINE_REPRESENTATION", "", 0, true );
4005 createSMESHAction( SMESHOp::OpRepresentationArcs, "ARC_REPRESENTATION", "", 0, true );
4007 createSMESHAction( SMESHOp::OpEditHypothesis, "EDIT_HYPO" );
4008 createSMESHAction( SMESHOp::OpUnassign, "UNASSIGN" );
4009 createSMESHAction( SMESHOp::OpNumberingNodes, "NUM_NODES", "", 0, true );
4010 createSMESHAction( SMESHOp::OpNumberingElements, "NUM_ELEMENTS", "", 0, true );
4011 createSMESHAction( SMESHOp::OpProperties, "COLORS" );
4012 createSMESHAction( SMESHOp::OpTransparency, "TRANSP" );
4013 createSMESHAction( SMESHOp::OpClipping, "CLIP" );
4014 createSMESHAction( SMESHOp::OpAutoColor, "AUTO_COLOR" );
4015 createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
4017 createSMESHAction( SMESHOp::OpMinimumDistance, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
4018 createSMESHAction( SMESHOp::OpBoundingBox, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
4019 createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH", "ICON_MEASURE_LENGTH" );
4020 createSMESHAction( SMESHOp::OpPropertiesArea, "MEASURE_AREA", "ICON_MEASURE_AREA" );
4021 createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME", "ICON_MEASURE_VOLUME" );
4023 createSMESHAction( SMESHOp::OpHide, "HIDE" );
4024 createSMESHAction( SMESHOp::OpShow, "SHOW" );
4025 createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
4027 createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
4029 QList<int> aCtrlActions;
4030 aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode
4031 << SMESHOp::OpNodeConnectivityNb // node controls
4032 << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
4033 << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge // edge controls
4034 << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
4035 << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
4036 << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
4037 << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
4038 << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace // face controls
4039 << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
4040 << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
4041 << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume; // volume controls
4042 QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
4043 aCtrlGroup->setExclusive( true );
4044 for( int i = 0; i < aCtrlActions.size(); i++ )
4045 aCtrlGroup->addAction( action( aCtrlActions[i] ) );
4047 // ----- create menu --------------
4048 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
4049 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
4050 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
4051 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
4052 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
4053 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
4054 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
4055 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
4057 createMenu( separator(), fileId );
4059 QMenu* nodeMenu = new QMenu(); QMenu* edgeMenu = new QMenu();
4060 QMenu* faceMenu = new QMenu(); QMenu* volumeMenu = new QMenu();
4061 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
4062 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
4063 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10, -1, nodeMenu ),
4064 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10, -1, edgeMenu ),
4065 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10, -1, faceMenu ),
4066 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10, -1, volumeMenu ),
4067 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
4068 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
4069 //renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
4070 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
4071 basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
4073 //createMenu( SMESHOp::OpImportDAT, importId, -1 );
4074 createMenu( SMESHOp::OpImportUNV, importId, -1 );
4075 createMenu( SMESHOp::OpImportMED, importId, -1 );
4076 createMenu( SMESHOp::OpImportSTL, importId, -1 );
4078 createMenu( SMESHOp::OpImportCGNS, importId, -1 );
4080 createMenu( SMESHOp::OpImportSAUV, importId, -1 );
4081 createMenu( SMESHOp::OpImportGMF, importId, -1 );
4082 createMenu( SMESHOp::OpExportDAT, exportId, -1 );
4083 createMenu( SMESHOp::OpExportMED, exportId, -1 );
4084 createMenu( SMESHOp::OpExportUNV, exportId, -1 );
4085 createMenu( SMESHOp::OpExportSTL, exportId, -1 );
4087 createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
4089 createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
4090 createMenu( SMESHOp::OpExportGMF, exportId, -1 );
4091 createMenu( separator(), fileId, 10 );
4093 createMenu( SMESHOp::OpDelete, editId, -1 );
4095 createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
4097 createMenu( SMESHOp::OpCreateMesh, meshId, -1 ); // "Mesh" menu
4098 createMenu( SMESHOp::OpCreateSubMesh, meshId, -1 );
4099 createMenu( SMESHOp::OpEditMeshOrSubMesh, meshId, -1 );
4100 createMenu( SMESHOp::OpBuildCompoundMesh, meshId, -1 );
4101 createMenu( SMESHOp::OpCopyMesh, meshId, -1 );
4102 createMenu( separator(), meshId, -1 );
4103 createMenu( SMESHOp::OpCompute, meshId, -1 );
4104 createMenu( SMESHOp::OpPreCompute, meshId, -1 );
4105 createMenu( SMESHOp::OpEvaluate, meshId, -1 );
4106 createMenu( SMESHOp::OpMeshOrder, meshId, -1 );
4107 createMenu( separator(), meshId, -1 );
4108 createMenu( SMESHOp::OpCreateGroup, meshId, -1 );
4109 createMenu( SMESHOp::OpCreateGeometryGroup, meshId, -1 );
4110 createMenu( SMESHOp::OpConstructGroup, meshId, -1 );
4111 createMenu( SMESHOp::OpEditGroup, meshId, -1 );
4112 createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4113 createMenu( separator(), meshId, -1 );
4114 createMenu( SMESHOp::OpUnionGroups, meshId, -1 );
4115 createMenu( SMESHOp::OpIntersectGroups, meshId, -1 );
4116 createMenu( SMESHOp::OpCutGroups, meshId, -1 );
4117 createMenu( separator(), meshId, -1 );
4118 createMenu( SMESHOp::OpGroupUnderlyingElem, meshId, -1 );
4119 createMenu( separator(), meshId, -1 );
4120 createMenu( SMESHOp::OpMeshInformation, meshId, -1 );
4121 //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4122 //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4123 createMenu( SMESHOp::OpFindElementByPoint, meshId, -1 );
4124 createMenu( separator(), meshId, -1 );
4126 createMenu( SMESHOp::OpFreeNode, nodeId, -1 );
4127 createMenu( SMESHOp::OpEqualNode, nodeId, -1 );
4128 //createMenu( SMESHOp::OpNodeConnectivityNb, nodeId, -1 );
4129 createMenu( SMESHOp::OpFreeBorder, edgeId, -1 );
4130 createMenu( SMESHOp::OpLength, edgeId, -1 );
4131 createMenu( SMESHOp::OpConnection, edgeId, -1 );
4132 createMenu( SMESHOp::OpEqualEdge, edgeId, -1 );
4133 createMenu( SMESHOp::OpFreeEdge, faceId, -1 );
4134 createMenu( SMESHOp::OpFreeFace, faceId, -1 );
4135 createMenu( SMESHOp::OpBareBorderFace, faceId, -1 );
4136 createMenu( SMESHOp::OpOverConstrainedFace, faceId, -1 );
4137 createMenu( SMESHOp::OpLength2D, faceId, -1 );
4138 createMenu( SMESHOp::OpConnection2D, faceId, -1 );
4139 createMenu( SMESHOp::OpArea, faceId, -1 );
4140 createMenu( SMESHOp::OpTaper, faceId, -1 );
4141 createMenu( SMESHOp::OpAspectRatio, faceId, -1 );
4142 createMenu( SMESHOp::OpMinimumAngle, faceId, -1 );
4143 createMenu( SMESHOp::OpWarpingAngle, faceId, -1 );
4144 createMenu( SMESHOp::OpSkew, faceId, -1 );
4145 createMenu( SMESHOp::OpMaxElementLength2D, faceId, -1 );
4146 createMenu( SMESHOp::OpEqualFace, faceId, -1 );
4147 createMenu( SMESHOp::OpAspectRatio3D, volumeId, -1 );
4148 createMenu( SMESHOp::OpVolume, volumeId, -1 );
4149 createMenu( SMESHOp::OpMaxElementLength3D, volumeId, -1 );
4150 createMenu( SMESHOp::OpBareBorderVolume, volumeId, -1 );
4151 createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4152 createMenu( SMESHOp::OpEqualVolume, volumeId, -1 );
4153 createMenu( separator(), ctrlId, -1 );
4154 createMenu( SMESHOp::OpReset, ctrlId, -1 );
4155 createMenu( separator(), ctrlId, -1 );
4156 createMenu( SMESHOp::OpOverallMeshQuality, ctrlId, -1 );
4158 createMenu( SMESHOp::OpNode, addId, -1 );
4159 createMenu( SMESHOp::OpElem0D, addId, -1 );
4160 createMenu( SMESHOp::OpElem0DOnElemNodes, addId, -1 );
4161 createMenu( SMESHOp::OpBall, addId, -1 );
4162 createMenu( SMESHOp::OpEdge, addId, -1 );
4163 createMenu( SMESHOp::OpTriangle, addId, -1 );
4164 createMenu( SMESHOp::OpQuadrangle, addId, -1 );
4165 createMenu( SMESHOp::OpPolygon, addId, -1 );
4166 createMenu( SMESHOp::OpTetrahedron, addId, -1 );
4167 createMenu( SMESHOp::OpHexahedron, addId, -1 );
4168 createMenu( SMESHOp::OpPentahedron, addId, -1 );
4169 createMenu( SMESHOp::OpPyramid, addId, -1 );
4170 createMenu( SMESHOp::OpHexagonalPrism, addId, -1 );
4171 createMenu( SMESHOp::OpPolyhedron, addId, -1 );
4172 createMenu( separator(), addId, -1 );
4173 createMenu( SMESHOp::OpQuadraticEdge, addId, -1 );
4174 createMenu( SMESHOp::OpQuadraticTriangle, addId, -1 );
4175 createMenu( SMESHOp::OpBiQuadraticTriangle , addId, -1 );
4176 createMenu( SMESHOp::OpQuadraticQuadrangle, addId, -1 );
4177 createMenu( SMESHOp::OpBiQuadraticQuadrangle, addId, -1 );
4178 createMenu( SMESHOp::OpQuadraticPolygon, addId, -1 );
4179 createMenu( SMESHOp::OpQuadraticTetrahedron, addId, -1 );
4180 createMenu( SMESHOp::OpQuadraticPyramid, addId, -1 );
4181 createMenu( SMESHOp::OpQuadraticPentahedron, addId, -1 );
4182 createMenu( SMESHOp::OpQuadraticHexahedron, addId, -1 );
4183 createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4185 createMenu( SMESHOp::OpRemoveNodes, removeId, -1 );
4186 createMenu( SMESHOp::OpRemoveElements, removeId, -1 );
4187 createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4188 createMenu( separator(), removeId, -1 );
4189 createMenu( SMESHOp::OpDeleteGroup, removeId, -1 );
4190 createMenu( separator(), removeId, -1 );
4191 createMenu( SMESHOp::OpClearMesh, removeId, -1 );
4193 //createMenu( SMESHOp::OpRenumberingNodes, renumId, -1 );
4194 //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4196 createMenu( SMESHOp::OpTranslation, transfId, -1 );
4197 createMenu( SMESHOp::OpRotation, transfId, -1 );
4198 createMenu( SMESHOp::OpSymmetry, transfId, -1 );
4199 createMenu( SMESHOp::OpScale, transfId, -1 );
4200 createMenu( SMESHOp::OpSewing, transfId, -1 );
4201 createMenu( SMESHOp::OpMergeNodes, transfId, -1 );
4202 createMenu( SMESHOp::OpMergeElements, transfId, -1 );
4203 createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4205 createMenu( SMESHOp::OpMoveNode, modifyId, -1 );
4206 createMenu( SMESHOp::OpDiagonalInversion, modifyId, -1 );
4207 createMenu( SMESHOp::OpUnionOfTwoTriangle, modifyId, -1 );
4208 createMenu( SMESHOp::OpOrientation, modifyId, -1 );
4209 createMenu( SMESHOp::OpReorientFaces, modifyId, -1 );
4210 createMenu( SMESHOp::OpUnionOfTriangles, modifyId, -1 );
4211 createMenu( SMESHOp::OpCuttingOfQuadrangles, modifyId, -1 );
4212 createMenu( SMESHOp::OpSplitVolumes, modifyId, -1 );
4213 createMenu( SMESHOp::OpSplitBiQuadratic, modifyId, -1 );
4214 createMenu( SMESHOp::OpSmoothing, modifyId, -1 );
4215 createMenu( SMESHOp::OpExtrusion, modifyId, -1 );
4216 createMenu( SMESHOp::OpExtrusionAlongAPath , modifyId, -1 );
4217 createMenu( SMESHOp::OpRevolution, modifyId, -1 );
4218 createMenu( SMESHOp::OpPatternMapping, modifyId, -1 );
4219 createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4220 createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4222 createMenu( SMESHOp::OpMinimumDistance, measureId, -1 );
4223 createMenu( SMESHOp::OpBoundingBox, measureId, -1 );
4224 createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4225 createMenu( SMESHOp::OpPropertiesArea, basicPropId, -1 );
4226 createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4227 createMenu( SMESHOp::OpUpdate, viewId, -1 );
4229 connect( nodeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4230 connect( edgeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4231 connect( faceMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4232 connect( volumeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4234 // ----- create toolbars --------------
4235 int meshTb = createTool( tr( "TB_MESH" ), QString( "SMESHMeshToolbar" ) ),
4236 info = createTool( tr( "TB_INFO" ), QString( "SMESHInformationToolbar" ) ),
4237 groupTb = createTool( tr( "TB_GROUP" ), QString( "SMESHGroupToolbar" ) ),
4238 ctrl0dTb = createTool( tr( "TB_CTRL0D" ), QString( "SMESHNodeControlsToolbar" ) ),
4239 ctrl1dTb = createTool( tr( "TB_CTRL1D" ), QString( "SMESHEdgeControlsToolbar" ) ),
4240 ctrl2dTb = createTool( tr( "TB_CTRL2D" ), QString( "SMESHFaceControlsToolbar" ) ),
4241 ctrl3dTb = createTool( tr( "TB_CTRL3D" ), QString( "SMESHVolumeControlsToolbar" ) ),
4242 addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ),
4243 addNonElemTb = createTool( tr( "TB_ADDNON" ), QString( "SMESHAddElementToolbar" ) ),
4244 remTb = createTool( tr( "TB_REM" ), QString( "SMESHRemoveToolbar" ) ),
4245 //renumbTb = createTool( tr( "TB_RENUMBER" ), QString( "SMESHRenumberingToolbar" ) ),
4246 transformTb = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ),
4247 modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ),
4248 measuremTb = createTool( tr( "TB_MEASUREM" ), QString( "SMESHMeasurementsToolbar" ) ),
4249 dispModeTb = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4251 createTool( SMESHOp::OpCreateMesh, meshTb );
4252 createTool( SMESHOp::OpCreateSubMesh, meshTb );
4253 createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4254 createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4255 createTool( SMESHOp::OpCopyMesh, meshTb );
4256 createTool( separator(), meshTb );
4257 createTool( SMESHOp::OpCompute, meshTb );
4258 createTool( SMESHOp::OpPreCompute, meshTb );
4259 createTool( SMESHOp::OpEvaluate, meshTb );
4260 createTool( SMESHOp::OpMeshOrder, meshTb );
4262 createTool( SMESHOp::OpCreateGroup, groupTb );
4263 createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4264 createTool( SMESHOp::OpConstructGroup, groupTb );
4265 createTool( SMESHOp::OpEditGroup, groupTb );
4267 createTool( SMESHOp::OpMeshInformation, info );
4268 //createTool( SMESHOp::OpStdInfo, meshTb );
4269 //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4270 createTool( SMESHOp::OpFindElementByPoint, info );
4272 createTool( SMESHOp::OpFreeNode, ctrl0dTb );
4273 createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4274 //createTool( SMESHOp::OpNodeConnectivityNb, ctrl0dTb );
4276 createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4277 createTool( SMESHOp::OpLength, ctrl1dTb );
4278 createTool( SMESHOp::OpConnection, ctrl1dTb );
4279 createTool( SMESHOp::OpEqualEdge, ctrl1dTb );
4281 createTool( SMESHOp::OpFreeEdge, ctrl2dTb );
4282 createTool( SMESHOp::OpFreeFace, ctrl2dTb );
4283 createTool( SMESHOp::OpBareBorderFace, ctrl2dTb );
4284 createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4285 createTool( SMESHOp::OpLength2D, ctrl2dTb );
4286 createTool( SMESHOp::OpConnection2D, ctrl2dTb );
4287 createTool( SMESHOp::OpArea, ctrl2dTb );
4288 createTool( SMESHOp::OpTaper, ctrl2dTb );
4289 createTool( SMESHOp::OpAspectRatio, ctrl2dTb );
4290 createTool( SMESHOp::OpMinimumAngle, ctrl2dTb );
4291 createTool( SMESHOp::OpWarpingAngle, ctrl2dTb );
4292 createTool( SMESHOp::OpSkew, ctrl2dTb );
4293 createTool( SMESHOp::OpMaxElementLength2D, ctrl2dTb );
4294 createTool( SMESHOp::OpEqualFace, ctrl2dTb );
4296 createTool( SMESHOp::OpAspectRatio3D, ctrl3dTb );
4297 createTool( SMESHOp::OpVolume, ctrl3dTb );
4298 createTool( SMESHOp::OpMaxElementLength3D, ctrl3dTb );
4299 createTool( SMESHOp::OpBareBorderVolume, ctrl3dTb );
4300 createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
4301 createTool( SMESHOp::OpEqualVolume, ctrl3dTb );
4303 createTool( SMESHOp::OpNode, addElemTb );
4304 createTool( SMESHOp::OpElem0D, addElemTb );
4305 createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4306 createTool( SMESHOp::OpBall, addElemTb );
4307 createTool( SMESHOp::OpEdge, addElemTb );
4308 createTool( SMESHOp::OpTriangle, addElemTb );
4309 createTool( SMESHOp::OpQuadrangle, addElemTb );
4310 createTool( SMESHOp::OpPolygon, addElemTb );
4311 createTool( SMESHOp::OpTetrahedron, addElemTb );
4312 createTool( SMESHOp::OpHexahedron, addElemTb );
4313 createTool( SMESHOp::OpPentahedron, addElemTb );
4314 createTool( SMESHOp::OpPyramid, addElemTb );
4315 createTool( SMESHOp::OpHexagonalPrism, addElemTb );
4316 createTool( SMESHOp::OpPolyhedron, addElemTb );
4318 createTool( SMESHOp::OpQuadraticEdge, addNonElemTb );
4319 createTool( SMESHOp::OpQuadraticTriangle, addNonElemTb );
4320 createTool( SMESHOp::OpBiQuadraticTriangle, addNonElemTb );
4321 createTool( SMESHOp::OpQuadraticQuadrangle, addNonElemTb );
4322 createTool( SMESHOp::OpBiQuadraticQuadrangle, addNonElemTb );
4323 createTool( SMESHOp::OpQuadraticPolygon, addNonElemTb );
4324 createTool( SMESHOp::OpQuadraticTetrahedron, addNonElemTb );
4325 createTool( SMESHOp::OpQuadraticPyramid, addNonElemTb );
4326 createTool( SMESHOp::OpQuadraticPentahedron, addNonElemTb );
4327 createTool( SMESHOp::OpQuadraticHexahedron, addNonElemTb );
4328 createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4330 createTool( SMESHOp::OpRemoveNodes, remTb );
4331 createTool( SMESHOp::OpRemoveElements, remTb );
4332 createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4333 createTool( SMESHOp::OpClearMesh, remTb );
4335 //createTool( SMESHOp::OpRenumberingNodes, renumbTb );
4336 //createTool( SMESHOp::OpRenumberingElements, renumbTb );
4338 createTool( SMESHOp::OpTranslation, transformTb );
4339 createTool( SMESHOp::OpRotation, transformTb );
4340 createTool( SMESHOp::OpSymmetry, transformTb );
4341 createTool( SMESHOp::OpScale, transformTb );
4342 createTool( SMESHOp::OpSewing, transformTb );
4343 createTool( SMESHOp::OpMergeNodes, transformTb );
4344 createTool( SMESHOp::OpMergeElements, transformTb );
4345 createTool( SMESHOp::OpDuplicateNodes, transformTb );
4347 createTool( SMESHOp::OpMoveNode, modifyTb );
4348 createTool( SMESHOp::OpDiagonalInversion, modifyTb );
4349 createTool( SMESHOp::OpUnionOfTwoTriangle, modifyTb );
4350 createTool( SMESHOp::OpOrientation, modifyTb );
4351 createTool( SMESHOp::OpReorientFaces, modifyTb );
4352 createTool( SMESHOp::OpUnionOfTriangles, modifyTb );
4353 createTool( SMESHOp::OpCuttingOfQuadrangles, modifyTb );
4354 createTool( SMESHOp::OpSplitVolumes, modifyTb );
4355 createTool( SMESHOp::OpSplitBiQuadratic, modifyTb );
4356 createTool( SMESHOp::OpSmoothing, modifyTb );
4357 createTool( SMESHOp::OpExtrusion, modifyTb );
4358 createTool( SMESHOp::OpExtrusionAlongAPath, modifyTb );
4359 createTool( SMESHOp::OpRevolution, modifyTb );
4360 createTool( SMESHOp::OpPatternMapping, modifyTb );
4361 createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4362 createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4364 createTool( SMESHOp::OpMinimumDistance, measuremTb );
4366 createTool( SMESHOp::OpUpdate, dispModeTb );
4368 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4369 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4373 OB = "'ObjectBrowser'",
4374 View = "'" + SVTK_Viewer::Type() + "'",
4376 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4377 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4378 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4379 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4380 smesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::COMPONENT ) ),
4381 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4382 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4383 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4384 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4385 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4386 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4387 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4389 mesh_part = mesh + " " + subMesh + " " + group,
4390 mesh_group = mesh + " " + group,
4391 mesh_submesh = mesh + " " + subMesh,
4392 hyp_alg = hypo + " " + algo;
4394 // popup for object browser
4396 isInvisible("not( isVisible )"),
4397 isEmpty("numberOfNodes = 0"),
4398 isNotEmpty("numberOfNodes <> 0"),
4400 // has nodes, edges, etc in VISIBLE! actor
4401 hasNodes("(numberOfNodes > 0 ) && hasActor"),
4402 hasElems("(count( elemTypes ) > 0)"),
4403 hasDifferentElems("(count( elemTypes ) > 1)"),
4404 hasDifferentObjElems("(count( objElemTypes ) > 1)"),
4405 hasBalls("({'BallElem'} in elemTypes)"),
4406 hasElems0d("({'Elem0d'} in elemTypes)"),
4407 hasEdges("({'Edge'} in elemTypes)"),
4408 hasFaces("({'Face'} in elemTypes)"),
4409 hasVolumes("({'Volume'} in elemTypes)"),
4410 hasFacesOrVolumes("(({'Face'} in elemTypes) || ({'Volume'} in elemTypes)) ");
4412 createPopupItem( SMESHOp::OpFileInformation, OB, mesh, "&& selcount=1 && isImported" );
4413 createPopupItem( SMESHOp::OpCreateSubMesh, OB, mesh, "&& hasGeomReference");
4414 createPopupItem( SMESHOp::OpEditMesh, OB, mesh, "&& selcount=1" );
4415 createPopupItem( SMESHOp::OpEditSubMesh, OB, subMesh, "&& selcount=1 && hasGeomReference" );
4416 createPopupItem( SMESHOp::OpEditGroup, OB, group );
4417 createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4419 popupMgr()->insert( separator(), -1, 0 );
4420 createPopupItem( SMESHOp::OpCompute, OB, mesh, "&& selcount=1 && isComputable" );
4421 createPopupItem( SMESHOp::OpComputeSubMesh, OB, subMesh, "&& selcount=1 && isComputable" );
4422 createPopupItem( SMESHOp::OpPreCompute, OB, mesh, "&& selcount=1 && isPreComputable" );
4423 createPopupItem( SMESHOp::OpEvaluate, OB, mesh, "&& selcount=1 && isComputable" );
4424 createPopupItem( SMESHOp::OpMeshOrder, OB, mesh, "&& selcount=1 && isComputable && hasGeomReference" );
4425 createPopupItem( SMESHOp::OpUpdate, OB, mesh_part );
4426 createPopupItem( SMESHOp::OpMeshInformation, OB, mesh_part );
4427 createPopupItem( SMESHOp::OpFindElementByPoint,OB, mesh_group, "&& selcount=1" );
4428 createPopupItem( SMESHOp::OpOverallMeshQuality,OB, mesh_part );
4429 popupMgr()->insert( separator(), -1, 0 );
4430 createPopupItem( SMESHOp::OpCreateGroup, OB, mesh, "&& selcount=1" );
4431 createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh, "&& selcount=1 && hasGeomReference" );
4432 createPopupItem( SMESHOp::OpConstructGroup, OB, subMesh );
4433 popupMgr()->insert( separator(), -1, 0 );
4434 createPopupItem( SMESHOp::OpEditHypothesis, OB, hypo, "&& isEditableHyp");
4435 createPopupItem( SMESHOp::OpUnassign, OB, hyp_alg );
4436 popupMgr()->insert( separator(), -1, 0 );
4437 createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh_submesh );
4438 createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh_group, "&& selcount=1 && dim>=2");
4439 popupMgr()->insert( separator(), -1, 0 );
4440 createPopupItem( SMESHOp::OpClearMesh, OB, mesh );
4441 //popupMgr()->insert( separator(), -1, 0 );
4443 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4444 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4445 QString only_one_2D = only_one_non_empty + " && dim>1";
4447 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4448 createPopupItem( SMESHOp::OpPopupExportMED, OB, mesh_group, multiple_non_empty, anId );
4449 createPopupItem( SMESHOp::OpPopupExportUNV, OB, mesh_group, only_one_non_empty, anId );
4450 createPopupItem( SMESHOp::OpPopupExportSTL, OB, mesh_group, only_one_2D, anId );
4452 createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4454 createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, only_one_non_empty, anId );
4455 createPopupItem( SMESHOp::OpPopupExportGMF, OB, mesh_group, only_one_non_empty, anId );
4456 createPopupItem( SMESHOp::OpPopupExportDAT, OB, mesh_group, only_one_non_empty, anId );
4457 createPopupItem( SMESHOp::OpDelete, OB, mesh_part + " " + hyp_alg );
4458 createPopupItem( SMESHOp::OpDeleteGroup, OB, group );
4460 anId = popupMgr()->insert( tr( "MEN_IMPORT" ), -1, -1 ); // IMPORT submenu
4461 createPopupItem( SMESHOp::OpPopupImportMED, OB, smesh, "", anId );
4462 createPopupItem( SMESHOp::OpPopupImportUNV, OB, smesh, "", anId );
4463 createPopupItem( SMESHOp::OpPopupImportSTL, OB, smesh, "", anId );
4465 createPopupItem( SMESHOp::OpPopupImportCGNS, OB, smesh, "", anId );
4467 createPopupItem( SMESHOp::OpPopupImportSAUV, OB, smesh, "", anId );
4468 createPopupItem( SMESHOp::OpPopupImportGMF, OB, smesh, "", anId );
4469 createPopupItem( SMESHOp::OpPopupImportDAT, OB, smesh, "", anId );
4470 popupMgr()->insert( separator(), -1, 0 );
4473 createPopupItem( SMESHOp::OpEditGroup, View, group );
4474 createPopupItem( SMESHOp::OpAddElemGroupPopup, View, elems, "&& guiState = 800" );
4475 createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems, "&& guiState = 800" );
4477 popupMgr()->insert( separator(), -1, 0 );
4478 createPopupItem( SMESHOp::OpUpdate, View, mesh_part );
4479 createPopupItem( SMESHOp::OpMeshInformation, View, mesh_part );
4480 createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4481 createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh );
4482 popupMgr()->insert( separator(), -1, 0 );
4484 createPopupItem( SMESHOp::OpAutoColor, OB + " " + View, mesh, "&& (not isAutoColor)" );
4485 createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4486 popupMgr()->insert( separator(), -1, 0 );
4488 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4489 QString aType = QString( "%1type in {%2}" ).arg( lc );
4490 aType = aType.arg( mesh_part );
4491 QString aMeshInVTK = aClient + "&&" + aType;
4493 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4494 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4495 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4497 //-------------------------------------------------
4499 //-------------------------------------------------
4500 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4502 popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4503 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4504 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4506 popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4507 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4508 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4510 popupMgr()->insert( separator(), -1, -1 );
4512 //-------------------------------------------------
4514 //-------------------------------------------------
4515 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4517 popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4518 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4519 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4521 popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4522 popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4523 popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4525 popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4526 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4527 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4529 popupMgr()->insert( separator(), anId, -1 );
4531 popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4532 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4533 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4535 //-------------------------------------------------
4537 //-------------------------------------------------
4538 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4540 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4542 popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4543 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4544 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4546 popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4547 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4548 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4550 popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4551 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4552 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4554 popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4555 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4556 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4558 popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4559 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4560 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4562 popupMgr()->insert( separator(), anId, -1 );
4564 popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4565 popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&& $type in {" + mesh + "} &&" + hasDifferentObjElems, QtxPopupMgr::VisibleRule );
4567 popupMgr()->insert( separator(), anId, -1 );
4569 popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4570 popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4573 //-------------------------------------------------
4574 // Representation of the 2D Quadratic elements
4575 //-------------------------------------------------
4576 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4577 popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4578 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "&& isVisible && isQuadratic",QtxPopupMgr::VisibleRule );
4579 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4581 popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4582 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "&& isVisible && isQuadratic", QtxPopupMgr::VisibleRule );
4583 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4585 //-------------------------------------------------
4586 // Orientation of faces
4587 //-------------------------------------------------
4588 popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4589 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4590 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4592 //-------------------------------------------------
4594 //-------------------------------------------------
4595 popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4596 popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4598 //-------------------------------------------------
4600 //-------------------------------------------------
4601 popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4602 popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4604 //-------------------------------------------------
4606 //-------------------------------------------------
4608 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4609 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4610 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4611 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4613 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4615 popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4616 popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4618 popupMgr()->insert( separator(), anId, -1 );
4620 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4622 popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4623 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4624 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4626 popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4627 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4628 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4630 // popupMgr()->insert( action( SMESHOp::OpNodeConnectivityNb ), aSubId, -1 );
4631 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4632 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), "controlMode = 'eNodeConnectivityNb'", QtxPopupMgr::ToggleRule );
4634 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4636 popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4637 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVTK + "&&" + hasEdges + "&&" + hasFacesOrVolumes, QtxPopupMgr::VisibleRule );
4638 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4640 popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4641 popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4642 popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4644 popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4645 popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4646 popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4647 popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4648 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4649 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4651 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4653 popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4654 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4655 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4657 popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4658 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4659 QtxPopupMgr::VisibleRule );
4660 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4662 popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4663 popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4664 popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4666 popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4667 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4668 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4670 popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
4671 popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4672 popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4674 popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
4675 popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4676 popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4678 popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
4679 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4680 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4682 popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
4683 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4684 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4686 popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
4687 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4688 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4690 popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
4691 popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4692 popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4694 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
4695 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4696 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4698 popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
4699 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4700 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4702 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
4703 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4704 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4705 popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
4706 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4707 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4709 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4711 popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D ), aSubId, -1 );
4712 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4713 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4715 popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
4716 popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4717 popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4719 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
4720 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4721 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4723 popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
4724 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4725 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4727 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
4728 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4729 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4731 popupMgr()->insert ( action( SMESHOp::OpEqualVolume ), aSubId, -1 );
4732 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4733 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4735 popupMgr()->insert( separator(), anId, -1 );
4737 popupMgr()->insert( action( SMESHOp::OpShowScalarBar ), anId, -1 );
4738 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4739 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone' && isScalarBarVisible", QtxPopupMgr::ToggleRule );
4740 popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
4741 popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4743 popupMgr()->insert( separator(), anId, -1 );
4745 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4747 popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
4748 popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4750 popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
4751 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4752 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isScalarBarVisible && isDistributionVisible", QtxPopupMgr::ToggleRule);
4754 #ifndef DISABLE_PLOT2DVIEWER
4755 popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
4756 popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4759 //-------------------------------------------------
4761 //-------------------------------------------------
4762 popupMgr()->insert( separator(), -1, -1 );
4763 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4764 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4765 popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
4766 popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4768 popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
4769 popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4771 popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
4772 popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4774 popupMgr()->insert( separator(), -1, -1 );
4776 //-------------------------------------------------
4778 //-------------------------------------------------
4779 popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
4780 popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4782 popupMgr()->insert( separator(), -1, -1 );
4784 popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
4785 popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
4786 popupMgr()->insert( separator(), -1, -1 );
4788 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4789 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4791 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4792 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4795 //================================================================================
4797 * \brief Return true if SMESH or GEOM objects are selected.
4798 * Is called form LightApp_Module::activateModule() which clear selection if
4799 * not isSelectionCompatible()
4801 //================================================================================
4803 bool SMESHGUI::isSelectionCompatible()
4805 bool isCompatible = true;
4806 SALOME_ListIO selected;
4807 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4808 Sel->selectedObjects( selected );
4810 SALOME_ListIteratorOfListIO It( selected );
4811 for ( ; isCompatible && It.More(); It.Next())
4813 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4814 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4816 return isCompatible;
4820 bool SMESHGUI::reusableOperation( const int id )
4822 // compute, evaluate and precompute are not reusable operations
4823 return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate ) ? false : SalomeApp_Module::reusableOperation( id );
4826 bool SMESHGUI::activateModule( SUIT_Study* study )
4828 bool res = SalomeApp_Module::activateModule( study );
4830 setMenuShown( true );
4831 setToolShown( true );
4833 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4834 PyGILState_STATE gstate = PyGILState_Ensure();
4835 PyObject* pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4836 if ( !pluginsmanager ) {
4840 PyObject* result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toUtf8().data(),tr("SMESH_PLUGINS_OTHER").toUtf8().data());
4845 PyGILState_Release(gstate);
4846 // end of SMESH plugins loading
4848 // Reset actions accelerator keys
4849 action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
4851 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4852 GetSMESHGen()->SetCurrentStudy(SALOMEDS::Study::_nil());
4853 if ( SalomeApp_Study* s = dynamic_cast<SalomeApp_Study*>( study )) {
4854 if ( _PTR(Study) aStudy = s->studyDS() )
4855 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
4858 // get all view currently opened in the study and connect their signals to
4859 // the corresponding slots of the class.
4860 SUIT_Desktop* aDesk = study->application()->desktop();
4862 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4863 SUIT_ViewWindow* wnd;
4864 foreach ( wnd, wndList )
4868 Py_XDECREF(pluginsmanager);
4872 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4874 setMenuShown( false );
4875 setToolShown( false );
4877 EmitSignalCloseAllDialogs();
4879 // Unset actions accelerator keys
4880 action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
4882 return SalomeApp_Module::deactivateModule( study );
4885 void SMESHGUI::studyClosed( SUIT_Study* s )
4889 SMESH::RemoveVisuData( s->id() );
4890 SalomeApp_Module::studyClosed( s );
4893 void SMESHGUI::OnGUIEvent()
4895 const QObject* obj = sender();
4896 if ( !obj || !obj->inherits( "QAction" ) )
4898 int id = actionId((QAction*)obj);
4903 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4905 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
4906 if ( CORBA::is_nil( myComponentSMESH ) )
4908 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4910 aGUI.myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4911 return aGUI.myComponentSMESH;
4914 myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4915 return myComponentSMESH;
4918 QString SMESHGUI::engineIOR() const
4920 CORBA::ORB_var anORB = getApp()->orb();
4921 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4922 return QString( anIOR.in() );
4925 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4927 SalomeApp_Module::contextMenuPopup( client, menu, title );
4929 selectionMgr()->selectedObjects( lst );
4930 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4931 Handle(SALOME_InteractiveObject) io = lst.First();
4932 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4933 _PTR(Study) study = appStudy->studyDS();
4934 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4936 QString aName = QString( SMESH::fromUtf8(obj->GetName()) );
4937 while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4938 aName.remove( (aName.length() - 1), 1 );
4944 LightApp_Selection* SMESHGUI::createSelection() const
4946 return new SMESHGUI_Selection();
4949 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4951 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4952 aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
4953 #ifndef DISABLE_PYCONSOLE
4954 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4958 void SMESHGUI::viewManagers( QStringList& list ) const
4960 list.append( SVTK_Viewer::Type() );
4963 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4965 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4966 SMESH::UpdateSelectionProp( this );
4968 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
4969 for(int i = 0; i < aViews.count() ; i++){
4970 SUIT_ViewWindow *sf = aViews[i];
4973 EmitSignalActivatedViewManager();
4977 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
4979 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
4980 myClippingPlaneInfoMap.erase( theViewManager );
4983 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
4985 theActor->AddObserver( SMESH::DeleteActorEvent,
4986 myEventCallbackCommand.GetPointer(),
4990 void SMESHGUI::ProcessEvents( vtkObject* theObject,
4991 unsigned long theEvent,
4992 void* theClientData,
4995 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
4996 if( theObject && (int) theEvent == SMESH::DeleteActorEvent ) {
4997 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
4998 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
4999 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
5000 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
5001 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
5002 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
5003 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
5004 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
5005 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
5006 SMESH::TActorList::iterator anIter3 = anActorList.begin();
5007 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
5008 if( anActor == *anIter3 ) {
5009 anActorList.erase( anIter3 );
5020 void SMESHGUI::createPreferences()
5022 // General tab ------------------------------------------------------------------------
5023 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
5025 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
5026 setPreferenceProperty( autoUpdate, "columns", 2 );
5027 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
5028 setPreferenceProperty( lim, "min", 0 );
5029 setPreferenceProperty( lim, "max", 100000000 );
5030 setPreferenceProperty( lim, "step", 1000 );
5031 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5032 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
5034 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
5035 setPreferenceProperty( dispgroup, "columns", 2 );
5036 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
5038 modes.append( tr("MEN_WIRE") );
5039 modes.append( tr("MEN_SHADE") );
5040 modes.append( tr("MEN_NODES") );
5041 modes.append( tr("MEN_SHRINK") );
5042 QList<QVariant> indices;
5043 indices.append( 0 );
5044 indices.append( 1 );
5045 indices.append( 2 );
5046 indices.append( 3 );
5047 setPreferenceProperty( dispmode, "strings", modes );
5048 setPreferenceProperty( dispmode, "indexes", indices );
5050 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
5051 setPreferenceProperty( arcgroup, "columns", 2 );
5052 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
5053 QStringList quadraticModes;
5054 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
5055 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
5057 indices.append( 0 );
5058 indices.append( 1 );
5059 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
5060 setPreferenceProperty( quadraticmode, "indexes", indices );
5062 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
5063 "SMESH", "max_angle" );
5064 setPreferenceProperty( maxAngle, "min", 1 );
5065 setPreferenceProperty( maxAngle, "max", 90 );
5067 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
5068 setPreferenceProperty( qaGroup, "columns", 2 );
5069 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
5070 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
5071 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
5072 setPreferenceProperty( prec, "min", 0 );
5073 setPreferenceProperty( prec, "max", 100 );
5074 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
5075 setPreferenceProperty( doubleNodesTol, "precision", 10 );
5076 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
5077 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
5078 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
5081 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
5082 setPreferenceProperty( exportgroup, "columns", 2 );
5083 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
5084 addPreference( tr( "PREF_SHOW_WARN" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "show_warning" );
5085 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
5087 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
5088 setPreferenceProperty( computeGroup, "columns", 2 );
5089 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
5091 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5092 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5093 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5095 indices.append( 0 );
5096 indices.append( 1 );
5097 indices.append( 2 );
5098 setPreferenceProperty( notifyMode, "strings", modes );
5099 setPreferenceProperty( notifyMode, "indexes", indices );
5101 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5102 setPreferenceProperty( infoGroup, "columns", 2 );
5103 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5105 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5106 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5108 indices.append( 0 );
5109 indices.append( 1 );
5110 setPreferenceProperty( elemInfo, "strings", modes );
5111 setPreferenceProperty( elemInfo, "indexes", indices );
5112 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5113 setPreferenceProperty( nodesLim, "min", 0 );
5114 setPreferenceProperty( nodesLim, "max", 10000000 );
5115 setPreferenceProperty( nodesLim, "step", 10000 );
5116 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5117 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5118 setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5119 setPreferenceProperty( ctrlLim, "min", 0 );
5120 setPreferenceProperty( ctrlLim, "max", 10000000 );
5121 setPreferenceProperty( ctrlLim, "step", 1000 );
5122 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5123 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5124 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5125 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5126 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5128 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5129 setPreferenceProperty( segGroup, "columns", 2 );
5130 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5131 "SMESH", "segmentation" );
5132 setPreferenceProperty( segLen, "min", 1 );
5133 setPreferenceProperty( segLen, "max", 10000000 );
5134 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5135 "SMESH", "nb_segments_per_edge" );
5136 setPreferenceProperty( nbSeg, "min", 1 );
5137 setPreferenceProperty( nbSeg, "max", 10000000 );
5139 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5140 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5141 "SMESH", "forget_mesh_on_hyp_modif" );
5144 // Quantities with individual precision settings
5145 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5146 setPreferenceProperty( precGroup, "columns", 2 );
5148 const int nbQuantities = 6;
5149 int precs[nbQuantities], ii = 0;
5150 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5151 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5152 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5153 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5154 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5155 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5156 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5157 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5158 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5159 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5160 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5161 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5163 // Set property for precision value for spinboxes
5164 for ( ii = 0; ii < nbQuantities; ii++ ){
5165 setPreferenceProperty( precs[ii], "min", -14 );
5166 setPreferenceProperty( precs[ii], "max", 14 );
5167 setPreferenceProperty( precs[ii], "precision", 2 );
5170 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5171 setPreferenceProperty( previewGroup, "columns", 2 );
5172 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5173 setPreferenceProperty( chunkSize, "min", 1 );
5174 setPreferenceProperty( chunkSize, "max", 1000 );
5175 setPreferenceProperty( chunkSize, "step", 50 );
5177 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5178 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5180 // Mesh tab ------------------------------------------------------------------------
5181 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5182 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5183 setPreferenceProperty( nodeGroup, "columns", 3 );
5185 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5187 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5189 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5190 QList<QVariant> aMarkerTypeIndicesList;
5191 QList<QVariant> aMarkerTypeIconsList;
5192 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5193 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5194 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5195 aMarkerTypeIndicesList << i;
5196 aMarkerTypeIconsList << pixmap;
5198 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5199 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
5201 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5203 QList<QVariant> aMarkerScaleIndicesList;
5204 QStringList aMarkerScaleValuesList;
5205 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5206 aMarkerScaleIndicesList << i;
5207 //aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5208 aMarkerScaleValuesList << QString::number( i );
5210 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5211 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5213 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5214 //setPreferenceProperty( elemGroup, "columns", 2 );
5216 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5217 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5218 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5219 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5220 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5221 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5222 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5223 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5224 addPreference( tr( "PREF_PREVIEW_COLOR" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5227 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5228 setPreferenceProperty( grpGroup, "columns", 2 );
5230 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5231 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5233 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5234 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5235 /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5236 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5237 double ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5238 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5239 double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5240 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5241 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
5242 LightApp_Preferences::IntSpin, "SMESH", "element_width");
5243 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5244 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5245 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5246 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5248 setPreferenceProperty( size0d, "min", 1 );
5249 setPreferenceProperty( size0d, "max", 10 );
5251 // setPreferenceProperty( ballSize, "min", 1 );
5252 // setPreferenceProperty( ballSize, "max", 10 );
5254 setPreferenceProperty( ballDiameter, "min", 1e-7 );
5255 setPreferenceProperty( ballDiameter, "max", 1e9 );
5256 setPreferenceProperty( ballDiameter, "step", 0.1 );
5258 setPreferenceProperty( ballScale, "min", 1e-2 );
5259 setPreferenceProperty( ballScale, "max", 1e7 );
5260 setPreferenceProperty( ballScale, "step", 0.5 );
5262 setPreferenceProperty( elemW, "min", 1 );
5263 setPreferenceProperty( elemW, "max", 5 );
5265 setPreferenceProperty( outW, "min", 1 );
5266 setPreferenceProperty( outW, "max", 5 );
5268 setPreferenceProperty( shrink, "min", 0 );
5269 setPreferenceProperty( shrink, "max", 100 );
5271 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5272 setPreferenceProperty( numGroup, "columns", 2 );
5274 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5275 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5277 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5278 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5280 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5281 setPreferenceProperty( orientGroup, "columns", 1 );
5283 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5284 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5286 setPreferenceProperty( orientScale, "min", 0.05 );
5287 setPreferenceProperty( orientScale, "max", 0.5 );
5288 setPreferenceProperty( orientScale, "step", 0.05 );
5290 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5292 // Selection tab ------------------------------------------------------------------------
5293 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5295 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5296 setPreferenceProperty( selGroup, "columns", 2 );
5298 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5299 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5301 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5302 setPreferenceProperty( preGroup, "columns", 2 );
5304 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5306 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5307 setPreferenceProperty( precSelGroup, "columns", 2 );
5309 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5310 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5311 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5313 // Scalar Bar tab ------------------------------------------------------------------------
5314 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5315 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5316 setPreferenceProperty( fontGr, "columns", 2 );
5318 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5319 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5321 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5322 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5324 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5325 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5327 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5328 setPreferenceProperty( numcol, "min", 2 );
5329 setPreferenceProperty( numcol, "max", 256 );
5331 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5332 setPreferenceProperty( numlab, "min", 2 );
5333 setPreferenceProperty( numlab, "max", 65 );
5335 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5336 setPreferenceProperty( orientGr, "columns", 2 );
5337 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5338 QStringList orients;
5339 orients.append( tr( "SMESH_VERTICAL" ) );
5340 orients.append( tr( "SMESH_HORIZONTAL" ) );
5341 indices.clear(); indices.append( 0 ); indices.append( 1 );
5342 setPreferenceProperty( orient, "strings", orients );
5343 setPreferenceProperty( orient, "indexes", indices );
5345 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5346 setPreferenceProperty( posVSizeGr, "columns", 2 );
5347 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5348 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5349 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5350 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5351 setPreferenceProperty( xv, "step", 0.1 );
5352 setPreferenceProperty( xv, "min", 0.0 );
5353 setPreferenceProperty( xv, "max", 1.0 );
5354 setPreferenceProperty( yv, "step", 0.1 );
5355 setPreferenceProperty( yv, "min", 0.0 );
5356 setPreferenceProperty( yv, "max", 1.0 );
5357 setPreferenceProperty( wv, "step", 0.1 );
5358 setPreferenceProperty( wv, "min", 0.0 );
5359 setPreferenceProperty( wv, "max", 1.0 );
5360 setPreferenceProperty( hv, "min", 0.0 );
5361 setPreferenceProperty( hv, "max", 1.0 );
5362 setPreferenceProperty( hv, "step", 0.1 );
5364 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5365 setPreferenceProperty( posHSizeGr, "columns", 2 );
5366 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5367 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5368 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5369 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5370 setPreferenceProperty( xv, "min", 0.0 );
5371 setPreferenceProperty( xv, "max", 1.0 );
5372 setPreferenceProperty( xv, "step", 0.1 );
5373 setPreferenceProperty( xh, "min", 0.0 );
5374 setPreferenceProperty( xh, "max", 1.0 );
5375 setPreferenceProperty( xh, "step", 0.1 );
5376 setPreferenceProperty( yh, "min", 0.0 );
5377 setPreferenceProperty( yh, "max", 1.0 );
5378 setPreferenceProperty( yh, "step", 0.1 );
5379 setPreferenceProperty( wh, "min", 0.0 );
5380 setPreferenceProperty( wh, "max", 1.0 );
5381 setPreferenceProperty( wh, "step", 0.1 );
5382 setPreferenceProperty( hh, "min", 0.0 );
5383 setPreferenceProperty( hh, "max", 1.0 );
5384 setPreferenceProperty( hh, "step", 0.1 );
5386 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5387 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5388 setPreferenceProperty( distributionGr, "columns", 3 );
5390 types.append( tr( "SMESH_MONOCOLOR" ) );
5391 types.append( tr( "SMESH_MULTICOLOR" ) );
5392 indices.clear(); indices.append( 0 ); indices.append( 1 );
5393 setPreferenceProperty( coloringType, "strings", types );
5394 setPreferenceProperty( coloringType, "indexes", indices );
5395 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5399 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5401 if ( sect=="SMESH" ) {
5402 float sbX1 = 0.01, sbY1 = 0.01, sbW = 0.08, sbH = 0.08;
5403 float aTol = 1.00000009999999;
5404 std::string aWarning;
5405 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5407 if ( name== "selection_object_color" ||
5408 name=="selection_element_color" ||
5409 name== "highlight_color" ||
5410 name=="selection_precision_node" ||
5411 name=="selection_precision_element" ||
5412 name=="selection_precision_object" )
5414 SMESH::UpdateSelectionProp( this );
5416 else if (name == "scalar_bar_vertical_x" || name == "scalar_bar_vertical_width")
5418 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5419 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5420 if ( sbX1+sbW > aTol ) {
5421 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5424 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5425 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5428 else if (name == "scalar_bar_vertical_y" || name == "scalar_bar_vertical_height" )
5430 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5431 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5432 if ( sbY1 + sbH > aTol ) {
5433 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5434 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5435 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5438 else if (name == "scalar_bar_horizontal_x" || name == "scalar_bar_horizontal_width")
5440 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5441 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5442 if ( sbX1 + sbW > aTol ) {
5443 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5446 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5447 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5450 else if (name == "scalar_bar_horizontal_y" || name == "scalar_bar_horizontal_height")
5452 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5453 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5454 if ( sbY1 + sbH > aTol ) {
5455 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5458 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5459 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5462 else if ( name == "segmentation" )
5464 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5465 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5467 else if ( name == "nb_segments_per_edge" )
5469 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5470 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5472 else if ( name == "historical_python_dump" || name == "forget_mesh_on_hyp_modif" || name == "default_grp_color" )
5474 QString val = aResourceMgr->stringValue( "SMESH", name );
5475 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5477 else if ( name == "numbering_node_color" || name == "numbering_node_font" )
5479 SMESH::UpdateFontProp( this );
5481 else if ( name == "numbering_elem_color" || name == "numbering_elem_font" )
5483 SMESH::UpdateFontProp( this );
5486 if ( aWarning.size() != 0 ) {
5487 aWarning += "The default values are applied instead.";
5488 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5489 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5490 QObject::tr(aWarning.c_str()));
5495 //================================================================================
5497 * \brief Update something in accordance with update flags
5498 * \param theFlags - update flags
5500 * Update viewer or/and object browser etc. in accordance with update flags ( see
5501 * LightApp_UpdateFlags enumeration ).
5503 //================================================================================
5504 void SMESHGUI::update( const int flags )
5506 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5507 SMESH::UpdateView();
5509 SalomeApp_Module::update( flags );
5512 //================================================================================
5514 * \brief Set default selection mode
5516 * SLOT called when operation committed. Sets default selection mode
5518 //================================================================================
5519 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5521 SVTK_ViewWindow* vtkWnd =
5522 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5524 vtkWnd->SetSelectionMode( ActorSelection );
5527 //================================================================================
5529 * \brief Set default selection mode
5531 * SLOT called when operation aborted. Sets default selection mode
5533 //================================================================================
5534 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5536 SVTK_ViewWindow* vtkWnd =
5537 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5539 vtkWnd->SetSelectionMode( ActorSelection );
5542 //================================================================================
5544 * \brief Creates operation with given identifier
5545 * \param id - identifier of operation to be started
5546 * \return Pointer on created operation or NULL if operation is not created
5548 * Virtual method redefined from the base class creates operation with given id.
5549 * It is called called automatically from startOperation method of base class.
5551 //================================================================================
5552 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5554 LightApp_Operation* op = 0;
5555 // to do : create operation here
5558 case SMESHOp::OpSplitBiQuadratic:
5559 op = new SMESHGUI_SplitBiQuadOp();
5561 case SMESHOp::OpConvertMeshToQuadratic:
5562 op = new SMESHGUI_ConvToQuadOp();
5564 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5565 op = new SMESHGUI_Make2DFrom3DOp();
5567 case SMESHOp::OpReorientFaces:
5568 op = new SMESHGUI_ReorientFacesOp();
5570 case SMESHOp::OpCreateMesh:
5571 op = new SMESHGUI_MeshOp( true, true );
5573 case SMESHOp::OpCreateSubMesh:
5574 op = new SMESHGUI_MeshOp( true, false );
5576 case SMESHOp::OpEditMeshOrSubMesh:
5577 case SMESHOp::OpEditMesh:
5578 case SMESHOp::OpEditSubMesh:
5579 op = new SMESHGUI_MeshOp( false );
5581 case SMESHOp::OpCompute:
5582 case SMESHOp::OpComputeSubMesh:
5583 op = new SMESHGUI_ComputeOp();
5585 case SMESHOp::OpPreCompute:
5586 op = new SMESHGUI_PrecomputeOp();
5588 case SMESHOp::OpEvaluate:
5589 op = new SMESHGUI_EvaluateOp();
5591 case SMESHOp::OpMeshOrder:
5592 op = new SMESHGUI_MeshOrderOp();
5594 case SMESHOp::OpCreateGeometryGroup:
5595 op = new SMESHGUI_GroupOnShapeOp();
5597 case SMESHOp::OpFindElementByPoint:
5598 op = new SMESHGUI_FindElemByPointOp();
5600 case SMESHOp::OpMoveNode: // Make mesh pass through point
5601 op = new SMESHGUI_MakeNodeAtPointOp();
5603 case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
5604 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5611 op = SalomeApp_Module::createOperation( id );
5615 //================================================================================
5617 * \brief Stops current operations and starts a given one
5618 * \param id - The id of the operation to start
5620 //================================================================================
5622 void SMESHGUI::switchToOperation(int id)
5624 if ( _PTR(Study) aStudy = SMESH::GetActiveStudyDocument() )
5625 activeStudy()->abortAllOperations();
5626 startOperation( id );
5629 LightApp_Displayer* SMESHGUI::displayer()
5632 myDisplayer = new SMESHGUI_Displayer( getApp() );
5636 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5639 int aTolerance = 64;
5640 int anIterations = 0;
5646 if( anIterations % aPeriod == 0 )
5649 if( aTolerance < 1 )
5653 aHue = (int)( 360.0 * rand() / RAND_MAX );
5656 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5657 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5658 for( ; it != itEnd; ++it )
5660 SALOMEDS::Color anAutoColor = *it;
5661 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5664 aQColor.getHsv( &h, &s, &v );
5665 if( abs( h - aHue ) < aTolerance )
5677 aColor.setHsv( aHue, 255, 255 );
5679 SALOMEDS::Color aSColor;
5680 aSColor.R = aColor.redF();
5681 aSColor.G = aColor.greenF();
5682 aSColor.B = aColor.blueF();
5687 const char* gSeparator = "_"; // character used to separate parameter names
5688 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5689 const char* gPathSep = "|"; // character used to separate paths
5692 * \brief Store visual parameters
5694 * This method is called just before the study document is saved.
5695 * Store visual parameters in AttributeParameter attribue(s)
5697 void SMESHGUI::storeVisualParameters (int savePoint)
5700 Kernel_Utils::Localizer loc;
5702 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5703 if (!appStudy || !appStudy->studyDS())
5705 _PTR(Study) studyDS = appStudy->studyDS();
5707 // componentName is used for encoding of entries when storing them in IParameters
5708 std::string componentName = myComponentSMESH->ComponentDataType();
5709 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5710 //if (!aSComponent) return;
5713 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5714 componentName.c_str(),
5716 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5718 // store map of custom markers
5719 const VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5720 if( !aMarkerMap.empty() )
5722 VTK::MarkerMap::const_iterator anIter = aMarkerMap.begin();
5723 for( ; anIter != aMarkerMap.end(); anIter++ )
5725 int anId = anIter->first;
5726 VTK::MarkerData aMarkerData = anIter->second;
5727 std::string aMarkerFileName = aMarkerData.first;
5728 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5729 if( aMarkerTexture.size() < 3 )
5730 continue; // should contain at least width, height and the first value
5732 QString aPropertyName( "texture" );
5733 aPropertyName += gSeparator;
5734 aPropertyName += QString::number( anId );
5736 QString aPropertyValue = aMarkerFileName.c_str();
5737 aPropertyValue += gPathSep;
5739 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5740 ushort aWidth = *aTextureIter++;
5741 ushort aHeight = *aTextureIter++;
5742 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5743 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5744 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5745 aPropertyValue += QString::number( *aTextureIter );
5747 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5751 // viewers counters are used for storing view_numbers in IParameters
5754 // main cycle to store parameters of displayed objects
5755 QList<SUIT_ViewManager*> lst;
5756 QList<SUIT_ViewManager*>::Iterator it;
5757 getApp()->viewManagers(lst);
5758 for (it = lst.begin(); it != lst.end(); it++)
5760 SUIT_ViewManager* vman = *it;
5761 QString vType = vman->getType();
5763 // saving VTK actors properties
5764 if (vType == SVTK_Viewer::Type())
5766 // store the clipping planes attached to the view manager
5767 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5768 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5769 if( anIter != myClippingPlaneInfoMap.end() )
5770 aClippingPlaneInfoList = anIter->second;
5772 if( !aClippingPlaneInfoList.empty() ) {
5773 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5774 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5776 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5777 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5779 QString aPropertyName( "ClippingPlane" );
5780 aPropertyName += gSeparator;
5781 aPropertyName += QString::number( vtkViewers );
5782 aPropertyName += gSeparator;
5783 aPropertyName += QString::number( anId );
5785 QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
5786 aPropertyValue += gDigitsSep;
5787 aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
5788 aPropertyValue += gDigitsSep;
5789 if ( aPlane->PlaneMode == SMESH::Absolute ) {
5790 aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
5791 aPropertyValue += gDigitsSep;
5792 aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
5793 aPropertyValue += gDigitsSep;
5794 aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
5795 aPropertyValue += gDigitsSep;
5796 aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
5797 aPropertyValue += gDigitsSep;
5798 aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
5799 aPropertyValue += gDigitsSep;
5800 aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
5801 aPropertyValue += gDigitsSep;
5802 aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
5804 else if ( aPlane->PlaneMode == SMESH::Relative ) {
5805 aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
5806 aPropertyValue += gDigitsSep;
5807 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5808 aPropertyValue += gDigitsSep;
5809 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5810 aPropertyValue += gDigitsSep;
5811 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5814 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5818 QVector<SUIT_ViewWindow*> views = vman->getViews();
5819 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5821 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5823 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5824 vtkActorCollection* allActors = aCopy.GetActors();
5825 allActors->InitTraversal();
5826 while (vtkActor* actor = allActors->GetNextActor())
5828 if (actor->GetVisibility()) // store only visible actors
5830 SMESH_Actor* aSmeshActor = 0;
5831 if (actor->IsA("SMESH_Actor"))
5832 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5833 if (aSmeshActor && aSmeshActor->hasIO())
5835 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5838 // entry is "encoded" = it does NOT contain component address,
5839 // since it is a subject to change on next component loading
5840 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5842 std::string param, vtkParam = vType.toLatin1().data();
5843 vtkParam += gSeparator;
5844 vtkParam += QString::number(vtkViewers).toLatin1().data();
5845 vtkParam += gSeparator;
5848 param = vtkParam + "Visibility";
5849 ip->setParameter(entry, param, "On");
5852 param = vtkParam + "Representation";
5853 ip->setParameter(entry, param, QString::number
5854 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5857 param = vtkParam + "IsShrunk";
5858 ip->setParameter(entry, param, QString::number
5859 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5861 // Displayed entities
5862 unsigned int aMode = aSmeshActor->GetEntityMode();
5863 bool isE = aMode & SMESH_Actor::eEdges;
5864 bool isF = aMode & SMESH_Actor::eFaces;
5865 bool isV = aMode & SMESH_Actor::eVolumes;
5866 bool is0d = aMode & SMESH_Actor::e0DElements;
5867 bool isB = aMode & SMESH_Actor::eBallElem;
5869 QString modeStr ("e");
5870 modeStr += gDigitsSep; modeStr += QString::number(isE);
5871 modeStr += gDigitsSep; modeStr += "f";
5872 modeStr += gDigitsSep; modeStr += QString::number(isF);
5873 modeStr += gDigitsSep; modeStr += "v";
5874 modeStr += gDigitsSep; modeStr += QString::number(isV);
5875 modeStr += gDigitsSep; modeStr += "0d";
5876 modeStr += gDigitsSep; modeStr += QString::number(is0d);
5877 modeStr += gDigitsSep; modeStr += "b";
5878 modeStr += gDigitsSep; modeStr += QString::number(isB);
5880 param = vtkParam + "Entities";
5881 ip->setParameter(entry, param, modeStr.toLatin1().data());
5887 aSmeshActor->GetSufaceColor(r, g, b, delta);
5888 QStringList colorStr;
5889 colorStr << "surface";
5890 colorStr << QString::number(r);
5891 colorStr << QString::number(g);
5892 colorStr << QString::number(b);
5894 colorStr << "backsurface";
5895 colorStr << QString::number(delta);
5897 aSmeshActor->GetVolumeColor(r, g, b, delta);
5898 colorStr << "volume";
5899 colorStr << QString::number(r);
5900 colorStr << QString::number(g);
5901 colorStr << QString::number(b);
5902 colorStr << QString::number(delta);
5904 aSmeshActor->GetEdgeColor(r, g, b);
5906 colorStr << QString::number(r);
5907 colorStr << QString::number(g);
5908 colorStr << QString::number(b);
5910 aSmeshActor->GetNodeColor(r, g, b);
5912 colorStr << QString::number(r);
5913 colorStr << QString::number(g);
5914 colorStr << QString::number(b);
5916 aSmeshActor->GetOutlineColor(r, g, b);
5917 colorStr << "outline";
5918 colorStr << QString::number(r);
5919 colorStr << QString::number(g);
5920 colorStr << QString::number(b);
5922 aSmeshActor->Get0DColor(r, g, b);
5923 colorStr << "elem0d";
5924 colorStr << QString::number(r);
5925 colorStr << QString::number(g);
5926 colorStr << QString::number(b);
5928 aSmeshActor->GetBallColor(r, g, b);
5930 colorStr << QString::number(r);
5931 colorStr << QString::number(g);
5932 colorStr << QString::number(b);
5934 aSmeshActor->GetFacesOrientationColor(r, g, b);
5935 colorStr << "orientation";
5936 colorStr << QString::number(r);
5937 colorStr << QString::number(g);
5938 colorStr << QString::number(b);
5940 param = vtkParam + "Colors";
5941 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
5944 QStringList sizeStr;
5946 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
5947 sizeStr << "outline";
5948 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
5949 sizeStr << "elem0d";
5950 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
5952 //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
5953 sizeStr << QString::number((double)aSmeshActor->GetBallSize());
5954 sizeStr << QString::number((double)aSmeshActor->GetBallScale());
5955 sizeStr << "shrink";
5956 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
5957 sizeStr << "orientation";
5958 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
5959 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
5961 param = vtkParam + "Sizes";
5962 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
5967 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5968 if( aMarkerType == VTK::MT_USER ) {
5969 markerStr += "custom";
5970 markerStr += gDigitsSep;
5971 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
5975 markerStr += gDigitsSep;
5976 markerStr += QString::number( (int)aMarkerType );
5977 markerStr += gDigitsSep;
5978 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
5981 param = vtkParam + "PointMarker";
5982 ip->setParameter(entry, param, markerStr.toLatin1().data());
5985 param = vtkParam + "Opacity";
5986 ip->setParameter(entry, param,
5987 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
5990 param = vtkParam + "ClippingPlane";
5992 if( !aClippingPlaneInfoList.empty() ) {
5993 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
5994 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
5996 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
5997 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
5998 SMESH::TActorList::iterator anIter2 = anActorList.begin();
5999 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
6000 if( aSmeshActor == *anIter2 ) {
6001 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
6002 QString::number( anId ).toLatin1().constData() );
6009 ip->setParameter( entry, param, "Off" );
6010 } // if (io->hasEntry())
6011 } // SMESH_Actor && hasIO
6013 } // while.. actors traversal
6017 } // if (SVTK view model)
6018 } // for (viewManagers)
6021 // data structures for clipping planes processing
6025 bool isOpenGLClipping;
6026 vtkIdType RelativeOrientation;
6029 int AbsoluteOrientation;
6030 double X, Y, Z, Dx, Dy, Dz;
6032 typedef std::list<TPlaneData> TPlaneDataList;
6033 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
6035 typedef std::list<vtkActor*> TActorList;
6038 TActorList ActorList;
6039 SUIT_ViewManager* ViewManager;
6041 typedef std::list<TPlaneInfo> TPlaneInfoList;
6042 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
6045 * \brief Restore visual parameters
6047 * This method is called after the study document is opened.
6048 * Restore visual parameters from AttributeParameter attribue(s)
6050 void SMESHGUI::restoreVisualParameters (int savePoint)
6053 Kernel_Utils::Localizer loc;
6055 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6056 if (!appStudy || !appStudy->studyDS())
6058 _PTR(Study) studyDS = appStudy->studyDS();
6060 // componentName is used for encoding of entries when storing them in IParameters
6061 std::string componentName = myComponentSMESH->ComponentDataType();
6062 //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
6063 //if (!aSComponent) return;
6066 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6067 componentName.c_str(),
6069 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6071 // restore map of custom markers and map of clipping planes
6072 VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
6073 TPlaneDataMap aPlaneDataMap;
6075 std::vector<std::string> properties = ip->getProperties();
6076 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
6078 std::string property = *propIt;
6079 QString aPropertyName( property.c_str() );
6080 QString aPropertyValue( ip->getProperty( property ).c_str() );
6082 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
6083 if( aPropertyNameList.isEmpty() )
6086 QString aPropertyType = aPropertyNameList[0];
6087 if( aPropertyType == "texture" )
6089 if( aPropertyNameList.size() != 2 )
6093 int anId = aPropertyNameList[1].toInt( &ok );
6094 if( !ok || anId < 1 )
6097 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
6098 if( aPropertyValueList.size() != 2 )
6101 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
6102 QString aMarkerTextureString = aPropertyValueList[1];
6103 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
6104 if( aMarkerTextureStringList.size() != 3 )
6108 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6113 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6117 VTK::MarkerTexture aMarkerTexture;
6118 aMarkerTexture.push_back( aWidth );
6119 aMarkerTexture.push_back( aHeight );
6121 QString aMarkerTextureData = aMarkerTextureStringList[2];
6122 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6124 QChar aChar = aMarkerTextureData.at( i );
6125 if( aChar.isDigit() )
6126 aMarkerTexture.push_back( aChar.digitValue() );
6129 aMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6131 else if( aPropertyType == "ClippingPlane" )
6133 if( aPropertyNameList.size() != 3 )
6137 int aViewId = aPropertyNameList[1].toInt( &ok );
6138 if( !ok || aViewId < 0 )
6142 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6143 if( !ok || aClippingPlaneId < 0 )
6146 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6147 if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6150 TPlaneData aPlaneData;
6151 aPlaneData.AbsoluteOrientation = false;
6152 aPlaneData.RelativeOrientation = 0;
6153 aPlaneData.Distance = aPlaneData.Angle[0] = aPlaneData.Angle[1] = 0;
6154 aPlaneData.X = aPlaneData.Y = aPlaneData.Z = 0;
6155 aPlaneData.Dx = aPlaneData.Dy = aPlaneData.Dz = 0;
6157 aPlaneData.Id = aClippingPlaneId;
6160 aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6165 aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6169 if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6172 aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6177 aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6182 aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6187 aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6192 aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6197 aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6202 aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6206 else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6208 aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6213 aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6218 aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6223 aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6228 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6229 aPlaneDataList.push_back( aPlaneData );
6233 TPlaneInfoMap aPlaneInfoMap;
6235 std::vector<std::string> entries = ip->getEntries();
6237 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6239 // entry is a normal entry - it should be "decoded" (setting base address of component)
6240 QString entry (ip->decodeEntry(*entIt).c_str());
6242 // Check that the entry corresponds to a real object in the Study
6243 // as the object may be deleted or modified after the visual state is saved.
6244 _PTR(SObject) so = studyDS->FindObjectID(entry.toLatin1().data());
6245 if (!so) continue; //Skip the not existent entry
6247 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6248 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6250 std::vector<std::string>::iterator namesIt = paramNames.begin();
6251 std::vector<std::string>::iterator valuesIt = paramValues.begin();
6253 // actors are stored in a map after displaying of them for
6254 // quicker access in the future: map < viewID to actor >
6255 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6257 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6259 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6260 // '_' is used as separator and should not be used in viewer type or parameter names.
6261 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6262 if (lst.size() != 3)
6265 QString viewerTypStr = lst[0];
6266 QString viewIndexStr = lst[1];
6267 QString paramNameStr = lst[2];
6270 int viewIndex = viewIndexStr.toUInt(&ok);
6271 if (!ok) // bad conversion of view index to integer
6275 if (viewerTypStr == SVTK_Viewer::Type())
6277 SMESH_Actor* aSmeshActor = 0;
6278 if (vtkActors.IsBound(viewIndex))
6279 aSmeshActor = vtkActors.Find(viewIndex);
6281 QList<SUIT_ViewManager*> lst;
6282 getApp()->viewManagers(viewerTypStr, lst);
6284 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6285 SUIT_ViewManager* vman = NULL;
6286 if (viewIndex >= 0 && viewIndex < lst.count())
6287 vman = lst.at(viewIndex);
6289 if (paramNameStr == "Visibility")
6291 if (!aSmeshActor && displayer() && vman)
6293 SUIT_ViewModel* vmodel = vman->getViewModel();
6294 // SVTK view model can be casted to SALOME_View
6295 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6297 // store displayed actor in a temporary map for quicker
6298 // access later when restoring other parameters
6299 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6300 vtkRenderer* Renderer = vtkView->getRenderer();
6301 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6302 vtkActorCollection* theActors = aCopy.GetActors();
6303 theActors->InitTraversal();
6304 bool isFound = false;
6305 vtkActor *ac = theActors->GetNextActor();
6306 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6307 if (ac->IsA("SMESH_Actor")) {
6308 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6309 if (aGeomAc->hasIO()) {
6310 Handle(SALOME_InteractiveObject) io = aGeomAc->getIO();
6311 if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) {
6313 vtkActors.Bind(viewIndex, aGeomAc);
6319 } // if (paramNameStr == "Visibility")
6322 // the rest properties "work" with SMESH_Actor
6325 QString val ((*valuesIt).c_str());
6328 if (paramNameStr == "Representation") {
6329 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6332 else if (paramNameStr == "IsShrunk") {
6334 if (!aSmeshActor->IsShrunk())
6335 aSmeshActor->SetShrink();
6338 if (aSmeshActor->IsShrunk())
6339 aSmeshActor->UnShrink();
6342 // Displayed entities
6343 else if (paramNameStr == "Entities") {
6344 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6345 int aEntityMode = SMESH_Actor::eAllEntity;
6346 for ( int i = 0; i < mode.count(); i+=2 ) {
6347 if ( i < mode.count()-1 ) {
6348 QString type = mode[i];
6349 bool val = mode[i+1].toInt();
6350 if ( type == "e" && !val )
6351 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6352 else if ( type == "f" && !val )
6353 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6354 else if ( type == "v" && !val )
6355 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6356 else if ( type == "0d" && !val )
6357 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6358 else if ( type == "b" && !val )
6359 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6362 aSmeshActor->SetEntityMode( aEntityMode );
6365 else if (paramNameStr == "Colors") {
6366 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6373 QColor outlineColor;
6374 QColor orientationColor;
6380 // below lines are required to get default values for delta coefficients
6381 // of backface color for faces and color of reversed volumes
6382 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
6383 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6384 for ( int i = 0; i < colors.count(); i++ ) {
6385 QString type = colors[i];
6386 if ( type == "surface" ) {
6387 // face color is set by 3 values r:g:b, where
6388 // - r,g,b - is rgb color components
6389 if ( i+1 >= colors.count() ) break; // format error
6390 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6391 if ( i+2 >= colors.count() ) break; // format error
6392 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6393 if ( i+3 >= colors.count() ) break; // format error
6394 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6395 faceColor.setRgbF( r, g, b );
6398 else if ( type == "backsurface" ) {
6399 // backface color can be defined in several ways
6400 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6401 // - in latest versions, it is set as delta coefficient
6402 bool rgbOk = false, deltaOk;
6403 if ( i+1 >= colors.count() ) break; // format error
6404 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6405 int delta = colors[i+1].toInt( &deltaOk );
6407 if ( i+1 < colors.count() ) // index is shifted to 1
6408 g = colors[i+1].toDouble( &rgbOk );
6409 if ( rgbOk ) i++; // shift index
6410 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6411 b = colors[i+1].toDouble( &rgbOk );
6413 // - as currently there's no way to set directly backsurface color as it was before,
6414 // we ignore old dump where r,g,b triple was set
6415 // - also we check that delta parameter is set properly
6416 if ( !rgbOk && deltaOk )
6419 else if ( type == "volume" ) {
6420 // volume color is set by 4 values r:g:b:delta, where
6421 // - r,g,b - is a normal volume rgb color components
6422 // - delta - is a reversed volume color delta coefficient
6423 if ( i+1 >= colors.count() ) break; // format error
6424 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6425 if ( i+2 >= colors.count() ) break; // format error
6426 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6427 if ( i+3 >= colors.count() ) break; // format error
6428 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6429 if ( i+4 >= colors.count() ) break; // format error
6430 int delta = colors[i+4].toInt( &bOk );
6431 if ( !bOk ) break; // format error
6432 volumeColor.setRgbF( r, g, b );
6436 else if ( type == "edge" ) {
6437 // edge color is set by 3 values r:g:b, where
6438 // - r,g,b - is rgb color components
6439 if ( i+1 >= colors.count() ) break; // format error
6440 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6441 if ( i+2 >= colors.count() ) break; // format error
6442 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6443 if ( i+3 >= colors.count() ) break; // format error
6444 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6445 edgeColor.setRgbF( r, g, b );
6448 else if ( type == "node" ) {
6449 // node color is set by 3 values r:g:b, where
6450 // - r,g,b - is rgb color components
6451 if ( i+1 >= colors.count() ) break; // format error
6452 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6453 if ( i+2 >= colors.count() ) break; // format error
6454 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6455 if ( i+3 >= colors.count() ) break; // format error
6456 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6457 nodeColor.setRgbF( r, g, b );
6460 else if ( type == "elem0d" ) {
6461 // 0d element color is set by 3 values r:g:b, where
6462 // - r,g,b - is rgb color components
6463 if ( i+1 >= colors.count() ) break; // format error
6464 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6465 if ( i+2 >= colors.count() ) break; // format error
6466 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6467 if ( i+3 >= colors.count() ) break; // format error
6468 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6469 elem0dColor.setRgbF( r, g, b );
6472 else if ( type == "ball" ) {
6473 // ball color is set by 3 values r:g:b, where
6474 // - r,g,b - is rgb color components
6475 if ( i+1 >= colors.count() ) break; // format error
6476 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6477 if ( i+2 >= colors.count() ) break; // format error
6478 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6479 if ( i+3 >= colors.count() ) break; // format error
6480 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6481 ballColor.setRgbF( r, g, b );
6484 else if ( type == "outline" ) {
6485 // outline color is set by 3 values r:g:b, where
6486 // - r,g,b - is rgb color components
6487 if ( i+1 >= colors.count() ) break; // format error
6488 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6489 if ( i+2 >= colors.count() ) break; // format error
6490 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6491 if ( i+3 >= colors.count() ) break; // format error
6492 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6493 outlineColor.setRgbF( r, g, b );
6496 else if ( type == "orientation" ) {
6497 // orientation color is set by 3 values r:g:b, where
6498 // - r,g,b - is rgb color components
6499 if ( i+1 >= colors.count() ) break; // format error
6500 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6501 if ( i+2 >= colors.count() ) break; // format error
6502 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6503 if ( i+3 >= colors.count() ) break; // format error
6504 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6505 orientationColor.setRgbF( r, g, b );
6510 if ( nodeColor.isValid() )
6511 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6513 if ( edgeColor.isValid() )
6514 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6516 if ( faceColor.isValid() )
6517 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6519 if ( volumeColor.isValid() )
6520 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6521 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6522 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6524 if ( elem0dColor.isValid() )
6525 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6527 if ( ballColor.isValid() )
6528 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6530 if ( outlineColor.isValid() )
6531 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6532 // orientation color
6533 if ( orientationColor.isValid() )
6534 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6537 else if (paramNameStr == "Sizes") {
6538 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6541 int outlineWidth = -1;
6542 int elem0dSize = -1;
6543 //int ballSize = -1;
6544 double ballDiameter = -1.0;
6545 double ballScale = -1.0;
6546 double shrinkSize = -1;
6547 double orientationSize = -1;
6548 bool orientation3d = false;
6549 for ( int i = 0; i < sizes.count(); i++ ) {
6550 QString type = sizes[i];
6551 if ( type == "line" ) {
6552 // line (wireframe) width is given as single integer value
6553 if ( i+1 >= sizes.count() ) break; // format error
6554 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6558 if ( type == "outline" ) {
6559 // outline width is given as single integer value
6560 if ( i+1 >= sizes.count() ) break; // format error
6561 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6565 else if ( type == "elem0d" ) {
6566 // 0d element size is given as single integer value
6567 if ( i+1 >= sizes.count() ) break; // format error
6568 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6572 else if ( type == "ball" ) {
6573 // balls are specified by two values: size:scale, where
6574 // - size - is a integer value specifying size
6575 // - scale - is a double value specifying scale factor
6576 if ( i+1 >= sizes.count() ) break; // format error
6577 //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6578 double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6579 if ( i+2 >= sizes.count() ) break; // format error
6580 double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6586 else if ( type == "shrink" ) {
6587 // shrink factor is given as single floating point value
6588 if ( i+1 >= sizes.count() ) break; // format error
6589 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6593 else if ( type == "orientation" ) {
6594 // orientation vectors are specified by two values size:3d, where
6595 // - size - is a floating point value specifying scale factor
6596 // - 3d - is a boolean
6597 if ( i+1 >= sizes.count() ) break; // format error
6598 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6599 if ( i+2 >= sizes.count() ) break; // format error
6600 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6601 orientationSize = v1;
6602 orientation3d = (bool)v2;
6606 // line (wireframe) width
6607 if ( lineWidth > 0 )
6608 aSmeshActor->SetLineWidth( lineWidth );
6610 if ( outlineWidth > 0 )
6611 aSmeshActor->SetOutlineWidth( outlineWidth );
6612 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6613 aSmeshActor->SetOutlineWidth( lineWidth );
6615 if ( elem0dSize > 0 )
6616 aSmeshActor->Set0DSize( elem0dSize );
6618 /*if ( ballSize > 0 )
6619 aSmeshActor->SetBallSize( ballSize );*/
6621 if ( ballDiameter > 0 )
6622 aSmeshActor->SetBallSize( ballDiameter );
6624 if ( ballScale > 0.0 )
6625 aSmeshActor->SetBallScale( ballScale );
6627 if ( shrinkSize > 0 )
6628 aSmeshActor->SetShrinkFactor( shrinkSize );
6629 // orientation vectors
6630 if ( orientationSize > 0 ) {
6631 aSmeshActor->SetFacesOrientationScale( orientationSize );
6632 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6636 else if (paramNameStr == "PointMarker") {
6637 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6638 if( data.count() >= 2 ) {
6640 int aParam1 = data[1].toInt( &ok );
6642 if( data[0] == "std" && data.count() == 3 ) {
6643 int aParam2 = data[2].toInt( &ok );
6644 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6646 else if( data[0] == "custom" ) {
6647 VTK::MarkerMap::const_iterator markerIt = aMarkerMap.find( aParam1 );
6648 if( markerIt != aMarkerMap.end() ) {
6649 VTK::MarkerData aMarkerData = markerIt->second;
6650 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6657 else if (paramNameStr == "Opacity") {
6658 aSmeshActor->SetOpacity(val.toFloat());
6661 else if (paramNameStr.startsWith("ClippingPlane")) {
6662 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6663 // old format - val looks like "Off" or "1:0:0:0.5:0:0"
6664 // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
6665 // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
6666 // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
6667 // new format - val looks like "Off" or "0" (plane id)
6668 // (note: in new format "Off" value is used only for consistency,
6669 // so it is processed together with values in old format)
6670 bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
6671 if( anIsOldFormat ) {
6672 if (paramNameStr == "ClippingPlane1" || val == "Off")
6673 aSmeshActor->RemoveAllClippingPlanes();
6675 QList<SUIT_ViewManager*> lst;
6676 getApp()->viewManagers(viewerTypStr, lst);
6677 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6678 if (viewIndex >= 0 && viewIndex < lst.count()) {
6679 SUIT_ViewManager* vman = lst.at(viewIndex);
6680 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6682 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6684 SMESH::TActorList anActorList;
6685 anActorList.push_back( aSmeshActor );
6686 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
6687 aPlane->myViewWindow = vtkView;
6688 SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
6689 aPlane->PlaneMode = aMode;
6690 bool isOpenGLClipping = ( bool )vals[1].toInt();
6691 aPlane->IsOpenGLClipping = isOpenGLClipping;
6692 if ( aMode == SMESH::Absolute ) {
6693 aPlane->myAbsoluteOrientation = vals[2].toInt();
6694 aPlane->X = vals[3].toFloat();
6695 aPlane->Y = vals[4].toFloat();
6696 aPlane->Z = vals[5].toFloat();
6697 aPlane->Dx = vals[6].toFloat();
6698 aPlane->Dy = vals[7].toFloat();
6699 aPlane->Dz = vals[8].toFloat();
6701 else if ( aMode == SMESH::Relative ) {
6702 aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
6703 aPlane->myDistance = vals[3].toFloat();
6704 aPlane->myAngle[0] = vals[4].toFloat();
6705 aPlane->myAngle[1] = vals[5].toFloat();
6709 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6710 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6711 aClippingPlaneInfo.Plane = aPlane;
6712 aClippingPlaneInfo.ActorList = anActorList;
6713 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6721 int aPlaneId = val.toInt( &ok );
6722 if( ok && aPlaneId >= 0 ) {
6723 bool anIsDefinedPlane = false;
6724 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6725 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6726 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6727 TPlaneInfo& aPlaneInfo = *anIter;
6728 if( aPlaneInfo.PlaneId == aPlaneId ) {
6729 aPlaneInfo.ActorList.push_back( aSmeshActor );
6730 anIsDefinedPlane = true;
6734 if( !anIsDefinedPlane ) {
6735 TPlaneInfo aPlaneInfo;
6736 aPlaneInfo.PlaneId = aPlaneId;
6737 aPlaneInfo.ActorList.push_back( aSmeshActor );
6738 aPlaneInfo.ViewManager = vman;
6740 // to make the list sorted by plane id
6741 anIter = aPlaneInfoList.begin();
6742 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6743 const TPlaneInfo& aPlaneInfoRef = *anIter;
6744 if( aPlaneInfoRef.PlaneId > aPlaneId )
6747 aPlaneInfoList.insert( anIter, aPlaneInfo );
6752 } // if (aSmeshActor)
6753 } // other parameters than Visibility
6755 } // for names/parameters iterator
6756 } // for entries iterator
6758 // take into account planes with empty list of actors referred to them
6759 QList<SUIT_ViewManager*> aVMList;
6760 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6762 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6763 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6764 int aViewId = aPlaneDataIter->first;
6765 if( aViewId >= 0 && aViewId < aVMList.count() ) {
6766 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6768 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6770 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6771 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6772 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6773 const TPlaneData& aPlaneData = *anIter2;
6774 int aPlaneId = aPlaneData.Id;
6776 bool anIsFound = false;
6777 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6778 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6779 const TPlaneInfo& aPlaneInfo = *anIter3;
6780 if( aPlaneInfo.PlaneId == aPlaneId ) {
6787 TPlaneInfo aPlaneInfo; // ActorList field is empty
6788 aPlaneInfo.PlaneId = aPlaneId;
6789 aPlaneInfo.ViewManager = aViewManager;
6791 // to make the list sorted by plane id
6792 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6793 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6794 const TPlaneInfo& aPlaneInfoRef = *anIter4;
6795 if( aPlaneInfoRef.PlaneId > aPlaneId )
6798 aPlaneInfoList.insert( anIter4, aPlaneInfo );
6804 // add clipping planes to actors according to the restored parameters
6805 // and update the clipping plane map
6806 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6807 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6808 int aViewId = anIter1->first;
6809 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6811 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6812 if( anIter2 == aPlaneDataMap.end() )
6814 const TPlaneDataList& aPlaneDataList = anIter2->second;
6816 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6817 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6818 const TPlaneInfo& aPlaneInfo = *anIter3;
6819 int aPlaneId = aPlaneInfo.PlaneId;
6820 const TActorList& anActorList = aPlaneInfo.ActorList;
6821 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6825 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6829 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6831 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6832 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6833 const TPlaneData& aPlaneData = *anIter4;
6834 if( aPlaneData.Id == aPlaneId ) {
6835 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
6836 aPlane->myViewWindow = aViewWindow;
6837 aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
6838 aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
6839 if ( aPlane->PlaneMode == SMESH::Absolute ) {
6840 aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
6841 aPlane->X = aPlaneData.X;
6842 aPlane->Y = aPlaneData.Y;
6843 aPlane->Z = aPlaneData.Z;
6844 aPlane->Dx = aPlaneData.Dx;
6845 aPlane->Dy = aPlaneData.Dy;
6846 aPlane->Dz = aPlaneData.Dz;
6848 else if ( aPlane->PlaneMode == SMESH::Relative ) {
6849 aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
6850 aPlane->myDistance = aPlaneData.Distance;
6851 aPlane->myAngle[0] = aPlaneData.Angle[0];
6852 aPlane->myAngle[1] = aPlaneData.Angle[1];
6855 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6856 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6857 aClippingPlaneInfo.Plane = aPlane;
6858 aClippingPlaneInfo.ActorList = anActorList;
6859 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6870 // update all VTK views
6871 QList<SUIT_ViewManager*> lst;
6872 getApp()->viewManagers(lst);
6873 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6874 SUIT_ViewModel* vmodel = (*it)->getViewModel();
6875 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6876 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6877 // set OpenGL clipping planes
6878 VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
6879 vtkActorCollection* anAllActors = aCopy.GetActors();
6880 anAllActors->InitTraversal();
6881 while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
6882 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
6883 anActor->SetOpenGLClippingPlane();
6885 vtkView->getRenderer()->ResetCameraClippingRange();
6892 \brief Adds preferences for dfont of VTK viewer
6894 \param pIf group identifier
6895 \param param parameter
6896 \return identifier of preferences
6898 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
6900 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6902 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6905 fam.append( tr( "SMESH_FONT_ARIAL" ) );
6906 fam.append( tr( "SMESH_FONT_COURIER" ) );
6907 fam.append( tr( "SMESH_FONT_TIMES" ) );
6909 setPreferenceProperty( tfont, "fonts", fam );
6911 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6912 if ( needSize ) f = f | QtxFontEdit::Size;
6913 setPreferenceProperty( tfont, "features", f );
6919 \brief Actions after hypothesis edition
6920 Updates object browser after hypothesis edition
6922 void SMESHGUI::onHypothesisEdit( int result )
6925 SMESHGUI::Modified();
6926 updateObjBrowser( true );
6930 \brief Actions after choosing menu of control modes
6931 Updates control mode actions according to current selection
6933 void SMESHGUI::onUpdateControlActions()
6935 SALOME_ListIO selected;
6936 if ( LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr() )
6937 aSel->selectedObjects( selected );
6939 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
6940 if ( selected.Extent() ) {
6941 if ( selected.First()->hasEntry() ) {
6942 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( selected.First()->getEntry() )) {
6943 aControl = anActor->GetControlMode();
6944 SALOME_ListIteratorOfListIO it(selected);
6945 for ( it.Next(); it.More(); it.Next() ) {
6946 Handle(SALOME_InteractiveObject) anIO = it.Value();
6947 if ( anIO->hasEntry() ) {
6948 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
6949 if ( aControl != anActor->GetControlMode() ) {
6950 aControl = SMESH_Actor::eNone;
6960 int anAction = ActionToControl( aControl, true );
6962 action( anAction )->setChecked( true );
6964 QMenu* send = (QMenu*)sender();
6965 QList<QAction*> actions = send->actions();
6966 for ( int i = 0; i < actions.size(); i++ )
6967 actions[i]->setChecked( false );
6973 \brief Signal handler closing(SUIT_ViewWindow*) of a view
6974 \param pview view being closed
6976 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
6977 #ifndef DISABLE_PLOT2DVIEWER
6978 //Crear all Plot2d Viewers if need.
6979 SMESH::ClearPlot2Viewers(pview);
6981 EmitSignalCloseView();
6984 void SMESHGUI::message( const QString& msg )
6987 QStringList data = msg.split("/");
6988 if ( data.count() > 0 ) {
6989 if ( data.first() == "mesh_loading" ) {
6991 QString entry = data.count() > 1 ? data[1] : QString();
6992 if ( entry.isEmpty() )
6995 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
6997 _PTR(SObject) obj = study->FindObjectID( entry.toLatin1().constData() );
7000 name = SMESH::fromUtf8(obj->GetName());
7001 if ( name.isEmpty() )
7004 if ( data.last() == "stop" )
7005 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
7007 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
7008 QApplication::processEvents();
7014 \brief Connects or disconnects signals about activating and cloning view on the module slots
7015 \param pview view which is connected/disconnected
7017 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
7021 SUIT_ViewManager* viewMgr = pview->getViewManager();
7023 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7024 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7026 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7027 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7032 \brief Return \c true if object can be renamed
7034 bool SMESHGUI::renameAllowed( const QString& entry) const {
7035 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7039 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7043 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
7048 if(appStudy->isComponent(entry) || obj->isReference())
7051 // check type to prevent renaming of inappropriate objects
7052 int aType = SMESHGUI_Selection::type(qPrintable(entry), SMESH::GetActiveStudyDocument());
7053 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7054 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7055 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7056 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7057 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
7064 Rename object by entry.
7065 \param entry entry of the object
7066 \param name new name of the object
7067 \brief Return \c true if rename operation finished successfully, \c false otherwise.
7069 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
7071 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7075 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7080 _PTR(Study) aStudy = appStudy->studyDS();
7085 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
7087 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
7092 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
7093 _PTR(GenericAttribute) anAttr;
7094 _PTR(AttributeName) aName;
7096 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
7098 // check type to prevent renaming of inappropriate objects
7099 int aType = SMESHGUI_Selection::type( qPrintable(entry), SMESH::GetActiveStudyDocument() );
7100 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7101 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7102 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7103 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7104 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
7105 if ( !name.isEmpty() ) {
7106 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
7108 // update name of group object and its actor
7109 Handle(SALOME_InteractiveObject) IObject =
7110 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
7112 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
7113 if( !aGroupObject->_is_nil() ) {
7114 aGroupObject->SetName( qPrintable(name) );
7115 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
7116 anActor->setName( qPrintable(name) );
7126 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
7128 static QList<QColor> colors;
7130 if ( colors.isEmpty() ) {
7132 for (int s = 0; s < 2 ; s++)
7134 for (int v = 100; v >= 40; v = v - 20)
7136 for (int h = 0; h < 359 ; h = h + 60)
7138 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
7143 static int currentColor = randomize( colors.size() );
7145 SALOMEDS::Color color;
7146 color.R = (double)colors[currentColor].red() / 255.0;
7147 color.G = (double)colors[currentColor].green() / 255.0;
7148 color.B = (double)colors[currentColor].blue() / 255.0;
7150 currentColor = (currentColor+1) % colors.count();