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_DisplayEntitiesDlg.h"
44 #include "SMESHGUI_Displayer.h"
45 #include "SMESHGUI_DuplicateNodesDlg.h"
46 #include "SMESHGUI_ExtrusionAlongPathDlg.h"
47 #include "SMESHGUI_ExtrusionDlg.h"
48 #include "SMESHGUI_FaceGroupsSeparatedByEdgesDlg.h"
49 #include "SMESHGUI_FieldSelectorWdg.h"
50 #include "SMESHGUI_FileInfoDlg.h"
51 #include "SMESHGUI_FileValidator.h"
52 #include "SMESHGUI_FilterDlg.h"
53 #include "SMESHGUI_FilterLibraryDlg.h"
54 #include "SMESHGUI_FilterUtils.h"
55 #include "SMESHGUI_FindElemByPointDlg.h"
56 #include "SMESHGUI_GEOMGenUtils.h"
57 #include "SMESHGUI_GroupDlg.h"
58 #include "SMESHGUI_GroupOnShapeDlg.h"
59 #include "SMESHGUI_GroupOpDlg.h"
60 #include "SMESHGUI_GroupUtils.h"
61 #include "SMESHGUI_Hypotheses.h"
62 #include "SMESHGUI_HypothesesUtils.h"
63 #include "SMESHGUI_Make2DFrom3DOp.h"
64 #include "SMESHGUI_MakeNodeAtPointDlg.h"
65 #include "SMESHGUI_Measurements.h"
66 #include "SMESHGUI_MergeDlg.h"
67 #include "SMESHGUI_MeshInfo.h"
68 #include "SMESHGUI_MeshOp.h"
69 #include "SMESHGUI_MeshOrderOp.h"
70 #include "SMESHGUI_MeshPatternDlg.h"
71 #include "SMESHGUI_MeshUtils.h"
72 #include "SMESHGUI_MultiEditDlg.h"
73 #include "SMESHGUI_NodesDlg.h"
74 #include "SMESHGUI_OffsetDlg.h"
75 #include "SMESHGUI_Operations.h"
76 #include "SMESHGUI_PatternUtils.h"
77 #include "SMESHGUI_Preferences_ScalarBarDlg.h"
78 #include "SMESHGUI_PropertiesDlg.h"
79 #include "SMESHGUI_RemoveElementsDlg.h"
80 #include "SMESHGUI_RemoveNodesDlg.h"
81 #include "SMESHGUI_RenumberingDlg.h"
82 #include "SMESHGUI_ReorientFacesDlg.h"
83 #include "SMESHGUI_RevolutionDlg.h"
84 #include "SMESHGUI_RotationDlg.h"
85 #include "SMESHGUI_ScaleDlg.h"
86 #include "SMESHGUI_Selection.h"
87 #include "SMESHGUI_SewingDlg.h"
88 #include "SMESHGUI_SingleEditDlg.h"
89 #include "SMESHGUI_SmoothingDlg.h"
90 #include "SMESHGUI_SpinBox.h"
91 #include "SMESHGUI_SplitBiQuad.h"
92 #include "SMESHGUI_SymmetryDlg.h"
93 #include "SMESHGUI_TranslationDlg.h"
94 #include "SMESHGUI_TransparencyDlg.h"
95 #include "SMESHGUI_Utils.h"
96 #include "SMESHGUI_VTKUtils.h"
98 #include "SMESH_version.h"
100 #include "SMESH_ControlsDef.hxx"
101 #include "SMESH_Actor.h"
102 #include "SMESH_ActorUtils.h"
103 #include "SMESH_Client.hxx"
104 #include "SMESH_ScalarBarActor.h"
105 #include <SMESH_Comment.hxx>
106 #include "SMESH_TypeFilter.hxx"
108 // SALOME GUI includes
109 #include <LightApp_DataOwner.h>
110 #include <LightApp_NameDlg.h>
111 #include <LightApp_Preferences.h>
112 #include <LightApp_SelectionMgr.h>
113 #include <LightApp_UpdateFlags.h>
114 #include <QtxFontEdit.h>
115 #include <QtxPopupMgr.h>
116 #include <SALOME_ListIO.hxx>
117 #include <SUIT_Desktop.h>
118 #include <SUIT_FileDlg.h>
119 #include <SUIT_MessageBox.h>
120 #include <SUIT_OverrideCursor.h>
121 #include <SUIT_ResourceMgr.h>
122 #include <SUIT_Session.h>
123 #include <SVTK_ViewManager.h>
124 #include <SVTK_ViewModel.h>
125 #include <SVTK_ViewWindow.h>
126 #include <SalomeApp_Application.h>
127 #include <SalomeApp_CheckFileDlg.h>
128 #include <SalomeApp_DataObject.h>
129 #include <SalomeApp_Study.h>
130 #include <SalomeApp_Tools.h>
131 #include <VTKViewer_Algorithm.h>
133 #ifndef DISABLE_PLOT2DVIEWER
134 #include <SPlot2d_ViewModel.h>
135 #include <SPlot2d_Histogram.h>
139 #include <SALOMEconfig.h>
140 #include CORBA_CLIENT_HEADER(SALOMEDS_Attributes)
141 #include CORBA_CLIENT_HEADER(SMESH_MeshEditor)
142 #include CORBA_CLIENT_HEADER(SMESH_Measurements)
143 #include CORBA_CLIENT_HEADER(SMESH_Mesh)
146 // #define INCLUDE_MENUITEM_DEF // VSR commented ????????
147 #include <QApplication>
149 #include <QDialogButtonBox>
153 #include <QTextStream>
157 #include <boost/shared_ptr.hpp>
160 #include <vtkCallbackCommand.h>
161 #include <vtkCamera.h>
162 #include <vtkLookupTable.h>
163 #include <vtkPlane.h>
164 #include <vtkRenderer.h>
166 // SALOME KERNEL includes
167 #include <SALOMEDSClient_ClientFactory.hxx>
168 #include <SALOMEDSClient_IParameters.hxx>
169 #include <SALOMEDSClient_SComponent.hxx>
170 #include <SALOMEDSClient_StudyBuilder.hxx>
171 #include <SALOMEDS_Study.hxx>
172 #include <SALOMEDS_SObject.hxx>
173 #include "utilities.h"
176 #include <Standard_ErrorHandler.hxx>
177 #include <NCollection_DataMap.hxx>
178 #include <NCollection_DoubleMap.hxx>
180 #include <Basics_Utils.hxx>
182 // Below macro, when uncommented, switches on simplified (more performant) algorithm
183 // of auto-color picking up
184 #define SIMPLE_AUTOCOLOR
189 //=============================================================
190 void ImportMeshesFromFile(SMESH::SMESH_Gen_ptr theComponentMesh,
193 void ExportMeshToFile(int theCommandID);
195 void SetDisplayMode(int theCommandID, VTK::MarkerMap& theMarkerMap);
197 void SetDisplayEntity(int theCommandID);
199 int ActionToControl( int theID, bool theReversed = false );
201 void Control( int theCommandID );
204 //================================================================================
206 * \brief Reads meshes from file
208 //================================================================================
210 void ImportMeshesFromFile( SMESH::SMESH_Gen_ptr theComponentMesh,
214 std::string myExtension;
216 if ( theCommandID == SMESHOp::OpImportMED ||
217 theCommandID == SMESHOp::OpPopupImportMED ) {
218 filter.append( QObject::tr( "MED_FILES_FILTER" ) + " (*.*med)" );
219 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
221 else if ( theCommandID == SMESHOp::OpImportUNV ||
222 theCommandID == SMESHOp::OpPopupImportUNV ) {
223 filter.append( QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)" );
225 else if ( theCommandID == SMESHOp::OpImportDAT ||
226 theCommandID == SMESHOp::OpPopupImportDAT ) {
227 filter.append( QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)" );
229 else if ( theCommandID == SMESHOp::OpImportSTL ||
230 theCommandID == SMESHOp::OpPopupImportSTL ) {
231 filter.append( QObject::tr( "STL_FILES_FILTER" ) + " (*.stl)" );
233 else if ( theCommandID == SMESHOp::OpImportCGNS ||
234 theCommandID == SMESHOp::OpPopupImportCGNS ) {
235 filter.append( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
237 else if ( theCommandID == SMESHOp::OpImportSAUV ||
238 theCommandID == SMESHOp::OpPopupImportSAUV ) {
239 filter.append( QObject::tr( "SAUV_FILES_FILTER" ) + " (*.sauv *.sauve)" );
240 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
242 else if ( theCommandID == SMESHOp::OpImportGMF ||
243 theCommandID == SMESHOp::OpPopupImportGMF ) {
244 filter.append( QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" );
245 filter.append( QObject::tr( "GMF_BINARY_FILES_FILTER") + " (*.meshb)" );
248 QString anInitialPath = "";
249 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
250 anInitialPath = QDir::currentPath();
252 QStringList filenames;
253 bool toCreateGroups = true;
255 // if ( theCommandID == SMESHOp::OpImportGMF ) { // GMF
256 // SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg
257 // ( SMESHGUI::desktop(), true, QObject::tr("SMESH_REQUIRED_GROUPS"), true, true );
258 // fd->setWindowTitle( QObject::tr( "SMESH_IMPORT_MESH" ) );
259 // fd->setNameFilters( filter );
260 // fd->SetChecked( true );
262 // filenames << fd->selectedFile();
263 // toCreateGroups = fd->IsChecked();
269 filenames = SUIT_FileDlg::getOpenFileNames( SMESHGUI::desktop(),
272 QObject::tr( "SMESH_IMPORT_MESH" ) );
274 if ( filenames.count() > 0 )
276 SUIT_OverrideCursor wc;
277 _PTR(Study) aStudy = SMESH::getStudy();
280 QStringList anEntryList;
281 bool isEmpty = false;
282 for ( QStringList::ConstIterator it = filenames.begin(); it != filenames.end(); ++it )
284 QString filename = *it;
285 SMESH::mesh_array_var aMeshes = new SMESH::mesh_array;
287 switch ( theCommandID ) {
288 case SMESHOp::OpImportDAT:
289 case SMESHOp::OpPopupImportDAT:
291 // DAT format (currently unsupported)
292 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
293 arg( QObject::tr( "SMESH_ERR_NOT_SUPPORTED_FORMAT" ) ) );
296 case SMESHOp::OpImportUNV:
297 case SMESHOp::OpPopupImportUNV:
300 aMeshes->length( 1 );
301 aMeshes[0] = theComponentMesh->CreateMeshesFromUNV( filename.toUtf8().constData() );
302 if ( aMeshes[0]->_is_nil() )
303 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
304 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
307 case SMESHOp::OpImportMED:
308 case SMESHOp::OpPopupImportMED:
311 SMESH::DriverMED_ReadStatus res;
312 aMeshes = theComponentMesh->CreateMeshesFromMED( filename.toUtf8().constData(), res );
313 if ( res != SMESH::DRS_OK ) {
314 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
315 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
319 case SMESHOp::OpImportSTL:
320 case SMESHOp::OpPopupImportSTL:
323 aMeshes->length( 1 );
324 aMeshes[0] = theComponentMesh->CreateMeshesFromSTL( filename.toUtf8().constData() );
325 if ( aMeshes[0]->_is_nil() ) {
326 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
327 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
331 case SMESHOp::OpImportCGNS:
332 case SMESHOp::OpPopupImportCGNS:
335 SMESH::DriverMED_ReadStatus res;
336 aMeshes = theComponentMesh->CreateMeshesFromCGNS( filename.toUtf8().constData(), res );
337 if ( res != SMESH::DRS_OK ) {
338 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
339 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
343 case SMESHOp::OpImportSAUV:
344 case SMESHOp::OpPopupImportSAUV:
347 SMESH::DriverMED_ReadStatus res;
348 aMeshes = theComponentMesh->CreateMeshesFromSAUV( filename.toUtf8().constData(), res );
349 if ( res != SMESH::DRS_OK ) {
350 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
351 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
355 case SMESHOp::OpImportGMF:
356 case SMESHOp::OpPopupImportGMF:
359 SMESH::ComputeError_var res;
360 aMeshes->length( 1 );
361 aMeshes[0] = theComponentMesh->CreateMeshesFromGMF( filename.toUtf8().constData(),
364 if ( res->code != SMESH::DRS_OK ) {
365 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
366 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res->code ).toLatin1().data() ) ) );
367 if ( strlen( res->comment.in() ) > 0 ) {
368 errors.back() += ": ";
369 errors.back() += res->comment.in();
376 catch ( const SALOME::SALOME_Exception& S_ex ) {
377 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
378 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
381 for ( int i = 0, iEnd = aMeshes->length(); i < iEnd; i++ )
383 _PTR(SObject) aMeshSO = SMESH::FindSObject( aMeshes[i] );
385 _PTR(StudyBuilder) aBuilder = aStudy->NewBuilder();
386 _PTR(AttributePixMap) aPixmap = aBuilder->FindOrCreateAttribute( aMeshSO, "AttributePixMap" );
387 aPixmap->SetPixMap( "ICON_SMESH_TREE_MESH_IMPORTED" );
388 if ( theCommandID == SMESHOp::OpImportUNV ) // mesh names aren't taken from the file for UNV import
389 SMESH::SetName( aMeshSO, QFileInfo(filename).fileName() );
391 anEntryList.append( aMeshSO->GetID().c_str() );
399 // update Object browser
400 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
402 // browse to the published meshes
403 if( LightApp_Application* anApp =
404 dynamic_cast<LightApp_Application*>( SUIT_Session::session()->activeApplication() ) )
405 anApp->browseObjects( anEntryList );
407 // show Error message box if there were errors
408 if ( errors.count() > 0 ) {
409 SUIT_MessageBox::critical( SMESHGUI::desktop(),
410 QObject::tr( "SMESH_ERROR" ),
411 QObject::tr( "SMESH_IMPORT_ERRORS" ) + "\n" + errors.join( "\n" ) );
414 // show warning message box, if some imported mesh is empty
416 SUIT_MessageBox::warning( SMESHGUI::desktop(),
417 QObject::tr( "SMESH_WRN_WARNING" ),
418 QObject::tr( "SMESH_DRS_SOME_EMPTY" ) );
423 //================================================================================
425 * \brief Export selected meshes or groups into a file
427 //================================================================================
429 void ExportMeshToFile( int theCommandID )
431 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
432 SALOME_ListIO selected;
434 aSel->selectedObjects( selected );
436 const bool isDAT = ( theCommandID == SMESHOp::OpExportDAT ||
437 theCommandID == SMESHOp::OpPopupExportDAT );
438 const bool isMED = ( theCommandID == SMESHOp::OpExportMED ||
439 theCommandID == SMESHOp::OpPopupExportMED );
440 const bool isUNV = ( theCommandID == SMESHOp::OpExportUNV ||
441 theCommandID == SMESHOp::OpPopupExportUNV );
442 const bool isSTL = ( theCommandID == SMESHOp::OpExportSTL ||
443 theCommandID == SMESHOp::OpPopupExportSTL );
444 const bool isCGNS= ( theCommandID == SMESHOp::OpExportCGNS ||
445 theCommandID == SMESHOp::OpPopupExportCGNS );
446 const bool isSAUV= ( theCommandID == SMESHOp::OpExportSAUV ||
447 theCommandID == SMESHOp::OpPopupExportSAUV );
448 const bool isGMF = ( theCommandID == SMESHOp::OpExportGMF ||
449 theCommandID == SMESHOp::OpPopupExportGMF );
451 const bool multiMeshSupported = ( isMED || isCGNS ); // file can hold several meshes
452 if ( selected.Extent() == 0 || ( selected.Extent() > 1 && !multiMeshSupported ))
454 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
455 bool aCheckWarn = true;
457 aCheckWarn = resMgr->booleanValue( "SMESH", "show_warning", false );
458 // get mesh object from selection and check duplication of their names
459 bool hasDuplicatedMeshNames = false;
460 QList< QPair< SMESH::SMESH_IDSource_var, QString > > aMeshList;
461 QList< QPair< SMESH::SMESH_IDSource_var, QString > >::iterator aMeshIter;
462 SALOME_ListIteratorOfListIO It( selected );
463 for( ; It.More(); It.Next() )
465 Handle(SALOME_InteractiveObject) anIObject = It.Value();
466 SMESH::SMESH_IDSource_var aMeshItem =
467 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIObject);
468 if ( aMeshItem->_is_nil() ) {
469 SUIT_MessageBox::warning( SMESHGUI::desktop(),
470 QObject::tr( "SMESH_WRN_WARNING" ),
471 QObject::tr( "SMESH_BAD_MESH_SELECTION" ));
474 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( aMeshItem );
475 if ( aCheckWarn && !aGroup->_is_nil() )
477 QMessageBox msgBox(SUIT_MessageBox::Warning,
478 QObject::tr("SMESH_WRN_WARNING"),
479 QObject::tr("SMESH_EXPORT_ONLY_GPOUP"),
480 QMessageBox::StandardButton::NoButton,
481 SMESHGUI::desktop());
482 QCheckBox dontShowCheckBox(QObject::tr("SMESH_WRN_SHOW_DLG_CHECKBOX"));
483 msgBox.addButton(QMessageBox::Ok);
484 msgBox.addButton(QMessageBox::Cancel);
485 msgBox.setDefaultButton(QMessageBox::Cancel);
486 QGridLayout* lt = qobject_cast<QGridLayout*>(msgBox.layout());
487 QDialogButtonBox* btnbox = msgBox.findChild<QDialogButtonBox*>();
488 lt->addWidget(&dontShowCheckBox, lt->rowCount(), lt->columnCount()-1, lt->rowCount(), lt->columnCount());
489 lt->addWidget(btnbox, lt->rowCount(), 0, lt->rowCount(), lt->columnCount());
490 if ( msgBox.exec() != QMessageBox::Ok )
493 if ( dontShowCheckBox.checkState() == Qt::Checked && resMgr )
494 resMgr->setValue( "SMESH", "show_warning", false);
497 QString aMeshName = anIObject->getName();
499 // check for name duplications
500 if ( !hasDuplicatedMeshNames )
501 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
502 if( aMeshName == (*aMeshIter).second ) {
503 hasDuplicatedMeshNames = true;
508 aMeshList.append( QPair< SMESH::SMESH_IDSource_var, QString >( aMeshItem, aMeshName ) );
511 if( hasDuplicatedMeshNames && isMED ) {
512 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
513 QObject::tr("SMESH_WRN_WARNING"),
514 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_MESH_NAMES"),
515 QObject::tr("SMESH_BUT_YES"),
516 QObject::tr("SMESH_BUT_NO"), 0, 1);
521 aMeshIter = aMeshList.begin();
522 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
523 SMESH::SMESH_Mesh_var aMesh = aMeshOrGroup->GetMesh();
524 QString aMeshName = (*aMeshIter).second;
526 if ( isMED || isCGNS || isSAUV ) // formats where group names must be unique
528 // check for equal group names within each mesh
529 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
530 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
531 if ( !aMeshItem->_is_nil() && aMeshItem->HasDuplicatedGroupNamesMED()) {
532 int aRet = SUIT_MessageBox::warning
533 (SMESHGUI::desktop(),
534 QObject::tr("SMESH_WRN_WARNING"),
535 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_GRP").arg((*aMeshIter).second),
536 QObject::tr("SMESH_BUT_YES"),
537 QObject::tr("SMESH_BUT_NO"), 0, 1);
544 // Warn the user about presence of not supported elements
546 std::vector< SMESH::EntityType > notSupportedElemTypes, presentNotSupported;
550 notSupportedElemTypes.push_back( SMESH::Entity_0D );
551 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
556 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
557 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
558 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
559 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
560 notSupportedElemTypes.push_back( SMESH::Entity_Pyramid );
561 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
562 notSupportedElemTypes.push_back( SMESH::Entity_0D );
563 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
568 notSupportedElemTypes.push_back( SMESH::Entity_Edge );
569 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Edge );
570 notSupportedElemTypes.push_back( SMESH::Entity_0D );
571 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
576 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
581 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
582 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Triangle );
583 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Quadrangle );
584 notSupportedElemTypes.push_back( SMESH::Entity_TriQuad_Hexa );
585 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
586 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
587 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
588 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
593 notSupportedElemTypes.push_back( SMESH::Entity_0D );
594 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
595 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
596 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Pyramid );
597 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Penta );
598 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Penta );
599 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
600 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
601 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
602 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
604 if ( ! notSupportedElemTypes.empty() )
606 SMESH::long_array_var nbElems = aMeshOrGroup->GetMeshInfo();
607 for ( size_t iType = 0; iType < notSupportedElemTypes.size(); ++iType )
608 if ( nbElems[ notSupportedElemTypes[ iType ]] > 0 )
609 presentNotSupported.push_back( notSupportedElemTypes[ iType ]);
611 if ( !presentNotSupported.empty() )
614 const char* typeMsg[] = {
615 "SMESH_NODES", "SMESH_ELEMS0D","SMESH_EDGES","SMESH_QUADRATIC_EDGES",
616 "SMESH_TRIANGLES", "SMESH_QUADRATIC_TRIANGLES", "SMESH_BIQUADRATIC_TRIANGLES",
617 "SMESH_QUADRANGLES","SMESH_QUADRATIC_QUADRANGLES", "SMESH_BIQUADRATIC_QUADRANGLES",
618 "SMESH_POLYGONS","SMESH_QUADRATIC_POLYGONS",
619 "SMESH_TETRAHEDRA","SMESH_QUADRATIC_TETRAHEDRONS","SMESH_PYRAMIDS",
620 "SMESH_QUADRATIC_PYRAMIDS","SMESH_HEXAHEDRA","SMESH_QUADRATIC_HEXAHEDRONS",
621 "SMESH_TRIQUADRATIC_HEXAHEDRONS","SMESH_PENTAHEDRA","SMESH_QUADRATIC_PENTAHEDRONS",
622 "SMESH_BIQUADRATIC_PENTAHEDRONS",
623 "SMESH_OCTAHEDRA","SMESH_POLYEDRONS","SMESH_QUADRATIC_POLYEDRONS","SMESH_BALLS"
625 // is typeMsg complete? (compilation failure mains that enum SMDSAbs_EntityType changed)
626 const int nbTypes = sizeof( typeMsg ) / sizeof( const char* );
627 int _assert[( nbTypes == SMESH::Entity_Last ) ? 2 : -1 ]; _assert[0]=_assert[1]=0;
629 QString andStr = " " + QObject::tr("SMESH_AND") + " ", comma(", ");
630 for ( size_t iType = 0; iType < presentNotSupported.size(); ++iType ) {
631 typeNames += QObject::tr( typeMsg[ presentNotSupported[ iType ]]);
632 if ( iType != presentNotSupported.size() - 1 )
633 typeNames += ( iType == presentNotSupported.size() - 2 ) ? andStr : comma;
635 int aRet = SUIT_MessageBox::warning
636 (SMESHGUI::desktop(),
637 QObject::tr("SMESH_WRN_WARNING"),
638 QObject::tr("EXPORT_NOT_SUPPORTED").arg(aMeshName).arg(format).arg(typeNames),
639 QObject::tr("SMESH_BUT_YES"),
640 QObject::tr("SMESH_BUT_NO"), 0, 1);
645 // Get parameters of export operation
648 int aFormat =-1; // for MED version used for write
649 bool isOkToWrite = true; // to check MED file version compatibility before adding a mesh in an existing file
651 // Init the parameters with the default values
652 bool aIsASCII_STL = true;
653 bool toCreateGroups = false;
655 toCreateGroups = resMgr->booleanValue( "SMESH", "auto_groups", false );
656 bool toOverwrite = true;
657 bool toFindOutDim = true;
658 double zTol = resMgr ? resMgr->doubleValue( "SMESH", "med_ztolerance", 0. ) : 0.;
660 QString aFilter, aTitle = QObject::tr("SMESH_EXPORT_MESH");
661 QString anInitialPath = "";
662 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
663 anInitialPath = QDir::currentPath();
665 QList< QPair< GEOM::ListOfFields_var, QString > > aFieldList;
667 // Get a file name to write in and additional options
668 if ( isUNV || isDAT || isGMF ) // Export w/o options
671 aFilter = QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)";
673 aFilter = QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)";
675 aFilter = QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" +
676 ";;" + QObject::tr( "GMF_BINARY_FILES_FILTER" ) + " (*.meshb)";
677 if ( anInitialPath.isEmpty() ) anInitialPath = SUIT_FileDlg::getLastVisitedPath();
678 aFilename = SUIT_FileDlg::getFileName(SMESHGUI::desktop(),
679 anInitialPath + QString("/") + aMeshName,
680 aFilter, aTitle, false);
682 else if ( isCGNS )// Export to CGNS
684 const char* theByTypeResource = "cgns_group_elems_by_type";
685 toCreateGroups = SMESHGUI::resourceMgr()->booleanValue( "SMESH", theByTypeResource, false );
687 QStringList checkBoxes;
688 checkBoxes << QObject::tr("CGNS_EXPORT_ELEMS_BY_TYPE");
690 SalomeApp_CheckFileDlg* fd =
691 new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true );
692 fd->setWindowTitle( aTitle );
693 fd->setNameFilter( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
694 if ( !anInitialPath.isEmpty() )
695 fd->setDirectory( anInitialPath );
696 fd->selectFile(aMeshName);
697 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
698 fd->setValidator( fv );
699 fd->SetChecked( toCreateGroups, 0 );
702 aFilename = fd->selectedFile();
703 toOverwrite = fv->isOverwrite(aFilename);
704 toCreateGroups = fd->IsChecked(0);
705 SMESHGUI::resourceMgr()->setValue("SMESH", theByTypeResource, toCreateGroups );
709 else if ( isSTL ) // Export to STL
711 QMap<QString, int> aFilterMap;
712 aFilterMap.insert( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)", 1 );
713 aFilterMap.insert( QObject::tr( "STL_BIN_FILES_FILTER" ) + " (*.stl)", 0 );
716 QMap<QString, int>::const_iterator it = aFilterMap.begin();
717 for ( ; it != aFilterMap.end(); ++it )
718 filters.push_back( it.key() );
720 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
721 fd->setWindowTitle( aTitle );
722 fd->setNameFilters( filters );
723 fd->selectNameFilter( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
724 if ( !anInitialPath.isEmpty() )
725 fd->setDirectory( anInitialPath );
726 fd->selectFile(aMeshName);
730 aFilename = fd->selectedFile();
731 aIsASCII_STL = (aFilterMap[fd->selectedNameFilter()]) == 1 ? true: false;
736 else if ( isMED || isSAUV ) // Export to MED or SAUV
738 int defaultVersion = 0;
739 QMap<QString, int> aFilterMap;
741 //filters << QObject::tr( "MED_FILES_FILTER" ) + " (*.med)";
742 //QString vmed (aMesh->GetVersionString(-1, 2));
743 SMESH::long_array_var mvok = aMesh->GetMEDVersionsCompatibleForAppend();
744 if ( mvok->length() > 0)
745 defaultVersion = mvok[0]; // the current version to set the default filter on it
746 for ( CORBA::ULong i = 0; i < mvok->length(); ++i )
748 QString vs = (char*)( SMESH_Comment( mvok[i]/10 ) << "." << mvok[i]%10 );
749 MESSAGE("MED version: " << vs.toStdString());
750 aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( vs ) + " (*.med)", mvok[i]);
754 aFilterMap.insert("All files (*)", -1 );
755 aFilterMap.insert("SAUV files (*.sauv)", defaultVersion ); // 0 = default filter (defaultVersion)
756 aFilterMap.insert("SAUV files (*.sauve)", -1 );
759 QMap<QString, int>::const_iterator it = aFilterMap.begin();
760 QString aDefaultFilter = it.key();
761 for ( ; it != aFilterMap.end(); ++it ) {
762 filters.push_back( it.key() );
763 if (it.value() == defaultVersion) // explicit default for MED = current MED version
764 aDefaultFilter = it.key();
766 QStringList checkBoxes;
767 checkBoxes << QObject::tr("SMESH_AUTO_GROUPS") << QObject::tr("SMESH_AUTO_DIM");
769 SMESHGUI_FieldSelectorWdg* fieldSelWdg = new SMESHGUI_FieldSelectorWdg();
770 QList< QWidget* > wdgList;
771 if ( fieldSelWdg->GetAllFields( aMeshList, aFieldList ))
772 wdgList.append( fieldSelWdg );
774 QWidget* zTolWdg = new QWidget();
775 QCheckBox* zTolCheck = new QCheckBox( QObject::tr( "SMESH_ZTOLERANCE" ), zTolWdg );
776 SMESHGUI_SpinBox* zTolSpin = new SMESHGUI_SpinBox( zTolWdg );
777 QHBoxLayout* zTolLayout = new QHBoxLayout( zTolWdg );
778 zTolLayout->addWidget( zTolCheck );
779 zTolLayout->addWidget( zTolSpin );
780 zTolLayout->setMargin( 0 );
781 zTolSpin->RangeStepAndValidator( 0, 1e+100, 1., "length_precision" );
782 zTolSpin->setValue( zTol );
783 QObject::connect( zTolCheck, SIGNAL( toggled(bool)), zTolSpin, SLOT( setEnabled(bool)));
784 zTolCheck->setChecked( resMgr->booleanValue( "SMESH", "enable_ztolerance", false ));
785 zTolSpin ->setEnabled( zTolCheck->isChecked() );
786 wdgList.append( zTolWdg );
788 SalomeApp_CheckFileDlg* fd =
789 new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true, wdgList );
790 fd->setWindowTitle( aTitle );
791 fd->setNameFilters( filters );
792 fd->selectNameFilter( aDefaultFilter );
793 fd->SetChecked( toCreateGroups, 0 );
794 fd->SetChecked( toFindOutDim, 1 );
795 if ( !anInitialPath.isEmpty() )
796 fd->setDirectory( anInitialPath );
797 fd->selectFile(aMeshName);
800 QListView *lview = fd->findChild<QListView*>("listView");
802 lview->setMinimumHeight(200);
804 QTreeView *tview = fd->findChild<QTreeView*>("treeView");
806 tview->setMinimumHeight(200);
809 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
810 fd->setValidator( fv );
815 //MESSAGE("******* Loop on file dialog ***********");
818 aFilename = fd->selectedFile();
820 aFilename = QString::null;
823 aFormat = aFilterMap[fd->selectedNameFilter()];
824 //MESSAGE("selected version: " << aFormat << " file: " << aFilename.toUtf8().constData());
825 toOverwrite = fv->isOverwrite(aFilename);
826 //MESSAGE("toOverwrite:" << toOverwrite);
828 if ( !aFilename.isEmpty() ) {
830 // append is only possible if the existing file format is compatible
831 bool isVersionOk = SMESHGUI::GetSMESHGen()->CheckWriteCompatibility( aFilename.toUtf8().constData() );
832 MESSAGE("Append check, isVersionOk:" << isVersionOk);
833 if ( !isVersionOk ) {
834 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
835 QObject::tr("SMESH_WRN_WARNING"),
836 QObject::tr("SMESH_EXPORT_MED_VERSION_COLLISION").arg(aFilename),
837 QObject::tr("SMESH_BUT_YES"),
838 QObject::tr("SMESH_BUT_NO"), 0, 1);
842 //MESSAGE("incompatible MED file version for add, overwrite accepted");
848 //MESSAGE("incompatible MED file version for add, overwrite refused");
851 QStringList aMeshNamesCollisionList;
852 SMESH::string_array_var aMeshNames = SMESHGUI::GetSMESHGen()->GetMeshNames( aFilename.toUtf8().constData() );
853 for( int i = 0, n = aMeshNames->length(); i < n; i++ ) {
854 QString anExistingMeshName( aMeshNames[ i ] );
855 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
856 QString anExportMeshName = (*aMeshIter).second;
857 if( anExportMeshName == anExistingMeshName ) {
858 aMeshNamesCollisionList.append( anExportMeshName );
863 if( !aMeshNamesCollisionList.isEmpty() ) {
865 QString aMeshNamesCollisionString = aMeshNamesCollisionList.join( ", " );
866 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
867 QObject::tr("SMESH_WRN_WARNING"),
868 QObject::tr("SMESH_EXPORT_MED_MESH_NAMES_COLLISION").arg(aMeshNamesCollisionString),
869 QObject::tr("SMESH_BUT_YES"),
870 QObject::tr("SMESH_BUT_NO"),
871 QObject::tr("SMESH_BUT_CANCEL"), 0, 2);
872 MESSAGE("answer collision name " << aRet);
883 toCreateGroups = fd->IsChecked(0);
884 toFindOutDim = fd->IsChecked(1);
885 zTol = zTolCheck->isChecked() ? zTolSpin->value() : -1;
886 fieldSelWdg->GetSelectedFields();
887 if ( resMgr ) resMgr->setValue( "SMESH", "enable_ztolerance", zTolCheck->isChecked() );
889 if ( !fieldSelWdg->parent() )
891 if ( !zTolWdg->parent() )
902 if ( !aFilename.isEmpty() ) {
903 // Check whether the file already exists and delete it if yes
904 QFile aFile( aFilename );
905 if ( aFile.exists() && toOverwrite )
907 SUIT_OverrideCursor wc;
910 // Renumbering is not needed since SMDS redesign in V6.2.0 (Nov 2010)
911 // bool Renumber = false;
912 // // PAL 14172 : Check of we have to renumber or not from the preferences before export
914 // Renumber= resMgr->booleanValue("renumbering");
916 // SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
917 // aMeshEditor->RenumberNodes();
918 // aMeshEditor->RenumberElements();
919 // if ( SMESHGUI::automaticUpdate() )
920 // SMESH::UpdateView();
922 if ( isMED && isOkToWrite)
924 MESSAGE("OK to write MED file "<< aFilename.toUtf8().constData());
925 aMeshIter = aMeshList.begin();
926 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
928 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
929 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
930 const GEOM::ListOfFields& fields = aFieldList[ aMeshIndex ].first.in();
931 const QString& geoAssFields = aFieldList[ aMeshIndex ].second;
932 const bool hasFields = ( fields.length() || !geoAssFields.isEmpty() );
933 if ( !hasFields && aMeshOrGroup->_is_equivalent( aMeshItem ) && zTol < 0 )
934 aMeshItem->ExportMED( aFilename.toUtf8().data(), toCreateGroups, aFormat,
935 toOverwrite && aMeshIndex == 0, toFindOutDim );
937 aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toUtf8().data(),
938 toCreateGroups, aFormat,
939 toOverwrite && aMeshIndex == 0, toFindOutDim,
940 fields, geoAssFields.toLatin1().data(), zTol );
945 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ )
947 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
948 if( !aMeshItem->_is_nil() )
949 aMeshItem->ExportSAUV( aFilename.toUtf8().data(), toCreateGroups );
954 if ( aMeshOrGroup->_is_equivalent( aMesh ))
955 aMesh->ExportDAT( aFilename.toUtf8().data() );
957 aMesh->ExportPartToDAT( aMeshOrGroup, aFilename.toUtf8().data() );
961 if ( aMeshOrGroup->_is_equivalent( aMesh ))
962 aMesh->ExportUNV( aFilename.toUtf8().data() );
964 aMesh->ExportPartToUNV( aMeshOrGroup, aFilename.toUtf8().data() );
968 if ( aMeshOrGroup->_is_equivalent( aMesh ))
969 aMesh->ExportSTL( aFilename.toUtf8().data(), aIsASCII_STL );
971 aMesh->ExportPartToSTL( aMeshOrGroup, aFilename.toUtf8().data(), aIsASCII_STL );
975 aMeshIter = aMeshList.begin();
976 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
978 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
979 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
980 aMeshItem->ExportCGNS( aMeshOrGroup,
981 aFilename.toUtf8().data(),
982 toOverwrite && aMeshIndex == 0,
988 toCreateGroups = true;
989 aMesh->ExportGMF( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups );
992 catch (const SALOME::SALOME_Exception& S_ex){
994 SUIT_MessageBox::warning(SMESHGUI::desktop(),
995 QObject::tr("SMESH_WRN_WARNING"),
996 QObject::tr("SMESH_EXPORT_FAILED") + SalomeApp_Tools::ExceptionToString(S_ex));
1002 inline void InverseEntityMode(unsigned int& theOutputMode,
1003 unsigned int theMode)
1005 bool anIsNotPresent = ~theOutputMode & theMode;
1007 theOutputMode |= theMode;
1009 theOutputMode &= ~theMode;
1012 void SetDisplayEntity(int theCommandID)
1014 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1015 SALOME_ListIO selected;
1017 aSel->selectedObjects( selected );
1019 if ( selected.Extent() >= 1 ) {
1020 SUIT_OverrideCursor wc;
1021 SALOME_ListIteratorOfListIO It( selected );
1022 for( ; It.More(); It.Next()){
1023 Handle(SALOME_InteractiveObject) IObject = It.Value();
1024 if(IObject->hasEntry()){
1025 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1026 unsigned int aMode = anActor->GetEntityMode();
1027 switch(theCommandID){
1028 case SMESHOp::OpDE0DElements: InverseEntityMode(aMode,SMESH_Actor::e0DElements); break;
1029 case SMESHOp::OpDEEdges: InverseEntityMode(aMode,SMESH_Actor::eEdges); break;
1030 case SMESHOp::OpDEFaces: InverseEntityMode(aMode,SMESH_Actor::eFaces); break;
1031 case SMESHOp::OpDEVolumes: InverseEntityMode(aMode,SMESH_Actor::eVolumes); break;
1032 case SMESHOp::OpDEBalls: InverseEntityMode(aMode,SMESH_Actor::eBallElem); break;
1033 case SMESHOp::OpDEAllEntity: aMode = SMESH_Actor::eAllEntity; break;
1036 anActor->SetEntityMode(aMode);
1045 SalomeApp_Application* app =
1046 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1050 LightApp_SelectionMgr* aSel = app->selectionMgr();
1051 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1052 if ( !aSel || !appStudy )
1055 SALOME_ListIO selected;
1056 aSel->selectedObjects( selected );
1057 if ( selected.IsEmpty() )
1060 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1062 _PTR(Study) aStudy = appStudy->studyDS();
1063 _PTR(SObject) aMainSObject = aStudy->FindObjectID( anIObject->getEntry() );
1064 SMESH::SMESH_Mesh_var aMainObject = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1065 if ( aMainObject->_is_nil() )
1068 SUIT_OverrideCursor wc;
1070 aMainObject->SetAutoColor( true ); // mesh groups are re-colored here
1072 QList<SALOMEDS::Color> aReservedColors;
1074 SMESH::ListOfGroups aListOfGroups = *aMainObject->GetGroups();
1075 for ( int i = 0, n = aListOfGroups.length(); i < n; i++ )
1077 SMESH::SMESH_GroupBase_var aGroupObject = aListOfGroups[i];
1079 #ifdef SIMPLE_AUTOCOLOR // simplified algorithm for auto-colors
1080 SALOMEDS::Color aColor = SMESHGUI::getPredefinedUniqueColor();
1081 #else // old algorithm for auto-colors
1082 SALOMEDS::Color aColor = SMESHGUI::getUniqueColor( aReservedColors );
1083 aReservedColors.append( aColor );
1084 #endif // SIMPLE_AUTOCOLOR
1085 aGroupObject->SetColor( aColor );
1087 _PTR(SObject) aGroupSObject = SMESH::FindSObject(aGroupObject);
1088 if ( aGroupSObject ) {
1091 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry(aGroupSObject->GetID().c_str())) {
1092 switch ( aGroupObject->GetType ()) {
1094 anActor->SetNodeColor( aColor.R, aColor.G, aColor.B ); break;
1096 anActor->SetEdgeColor( aColor.R, aColor.G, aColor.B ); break;
1098 anActor->Set0DColor( aColor.R, aColor.G, aColor.B ); break;
1100 anActor->SetBallColor( aColor.R, aColor.G, aColor.B ); break;
1102 SMESH::GetColor("SMESH", "volume_color", c, delta, "255,0,170|-100");
1103 anActor->SetVolumeColor( aColor.R, aColor.G, aColor.B, delta ); break;
1106 SMESH::GetColor("SMESH", "fill_color", c, delta, "0,170,255|-100");
1107 anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B, delta );
1113 SMESH::RepaintCurrentView();
1116 void OverallMeshQuality()
1118 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1119 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1120 SALOME_ListIO selected;
1122 aSel->selectedObjects( selected );
1124 if ( selected.IsEmpty() ) return;
1125 SALOME_ListIteratorOfListIO It( selected );
1126 for ( ; It.More(); It.Next() ) {
1127 SMESHGUI_CtrlInfoDlg* ctrlDlg = new SMESHGUI_CtrlInfoDlg( SMESHGUI::desktop() );
1128 ctrlDlg->showInfo( It.Value() );
1133 QString functorToString( SMESH::Controls::FunctorPtr f )
1135 QString type = QObject::tr( "UNKNOWN_CONTROL" );
1136 if ( dynamic_cast< SMESH::Controls::Volume* >( f.get() ) )
1137 type = QObject::tr( "VOLUME_3D_ELEMENTS" );
1138 else if ( dynamic_cast< SMESH::Controls::MaxElementLength2D* >( f.get() ) )
1139 type = QObject::tr( "MAX_ELEMENT_LENGTH_2D" );
1140 else if ( dynamic_cast< SMESH::Controls::MaxElementLength3D* >( f.get() ) )
1141 type = QObject::tr( "MAX_ELEMENT_LENGTH_3D" );
1142 else if ( dynamic_cast< SMESH::Controls::MinimumAngle* >( f.get() ) )
1143 type = QObject::tr( "MINIMUMANGLE_ELEMENTS" );
1144 else if ( dynamic_cast< SMESH::Controls::AspectRatio* >( f.get() ) )
1145 type = QObject::tr( "ASPECTRATIO_ELEMENTS" );
1146 else if ( dynamic_cast< SMESH::Controls::AspectRatio3D* >( f.get() ) )
1147 type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" );
1148 else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) )
1149 type = QObject::tr( "WARP_ELEMENTS" );
1150 else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) )
1151 type = QObject::tr( "TAPER_ELEMENTS" );
1152 else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) )
1153 type = QObject::tr( "SKEW_ELEMENTS" );
1154 else if ( dynamic_cast< SMESH::Controls::Area* >( f.get() ) )
1155 type = QObject::tr( "AREA_ELEMENTS" );
1156 else if ( dynamic_cast< SMESH::Controls::Length* >( f.get() ) )
1157 type = QObject::tr( "LENGTH_EDGES" );
1158 else if ( dynamic_cast< SMESH::Controls::Length2D* >( f.get() ) )
1159 type = QObject::tr( "LENGTH2D_EDGES" );
1160 else if ( dynamic_cast< SMESH::Controls::Deflection2D* >( f.get() ) )
1161 type = QObject::tr( "DEFLECTION2D_FACES" );
1162 else if ( dynamic_cast< SMESH::Controls::MultiConnection* >( f.get() ) )
1163 type = QObject::tr( "MULTI_BORDERS" );
1164 else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) )
1165 type = QObject::tr( "MULTI2D_BORDERS" );
1166 else if ( dynamic_cast< SMESH::Controls::FreeNodes* >( f.get() ) )
1167 type = QObject::tr( "FREE_NODES" );
1168 else if ( dynamic_cast< SMESH::Controls::FreeEdges* >( f.get() ) )
1169 type = QObject::tr( "FREE_EDGES" );
1170 else if ( dynamic_cast< SMESH::Controls::FreeBorders* >( f.get() ) )
1171 type = QObject::tr( "FREE_BORDERS" );
1172 else if ( dynamic_cast< SMESH::Controls::FreeFaces* >( f.get() ) )
1173 type = QObject::tr( "FREE_FACES" );
1174 else if ( dynamic_cast< SMESH::Controls::BareBorderVolume* >( f.get() ) )
1175 type = QObject::tr( "BARE_BORDER_VOLUME" );
1176 else if ( dynamic_cast< SMESH::Controls::BareBorderFace* >( f.get() ) )
1177 type = QObject::tr( "BARE_BORDER_FACE" );
1178 else if ( dynamic_cast< SMESH::Controls::OverConstrainedVolume* >( f.get() ) )
1179 type = QObject::tr( "OVER_CONSTRAINED_VOLUME" );
1180 else if ( dynamic_cast< SMESH::Controls::OverConstrainedFace* >( f.get() ) )
1181 type = QObject::tr( "OVER_CONSTRAINED_FACE" );
1182 else if ( dynamic_cast< SMESH::Controls::CoincidentNodes* >( f.get() ) )
1183 type = QObject::tr( "EQUAL_NODE" );
1184 else if ( dynamic_cast< SMESH::Controls::CoincidentElements1D* >( f.get() ) )
1185 type = QObject::tr( "EQUAL_EDGE" );
1186 else if ( dynamic_cast< SMESH::Controls::CoincidentElements2D* >( f.get() ) )
1187 type = QObject::tr( "EQUAL_FACE" );
1188 else if ( dynamic_cast< SMESH::Controls::CoincidentElements3D* >( f.get() ) )
1189 type = QObject::tr( "EQUAL_VOLUME" );
1190 else if ( dynamic_cast< SMESH::Controls::NodeConnectivityNumber* >( f.get() ) )
1191 type = QObject::tr( "NODE_CONNECTIVITY_NB" );
1195 void SaveDistribution()
1197 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1198 SALOME_ListIO selected;
1200 aSel->selectedObjects( selected );
1202 if ( selected.Extent() == 1 ) {
1203 Handle(SALOME_InteractiveObject) anIO = selected.First();
1204 if ( anIO->hasEntry() ) {
1205 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1207 anActor->GetScalarBarActor() &&
1208 anActor->GetControlMode() != SMESH_Actor::eNone )
1210 SMESH_ScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor();
1211 SMESH::Controls::FunctorPtr aFunctor = anActor->GetFunctor();
1212 if ( aScalarBarActor && aFunctor ) {
1213 SMESH::Controls::NumericalFunctor* aNumFun =
1214 dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
1216 std::vector<int> elements;
1217 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
1218 if ( mesh->_is_nil() ) {
1219 SMESH::SMESH_IDSource_var idSource =
1220 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
1221 if ( !idSource->_is_nil() )
1223 SMESH::long_array_var ids = idSource->GetIDs();
1224 elements.resize( ids->length() );
1225 for ( unsigned i = 0; i < elements.size(); ++i )
1226 elements[i] = ids[i];
1229 int nbIntervals = aScalarBarActor->GetMaximumNumberOfColors();
1230 vtkLookupTable* lookupTable =
1231 static_cast<vtkLookupTable*>(aScalarBarActor->GetLookupTable());
1232 double * minmax = lookupTable->GetRange();
1233 bool isLogarithmic = lookupTable->GetScale() == VTK_SCALE_LOG10;
1234 std::vector<int> nbEvents;
1235 std::vector<double> funValues;
1236 aNumFun->GetHistogram( nbIntervals, nbEvents, funValues,
1237 elements, minmax, isLogarithmic );
1238 QString anInitialPath = "";
1239 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
1240 anInitialPath = QDir::currentPath();
1241 QString aMeshName = anIO->getName();
1243 filter.append( QObject::tr( "TEXT_FILES_FILTER" ) + " (*.txt)" );
1244 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
1245 QString aFilename = anInitialPath + "/" + aMeshName + "_" +
1246 functorToString( aFunctor ).toLower().simplified().replace( QRegExp( " |-" ), "_" ) + ".txt";
1247 aFilename = SUIT_FileDlg::getFileName( SMESHGUI::desktop(),
1250 QObject::tr( "SMESH_SAVE_DISTRIBUTION" ),
1252 if ( !aFilename.isEmpty() ) {
1253 QFile f( aFilename );
1254 if ( f.open( QFile::WriteOnly | QFile::Truncate ) ) {
1255 QTextStream out( &f );
1256 out << "# Mesh: " << aMeshName << endl;
1257 out << "# Control: " << functorToString( aFunctor ) << endl;
1259 out.setFieldWidth( 10 );
1260 for ( int i = 0; i < (int)qMin( nbEvents.size(), funValues.size()-1 ); i++ )
1261 out << funValues[i] << "\t" << funValues[i+1] << "\t" << nbEvents[i] << endl;
1272 void ShowElement( int theCommandID )
1274 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1275 SALOME_ListIO selected;
1277 aSel->selectedObjects( selected );
1279 if ( selected.Extent() == 1 ) {
1280 Handle(SALOME_InteractiveObject) anIO = selected.First();
1281 if ( anIO->hasEntry() ) {
1282 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1284 anActor->GetScalarBarActor() &&
1285 anActor->GetControlMode() != SMESH_Actor::eNone )
1287 SMESH_ScalarBarActor *aScalarBarActor = anActor->GetScalarBarActor();
1288 if ( theCommandID == SMESHOp::OpShowDistribution ) {
1289 aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility());
1291 else if ( theCommandID == SMESHOp::OpShowScalarBar ) {
1292 aScalarBarActor->SetVisibility( !aScalarBarActor->GetVisibility());
1299 #ifndef DISABLE_PLOT2DVIEWER
1300 void PlotDistribution()
1302 SalomeApp_Application* app =
1303 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1307 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1308 SALOME_ListIO selected;
1310 aSel->selectedObjects( selected );
1312 if ( selected.Extent() == 1 ) {
1313 Handle(SALOME_InteractiveObject) anIO = selected.First();
1314 if ( anIO->hasEntry() ) {
1315 //Find Actor by entry before getting Plot2d viewer,
1316 //because after call getViewManager( Plot2d_Viewer::Type(), true ) active window is Plot2d Viewer
1317 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1319 SUIT_ViewManager* aViewManager =
1320 app->getViewManager( Plot2d_Viewer::Type(), true ); // create if necessary
1324 SPlot2d_Viewer* aView = dynamic_cast<SPlot2d_Viewer*>(aViewManager->getViewModel());
1328 Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
1332 if ( anActor && anActor->GetControlMode() != SMESH_Actor::eNone )
1334 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1335 QString functorName = functorToString( anActor->GetFunctor());
1336 QString aHistogramName("%1 : %2");
1337 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1338 aHistogram->setName(aHistogramName);
1339 aHistogram->setHorTitle(functorName);
1340 aHistogram->setVerTitle(QObject::tr("DISTRIBUTION_NB_ENT"));
1341 aPlot->displayObject(aHistogram, true);
1346 #endif //DISABLE_PLOT2DVIEWER
1348 void DisableAutoColor()
1350 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1351 SALOME_ListIO selected;
1353 aSel->selectedObjects( selected );
1355 if ( selected.Extent() ) {
1356 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1357 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1358 if ( !aMesh->_is_nil() ) {
1359 aMesh->SetAutoColor( false );
1366 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1367 SALOME_ListIO selected;
1369 aSel->selectedObjects( selected );
1370 if ( selected.Extent() )
1372 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1373 _PTR(Study) aStudy = SMESH::getStudy();
1374 _PTR(SObject) aSObj = aStudy->FindObjectID(anIObject->getEntry());
1376 if ( aStudy->GetUseCaseBuilder()->SortChildren( aSObj, true/*AscendingOrder*/ ) ) {
1377 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1384 void SetDisplayMode(int theCommandID, VTK::MarkerMap& theMarkerMap)
1386 SALOME_ListIO selected;
1387 SalomeApp_Application* app =
1388 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1392 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1393 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1394 if ( !aSel || !appStudy )
1397 if ( theCommandID == SMESHOp::OpClipping ) { // Clipping dialog can be activated without selection
1398 if ( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
1399 aModule->EmitSignalDeactivateDialog();
1400 if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
1401 (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
1406 aSel->selectedObjects( selected );
1408 if ( selected.Extent() >= 1 )
1410 switch ( theCommandID ) {
1411 case SMESHOp::OpTransparency:
1413 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1414 (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
1417 case SMESHOp::OpProperties:
1420 QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
1421 QColor orientationColor, outlineColor, volumeColor;
1422 int deltaF = 0, deltaV = 0;
1425 double ballScale = 1.0;
1427 int outlineWidth = 1;
1428 double shrinkCoef = 0.0;
1429 double orientationScale = 0.0;
1430 bool orientation3d = false;
1431 VTK::MarkerType markerType = VTK::MT_NONE;
1432 VTK::MarkerScale markerScale = VTK::MS_NONE;
1434 bool hasNodes = false;
1435 int presentEntities = 0;
1436 bool firstTime = true;
1438 SALOME_ListIteratorOfListIO It( selected );
1439 for ( ; It.More(); It.Next() ) {
1440 Handle(SALOME_InteractiveObject) IObject = It.Value();
1441 if ( !IObject->hasEntry() ) continue;
1442 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1443 if ( !anActor || !anActor->GetObject() ) continue;
1446 // nodes: color, marker
1447 anActor->GetNodeColor( color[0], color[1], color[2] );
1448 nodeColor.setRgbF( color[0], color[1], color[2] );
1449 markerType = anActor->GetMarkerType();
1450 markerScale = anActor->GetMarkerScale();
1451 markerId = anActor->GetMarkerTexture();
1452 // edges: color, width
1453 anActor->GetEdgeColor( color[0], color[1], color[2] );
1454 edgeColor.setRgbF( color[0], color[1], color[2] );
1455 edgeWidth = qMax( (int)anActor->GetLineWidth(), 1 ); // minimum allowed width is 1
1456 // faces: front color, back color (delta)
1457 anActor->GetSufaceColor( color[0], color[1], color[2], deltaF );
1458 faceColor.setRgbF( color[0], color[1], color[2] );
1459 // faces: front color, back color (delta)
1460 anActor->GetVolumeColor( color[0], color[1], color[2], deltaV );
1461 volumeColor.setRgbF( color[0], color[1], color[2] );
1462 // 0d elements: color, size
1463 anActor->Get0DColor( color[0], color[1], color[2] );
1464 elem0dColor.setRgbF( color[0], color[1], color[2] );
1465 elem0dSize = qMax( (int)anActor->Get0DSize(), 1 ); // minimum allowed size is 1
1466 // balls: color, size
1467 anActor->GetBallColor( color[0], color[1], color[2] );
1468 ballColor.setRgbF( color[0], color[1], color[2] );
1469 //ballSize = qMax( (int)anActor->GetBallSize(), 1 ); // minimum allowed size is 1
1470 ballScale = qMax( (double)anActor->GetBallScale(), 1e-2 ); // minimum allowed scale is 1e-2
1472 anActor->GetOutlineColor( color[0], color[1], color[2] );
1473 outlineColor.setRgbF( color[0], color[1], color[2] );
1474 outlineWidth = qMax( (int)anActor->GetOutlineWidth(), 1 ); // minimum allowed width is 1
1475 // orientation vectors: color, scale, 3d flag
1476 anActor->GetFacesOrientationColor( color[0], color[1], color[2] );
1477 orientationColor.setRgbF( color[0], color[1], color[2] );
1478 orientationScale = anActor->GetFacesOrientationScale();
1479 orientation3d = anActor->GetFacesOrientation3DVectors();
1481 shrinkCoef = anActor->GetShrinkFactor();
1484 firstTime = false; // we only take properties from first object (for performance reasons)
1487 hasNodes = anActor->GetObject()->GetNbEntities( SMDSAbs_Node );
1488 if ( !(presentEntities & SMESH_Actor::eEdges) && anActor->GetObject()->GetNbEntities( SMDSAbs_Edge ) )
1489 presentEntities = presentEntities | SMESH_Actor::eEdges;
1490 if ( !(presentEntities & SMESH_Actor::eFaces) && anActor->GetObject()->GetNbEntities( SMDSAbs_Face ) )
1491 presentEntities = presentEntities | SMESH_Actor::eFaces;
1492 if ( !(presentEntities & SMESH_Actor::eVolumes) && anActor->GetObject()->GetNbEntities( SMDSAbs_Volume ) )
1493 presentEntities = presentEntities | SMESH_Actor::eVolumes;
1494 if ( !(presentEntities & SMESH_Actor::e0DElements) && anActor->GetObject()->GetNbEntities( SMDSAbs_0DElement ) )
1495 presentEntities = presentEntities | SMESH_Actor::e0DElements;
1496 if ( !(presentEntities & SMESH_Actor::eBallElem) && anActor->GetObject()->GetNbEntities( SMDSAbs_Ball ) )
1497 presentEntities = presentEntities | SMESH_Actor::eBallElem;
1499 // as we know that all types of elements are present, we can exit the loop
1500 if ( presentEntities == SMESH_Actor::eAllEntity )
1504 SMESHGUI_PropertiesDlg dlg( theMarkerMap, SMESHGUI::desktop() );
1505 // nodes: color, marker
1506 dlg.setNodeColor( nodeColor );
1507 if( markerType != VTK::MT_USER )
1508 dlg.setNodeMarker( markerType, markerScale );
1510 dlg.setNodeCustomMarker( markerId );
1511 // edges: color, line width
1512 dlg.setEdgeColor( edgeColor );
1513 dlg.setEdgeWidth( edgeWidth );
1514 // faces: front color, back color
1515 dlg.setFaceColor( faceColor, deltaF );
1516 // volumes: normal color, reversed color
1517 dlg.setVolumeColor( volumeColor, deltaV );
1518 // outlines: color, line width
1519 dlg.setOutlineColor( outlineColor );
1520 dlg.setOutlineWidth( outlineWidth );
1521 // 0d elements: color, size
1522 dlg.setElem0dColor( elem0dColor );
1523 dlg.setElem0dSize( elem0dSize );
1524 // balls: color, size
1525 dlg.setBallColor( ballColor );
1526 //dlg.setBallSize( ballSize );
1527 dlg.setBallScale( ballScale );
1528 // orientation: color, scale, 3d flag
1529 dlg.setOrientationColor( orientationColor );
1530 dlg.setOrientationSize( int( orientationScale * 100. ) );
1531 dlg.setOrientation3d( orientation3d );
1532 // shrink: scale factor
1533 dlg.setShrinkCoef( int( shrinkCoef * 100. ) );
1534 // hide unused controls
1535 dlg.showControls( presentEntities, hasNodes );
1538 nodeColor = dlg.nodeColor();
1539 markerType = dlg.nodeMarkerType();
1540 markerScale = dlg.nodeMarkerScale();
1541 markerId = dlg.nodeMarkerId();
1542 edgeColor = dlg.edgeColor();
1543 edgeWidth = dlg.edgeWidth();
1544 faceColor = dlg.faceColor();
1545 deltaF = dlg.faceColorDelta();
1546 volumeColor = dlg.volumeColor();
1547 deltaV = dlg.volumeColorDelta();
1548 outlineColor = dlg.outlineColor();
1549 outlineWidth = dlg.outlineWidth();
1550 elem0dColor = dlg.elem0dColor();
1551 elem0dSize = dlg.elem0dSize();
1552 ballColor = dlg.ballColor();
1553 // ballSize = dlg.ballSize();
1554 ballScale = dlg.ballScale();
1555 orientationColor = dlg.orientationColor();
1556 orientationScale = dlg.orientationSize() / 100.;
1557 orientation3d = dlg.orientation3d();
1558 shrinkCoef = dlg.shrinkCoef() / 100.;
1560 // store point markers that might be changed by the user
1561 theMarkerMap = dlg.customMarkers();
1563 // set properties from dialog box to the presentations
1564 SALOME_ListIteratorOfListIO It( selected );
1565 for ( ; It.More(); It.Next() ) {
1566 Handle(SALOME_InteractiveObject) IObject = It.Value();
1567 if ( !IObject->hasEntry() ) continue;
1568 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1569 if ( !anActor ) continue;
1571 // nodes: color, marker
1572 anActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
1573 if ( markerType != VTK::MT_USER ) {
1574 anActor->SetMarkerStd( markerType, markerScale );
1577 VTK::MarkerMap::const_iterator iter = theMarkerMap.find( markerId );
1578 if ( iter != theMarkerMap.end() )
1579 anActor->SetMarkerTexture( markerId, iter->second.second );
1581 // volumes: normal color, reversed color (delta)
1582 anActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
1583 // faces: front color, back color (delta)
1584 anActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
1585 // edges: color, width
1586 anActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
1587 anActor->SetLineWidth( edgeWidth );
1589 anActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
1590 anActor->SetOutlineWidth( outlineWidth );
1591 // 0D elements: color, size
1592 anActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
1593 anActor->Set0DSize( elem0dSize );
1594 // balls: color, size
1595 anActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
1596 // anActor->SetBallSize( ballSize );
1597 anActor->SetBallScale( ballScale );
1598 // orientation: color, scale, 3d flag
1599 anActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
1600 anActor->SetFacesOrientationScale( orientationScale );
1601 anActor->SetFacesOrientation3DVectors( orientation3d );
1603 anActor->SetShrinkFactor( shrinkCoef );
1605 // for groups, set also proper color
1606 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1607 if ( !aGroupObject->_is_nil() ) {
1608 SMESH::ElementType anElementType = aGroupObject->GetType();
1610 switch( anElementType ) {
1612 aColor = nodeColor; break;
1614 aColor = edgeColor; break;
1616 aColor = faceColor; break;
1618 aColor = volumeColor; break;
1620 aColor = elem0dColor; break;
1622 aColor = ballColor; break;
1626 if ( aColor.isValid() ) {
1627 SALOMEDS::Color aGroupColor;
1628 aGroupColor.R = aColor.redF();
1629 aGroupColor.G = aColor.greenF();
1630 aGroupColor.B = aColor.blueF();
1631 aGroupObject->SetColor( aGroupColor );
1633 } // if ( !aGroupObject->_is_nil() )
1634 } // for ( ; It.More(); It.Next() )
1635 SMESH::RepaintCurrentView();
1636 } // if ( dlg.exec() )
1638 } // case SMESHOp::OpProperties:
1639 } // switch(theCommandID)
1640 SUIT_OverrideCursor wc;
1641 SALOME_ListIteratorOfListIO It( selected );
1642 for( ; It.More(); It.Next()){
1643 Handle(SALOME_InteractiveObject) IObject = It.Value();
1644 if(IObject->hasEntry()){
1645 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1646 switch(theCommandID){
1647 case SMESHOp::OpDMWireframe:
1648 anActor->SetRepresentation(SMESH_Actor::eEdge);
1650 case SMESHOp::OpDMShading:
1651 anActor->SetRepresentation(SMESH_Actor::eSurface);
1653 case SMESHOp::OpDMShrink:
1654 if(anActor->IsShrunk())
1655 anActor->UnShrink();
1657 anActor->SetShrink();
1659 case SMESHOp::OpDMNodes:
1660 anActor->SetRepresentation(SMESH_Actor::ePoint);
1662 case SMESHOp::OpRepresentationLines:
1663 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1664 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1666 case SMESHOp::OpRepresentationArcs:
1667 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1668 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1674 SMESH::RepaintCurrentView();
1678 int ActionToControl( int theID, bool theReversed )
1680 NCollection_DoubleMap<int,int> ActionControl;
1681 ActionControl.Bind( 0, SMESH_Actor::eNone );
1682 ActionControl.Bind( SMESHOp::OpFreeNode, SMESH_Actor::eFreeNodes );
1683 ActionControl.Bind( SMESHOp::OpEqualNode, SMESH_Actor::eCoincidentNodes );
1684 ActionControl.Bind( SMESHOp::OpNodeConnectivityNb, SMESH_Actor::eNodeConnectivityNb );
1685 ActionControl.Bind( SMESHOp::OpFreeEdge, SMESH_Actor::eFreeEdges );
1686 ActionControl.Bind( SMESHOp::OpFreeBorder, SMESH_Actor::eFreeBorders );
1687 ActionControl.Bind( SMESHOp::OpLength, SMESH_Actor::eLength );
1688 ActionControl.Bind( SMESHOp::OpConnection, SMESH_Actor::eMultiConnection );
1689 ActionControl.Bind( SMESHOp::OpEqualEdge, SMESH_Actor::eCoincidentElems1D );
1690 ActionControl.Bind( SMESHOp::OpFreeFace, SMESH_Actor::eFreeFaces );
1691 ActionControl.Bind( SMESHOp::OpBareBorderFace, SMESH_Actor::eBareBorderFace );
1692 ActionControl.Bind( SMESHOp::OpOverConstrainedFace, SMESH_Actor::eOverConstrainedFace );
1693 ActionControl.Bind( SMESHOp::OpLength2D, SMESH_Actor::eLength2D );
1694 ActionControl.Bind( SMESHOp::OpDeflection2D, SMESH_Actor::eDeflection2D );
1695 ActionControl.Bind( SMESHOp::OpConnection2D, SMESH_Actor::eMultiConnection2D );
1696 ActionControl.Bind( SMESHOp::OpArea, SMESH_Actor::eArea );
1697 ActionControl.Bind( SMESHOp::OpTaper, SMESH_Actor::eTaper );
1698 ActionControl.Bind( SMESHOp::OpAspectRatio, SMESH_Actor::eAspectRatio );
1699 ActionControl.Bind( SMESHOp::OpMinimumAngle, SMESH_Actor::eMinimumAngle );
1700 ActionControl.Bind( SMESHOp::OpWarpingAngle, SMESH_Actor::eWarping );
1701 ActionControl.Bind( SMESHOp::OpSkew, SMESH_Actor::eSkew );
1702 ActionControl.Bind( SMESHOp::OpMaxElementLength2D, SMESH_Actor::eMaxElementLength2D );
1703 ActionControl.Bind( SMESHOp::OpEqualFace, SMESH_Actor::eCoincidentElems2D );
1704 ActionControl.Bind( SMESHOp::OpAspectRatio3D, SMESH_Actor::eAspectRatio3D );
1705 ActionControl.Bind( SMESHOp::OpVolume, SMESH_Actor::eVolume3D );
1706 ActionControl.Bind( SMESHOp::OpMaxElementLength3D, SMESH_Actor::eMaxElementLength3D );
1707 ActionControl.Bind( SMESHOp::OpBareBorderVolume, SMESH_Actor::eBareBorderVolume );
1708 ActionControl.Bind( SMESHOp::OpOverConstrainedVolume, SMESH_Actor::eOverConstrainedVolume );
1709 ActionControl.Bind( SMESHOp::OpEqualVolume, SMESH_Actor::eCoincidentElems3D );
1712 return ActionControl.IsBound2( theID ) ? ActionControl.Find2( theID ) : 0;
1713 return ActionControl.IsBound1( theID ) ? ActionControl.Find1( theID ) : 0;
1716 void Control( int theCommandID )
1718 SMESH_Actor::eControl aControl = SMESH_Actor::eControl( ActionToControl( theCommandID ));
1719 _PTR(Study) aStudy = SMESH::getStudy();
1721 SALOME_ListIO selected;
1722 if ( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
1723 aSel->selectedObjects( selected );
1725 if ( !selected.IsEmpty() ) {
1726 SALOME_ListIteratorOfListIO It(selected);
1727 for ( ; It.More(); It.Next())
1729 Handle(SALOME_InteractiveObject) anIO = It.Value();
1730 if ( !anIO.IsNull() ) {
1731 _PTR(SObject) SO = aStudy->FindObjectID( It.Value()->getEntry() );
1733 CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
1734 SMESH::SMESH_IDSource_var anIDSrc = SMESH::SMESH_IDSource::_narrow( aObject );
1735 if ( !anIDSrc->_is_nil() ) {
1736 SMESH_Actor *anActor = SMESH::FindActorByEntry( anIO->getEntry());
1737 if (( !anActor && selected.Extent() == 1 ) &&
1738 ( anActor = SMESH::CreateActor( anIO->getEntry() )))
1740 anActor->SetControlMode( aControl );
1741 SMESH::DisplayActor( SMESH::GetCurrentVtkView(), anActor );
1742 SMESH::UpdateView ( SMESH::eDisplay, anIO->getEntry() );
1746 if ( anActor->GetControlMode() != aControl )
1747 anActor->SetControlMode( aControl );
1748 QString functorName = functorToString( anActor->GetFunctor() );
1749 int anEntitiesCount = anActor->GetNumberControlEntities();
1750 if (anEntitiesCount >= 0)
1751 functorName = functorName + ": " + QString::number(anEntitiesCount);
1752 anActor->GetScalarBarActor()->SetTitle( functorName.toLatin1().constData() );
1753 SMESH::RepaintCurrentView();
1754 #ifndef DISABLE_PLOT2DVIEWER
1755 if ( anActor->GetPlot2Histogram() ) {
1756 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1757 QString aHistogramName("%1 : %2");
1758 aHistogramName = aHistogramName.arg( anIO->getName() ).arg( functorName );
1759 aHistogram->setName( aHistogramName );
1760 aHistogram->setHorTitle( functorName );
1761 SMESH::ProcessIn2DViewers( anActor );
1773 bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1774 SMESH::MeshObjectType theType,
1775 const QString theInTypeName,
1776 QString & theOutTypeName)
1778 SMESH_TypeFilter aTypeFilter( theType );
1780 if ( !theIO.IsNull() )
1782 entry = theIO->getEntry();
1783 LightApp_DataOwner owner( entry );
1784 if ( aTypeFilter.isOk( &owner )) {
1785 theOutTypeName = theInTypeName;
1793 QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1795 _PTR(Study) aStudy = SMESH::getStudy();
1796 _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1798 _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1799 CORBA::String_var anID = aSComp->GetID().c_str();
1800 if ( !strcmp(anID.in(),theIO->getEntry()) )
1806 CheckOIType ( theIO, SMESH::HYPOTHESIS, "Hypothesis", aTypeName ) ||
1807 CheckOIType ( theIO, SMESH::ALGORITHM, "Algorithm", aTypeName ) ||
1808 CheckOIType ( theIO, SMESH::MESH, "Mesh", aTypeName ) ||
1809 CheckOIType ( theIO, SMESH::SUBMESH, "SubMesh", aTypeName ) ||
1810 CheckOIType ( theIO, SMESH::GROUP, "Group", aTypeName )
1818 // QString CheckHomogeneousSelection()
1820 // LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1821 // SALOME_ListIO selected;
1823 // aSel->selectedObjects( selected );
1825 // QString RefType = CheckTypeObject(selected.First());
1826 // SALOME_ListIteratorOfListIO It(selected);
1827 // for ( ; It.More(); It.Next())
1829 // Handle(SALOME_InteractiveObject) IObject = It.Value();
1830 // QString Type = CheckTypeObject(IObject);
1831 // if ( Type.compare(RefType) != 0 )
1832 // return "Heterogeneous Selection";
1838 uint randomize( uint size )
1840 static bool initialized = false;
1841 if ( !initialized ) {
1842 qsrand( QDateTime::currentDateTime().toTime_t() );
1846 v = uint( (double)( v ) / RAND_MAX * size );
1847 v = qMax( uint(0), qMin ( v, size-1 ) );
1853 void SMESHGUI::OnEditDelete()
1855 // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1856 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1857 SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1859 _PTR(Study) aStudy = SMESH::getStudy();
1860 _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1861 _PTR(GenericAttribute) anAttr;
1862 _PTR(AttributeIOR) anIOR;
1864 const int objectCountLimit = 30; // PAL23599
1865 int objectCount = 0;
1867 QString aParentComponent = QString::null;
1869 for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1871 Handle(SALOME_InteractiveObject) anIO = anIt.Value();
1872 if ( anIO.IsNull() ) continue;
1874 QString father = "unknown", name;
1876 _PTR(SObject) aSO = aStudy->FindObjectID( anIO->getEntry() );
1878 father = QString::fromStdString( aSO->GetFatherComponent()->ComponentDataType() );
1879 // check if object is reference
1880 _PTR(SObject) aRefSObj;
1881 if ( aSO->ReferencedObject( aRefSObj ) ) {
1882 name = QString::fromStdString ( aRefSObj->GetName() );
1883 father = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1886 name = anIO->getName();
1889 if ( objectCount < objectCountLimit ) { // avoid occupying the whole screen
1890 aNameList.append("\n - ");
1891 aNameList.append( name );
1894 if( aParentComponent.isNull() )
1895 aParentComponent = father;
1896 else if( !aParentComponent.isEmpty() && aParentComponent!=father )
1897 aParentComponent = "";
1899 if ( objectCount >= objectCountLimit )
1900 aNameList.append("\n - ...");
1902 if ( objectCount == 0 )
1903 return; // No Valid Objects Selected
1905 if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
1906 SUIT_MessageBox::warning( SMESHGUI::desktop(),
1907 QObject::tr("ERR_ERROR"),
1908 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
1911 // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
1912 if (SUIT_MessageBox::warning
1913 (SMESHGUI::desktop(),
1914 QObject::tr("SMESH_WRN_WARNING"),
1915 QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
1916 SUIT_MessageBox::Yes | SUIT_MessageBox::No,
1917 SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
1920 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1922 // Put the whole hierarchy of sub-objects of the selected SO's into a list and
1923 // then treat them all starting from the deepest objects (at list back)
1924 std::list< _PTR(SObject) > listSO;
1925 SALOME_ListIteratorOfListIO It(selected);
1926 for( ; It.More(); It.Next()) // loop on selected IO's
1928 Handle(SALOME_InteractiveObject) IObject = It.Value();
1929 if(IObject->hasEntry()) {
1930 _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
1932 // disable removal of "SMESH" component object
1933 if(aSO->FindAttribute(anAttr, "AttributeIOR")){
1935 if ( engineIOR() == anIOR->Value().c_str() )
1938 //Check the referenced object
1939 _PTR(SObject) aRefSObject;
1940 if ( aSO && aSO->ReferencedObject( aRefSObject ) )
1941 aSO = aRefSObject; // Delete main Object instead of reference
1943 listSO.push_back( aSO );
1944 std::list< _PTR(SObject) >::iterator itSO = --listSO.end();
1945 for ( ; itSO != listSO.end(); ++itSO ) {
1946 _PTR(ChildIterator) it = aStudy->NewChildIterator( *itSO );
1947 for (it->InitEx(false); it->More(); it->Next())
1948 listSO.push_back( it->Value() );
1952 // Check if none of objects to delete is referred from outside
1953 std::list< _PTR(SObject) >::reverse_iterator ritSO;
1954 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1956 _PTR(SObject) SO = *ritSO;
1957 if ( !SO ) continue;
1958 std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( *ritSO );
1959 for (size_t i = 0; i < aReferences.size(); i++) {
1960 _PTR(SComponent) aComponent = aReferences[i]->GetFatherComponent();
1961 std::string type = aComponent->ComponentDataType();
1962 if ( type != "SMESH" )
1964 SUIT_MessageBox::warning( anApp->desktop(),
1965 QObject::tr("WRN_WARNING"),
1966 QObject::tr("DEP_OBJECT") );
1967 return; // outside SMESH, there is an object depending on a SMESH object
1972 // Call mesh->Clear() to prevent loading mesh from file caused by hypotheses removal
1973 for( It.Initialize( selected ); It.More(); It.Next()) // loop on selected IO's
1975 Handle(SALOME_InteractiveObject) IObject = It.Value();
1976 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface< SMESH::SMESH_Mesh >( IObject );
1977 if ( !mesh->_is_nil() )
1981 // Treat SO's in the list starting from the back
1982 aStudyBuilder->NewCommand(); // There is a transaction
1983 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1985 _PTR(SObject) SO = *ritSO;
1986 if ( !SO ) continue;
1987 std::string anEntry = SO->GetID();
1989 /** Erase graphical object and remove all its data **/
1990 if(SO->FindAttribute(anAttr, "AttributeIOR")) {
1991 SMESH::RemoveVisualObjectWithActors( anEntry.c_str(), true);
1993 /** Remove an object from data structures **/
1994 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
1995 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
1996 if ( !aGroup->_is_nil() ) { // DELETE GROUP
1997 SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
1998 aMesh->RemoveGroup( aGroup );
2000 else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
2001 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2002 aMesh->RemoveSubMesh( aSubMesh );
2005 Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
2006 ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
2007 QString objType = CheckTypeObject(IObject);
2008 if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
2009 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
2010 aStudyBuilder->RemoveObjectWithChildren( SO );
2012 else {// default action: remove SObject from the study
2013 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
2014 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
2016 aStudyBuilder->RemoveObjectWithChildren( SO );
2020 } /* listSO back loop */
2022 aStudyBuilder->CommitCommand();
2024 /* Clear any previous selection */
2026 aSel->setSelectedObjects( l1 );
2028 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
2032 SMESHGUI_EXPORT CAM_Module* createModule()
2034 return new SMESHGUI();
2037 SMESHGUI_EXPORT char* getModuleVersion() {
2038 return (char*)SMESH_VERSION_STR;
2042 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
2044 //=============================================================================
2048 //=============================================================================
2049 SMESHGUI::SMESHGUI() :
2050 SalomeApp_Module( "SMESH" )
2052 if ( CORBA::is_nil( myComponentSMESH ) )
2054 CORBA::Boolean anIsEmbeddedMode;
2055 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
2056 //MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
2058 // 0019923: EDF 765 SMESH : default values of hypothesis
2059 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
2060 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
2061 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
2062 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
2063 myComponentSMESH->SetDefaultNbSegments( nbSeg );
2065 const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif", "default_grp_color" };
2066 for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
2067 if ( aResourceMgr->hasValue( "SMESH", options[i] ))
2069 QString val = aResourceMgr->stringValue( "SMESH", options[i] );
2070 myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
2074 myActiveDialogBox = 0;
2075 myFilterLibraryDlg = 0;
2079 myEventCallbackCommand = vtkCallbackCommand::New();
2080 myEventCallbackCommand->Delete();
2081 myEventCallbackCommand->SetClientData( this );
2082 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
2085 /* load resources for all available meshers */
2086 SMESH::InitAvailableHypotheses();
2089 //=============================================================================
2093 //=============================================================================
2094 SMESHGUI::~SMESHGUI()
2098 //=============================================================================
2102 //=============================================================================
2103 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
2105 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2107 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
2112 //=============================================================================
2116 //=============================================================================
2117 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
2119 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2123 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2124 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2125 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2126 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2127 return autoUpdate && !exceeded;
2130 //=============================================================================
2134 //=============================================================================
2135 bool SMESHGUI::automaticUpdate( SMESH::SMESH_IDSource_ptr theMesh,
2136 int* entities, bool* limitExceeded, int* hidden, long* nbElements )
2138 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2142 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2143 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2144 bool incrementalLimit = resMgr->booleanValue( "SMESH", "incremental_limit", false );
2146 SMESH::long_array_var info = theMesh->GetMeshInfo();
2147 long nbOdElems = info[SMDSEntity_0D];
2148 long nbEdges = info[SMDSEntity_Edge] + info[SMDSEntity_Quad_Edge];
2149 long nbFaces = info[SMDSEntity_Triangle] + info[SMDSEntity_Quad_Triangle] + info[SMDSEntity_BiQuad_Triangle] +
2150 info[SMDSEntity_Quadrangle] + info[SMDSEntity_Quad_Quadrangle] + info[SMDSEntity_BiQuad_Quadrangle] +
2151 info[SMDSEntity_Polygon] + info[SMDSEntity_Quad_Polygon];
2152 long nbVolumes = info[SMDSEntity_Tetra] + info[SMDSEntity_Quad_Tetra] +
2153 info[SMDSEntity_Hexa] + info[SMDSEntity_Quad_Hexa] + info[SMDSEntity_TriQuad_Hexa] +
2154 info[SMDSEntity_Pyramid] + info[SMDSEntity_Quad_Pyramid] +
2155 info[SMDSEntity_Penta] + info[SMDSEntity_Quad_Penta] + info[SMDSEntity_BiQuad_Penta] +
2156 info[SMDSEntity_Polyhedra] +
2157 info[SMDSEntity_Hexagonal_Prism];
2158 long nbBalls = info[SMDSEntity_Ball];
2160 long requestedSize = nbOdElems + nbBalls + nbEdges + nbFaces + nbVolumes;
2161 *nbElements = requestedSize;
2163 *entities = SMESH_Actor::eAllEntity;
2166 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2168 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2170 if ( incrementalLimit ) {
2173 if ( nbOdElems > 0 ) {
2174 if ( total + nbOdElems > updateLimit ) {
2175 *entities = *entities & ~SMESH_Actor::e0DElements;
2176 *hidden = *hidden | SMESH_Actor::e0DElements;
2183 if ( nbEdges > 0 ) {
2184 if ( total + nbEdges > updateLimit ) {
2185 *entities = *entities & ~SMESH_Actor::eEdges;
2186 *hidden = *hidden | SMESH_Actor::eEdges;
2193 if ( nbFaces > 0 ) {
2194 if ( total + nbFaces > updateLimit ) {
2195 *entities = *entities & ~SMESH_Actor::eFaces;
2196 *hidden = *hidden | SMESH_Actor::eFaces;
2203 if ( nbVolumes > 0 ) {
2204 if ( total + nbVolumes > updateLimit ) {
2205 *entities = *entities & ~SMESH_Actor::eVolumes;
2206 *hidden = *hidden | SMESH_Actor::eVolumes;
2213 if ( nbBalls > 0 ) {
2214 if ( total + nbBalls > updateLimit ) {
2215 *entities = *entities & ~SMESH_Actor::eBallElem;
2216 *hidden = *hidden | SMESH_Actor::eBallElem;
2224 return autoUpdate && !exceeded;
2227 //=============================================================================
2231 //=============================================================================
2232 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
2234 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
2237 //=============================================================================
2241 //=============================================================================
2242 SMESHGUI* SMESHGUI::GetSMESHGUI()
2244 SMESHGUI* smeshMod = 0;
2245 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
2248 CAM_Module* module = app->module( "Mesh" );
2249 smeshMod = dynamic_cast<SMESHGUI*>( module );
2257 Standard_EXPORT SMESHGUI* GetComponentGUI()
2259 return SMESHGUI::GetSMESHGUI();
2263 //=============================================================================
2267 //=============================================================================
2268 void SMESHGUI::SetState(int aState)
2273 //=============================================================================
2277 //=============================================================================
2278 void SMESHGUI::ResetState()
2283 //=============================================================================
2287 //=============================================================================
2288 void SMESHGUI::EmitSignalDeactivateDialog()
2290 emit SignalDeactivateActiveDialog();
2293 //=============================================================================
2297 //=============================================================================
2298 void SMESHGUI::EmitSignalStudyFrameChanged()
2300 emit SignalStudyFrameChanged();
2303 //=============================================================================
2307 //=============================================================================
2308 void SMESHGUI::EmitSignalCloseAllDialogs()
2310 emit SignalCloseAllDialogs();
2313 //=============================================================================
2317 //=============================================================================
2318 void SMESHGUI::EmitSignalVisibilityChanged()
2320 emit SignalVisibilityChanged();
2323 //=============================================================================
2327 //=============================================================================
2328 void SMESHGUI::EmitSignalCloseView()
2330 emit SignalCloseView();
2333 //=============================================================================
2337 //=============================================================================
2338 void SMESHGUI::EmitSignalActivatedViewManager()
2340 emit SignalActivatedViewManager();
2343 //=============================================================================
2347 //=============================================================================
2348 QDialog *SMESHGUI::GetActiveDialogBox()
2350 return myActiveDialogBox;
2353 //=============================================================================
2357 //=============================================================================
2358 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2360 myActiveDialogBox = (QDialog *) aDlg;
2364 //=============================================================================
2368 //=============================================================================
2369 SUIT_Desktop* SMESHGUI::desktop()
2371 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2373 return app->desktop();
2378 //=============================================================================
2382 //=============================================================================
2383 SalomeApp_Study* SMESHGUI::activeStudy()
2385 SUIT_Application* app = SUIT_Session::session()->activeApplication();
2387 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2392 //=============================================================================
2396 //=============================================================================
2397 void SMESHGUI::Modified( bool theIsUpdateActions )
2399 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2400 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2401 appStudy->Modified();
2402 if( theIsUpdateActions )
2403 app->updateActions();
2408 //=============================================================================
2412 //=============================================================================
2413 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2415 /* Here the position is on the bottom right corner - 10 */
2416 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2418 SUIT_Desktop *PP = desktop();
2419 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2420 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2425 * \brief Verifies whether study of operation is locked
2426 * \param theMess - specifies whether message box must be shown if study is locked
2427 * \return State of study.
2429 * Verifies whether study of operation is locked. If second parameter is TRUE and study
2430 * is locked when corresponding message box appears
2432 bool SMESHGUI::isStudyLocked( bool theMessage )
2434 if ( SMESH::getStudy()->GetProperties()->IsLocked() )
2437 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2438 QObject::tr( "WRN_WARNING" ),
2439 QObject::tr( "WRN_STUDY_LOCKED" ) );
2445 //=============================================================================
2449 //=============================================================================
2450 bool SMESHGUI::OnGUIEvent( int theCommandID )
2452 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2456 SUIT_ResourceMgr* mgr = resourceMgr();
2460 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2461 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2463 //QAction* act = action( theCommandID );
2465 switch (theCommandID) {
2466 case SMESHOp::OpDelete:
2467 if(isStudyLocked()) break;
2470 case SMESHOp::OpImportDAT:
2471 case SMESHOp::OpImportUNV:
2472 case SMESHOp::OpImportMED:
2473 case SMESHOp::OpImportSTL:
2474 case SMESHOp::OpImportCGNS:
2475 case SMESHOp::OpImportSAUV:
2476 case SMESHOp::OpImportGMF:
2477 case SMESHOp::OpPopupImportDAT:
2478 case SMESHOp::OpPopupImportUNV:
2479 case SMESHOp::OpPopupImportMED:
2480 case SMESHOp::OpPopupImportSTL:
2481 case SMESHOp::OpPopupImportCGNS:
2482 case SMESHOp::OpPopupImportSAUV:
2483 case SMESHOp::OpPopupImportGMF:
2485 if(isStudyLocked()) break;
2486 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2490 case SMESHOp::OpFileInformation:
2492 SALOME_ListIO selected;
2493 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2495 aSel->selectedObjects( selected );
2496 if( selected.Extent() )
2498 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2499 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2500 if ( !aMesh->_is_nil() )
2502 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2508 case SMESHOp::OpExportDAT:
2509 case SMESHOp::OpExportMED:
2510 case SMESHOp::OpExportUNV:
2511 case SMESHOp::OpExportSTL:
2512 case SMESHOp::OpExportCGNS:
2513 case SMESHOp::OpExportSAUV:
2514 case SMESHOp::OpExportGMF:
2515 case SMESHOp::OpPopupExportDAT:
2516 case SMESHOp::OpPopupExportMED:
2517 case SMESHOp::OpPopupExportUNV:
2518 case SMESHOp::OpPopupExportSTL:
2519 case SMESHOp::OpPopupExportCGNS:
2520 case SMESHOp::OpPopupExportSAUV:
2521 case SMESHOp::OpPopupExportGMF:
2523 ::ExportMeshToFile(theCommandID);
2527 case SMESHOp::OpReset: // SCALAR BAR
2529 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2530 SALOME_ListIO selected;
2532 aSel->selectedObjects( selected );
2534 SALOME_ListIteratorOfListIO it(selected);
2535 for( ; it.More(); it.Next()) {
2536 Handle(SALOME_InteractiveObject) anIO = it.Value();
2537 if( anIO->hasEntry() ) {
2538 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2539 anActor->SetControlMode( SMESH_Actor::eNone );
2540 #ifndef DISABLE_PLOT2DVIEWER
2541 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2546 SMESH::UpdateView();
2549 case SMESHOp::OpScalarBarProperties:
2551 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2554 case SMESHOp::OpShowScalarBar:
2556 // show/hide scalar bar
2557 ::ShowElement(theCommandID);
2560 case SMESHOp::OpSaveDistribution:
2562 // dump control distribution data to the text file
2563 ::SaveDistribution();
2567 case SMESHOp::OpShowDistribution:
2569 // show/hide distribution
2570 ::ShowElement(theCommandID);
2574 #ifndef DISABLE_PLOT2DVIEWER
2575 case SMESHOp::OpPlotDistribution:
2577 // plot distribution
2578 ::PlotDistribution();
2584 case SMESHOp::OpAutoColor:
2588 case SMESHOp::OpDisableAutoColor:
2589 ::DisableAutoColor();
2592 case SMESHOp::OpClipping:
2593 case SMESHOp::OpTransparency:
2594 case SMESHOp::OpProperties: // Display preferences (colors, shrink size, line width, ...)
2597 case SMESHOp::OpDMWireframe:
2598 case SMESHOp::OpDMShading:
2599 case SMESHOp::OpDMNodes:
2600 case SMESHOp::OpDMShrink:
2601 ::SetDisplayMode(theCommandID, myMarkerMap);
2604 //2D quadratic representation
2605 case SMESHOp::OpRepresentationLines:
2606 case SMESHOp::OpRepresentationArcs:
2607 ::SetDisplayMode(theCommandID, myMarkerMap);
2611 case SMESHOp::OpDE0DElements:
2612 case SMESHOp::OpDEEdges:
2613 case SMESHOp::OpDEFaces:
2614 case SMESHOp::OpDEVolumes:
2615 case SMESHOp::OpDEBalls:
2616 case SMESHOp::OpDEAllEntity:
2617 ::SetDisplayEntity(theCommandID);
2620 // Choose entities to be displayed
2621 case SMESHOp::OpDEChoose:
2623 ( new SMESHGUI_DisplayEntitiesDlg( SMESHGUI::desktop() ) )->exec();
2627 case SMESHOp::OpOrientationOnFaces:
2629 SUIT_OverrideCursor wc;
2630 LightApp_SelectionMgr* mgr = selectionMgr();
2631 SALOME_ListIO selected; mgr->selectedObjects( selected );
2633 SALOME_ListIteratorOfListIO it(selected);
2634 for( ; it.More(); it.Next()) {
2635 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2636 if(anIObject->hasEntry()) {
2637 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2638 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2645 case SMESHOp::OpUpdate:
2647 if(isStudyLocked()) break;
2648 SUIT_OverrideCursor wc;
2651 SMESH::UpdateView();
2653 catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2654 SMESH::OnVisuException();
2656 catch (...) { // PAL16774 (Crash after display of many groups)
2657 SMESH::OnVisuException();
2661 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2662 aSel->selectedObjects( l );
2663 aSel->setSelectedObjects( l );
2667 case SMESHOp::OpHide:
2668 case SMESHOp::OpShow:
2669 case SMESHOp::OpShowOnly:
2671 SUIT_OverrideCursor wc;
2672 SMESH::EDisplaing anAction;
2673 switch (theCommandID) {
2674 case SMESHOp::OpHide: anAction = SMESH::eErase; break;
2675 case SMESHOp::OpShow: anAction = SMESH::eDisplay; break;
2676 case SMESHOp::OpShowOnly: anAction = SMESH::eDisplayOnly; break;
2679 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2680 SALOME_ListIO sel_objects, to_process;
2682 aSel->selectedObjects( sel_objects );
2684 if ( theCommandID==SMESHOp::OpShowOnly )
2686 //MESSAGE("anAction = SMESH::eDisplayOnly");
2687 startOperation( myEraseAll );
2690 extractContainers( sel_objects, to_process );
2695 SALOME_ListIteratorOfListIO It( to_process );
2696 for ( ; It.More(); It.Next())
2698 Handle(SALOME_InteractiveObject) IOS = It.Value();
2699 if ( IOS->hasEntry() )
2701 if ( !SMESH::UpdateView( anAction, IOS->getEntry() )) {
2702 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2703 break; // PAL16774 (Crash after display of many groups)
2705 if (anAction == SMESH::eDisplayOnly)
2706 anAction = SMESH::eDisplay;
2711 // PAL13338 + PAL15161 -->
2712 if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !isStudyLocked()) {
2713 SMESH::UpdateView();
2714 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2716 // PAL13338 + PAL15161 <--
2718 catch (...) { // PAL16774 (Crash after display of many groups)
2719 SMESH::OnVisuException();
2722 if (anAction == SMESH::eErase) {
2724 aSel->setSelectedObjects( l1 );
2727 aSel->setSelectedObjects( to_process );
2732 case SMESHOp::OpNode:
2734 if(isStudyLocked()) break;
2737 EmitSignalDeactivateDialog();
2739 ( new SMESHGUI_NodesDlg( this ) )->show();
2742 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"),tr("SMESH_WRN_VIEWER_VTK"));
2747 case SMESHOp::OpCreateMesh:
2748 case SMESHOp::OpCreateSubMesh:
2749 case SMESHOp::OpEditMeshOrSubMesh:
2750 case SMESHOp::OpEditMesh:
2751 case SMESHOp::OpEditSubMesh:
2752 case SMESHOp::OpCompute:
2753 case SMESHOp::OpComputeSubMesh:
2754 case SMESHOp::OpPreCompute:
2755 case SMESHOp::OpEvaluate:
2756 case SMESHOp::OpMeshOrder:
2757 startOperation( theCommandID );
2759 case SMESHOp::OpCopyMesh:
2761 if (isStudyLocked()) break;
2762 EmitSignalDeactivateDialog();
2763 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2766 case SMESHOp::OpBuildCompoundMesh:
2768 if (isStudyLocked()) break;
2769 EmitSignalDeactivateDialog();
2770 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2774 case SMESHOp::OpDiagonalInversion:
2775 case SMESHOp::OpUnionOfTwoTriangle:
2779 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2783 if ( isStudyLocked() )
2786 /*Standard_Boolean aRes;
2787 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2788 if ( aMesh->_is_nil() )
2790 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2791 tr( "SMESH_BAD_SELECTION" ) );
2795 EmitSignalDeactivateDialog();
2796 if ( theCommandID == SMESHOp::OpDiagonalInversion )
2797 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2799 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2802 case SMESHOp::OpOrientation:
2803 case SMESHOp::OpUnionOfTriangles:
2804 case SMESHOp::OpCuttingOfQuadrangles:
2805 case SMESHOp::OpSplitVolumes:
2809 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2813 if ( isStudyLocked() )
2816 EmitSignalDeactivateDialog();
2817 SMESHGUI_MultiEditDlg* aDlg = NULL;
2818 if ( theCommandID == SMESHOp::OpOrientation )
2819 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2820 else if ( theCommandID == SMESHOp::OpUnionOfTriangles )
2821 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2822 else if ( theCommandID == SMESHOp::OpSplitVolumes )
2823 aDlg = new SMESHGUI_SplitVolumesDlg(this);
2825 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2830 case SMESHOp::OpSmoothing:
2832 if(isStudyLocked()) break;
2834 EmitSignalDeactivateDialog();
2835 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2838 SUIT_MessageBox::warning(desktop(), tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2842 case SMESHOp::OpExtrusion:
2844 if (isStudyLocked()) break;
2846 EmitSignalDeactivateDialog();
2847 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2849 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2853 case SMESHOp::OpExtrusionAlongAPath:
2855 if (isStudyLocked()) break;
2857 EmitSignalDeactivateDialog();
2858 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2860 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2864 case SMESHOp::OpRevolution:
2866 if(isStudyLocked()) break;
2868 EmitSignalDeactivateDialog();
2869 ( new SMESHGUI_RevolutionDlg( this ) )->show();
2872 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2876 case SMESHOp::OpPatternMapping:
2878 if ( isStudyLocked() )
2882 EmitSignalDeactivateDialog();
2883 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2886 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2890 case SMESHOp::OpSplitBiQuadratic:
2891 case SMESHOp::OpConvertMeshToQuadratic:
2892 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
2893 case SMESHOp::OpReorientFaces:
2894 case SMESHOp::OpCreateGeometryGroup:
2896 startOperation( theCommandID );
2899 case SMESHOp::OpCreateGroup:
2903 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2907 if(isStudyLocked()) break;
2908 EmitSignalDeactivateDialog();
2909 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2911 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2912 SALOME_ListIO selected;
2914 aSel->selectedObjects( selected );
2916 int nbSel = selected.Extent();
2918 // check if mesh is selected
2919 aMesh = SMESH::GetMeshByIO( selected.First() );
2921 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2926 case SMESHOp::OpConstructGroup:
2930 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2934 if(isStudyLocked()) break;
2935 EmitSignalDeactivateDialog();
2937 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2938 SALOME_ListIO selected;
2940 aSel->selectedObjects( selected );
2942 int nbSel = selected.Extent();
2944 // check if submesh is selected
2945 Handle(SALOME_InteractiveObject) IObject = selected.First();
2946 if (IObject->hasEntry()) {
2947 _PTR(SObject) aSObj = SMESH::getStudy()->FindObjectID(IObject->getEntry());
2949 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2950 if (!aSubMesh->_is_nil()) {
2952 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2953 // get submesh elements list by types
2954 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2955 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2956 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2957 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2958 // create group for each type o elements
2959 QString aName = IObject->getName();
2960 QStringList anEntryList;
2961 if (aNodes->length() > 0) {
2962 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2963 aGroup->Add(aNodes.inout());
2964 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2965 anEntryList.append( aSObject->GetID().c_str() );
2967 if (aEdges->length() > 0) {
2968 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2969 aGroup->Add(aEdges.inout());
2970 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2971 anEntryList.append( aSObject->GetID().c_str() );
2973 if (aFaces->length() > 0) {
2974 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2975 aGroup->Add(aFaces.inout());
2976 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2977 anEntryList.append( aSObject->GetID().c_str() );
2979 if (aVolumes->length() > 0) {
2980 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2981 aGroup->Add(aVolumes.inout());
2982 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2983 anEntryList.append( aSObject->GetID().c_str() );
2986 anApp->browseObjects( anEntryList );
2988 catch(const SALOME::SALOME_Exception & S_ex){
2989 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2996 SUIT_MessageBox::warning(desktop(),
2997 tr("SMESH_WRN_WARNING"),
2998 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
3003 case SMESHOp::OpEditGroup:
3007 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3011 if(isStudyLocked()) break;
3012 EmitSignalDeactivateDialog();
3014 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3015 SALOME_ListIO selected;
3017 aSel->selectedObjects( selected );
3019 SALOME_ListIteratorOfListIO It (selected);
3020 int nbSelectedGroups = 0;
3021 for ( ; It.More(); It.Next() )
3023 SMESH::SMESH_GroupBase_var aGroup =
3024 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
3025 if (!aGroup->_is_nil()) {
3027 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
3031 if (nbSelectedGroups == 0)
3033 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
3039 case SMESHOp::OpAddElemGroupPopup: // Add elements to group
3041 if(isStudyLocked()) break;
3042 if (myState == 800) {
3043 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3044 if (aDlg) aDlg->onAdd();
3049 case SMESHOp::OpRemoveElemGroupPopup: // Remove elements from group
3051 if(isStudyLocked()) break;
3052 if (myState == 800) {
3053 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3054 if (aDlg) aDlg->onRemove();
3059 case SMESHOp::OpEditGeomGroupAsGroup:
3063 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3067 if(isStudyLocked()) break;
3068 EmitSignalDeactivateDialog();
3070 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3071 SALOME_ListIO selected;
3073 aSel->selectedObjects( selected );
3075 SALOME_ListIteratorOfListIO It (selected);
3076 for ( ; It.More(); It.Next() )
3078 SMESH::SMESH_GroupOnGeom_var aGroup =
3079 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
3080 if (!aGroup->_is_nil()) {
3081 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3086 SMESH::SMESH_GroupOnFilter_var aGroup =
3087 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
3088 if (!aGroup->_is_nil()) {
3089 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3097 case SMESHOp::OpUnionGroups:
3098 case SMESHOp::OpIntersectGroups:
3099 case SMESHOp::OpCutGroups:
3103 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3107 if ( isStudyLocked() )
3110 EmitSignalDeactivateDialog();
3112 SMESHGUI_GroupOpDlg* aDlg = 0;
3113 if ( theCommandID == SMESHOp::OpUnionGroups )
3114 aDlg = new SMESHGUI_UnionGroupsDlg( this );
3115 else if ( theCommandID == SMESHOp::OpIntersectGroups )
3116 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3118 aDlg = new SMESHGUI_CutGroupsDlg( this );
3125 case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
3127 if ( isStudyLocked() )
3130 EmitSignalDeactivateDialog();
3131 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3137 case SMESHOp::OpFaceGroupsByEdges: // Create face groups separated by sharp edges
3139 if ( isStudyLocked() )
3142 EmitSignalDeactivateDialog();
3143 SMESHGUI_FaceGroupsSeparatedByEdgesDlg* aDlg = new SMESHGUI_FaceGroupsSeparatedByEdgesDlg( this );
3149 case SMESHOp::OpDeleteGroup: // Delete groups with their contents
3153 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3157 if ( isStudyLocked() )
3160 EmitSignalDeactivateDialog();
3162 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3166 case SMESHOp::OpMeshInformation:
3167 case SMESHOp::OpWhatIs:
3169 int page = theCommandID == SMESHOp::OpMeshInformation ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3170 EmitSignalDeactivateDialog();
3171 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3172 SALOME_ListIO selected;
3174 aSel->selectedObjects( selected );
3176 if ( selected.Extent() > 1 ) { // a dlg for each IO
3177 SALOME_ListIteratorOfListIO It( selected );
3178 for ( ; It.More(); It.Next() ) {
3179 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3180 dlg->showInfo( It.Value() );
3185 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3191 case SMESHOp::OpFindElementByPoint:
3193 startOperation( theCommandID );
3197 case SMESHOp::OpEditHypothesis:
3199 if(isStudyLocked()) break;
3201 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3202 SALOME_ListIO selected;
3204 aSel->selectedObjects( selected );
3206 int nbSel = selected.Extent();
3209 Handle(SALOME_InteractiveObject) anIObject = selected.First();
3210 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3212 if ( !aHypothesis->_is_nil() )
3214 SMESHGUI_GenericHypothesisCreator* aCreator =
3215 SMESH::GetHypothesisCreator( SMESH::toQStr( aHypothesis->GetName() ));
3218 // set geometry of mesh and sub-mesh to aCreator
3219 aSel->selectedObjects( selected, "", /*convertReferences=*/false);
3220 if ( selected.Extent() == 1 )
3222 QString subGeomID, meshGeomID;
3223 Handle(SALOME_InteractiveObject) hypIO = selected.First();
3224 if ( SMESH::GetGeomEntries( hypIO, subGeomID, meshGeomID ))
3226 if ( subGeomID.isEmpty() ) subGeomID = meshGeomID;
3227 aCreator->setShapeEntry( subGeomID );
3228 aCreator->setMainShapeEntry( meshGeomID );
3232 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3242 case SMESHOp::OpUnassign: // REMOVE HYPOTHESIS / ALGORITHMS
3244 if(isStudyLocked()) break;
3245 SUIT_OverrideCursor wc;
3247 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3248 SALOME_ListIO selected;
3250 aSel->selectedObjects( selected, QString::null, false );
3252 SALOME_ListIteratorOfListIO It(selected);
3253 for (int i = 0; It.More(); It.Next(), i++) {
3254 Handle(SALOME_InteractiveObject) IObject = It.Value();
3255 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3258 aSel->setSelectedObjects( l1 );
3263 case SMESHOp::OpElem0D:
3264 case SMESHOp::OpBall:
3265 case SMESHOp::OpEdge:
3266 case SMESHOp::OpTriangle:
3267 case SMESHOp::OpQuadrangle:
3268 case SMESHOp::OpPolygon:
3269 case SMESHOp::OpTetrahedron:
3270 case SMESHOp::OpHexahedron:
3271 case SMESHOp::OpPentahedron:
3272 case SMESHOp::OpPyramid:
3273 case SMESHOp::OpHexagonalPrism:
3275 if(isStudyLocked()) break;
3277 EmitSignalDeactivateDialog();
3278 SMDSAbs_EntityType type = SMDSEntity_Edge;
3279 switch (theCommandID) {
3280 case SMESHOp::OpElem0D: type = SMDSEntity_0D; break;
3281 case SMESHOp::OpBall: type = SMDSEntity_Ball; break;
3282 case SMESHOp::OpTriangle: type = SMDSEntity_Triangle; break;
3283 case SMESHOp::OpQuadrangle: type = SMDSEntity_Quadrangle; break;
3284 case SMESHOp::OpTetrahedron: type = SMDSEntity_Tetra; break;
3285 case SMESHOp::OpPolygon: type = SMDSEntity_Polygon; break;
3286 case SMESHOp::OpHexahedron: type = SMDSEntity_Hexa; break;
3287 case SMESHOp::OpPentahedron: type = SMDSEntity_Penta; break;
3288 case SMESHOp::OpPyramid: type = SMDSEntity_Pyramid; break;
3289 case SMESHOp::OpHexagonalPrism: type = SMDSEntity_Hexagonal_Prism; break;
3292 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3295 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3299 case SMESHOp::OpPolyhedron:
3301 if(isStudyLocked()) break;
3303 EmitSignalDeactivateDialog();
3304 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3307 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3311 case SMESHOp::OpQuadraticEdge:
3312 case SMESHOp::OpQuadraticTriangle:
3313 case SMESHOp::OpBiQuadraticTriangle:
3314 case SMESHOp::OpQuadraticQuadrangle:
3315 case SMESHOp::OpBiQuadraticQuadrangle:
3316 case SMESHOp::OpQuadraticPolygon:
3317 case SMESHOp::OpQuadraticTetrahedron:
3318 case SMESHOp::OpQuadraticPyramid:
3319 case SMESHOp::OpQuadraticPentahedron:
3320 case SMESHOp::OpBiQuadraticPentahedron:
3321 case SMESHOp::OpQuadraticHexahedron:
3322 case SMESHOp::OpTriQuadraticHexahedron:
3324 if(isStudyLocked()) break;
3326 EmitSignalDeactivateDialog();
3327 SMDSAbs_EntityType type = SMDSEntity_Last;
3329 switch (theCommandID) {
3330 case SMESHOp::OpQuadraticEdge: type = SMDSEntity_Quad_Edge; break;
3331 case SMESHOp::OpQuadraticTriangle: type = SMDSEntity_Quad_Triangle; break;
3332 case SMESHOp::OpBiQuadraticTriangle: type = SMDSEntity_BiQuad_Triangle; break;
3333 case SMESHOp::OpQuadraticQuadrangle: type = SMDSEntity_Quad_Quadrangle; break;
3334 case SMESHOp::OpBiQuadraticQuadrangle: type = SMDSEntity_BiQuad_Quadrangle; break;
3335 case SMESHOp::OpQuadraticPolygon: type = SMDSEntity_Quad_Polygon; break;
3336 case SMESHOp::OpQuadraticTetrahedron: type = SMDSEntity_Quad_Tetra; break;
3337 case SMESHOp::OpQuadraticPyramid: type = SMDSEntity_Quad_Pyramid; break;
3338 case SMESHOp::OpQuadraticPentahedron: type = SMDSEntity_Quad_Penta; break;
3339 case SMESHOp::OpBiQuadraticPentahedron: type = SMDSEntity_BiQuad_Penta; break;
3340 case SMESHOp::OpQuadraticHexahedron: type = SMDSEntity_Quad_Hexa; break;
3341 case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
3344 if ( type != SMDSEntity_Last )
3345 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3348 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3349 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3353 case SMESHOp::OpRemoveNodes:
3355 if(isStudyLocked()) break;
3357 EmitSignalDeactivateDialog();
3358 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3361 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3362 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3366 case SMESHOp::OpRemoveElements: // REMOVES ELEMENTS
3368 if(isStudyLocked()) break;
3370 EmitSignalDeactivateDialog();
3371 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3375 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3376 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3380 case SMESHOp::OpClearMesh: {
3382 if(isStudyLocked()) break;
3384 SALOME_ListIO selected;
3385 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3386 aSel->selectedObjects( selected );
3388 SUIT_OverrideCursor wc;
3389 SALOME_ListIteratorOfListIO It (selected);
3390 for ( ; It.More(); It.Next() )
3392 Handle(SALOME_InteractiveObject) IOS = It.Value();
3393 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3394 if ( aMesh->_is_nil()) continue;
3397 if ( aMesh->NbNodes() == 0 ) // imported mesh is not empty
3398 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3399 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3400 // hide groups and submeshes
3401 _PTR(ChildIterator) anIter =
3402 SMESH::getStudy()->NewChildIterator( aMeshSObj );
3403 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3405 _PTR(SObject) so = anIter->Value();
3406 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3409 catch (const SALOME::SALOME_Exception& S_ex){
3411 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3415 SMESH::UpdateView();
3419 case SMESHOp::OpRemoveOrphanNodes:
3421 if(isStudyLocked()) break;
3422 SALOME_ListIO selected;
3423 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3424 aSel->selectedObjects( selected );
3425 if ( selected.Extent() == 1 ) {
3426 Handle(SALOME_InteractiveObject) anIO = selected.First();
3427 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3428 if ( !aMesh->_is_nil() ) {
3429 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3430 tr( "SMESH_WARNING" ),
3431 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3432 SUIT_MessageBox::Yes |
3433 SUIT_MessageBox::No,
3434 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3437 SUIT_OverrideCursor wc;
3438 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3439 int removed = aMeshEditor->RemoveOrphanNodes();
3440 SUIT_MessageBox::information(SMESHGUI::desktop(),
3441 tr("SMESH_INFORMATION"),
3442 tr("NB_NODES_REMOVED").arg(removed));
3443 if ( removed > 0 ) {
3444 SMESH::UpdateView();
3445 SMESHGUI::Modified();
3448 catch (const SALOME::SALOME_Exception& S_ex) {
3449 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3458 case SMESHOp::OpRenumberingNodes:
3460 if(isStudyLocked()) break;
3462 EmitSignalDeactivateDialog();
3463 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3467 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3468 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3472 case SMESHOp::OpRenumberingElements:
3474 if(isStudyLocked()) break;
3476 EmitSignalDeactivateDialog();
3477 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3481 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3482 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3486 case SMESHOp::OpTranslation:
3488 if(isStudyLocked()) break;
3490 EmitSignalDeactivateDialog();
3491 ( new SMESHGUI_TranslationDlg( this ) )->show();
3494 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3495 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3499 case SMESHOp::OpRotation:
3501 if(isStudyLocked()) break;
3503 EmitSignalDeactivateDialog();
3504 ( new SMESHGUI_RotationDlg( this ) )->show();
3507 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3508 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3512 case SMESHOp::OpSymmetry:
3514 if(isStudyLocked()) break;
3516 EmitSignalDeactivateDialog();
3517 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3520 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3521 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3525 case SMESHOp::OpScale:
3527 if(isStudyLocked()) break;
3529 EmitSignalDeactivateDialog();
3530 ( new SMESHGUI_ScaleDlg( this ) )->show();
3533 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3534 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3539 case SMESHOp::OpOffset:
3541 if(isStudyLocked()) break;
3543 EmitSignalDeactivateDialog();
3544 ( new SMESHGUI_OffsetDlg( this ) )->show();
3547 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3548 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3553 case SMESHOp::OpSewing:
3555 if(isStudyLocked()) break;
3557 EmitSignalDeactivateDialog();
3558 ( new SMESHGUI_SewingDlg( this ) )->show();
3561 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3562 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3566 case SMESHOp::OpMergeNodes:
3568 if(isStudyLocked()) break;
3570 EmitSignalDeactivateDialog();
3571 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3574 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3575 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3579 case SMESHOp::OpMergeElements:
3581 if (isStudyLocked()) break;
3583 EmitSignalDeactivateDialog();
3584 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3586 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3587 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3592 case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
3593 startOperation( SMESHOp::OpMoveNode );
3596 case SMESHOp::OpDuplicateNodes:
3598 if(isStudyLocked()) break;
3600 EmitSignalDeactivateDialog();
3601 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3604 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3605 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3610 case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
3611 startOperation( SMESHOp::OpElem0DOnElemNodes );
3614 case SMESHOp::OpSelectFiltersLibrary: // Library of selection filters
3616 static QList<int> aTypes;
3617 if ( aTypes.isEmpty() )
3619 aTypes.append( SMESH::NODE );
3620 aTypes.append( SMESH::EDGE );
3621 aTypes.append( SMESH::FACE );
3622 aTypes.append( SMESH::VOLUME );
3624 if (!myFilterLibraryDlg)
3625 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3626 else if (myFilterLibraryDlg->isHidden())
3627 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3628 myFilterLibraryDlg->raise();
3632 case SMESHOp::OpFreeNode:
3633 case SMESHOp::OpEqualNode:
3634 case SMESHOp::OpNodeConnectivityNb:
3635 case SMESHOp::OpFreeEdge:
3636 case SMESHOp::OpFreeBorder:
3637 case SMESHOp::OpLength:
3638 case SMESHOp::OpConnection:
3639 case SMESHOp::OpEqualEdge:
3640 case SMESHOp::OpFreeFace:
3641 case SMESHOp::OpBareBorderFace:
3642 case SMESHOp::OpOverConstrainedFace:
3643 case SMESHOp::OpLength2D:
3644 case SMESHOp::OpDeflection2D:
3645 case SMESHOp::OpConnection2D:
3646 case SMESHOp::OpArea:
3647 case SMESHOp::OpTaper:
3648 case SMESHOp::OpAspectRatio:
3649 case SMESHOp::OpMinimumAngle:
3650 case SMESHOp::OpWarpingAngle:
3651 case SMESHOp::OpSkew:
3652 case SMESHOp::OpMaxElementLength2D:
3653 case SMESHOp::OpEqualFace:
3654 case SMESHOp::OpAspectRatio3D:
3655 case SMESHOp::OpVolume:
3656 case SMESHOp::OpMaxElementLength3D:
3657 case SMESHOp::OpBareBorderVolume:
3658 case SMESHOp::OpOverConstrainedVolume:
3659 case SMESHOp::OpEqualVolume:
3662 LightApp_SelectionMgr* mgr = selectionMgr();
3663 SALOME_ListIO selected; mgr->selectedObjects( selected );
3665 if( !selected.IsEmpty() ) {
3666 SUIT_OverrideCursor wc;
3667 ::Control( theCommandID );
3670 SUIT_MessageBox::warning(desktop(),
3671 tr( "SMESH_WRN_WARNING" ),
3672 tr( "SMESH_BAD_SELECTION" ) );
3676 SUIT_MessageBox::warning(desktop(),
3677 tr( "SMESH_WRN_WARNING" ),
3678 tr( "NOT_A_VTK_VIEWER" ) );
3681 case SMESHOp::OpOverallMeshQuality:
3682 OverallMeshQuality();
3684 case SMESHOp::OpNumberingNodes:
3686 SUIT_OverrideCursor wc;
3687 LightApp_SelectionMgr* mgr = selectionMgr();
3688 SALOME_ListIO selected; mgr->selectedObjects( selected );
3690 SALOME_ListIteratorOfListIO it(selected);
3691 for( ; it.More(); it.Next()) {
3692 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3693 if(anIObject->hasEntry()) {
3694 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3695 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3701 case SMESHOp::OpNumberingElements:
3703 SUIT_OverrideCursor wc;
3704 LightApp_SelectionMgr* mgr = selectionMgr();
3705 SALOME_ListIO selected; mgr->selectedObjects( selected );
3707 SALOME_ListIteratorOfListIO it(selected);
3708 for( ; it.More(); it.Next()) {
3709 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3710 if(anIObject->hasEntry())
3711 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3712 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3717 case SMESHOp::OpPropertiesLength:
3718 case SMESHOp::OpPropertiesArea:
3719 case SMESHOp::OpPropertiesVolume:
3720 case SMESHOp::OpMinimumDistance:
3721 case SMESHOp::OpBoundingBox:
3722 case SMESHOp::OpAngle:
3724 int page = SMESHGUI_MeasureDlg::MinDistance;
3725 if ( theCommandID == SMESHOp::OpBoundingBox )
3726 page = SMESHGUI_MeasureDlg::BoundingBox;
3727 else if ( theCommandID == SMESHOp::OpPropertiesLength )
3728 page = SMESHGUI_MeasureDlg::Length;
3729 else if ( theCommandID == SMESHOp::OpPropertiesArea )
3730 page = SMESHGUI_MeasureDlg::Area;
3731 else if ( theCommandID == SMESHOp::OpPropertiesVolume )
3732 page = SMESHGUI_MeasureDlg::Volume;
3733 else if ( theCommandID == SMESHOp::OpAngle )
3734 page = SMESHGUI_MeasureDlg::Angle;
3736 EmitSignalDeactivateDialog();
3737 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3741 case SMESHOp::OpSortChild:
3747 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3748 //updateObjBrowser();
3752 //=============================================================================
3756 //=============================================================================
3757 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3762 //=============================================================================
3766 //=============================================================================
3767 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3772 //=============================================================================
3776 //=============================================================================
3777 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3782 //=============================================================================
3783 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3784 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3786 //=============================================================================
3787 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3788 SUIT_ViewWindow* wnd )
3790 if(theIO->hasEntry()){
3791 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3792 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3796 //=======================================================================
3797 // function : createSMESHAction
3799 //=======================================================================
3800 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3801 const int key, const bool toggle, const QString& shortcutAction )
3804 QWidget* parent = application()->desktop();
3805 SUIT_ResourceMgr* resMgr = resourceMgr();
3807 if ( !icon_id.isEmpty() )
3808 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3810 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3811 if ( !pix.isNull() )
3812 icon = QIcon( pix );
3814 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3815 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3816 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3818 createAction( id, tooltip, icon, menu, status_bar, key, parent,
3819 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3822 //=======================================================================
3823 // function : createPopupItem
3825 //=======================================================================
3826 void SMESHGUI::createPopupItem( const int id,
3827 const QString& clients,
3828 const QString& types,
3829 const QString& theRule,
3832 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3833 popupMgr()->insert( action( id ), pId, 0 );
3835 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3836 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
3837 QString rule = "(%1) and (%2) and (%3)";
3838 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3839 if( clients.isEmpty() )
3840 rule = rule.arg( QString( "true" ) );
3842 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3843 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3846 bool cont = myRules.contains( id );
3848 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3850 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3851 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3854 //=======================================================================
3855 // function : initialize
3857 //=======================================================================
3858 void SMESHGUI::initialize( CAM_Application* app )
3860 SalomeApp_Module::initialize( app );
3862 // SUIT_ResourceMgr* mgr = app->resourceMgr();
3864 /* Automatic Update flag */
3865 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3867 // ----- create actions --------------
3869 //createSMESHAction( SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
3870 createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_I) );
3871 createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
3872 createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL" );
3874 createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
3876 createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
3877 createSMESHAction( SMESHOp::OpImportGMF, "IMPORT_GMF" );
3878 createSMESHAction( SMESHOp::OpPopupImportUNV, "IMPORT_UNV");
3879 createSMESHAction( SMESHOp::OpPopupImportMED, "IMPORT_MED");
3880 createSMESHAction( SMESHOp::OpPopupImportSTL, "IMPORT_STL" );
3882 createSMESHAction( SMESHOp::OpPopupImportCGNS, "IMPORT_CGNS" );
3884 createSMESHAction( SMESHOp::OpPopupImportSAUV, "IMPORT_SAUV" );
3885 createSMESHAction( SMESHOp::OpPopupImportGMF, "IMPORT_GMF" );
3887 createSMESHAction( SMESHOp::OpExportDAT, "DAT" );
3888 createSMESHAction( SMESHOp::OpExportMED, "MED" );
3889 createSMESHAction( SMESHOp::OpExportUNV, "UNV" );
3890 createSMESHAction( SMESHOp::OpExportSTL, "STL" );
3892 createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
3894 createSMESHAction( SMESHOp::OpExportSAUV, "SAUV");
3895 createSMESHAction( SMESHOp::OpExportGMF, "GMF" );
3896 createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
3897 createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
3898 createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
3899 createSMESHAction( SMESHOp::OpPopupExportSTL, "STL" );
3901 createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
3903 createSMESHAction( SMESHOp::OpPopupExportSAUV, "SAUV");
3904 createSMESHAction( SMESHOp::OpPopupExportGMF, "GMF" );
3905 createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
3906 createSMESHAction( SMESHOp::OpDelete, "DELETE", "ICON_DELETE", Qt::Key_Delete );
3907 createSMESHAction( SMESHOp::OpSelectFiltersLibrary, "SEL_FILTER_LIB" );
3908 createSMESHAction( SMESHOp::OpCreateMesh, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
3909 createSMESHAction( SMESHOp::OpCreateSubMesh, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
3910 createSMESHAction( SMESHOp::OpEditMeshOrSubMesh, "EDIT_MESHSUBMESH", "ICON_DLG_EDIT_MESH" );
3911 createSMESHAction( SMESHOp::OpEditMesh, "EDIT_MESH", "ICON_DLG_EDIT_MESH" );
3912 createSMESHAction( SMESHOp::OpEditSubMesh, "EDIT_SUBMESH", "ICON_DLG_EDIT_MESH" );
3913 createSMESHAction( SMESHOp::OpBuildCompoundMesh, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
3914 createSMESHAction( SMESHOp::OpCopyMesh, "COPY_MESH", "ICON_COPY_MESH" );
3915 createSMESHAction( SMESHOp::OpCompute, "COMPUTE", "ICON_COMPUTE" );
3916 createSMESHAction( SMESHOp::OpComputeSubMesh, "COMPUTE_SUBMESH", "ICON_COMPUTE" );
3917 createSMESHAction( SMESHOp::OpPreCompute, "PRECOMPUTE", "ICON_PRECOMPUTE" );
3918 createSMESHAction( SMESHOp::OpEvaluate, "EVALUATE", "ICON_EVALUATE" );
3919 createSMESHAction( SMESHOp::OpMeshOrder, "MESH_ORDER", "ICON_MESH_ORDER");
3920 createSMESHAction( SMESHOp::OpCreateGroup, "CREATE_GROUP", "ICON_CREATE_GROUP" );
3921 createSMESHAction( SMESHOp::OpCreateGeometryGroup, "CREATE_GEO_GROUP", "ICON_CREATE_GEO_GROUP" );
3922 createSMESHAction( SMESHOp::OpConstructGroup, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
3923 createSMESHAction( SMESHOp::OpEditGroup, "EDIT_GROUP", "ICON_EDIT_GROUP" );
3924 createSMESHAction( SMESHOp::OpEditGeomGroupAsGroup, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3925 createSMESHAction( SMESHOp::OpUnionGroups, "UN_GROUP", "ICON_UNION" );
3926 createSMESHAction( SMESHOp::OpIntersectGroups, "INT_GROUP", "ICON_INTERSECT" );
3927 createSMESHAction( SMESHOp::OpCutGroups, "CUT_GROUP", "ICON_CUT" );
3928 createSMESHAction( SMESHOp::OpGroupUnderlyingElem, "UNDERLYING_ELEMS", "ICON_UNDERLYING_ELEMS" );
3929 createSMESHAction( SMESHOp::OpFaceGroupsByEdges, "FACE_GROUPS_BY_EDGES", "ICON_FACE_GROUPS_BY_EDGES" );
3930 createSMESHAction( SMESHOp::OpAddElemGroupPopup, "ADD_TO_GROUP" );
3931 createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE_FROM_GROUP" );
3932 createSMESHAction( SMESHOp::OpDeleteGroup, "DEL_GROUP", "ICON_DEL_GROUP" );
3933 createSMESHAction( SMESHOp::OpMeshInformation , "ADV_INFO", "ICON_ADV_INFO" );
3934 //createSMESHAction( SMESHOp::OpStdInfo, "STD_INFO", "ICON_STD_INFO" );
3935 //createSMESHAction( SMESHOp::OpWhatIs, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3936 createSMESHAction( SMESHOp::OpFindElementByPoint, "FIND_ELEM", "ICON_FIND_ELEM" );
3938 createSMESHAction( SMESHOp::OpFreeNode, "FREE_NODE", "ICON_FREE_NODE", 0, true );
3939 createSMESHAction( SMESHOp::OpEqualNode, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
3940 createSMESHAction( SMESHOp::OpNodeConnectivityNb, "NODE_CONNECTIVITY_NB", "ICON_NODE_CONN_NB", 0, true );
3941 createSMESHAction( SMESHOp::OpFreeEdge, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
3942 createSMESHAction( SMESHOp::OpFreeBorder, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
3943 createSMESHAction( SMESHOp::OpLength, "LENGTH", "ICON_LENGTH", 0, true );
3944 createSMESHAction( SMESHOp::OpConnection, "CONNECTION", "ICON_CONNECTION", 0, true );
3945 createSMESHAction( SMESHOp::OpEqualEdge, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
3946 createSMESHAction( SMESHOp::OpFreeFace, "FREE_FACES", "ICON_FREE_FACES", 0, true );
3947 createSMESHAction( SMESHOp::OpBareBorderFace, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
3948 createSMESHAction( SMESHOp::OpOverConstrainedFace, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
3949 createSMESHAction( SMESHOp::OpLength2D, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
3950 createSMESHAction( SMESHOp::OpDeflection2D, "DEFLECTION_2D", "ICON_DEFLECTION_2D", 0, true );
3951 createSMESHAction( SMESHOp::OpConnection2D, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
3952 createSMESHAction( SMESHOp::OpArea, "AREA", "ICON_AREA", 0, true );
3953 createSMESHAction( SMESHOp::OpTaper, "TAPER", "ICON_TAPER", 0, true );
3954 createSMESHAction( SMESHOp::OpAspectRatio, "ASPECT", "ICON_ASPECT", 0, true );
3955 createSMESHAction( SMESHOp::OpMinimumAngle, "MIN_ANG", "ICON_ANGLE", 0, true );
3956 createSMESHAction( SMESHOp::OpWarpingAngle, "WARP", "ICON_WARP", 0, true );
3957 createSMESHAction( SMESHOp::OpSkew, "SKEW", "ICON_SKEW", 0, true );
3958 createSMESHAction( SMESHOp::OpMaxElementLength2D, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
3959 createSMESHAction( SMESHOp::OpEqualFace, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
3960 createSMESHAction( SMESHOp::OpAspectRatio3D, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
3961 createSMESHAction( SMESHOp::OpVolume, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
3962 createSMESHAction( SMESHOp::OpMaxElementLength3D, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
3963 createSMESHAction( SMESHOp::OpBareBorderVolume, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
3964 createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
3965 createSMESHAction( SMESHOp::OpEqualVolume, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
3966 createSMESHAction( SMESHOp::OpOverallMeshQuality, "OVERALL_MESH_QUALITY", "ICON_OVL_MESH_QUALITY" );
3968 createSMESHAction( SMESHOp::OpNode, "NODE", "ICON_DLG_NODE" );
3969 createSMESHAction( SMESHOp::OpElem0D, "ELEM0D", "ICON_DLG_ELEM0D" );
3970 createSMESHAction( SMESHOp::OpElem0DOnElemNodes, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
3971 createSMESHAction( SMESHOp::OpBall, "BALL", "ICON_DLG_BALL" );
3972 createSMESHAction( SMESHOp::OpEdge, "EDGE", "ICON_DLG_EDGE" );
3973 createSMESHAction( SMESHOp::OpTriangle, "TRIANGLE", "ICON_DLG_TRIANGLE" );
3974 createSMESHAction( SMESHOp::OpQuadrangle, "QUAD", "ICON_DLG_QUADRANGLE" );
3975 createSMESHAction( SMESHOp::OpPolygon, "POLYGON", "ICON_DLG_POLYGON" );
3976 createSMESHAction( SMESHOp::OpTetrahedron, "TETRA", "ICON_DLG_TETRAS" );
3977 createSMESHAction( SMESHOp::OpHexahedron, "HEXA", "ICON_DLG_HEXAS" );
3978 createSMESHAction( SMESHOp::OpPentahedron, "PENTA", "ICON_DLG_PENTA" );
3979 createSMESHAction( SMESHOp::OpPyramid , "PYRAMID", "ICON_DLG_PYRAMID" );
3980 createSMESHAction( SMESHOp::OpHexagonalPrism, "OCTA", "ICON_DLG_OCTA" );
3981 createSMESHAction( SMESHOp::OpPolyhedron, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
3982 createSMESHAction( SMESHOp::OpQuadraticEdge, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
3983 createSMESHAction( SMESHOp::OpQuadraticTriangle, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
3984 createSMESHAction( SMESHOp::OpBiQuadraticTriangle, "BIQUADRATIC_TRIANGLE", "ICON_DLG_BIQUADRATIC_TRIANGLE" );
3985 createSMESHAction( SMESHOp::OpQuadraticQuadrangle, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
3986 createSMESHAction( SMESHOp::OpBiQuadraticQuadrangle, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
3987 createSMESHAction( SMESHOp::OpQuadraticPolygon, "QUADRATIC_POLYGON", "ICON_DLG_QUADRATIC_POLYGON" );
3988 createSMESHAction( SMESHOp::OpQuadraticTetrahedron, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
3989 createSMESHAction( SMESHOp::OpQuadraticPyramid, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
3990 createSMESHAction( SMESHOp::OpQuadraticPentahedron, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
3991 createSMESHAction( SMESHOp::OpBiQuadraticPentahedron, "BIQUADRATIC_PENTAHEDRON", "ICON_DLG_BIQUADRATIC_PENTAHEDRON" );
3992 createSMESHAction( SMESHOp::OpQuadraticHexahedron, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
3993 createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
3995 createSMESHAction( SMESHOp::OpRemoveNodes, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
3996 createSMESHAction( SMESHOp::OpRemoveElements, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
3997 createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
3998 createSMESHAction( SMESHOp::OpClearMesh, "CLEAR_MESH", "ICON_CLEAR_MESH" );
4000 //createSMESHAction( SMESHOp::OpRenumberingNodes, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
4001 //createSMESHAction( SMESHOp::OpRenumberingElements, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
4003 createSMESHAction( SMESHOp::OpTranslation, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
4004 createSMESHAction( SMESHOp::OpRotation, "ROT", "ICON_DLG_MESH_ROTATION" );
4005 createSMESHAction( SMESHOp::OpSymmetry, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
4006 createSMESHAction( SMESHOp::OpScale, "SCALE", "ICON_DLG_MESH_SCALE" );
4007 createSMESHAction( SMESHOp::OpOffset, "OFFSET", "ICON_DLG_MESH_OFFSET" );
4008 createSMESHAction( SMESHOp::OpSewing, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
4009 createSMESHAction( SMESHOp::OpMergeNodes, "MERGE", "ICON_SMESH_MERGE_NODES" );
4010 createSMESHAction( SMESHOp::OpMergeElements, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
4011 createSMESHAction( SMESHOp::OpMoveNode, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
4012 createSMESHAction( SMESHOp::OpDuplicateNodes, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
4013 createSMESHAction( SMESHOp::OpDiagonalInversion, "INV", "ICON_DLG_MESH_DIAGONAL" );
4014 createSMESHAction( SMESHOp::OpUnionOfTwoTriangle, "UNION2", "ICON_UNION2TRI" );
4015 createSMESHAction( SMESHOp::OpOrientation, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
4016 createSMESHAction( SMESHOp::OpReorientFaces, "REORIENT_2D", "ICON_REORIENT_2D" );
4017 createSMESHAction( SMESHOp::OpUnionOfTriangles, "UNION", "ICON_UNIONTRI" );
4018 createSMESHAction( SMESHOp::OpCuttingOfQuadrangles, "CUT", "ICON_CUTQUAD" );
4019 createSMESHAction( SMESHOp::OpSplitVolumes, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
4020 createSMESHAction( SMESHOp::OpSplitBiQuadratic, "SPLIT_BIQUAD", "ICON_SPLIT_BIQUAD" );
4021 createSMESHAction( SMESHOp::OpSmoothing, "SMOOTH", "ICON_DLG_SMOOTHING" );
4022 createSMESHAction( SMESHOp::OpExtrusion, "EXTRUSION", "ICON_EXTRUSION" );
4023 createSMESHAction( SMESHOp::OpExtrusionAlongAPath, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
4024 createSMESHAction( SMESHOp::OpRevolution, "REVOLUTION", "ICON_REVOLUTION" );
4025 createSMESHAction( SMESHOp::OpPatternMapping, "MAP", "ICON_MAP" );
4026 createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
4027 createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D", "ICON_2D_FROM_3D" );
4029 createSMESHAction( SMESHOp::OpReset, "RESET" );
4030 createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
4031 createSMESHAction( SMESHOp::OpShowScalarBar, "SHOW_SCALAR_BAR","",0, true );
4032 createSMESHAction( SMESHOp::OpSaveDistribution, "SAVE_DISTRIBUTION" );
4033 createSMESHAction( SMESHOp::OpShowDistribution, "SHOW_DISTRIBUTION","",0, true );
4034 #ifndef DISABLE_PLOT2DVIEWER
4035 createSMESHAction( SMESHOp::OpPlotDistribution, "PLOT_DISTRIBUTION" );
4037 createSMESHAction( SMESHOp::OpDMWireframe, "WIRE", "ICON_WIRE", 0, true );
4038 createSMESHAction( SMESHOp::OpDMShading, "SHADE", "ICON_SHADE", 0, true );
4039 createSMESHAction( SMESHOp::OpDMNodes, "NODES", "ICON_POINTS", 0, true );
4040 createSMESHAction( SMESHOp::OpDMShrink, "SHRINK", "ICON_SHRINK", 0, true );
4041 createSMESHAction( SMESHOp::OpUpdate, "UPDATE", "ICON_UPDATE" );
4042 createSMESHAction( SMESHOp::OpDE0DElements, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
4043 createSMESHAction( SMESHOp::OpDEEdges, "EDGES", "ICON_DLG_EDGE", 0, true );
4044 createSMESHAction( SMESHOp::OpDEFaces, "FACES", "ICON_DLG_TRIANGLE", 0, true );
4045 createSMESHAction( SMESHOp::OpDEVolumes, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
4046 createSMESHAction( SMESHOp::OpDEBalls, "BALLS", "ICON_DLG_BALL", 0, true );
4047 createSMESHAction( SMESHOp::OpDEChoose, "CHOOSE", "ICON_DLG_CHOOSE", 0, false );
4048 createSMESHAction( SMESHOp::OpDEAllEntity, "ALL", "ICON_DLG_CHOOSE_ALL", 0, false );
4049 createSMESHAction( SMESHOp::OpOrientationOnFaces, "FACE_ORIENTATION", "", 0, true );
4051 createSMESHAction( SMESHOp::OpRepresentationLines, "LINE_REPRESENTATION", "", 0, true );
4052 createSMESHAction( SMESHOp::OpRepresentationArcs, "ARC_REPRESENTATION", "", 0, true );
4054 createSMESHAction( SMESHOp::OpEditHypothesis, "EDIT_HYPO" );
4055 createSMESHAction( SMESHOp::OpUnassign, "UNASSIGN" );
4056 createSMESHAction( SMESHOp::OpNumberingNodes, "NUM_NODES", "", 0, true );
4057 createSMESHAction( SMESHOp::OpNumberingElements, "NUM_ELEMENTS", "", 0, true );
4058 createSMESHAction( SMESHOp::OpProperties, "COLORS" );
4059 createSMESHAction( SMESHOp::OpTransparency, "TRANSP" );
4060 createSMESHAction( SMESHOp::OpClipping, "CLIP" );
4061 createSMESHAction( SMESHOp::OpAutoColor, "AUTO_COLOR" );
4062 createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
4064 createSMESHAction( SMESHOp::OpMinimumDistance, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
4065 createSMESHAction( SMESHOp::OpBoundingBox, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
4066 createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH", "ICON_MEASURE_LENGTH" );
4067 createSMESHAction( SMESHOp::OpPropertiesArea, "MEASURE_AREA", "ICON_MEASURE_AREA" );
4068 createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME", "ICON_MEASURE_VOLUME" );
4069 createSMESHAction( SMESHOp::OpAngle, "MEASURE_ANGLE", "ICON_MEASURE_ANGLE" );
4071 createSMESHAction( SMESHOp::OpHide, "HIDE", "ICON_HIDE" );
4072 createSMESHAction( SMESHOp::OpShow, "SHOW", "ICON_SHOW" );
4073 createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
4075 createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
4077 QList<int> aCtrlActions;
4078 aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode
4079 << SMESHOp::OpNodeConnectivityNb // node controls
4080 << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
4081 << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge // edge controls
4082 << SMESHOp::OpDeflection2D
4083 << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
4084 << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
4085 << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
4086 << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
4087 << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace // face controls
4088 << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
4089 << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
4090 << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume; // volume controls
4091 QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
4092 aCtrlGroup->setExclusive( true );
4093 for( int i = 0; i < aCtrlActions.size(); i++ )
4094 aCtrlGroup->addAction( action( aCtrlActions[i] ) );
4096 // ----- create menu --------------
4097 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
4098 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
4099 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
4100 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
4101 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
4102 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
4103 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
4104 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
4106 createMenu( separator(), fileId );
4108 QMenu* nodeMenu = new QMenu(); QMenu* edgeMenu = new QMenu();
4109 QMenu* faceMenu = new QMenu(); QMenu* volumeMenu = new QMenu();
4110 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
4111 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
4112 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10, -1, nodeMenu ),
4113 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10, -1, edgeMenu ),
4114 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10, -1, faceMenu ),
4115 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10, -1, volumeMenu ),
4116 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
4117 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
4118 //renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
4119 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
4120 basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
4122 //createMenu( SMESHOp::OpImportDAT, importId, -1 );
4123 createMenu( SMESHOp::OpImportUNV, importId, -1 );
4124 createMenu( SMESHOp::OpImportMED, importId, -1 );
4125 createMenu( SMESHOp::OpImportSTL, importId, -1 );
4127 createMenu( SMESHOp::OpImportCGNS, importId, -1 );
4129 createMenu( SMESHOp::OpImportSAUV, importId, -1 );
4130 createMenu( SMESHOp::OpImportGMF, importId, -1 );
4131 createMenu( SMESHOp::OpExportDAT, exportId, -1 );
4132 createMenu( SMESHOp::OpExportMED, exportId, -1 );
4133 createMenu( SMESHOp::OpExportUNV, exportId, -1 );
4134 createMenu( SMESHOp::OpExportSTL, exportId, -1 );
4136 createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
4138 createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
4139 createMenu( SMESHOp::OpExportGMF, exportId, -1 );
4140 createMenu( separator(), fileId, 10 );
4142 createMenu( SMESHOp::OpDelete, editId, -1 );
4144 createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
4146 createMenu( SMESHOp::OpCreateMesh, meshId, -1 ); // "Mesh" menu
4147 createMenu( SMESHOp::OpCreateSubMesh, meshId, -1 );
4148 createMenu( SMESHOp::OpEditMeshOrSubMesh, meshId, -1 );
4149 createMenu( SMESHOp::OpBuildCompoundMesh, meshId, -1 );
4150 createMenu( SMESHOp::OpCopyMesh, meshId, -1 );
4151 createMenu( separator(), meshId, -1 );
4152 createMenu( SMESHOp::OpCompute, meshId, -1 );
4153 createMenu( SMESHOp::OpPreCompute, meshId, -1 );
4154 createMenu( SMESHOp::OpEvaluate, meshId, -1 );
4155 createMenu( SMESHOp::OpMeshOrder, meshId, -1 );
4156 createMenu( separator(), meshId, -1 );
4157 createMenu( SMESHOp::OpCreateGroup, meshId, -1 );
4158 createMenu( SMESHOp::OpCreateGeometryGroup, meshId, -1 );
4159 createMenu( SMESHOp::OpConstructGroup, meshId, -1 );
4160 createMenu( SMESHOp::OpEditGroup, meshId, -1 );
4161 createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4162 createMenu( separator(), meshId, -1 );
4163 createMenu( SMESHOp::OpUnionGroups, meshId, -1 );
4164 createMenu( SMESHOp::OpIntersectGroups, meshId, -1 );
4165 createMenu( SMESHOp::OpCutGroups, meshId, -1 );
4166 createMenu( separator(), meshId, -1 );
4167 createMenu( SMESHOp::OpGroupUnderlyingElem, meshId, -1 );
4168 createMenu( SMESHOp::OpFaceGroupsByEdges, meshId, -1 );
4169 createMenu( separator(), meshId, -1 );
4170 createMenu( SMESHOp::OpMeshInformation, meshId, -1 );
4171 //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4172 //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4173 createMenu( SMESHOp::OpFindElementByPoint, meshId, -1 );
4174 createMenu( separator(), meshId, -1 );
4176 createMenu( SMESHOp::OpFreeNode, nodeId, -1 );
4177 createMenu( SMESHOp::OpEqualNode, nodeId, -1 );
4178 //createMenu( SMESHOp::OpNodeConnectivityNb, nodeId, -1 );
4179 createMenu( SMESHOp::OpFreeBorder, edgeId, -1 );
4180 createMenu( SMESHOp::OpLength, edgeId, -1 );
4181 createMenu( SMESHOp::OpConnection, edgeId, -1 );
4182 createMenu( SMESHOp::OpEqualEdge, edgeId, -1 );
4183 createMenu( SMESHOp::OpFreeEdge, faceId, -1 );
4184 createMenu( SMESHOp::OpFreeFace, faceId, -1 );
4185 createMenu( SMESHOp::OpBareBorderFace, faceId, -1 );
4186 createMenu( SMESHOp::OpOverConstrainedFace, faceId, -1 );
4187 createMenu( SMESHOp::OpLength2D, faceId, -1 );
4188 createMenu( SMESHOp::OpConnection2D, faceId, -1 );
4189 createMenu( SMESHOp::OpArea, faceId, -1 );
4190 createMenu( SMESHOp::OpTaper, faceId, -1 );
4191 createMenu( SMESHOp::OpAspectRatio, faceId, -1 );
4192 createMenu( SMESHOp::OpMinimumAngle, faceId, -1 );
4193 createMenu( SMESHOp::OpWarpingAngle, faceId, -1 );
4194 createMenu( SMESHOp::OpSkew, faceId, -1 );
4195 createMenu( SMESHOp::OpMaxElementLength2D, faceId, -1 );
4196 createMenu( SMESHOp::OpEqualFace, faceId, -1 );
4197 createMenu( SMESHOp::OpDeflection2D, faceId, -1 );
4198 createMenu( SMESHOp::OpAspectRatio3D, volumeId, -1 );
4199 createMenu( SMESHOp::OpVolume, volumeId, -1 );
4200 createMenu( SMESHOp::OpMaxElementLength3D, volumeId, -1 );
4201 createMenu( SMESHOp::OpBareBorderVolume, volumeId, -1 );
4202 createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4203 createMenu( SMESHOp::OpEqualVolume, volumeId, -1 );
4204 createMenu( separator(), ctrlId, -1 );
4205 createMenu( SMESHOp::OpReset, ctrlId, -1 );
4206 createMenu( separator(), ctrlId, -1 );
4207 createMenu( SMESHOp::OpOverallMeshQuality, ctrlId, -1 );
4209 createMenu( SMESHOp::OpNode, addId, -1 );
4210 createMenu( SMESHOp::OpElem0D, addId, -1 );
4211 createMenu( SMESHOp::OpElem0DOnElemNodes, addId, -1 );
4212 createMenu( SMESHOp::OpBall, addId, -1 );
4213 createMenu( SMESHOp::OpEdge, addId, -1 );
4214 createMenu( SMESHOp::OpTriangle, addId, -1 );
4215 createMenu( SMESHOp::OpQuadrangle, addId, -1 );
4216 createMenu( SMESHOp::OpPolygon, addId, -1 );
4217 createMenu( SMESHOp::OpTetrahedron, addId, -1 );
4218 createMenu( SMESHOp::OpHexahedron, addId, -1 );
4219 createMenu( SMESHOp::OpPentahedron, addId, -1 );
4220 createMenu( SMESHOp::OpPyramid, addId, -1 );
4221 createMenu( SMESHOp::OpHexagonalPrism, addId, -1 );
4222 createMenu( SMESHOp::OpPolyhedron, addId, -1 );
4223 createMenu( separator(), addId, -1 );
4224 createMenu( SMESHOp::OpQuadraticEdge, addId, -1 );
4225 createMenu( SMESHOp::OpQuadraticTriangle, addId, -1 );
4226 createMenu( SMESHOp::OpBiQuadraticTriangle , addId, -1 );
4227 createMenu( SMESHOp::OpQuadraticQuadrangle, addId, -1 );
4228 createMenu( SMESHOp::OpBiQuadraticQuadrangle, addId, -1 );
4229 createMenu( SMESHOp::OpQuadraticPolygon, addId, -1 );
4230 createMenu( SMESHOp::OpQuadraticTetrahedron, addId, -1 );
4231 createMenu( SMESHOp::OpQuadraticPyramid, addId, -1 );
4232 createMenu( SMESHOp::OpQuadraticPentahedron, addId, -1 );
4233 createMenu( SMESHOp::OpBiQuadraticPentahedron, addId, -1 );
4234 createMenu( SMESHOp::OpQuadraticHexahedron, addId, -1 );
4235 createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4237 createMenu( SMESHOp::OpRemoveNodes, removeId, -1 );
4238 createMenu( SMESHOp::OpRemoveElements, removeId, -1 );
4239 createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4240 createMenu( separator(), removeId, -1 );
4241 createMenu( SMESHOp::OpDeleteGroup, removeId, -1 );
4242 createMenu( separator(), removeId, -1 );
4243 createMenu( SMESHOp::OpClearMesh, removeId, -1 );
4245 //createMenu( SMESHOp::OpRenumberingNodes, renumId, -1 );
4246 //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4248 createMenu( SMESHOp::OpMergeNodes, transfId, -1 );
4249 createMenu( SMESHOp::OpMergeElements, transfId, -1 );
4250 createMenu( SMESHOp::OpTranslation, transfId, -1 );
4251 createMenu( SMESHOp::OpRotation, transfId, -1 );
4252 createMenu( SMESHOp::OpSymmetry, transfId, -1 );
4253 createMenu( SMESHOp::OpScale, transfId, -1 );
4254 createMenu( SMESHOp::OpOffset, transfId, -1 );
4255 createMenu( SMESHOp::OpSewing, transfId, -1 );
4256 createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4258 createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4259 createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4260 createMenu( SMESHOp::OpExtrusion, modifyId, -1 );
4261 createMenu( SMESHOp::OpExtrusionAlongAPath, modifyId, -1 );
4262 createMenu( SMESHOp::OpRevolution, modifyId, -1 );
4263 createMenu( SMESHOp::OpOrientation, modifyId, -1 );
4264 createMenu( SMESHOp::OpReorientFaces, modifyId, -1 );
4265 createMenu( SMESHOp::OpMoveNode, modifyId, -1 );
4266 createMenu( SMESHOp::OpDiagonalInversion, modifyId, -1 );
4267 createMenu( SMESHOp::OpUnionOfTwoTriangle, modifyId, -1 );
4268 createMenu( SMESHOp::OpUnionOfTriangles, modifyId, -1 );
4269 createMenu( SMESHOp::OpCuttingOfQuadrangles, modifyId, -1 );
4270 createMenu( SMESHOp::OpSplitVolumes, modifyId, -1 );
4271 createMenu( SMESHOp::OpSplitBiQuadratic, modifyId, -1 );
4272 createMenu( SMESHOp::OpSmoothing, modifyId, -1 );
4273 createMenu( SMESHOp::OpPatternMapping, modifyId, -1 );
4275 createMenu( SMESHOp::OpMinimumDistance, measureId, -1 );
4276 createMenu( SMESHOp::OpBoundingBox, measureId, -1 );
4277 createMenu( SMESHOp::OpAngle, measureId, -1 );
4278 createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4279 createMenu( SMESHOp::OpPropertiesArea, basicPropId, -1 );
4280 createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4281 createMenu( SMESHOp::OpUpdate, viewId, -1 );
4283 connect( nodeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4284 connect( edgeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4285 connect( faceMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4286 connect( volumeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4288 // ----- create toolbars --------------
4289 int meshTb = createTool( tr( "TB_MESH" ), QString( "SMESHMeshToolbar" ) ),
4290 info = createTool( tr( "TB_INFO" ), QString( "SMESHInformationToolbar" ) ),
4291 groupTb = createTool( tr( "TB_GROUP" ), QString( "SMESHGroupToolbar" ) ),
4292 ctrl0dTb = createTool( tr( "TB_CTRL0D" ), QString( "SMESHNodeControlsToolbar" ) ),
4293 ctrl1dTb = createTool( tr( "TB_CTRL1D" ), QString( "SMESHEdgeControlsToolbar" ) ),
4294 ctrl2dTb = createTool( tr( "TB_CTRL2D" ), QString( "SMESHFaceControlsToolbar" ) ),
4295 ctrl3dTb = createTool( tr( "TB_CTRL3D" ), QString( "SMESHVolumeControlsToolbar" ) ),
4296 addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ),
4297 addNonElemTb = createTool( tr( "TB_ADDNON" ), QString( "SMESHAddElementToolbar" ) ),
4298 remTb = createTool( tr( "TB_REM" ), QString( "SMESHRemoveToolbar" ) ),
4299 //renumbTb = createTool( tr( "TB_RENUMBER" ), QString( "SMESHRenumberingToolbar" ) ),
4300 transformTb = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ),
4301 modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ),
4302 measuremTb = createTool( tr( "TB_MEASUREM" ), QString( "SMESHMeasurementsToolbar" ) ),
4303 dispModeTb = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4305 createTool( SMESHOp::OpCreateMesh, meshTb );
4306 createTool( SMESHOp::OpCreateSubMesh, meshTb );
4307 createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4308 createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4309 createTool( SMESHOp::OpCopyMesh, meshTb );
4310 createTool( separator(), meshTb );
4311 createTool( SMESHOp::OpCompute, meshTb );
4312 createTool( SMESHOp::OpPreCompute, meshTb );
4313 createTool( SMESHOp::OpEvaluate, meshTb );
4314 createTool( SMESHOp::OpMeshOrder, meshTb );
4316 createTool( SMESHOp::OpCreateGroup, groupTb );
4317 createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4318 createTool( SMESHOp::OpConstructGroup, groupTb );
4319 createTool( SMESHOp::OpEditGroup, groupTb );
4321 createTool( SMESHOp::OpMeshInformation, info );
4322 //createTool( SMESHOp::OpStdInfo, meshTb );
4323 //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4324 createTool( SMESHOp::OpFindElementByPoint, info );
4326 createTool( SMESHOp::OpFreeNode, ctrl0dTb );
4327 createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4328 //createTool( SMESHOp::OpNodeConnectivityNb, ctrl0dTb );
4330 createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4331 createTool( SMESHOp::OpLength, ctrl1dTb );
4332 createTool( SMESHOp::OpConnection, ctrl1dTb );
4333 createTool( SMESHOp::OpEqualEdge, ctrl1dTb );
4335 createTool( SMESHOp::OpFreeEdge, ctrl2dTb );
4336 createTool( SMESHOp::OpFreeFace, ctrl2dTb );
4337 createTool( SMESHOp::OpBareBorderFace, ctrl2dTb );
4338 createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4339 createTool( SMESHOp::OpLength2D, ctrl2dTb );
4340 createTool( SMESHOp::OpConnection2D, ctrl2dTb );
4341 createTool( SMESHOp::OpArea, ctrl2dTb );
4342 createTool( SMESHOp::OpTaper, ctrl2dTb );
4343 createTool( SMESHOp::OpAspectRatio, ctrl2dTb );
4344 createTool( SMESHOp::OpMinimumAngle, ctrl2dTb );
4345 createTool( SMESHOp::OpWarpingAngle, ctrl2dTb );
4346 createTool( SMESHOp::OpSkew, ctrl2dTb );
4347 createTool( SMESHOp::OpMaxElementLength2D, ctrl2dTb );
4348 createTool( SMESHOp::OpEqualFace, ctrl2dTb );
4349 createTool( SMESHOp::OpDeflection2D, ctrl2dTb );
4351 createTool( SMESHOp::OpAspectRatio3D, ctrl3dTb );
4352 createTool( SMESHOp::OpVolume, ctrl3dTb );
4353 createTool( SMESHOp::OpMaxElementLength3D, ctrl3dTb );
4354 createTool( SMESHOp::OpBareBorderVolume, ctrl3dTb );
4355 createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
4356 createTool( SMESHOp::OpEqualVolume, ctrl3dTb );
4358 createTool( SMESHOp::OpNode, addElemTb );
4359 createTool( SMESHOp::OpElem0D, addElemTb );
4360 createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4361 createTool( SMESHOp::OpBall, addElemTb );
4362 createTool( SMESHOp::OpEdge, addElemTb );
4363 createTool( SMESHOp::OpTriangle, addElemTb );
4364 createTool( SMESHOp::OpQuadrangle, addElemTb );
4365 createTool( SMESHOp::OpPolygon, addElemTb );
4366 createTool( SMESHOp::OpTetrahedron, addElemTb );
4367 createTool( SMESHOp::OpHexahedron, addElemTb );
4368 createTool( SMESHOp::OpPentahedron, addElemTb );
4369 createTool( SMESHOp::OpPyramid, addElemTb );
4370 createTool( SMESHOp::OpHexagonalPrism, addElemTb );
4371 createTool( SMESHOp::OpPolyhedron, addElemTb );
4373 createTool( SMESHOp::OpQuadraticEdge, addNonElemTb );
4374 createTool( SMESHOp::OpQuadraticTriangle, addNonElemTb );
4375 createTool( SMESHOp::OpBiQuadraticTriangle, addNonElemTb );
4376 createTool( SMESHOp::OpQuadraticQuadrangle, addNonElemTb );
4377 createTool( SMESHOp::OpBiQuadraticQuadrangle, addNonElemTb );
4378 createTool( SMESHOp::OpQuadraticPolygon, addNonElemTb );
4379 createTool( SMESHOp::OpQuadraticTetrahedron, addNonElemTb );
4380 createTool( SMESHOp::OpQuadraticPyramid, addNonElemTb );
4381 createTool( SMESHOp::OpQuadraticPentahedron, addNonElemTb );
4382 createTool( SMESHOp::OpBiQuadraticPentahedron, addNonElemTb );
4383 createTool( SMESHOp::OpQuadraticHexahedron, addNonElemTb );
4384 createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4386 createTool( SMESHOp::OpRemoveNodes, remTb );
4387 createTool( SMESHOp::OpRemoveElements, remTb );
4388 createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4389 createTool( SMESHOp::OpClearMesh, remTb );
4391 //createTool( SMESHOp::OpRenumberingNodes, renumbTb );
4392 //createTool( SMESHOp::OpRenumberingElements, renumbTb );
4394 createTool( SMESHOp::OpMergeNodes, transformTb );
4395 createTool( SMESHOp::OpMergeElements, transformTb );
4396 createTool( SMESHOp::OpTranslation, transformTb );
4397 createTool( SMESHOp::OpRotation, transformTb );
4398 createTool( SMESHOp::OpSymmetry, transformTb );
4399 createTool( SMESHOp::OpScale, transformTb );
4400 createTool( SMESHOp::OpOffset, transformTb );
4401 createTool( SMESHOp::OpSewing, transformTb );
4402 createTool( SMESHOp::OpDuplicateNodes, transformTb );
4404 createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4405 createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4406 createTool( SMESHOp::OpExtrusion, modifyTb );
4407 createTool( SMESHOp::OpExtrusionAlongAPath, modifyTb );
4408 createTool( SMESHOp::OpRevolution, modifyTb );
4409 createTool( SMESHOp::OpOrientation, modifyTb );
4410 createTool( SMESHOp::OpReorientFaces, modifyTb );
4411 createTool( SMESHOp::OpMoveNode, modifyTb );
4412 createTool( SMESHOp::OpDiagonalInversion, modifyTb );
4413 createTool( SMESHOp::OpUnionOfTwoTriangle, modifyTb );
4414 createTool( SMESHOp::OpUnionOfTriangles, modifyTb );
4415 createTool( SMESHOp::OpCuttingOfQuadrangles, modifyTb );
4416 createTool( SMESHOp::OpSplitVolumes, modifyTb );
4417 createTool( SMESHOp::OpSplitBiQuadratic, modifyTb );
4418 createTool( SMESHOp::OpSmoothing, modifyTb );
4419 createTool( SMESHOp::OpPatternMapping, modifyTb );
4421 createTool( SMESHOp::OpMinimumDistance, measuremTb );
4423 createTool( SMESHOp::OpUpdate, dispModeTb );
4425 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4426 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4430 OB = "'ObjectBrowser'",
4431 View = "'" + SVTK_Viewer::Type() + "'",
4433 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4434 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4435 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4436 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4437 smesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::COMPONENT ) ),
4438 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4439 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4440 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4441 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4442 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4443 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4444 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4446 mesh_part = mesh + " " + subMesh + " " + group,
4447 mesh_group = mesh + " " + group,
4448 mesh_submesh = mesh + " " + subMesh,
4449 hyp_alg = hypo + " " + algo;
4451 // popup for object browser
4453 isInvisible("not( isVisible )"),
4454 isEmpty("numberOfNodes = 0"),
4455 isNotEmpty("numberOfNodes <> 0"),
4457 // has nodes, edges, etc in VISIBLE! actor
4458 hasNodes("(numberOfNodes > 0 ) && hasActor"),
4459 hasElems("(count( elemTypes ) > 0)"),
4460 hasDifferentElems("(count( elemTypes ) > 1)"),
4461 hasDifferentObjElems("(count( objElemTypes ) > 1)"),
4462 hasBalls("({'BallElem'} in elemTypes)"),
4463 hasElems0d("({'Elem0d'} in elemTypes)"),
4464 hasEdges("({'Edge'} in elemTypes)"),
4465 hasFaces("({'Face'} in elemTypes)"),
4466 hasVolumes("({'Volume'} in elemTypes)"),
4467 hasFacesOrVolumes("(({'Face'} in elemTypes) || ({'Volume'} in elemTypes)) ");
4469 createPopupItem( SMESHOp::OpFileInformation, OB, mesh, "&& selcount=1 && isImported" );
4470 createPopupItem( SMESHOp::OpCreateSubMesh, OB, mesh, "&& hasGeomReference");
4471 createPopupItem( SMESHOp::OpEditMesh, OB, mesh, "&& selcount=1" );
4472 createPopupItem( SMESHOp::OpEditSubMesh, OB, subMesh, "&& selcount=1 && hasGeomReference" );
4473 createPopupItem( SMESHOp::OpEditGroup, OB, group );
4474 createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4476 popupMgr()->insert( separator(), -1, 0 );
4477 createPopupItem( SMESHOp::OpCompute, OB, mesh, "&& selcount=1 && isComputable" );
4478 createPopupItem( SMESHOp::OpComputeSubMesh, OB, subMesh, "&& selcount=1 && isComputable" );
4479 createPopupItem( SMESHOp::OpPreCompute, OB, mesh, "&& selcount=1 && isPreComputable" );
4480 createPopupItem( SMESHOp::OpEvaluate, OB, mesh, "&& selcount=1 && isComputable" );
4481 createPopupItem( SMESHOp::OpMeshOrder, OB, mesh, "&& selcount=1 && isComputable && hasGeomReference" );
4482 createPopupItem( SMESHOp::OpUpdate, OB, mesh_part );
4483 createPopupItem( SMESHOp::OpMeshInformation, OB, mesh_part );
4484 createPopupItem( SMESHOp::OpFindElementByPoint,OB, mesh_group, "&& selcount=1" );
4485 createPopupItem( SMESHOp::OpOverallMeshQuality,OB, mesh_part );
4486 popupMgr()->insert( separator(), -1, 0 );
4487 createPopupItem( SMESHOp::OpCreateGroup, OB, mesh, "&& selcount=1" );
4488 createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh, "&& selcount=1 && hasGeomReference" );
4489 createPopupItem( SMESHOp::OpConstructGroup, OB, subMesh );
4490 popupMgr()->insert( separator(), -1, 0 );
4491 createPopupItem( SMESHOp::OpEditHypothesis, OB, hypo, "&& isEditableHyp");
4492 createPopupItem( SMESHOp::OpUnassign, OB, hyp_alg );
4493 popupMgr()->insert( separator(), -1, 0 );
4494 createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh_submesh );
4495 createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh_group, "&& selcount=1 && dim>=2");
4496 popupMgr()->insert( separator(), -1, 0 );
4497 createPopupItem( SMESHOp::OpClearMesh, OB, mesh );
4498 //popupMgr()->insert( separator(), -1, 0 );
4500 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4501 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4502 QString only_one_2D = only_one_non_empty + " && dim>1";
4504 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4505 createPopupItem( SMESHOp::OpPopupExportMED, OB, mesh_group, multiple_non_empty, anId );
4506 createPopupItem( SMESHOp::OpPopupExportUNV, OB, mesh_group, only_one_non_empty, anId );
4507 createPopupItem( SMESHOp::OpPopupExportSTL, OB, mesh_group, only_one_2D, anId );
4509 createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4511 createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, only_one_non_empty, anId );
4512 createPopupItem( SMESHOp::OpPopupExportGMF, OB, mesh_group, only_one_non_empty, anId );
4513 createPopupItem( SMESHOp::OpPopupExportDAT, OB, mesh_group, only_one_non_empty, anId );
4514 createPopupItem( SMESHOp::OpDelete, OB, mesh_part + " " + hyp_alg );
4515 createPopupItem( SMESHOp::OpDeleteGroup, OB, group );
4517 anId = popupMgr()->insert( tr( "MEN_IMPORT" ), -1, -1 ); // IMPORT submenu
4518 createPopupItem( SMESHOp::OpPopupImportMED, OB, smesh, "", anId );
4519 createPopupItem( SMESHOp::OpPopupImportUNV, OB, smesh, "", anId );
4520 createPopupItem( SMESHOp::OpPopupImportSTL, OB, smesh, "", anId );
4522 createPopupItem( SMESHOp::OpPopupImportCGNS, OB, smesh, "", anId );
4524 createPopupItem( SMESHOp::OpPopupImportSAUV, OB, smesh, "", anId );
4525 createPopupItem( SMESHOp::OpPopupImportGMF, OB, smesh, "", anId );
4526 createPopupItem( SMESHOp::OpPopupImportDAT, OB, smesh, "", anId );
4527 popupMgr()->insert( separator(), -1, 0 );
4530 createPopupItem( SMESHOp::OpEditGroup, View, group );
4531 createPopupItem( SMESHOp::OpAddElemGroupPopup, View, elems, "&& guiState = 800" );
4532 createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems, "&& guiState = 800" );
4534 popupMgr()->insert( separator(), -1, 0 );
4535 createPopupItem( SMESHOp::OpUpdate, View, mesh_part );
4536 createPopupItem( SMESHOp::OpMeshInformation, View, mesh_part );
4537 createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4538 createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh );
4539 popupMgr()->insert( separator(), -1, 0 );
4541 createPopupItem( SMESHOp::OpAutoColor, OB + " " + View, mesh, "&& (not isAutoColor)" );
4542 createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4543 popupMgr()->insert( separator(), -1, 0 );
4545 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4546 QString aType = QString( "%1type in {%2}" ).arg( lc );
4547 aType = aType.arg( mesh_part );
4548 QString aMeshInVTK = aClient + "&&" + aType;
4550 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4551 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4552 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4554 //-------------------------------------------------
4556 //-------------------------------------------------
4557 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4559 popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4560 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4561 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4563 popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4564 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4565 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4567 popupMgr()->insert( separator(), -1, -1 );
4569 //-------------------------------------------------
4571 //-------------------------------------------------
4572 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4574 popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4575 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4576 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4578 popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4579 popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4580 popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4582 popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4583 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4584 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4586 popupMgr()->insert( separator(), anId, -1 );
4588 popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4589 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4590 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4592 //-------------------------------------------------
4594 //-------------------------------------------------
4595 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4597 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4599 popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4600 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4601 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4603 popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4604 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4605 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4607 popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4608 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4609 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4611 popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4612 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4613 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4615 popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4616 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4617 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4619 popupMgr()->insert( separator(), anId, -1 );
4621 popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4622 popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&& $type in {" + mesh + "} &&" + hasDifferentObjElems, QtxPopupMgr::VisibleRule );
4624 popupMgr()->insert( separator(), anId, -1 );
4626 popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4627 popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4630 //-------------------------------------------------
4631 // Representation of the 2D Quadratic elements
4632 //-------------------------------------------------
4633 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4634 popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4635 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "&& isVisible && isQuadratic",QtxPopupMgr::VisibleRule );
4636 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4638 popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4639 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "&& isVisible && isQuadratic", QtxPopupMgr::VisibleRule );
4640 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4642 //-------------------------------------------------
4643 // Orientation of faces
4644 //-------------------------------------------------
4645 popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4646 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4647 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4649 //-------------------------------------------------
4651 //-------------------------------------------------
4652 popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4653 popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4655 //-------------------------------------------------
4657 //-------------------------------------------------
4658 popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4659 popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4661 //-------------------------------------------------
4663 //-------------------------------------------------
4665 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4666 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4667 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4668 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4670 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4672 popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4673 popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4675 popupMgr()->insert( separator(), anId, -1 );
4677 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4679 popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4680 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4681 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4683 popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4684 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4685 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4687 // popupMgr()->insert( action( SMESHOp::OpNodeConnectivityNb ), aSubId, -1 );
4688 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4689 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), "controlMode = 'eNodeConnectivityNb'", QtxPopupMgr::ToggleRule );
4691 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4693 popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4694 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVTK + "&&" + hasEdges + "&&" + hasFacesOrVolumes, QtxPopupMgr::VisibleRule );
4695 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4697 popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4698 popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4699 popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4701 popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4702 popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4703 popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4704 popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4705 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4706 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4708 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4710 popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4711 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4712 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4714 popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4715 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4716 QtxPopupMgr::VisibleRule );
4717 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4719 popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4720 popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4721 popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4723 popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4724 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4725 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4727 popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
4728 popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4729 popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4731 popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
4732 popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4733 popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4735 popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
4736 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4737 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4739 popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
4740 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4741 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4743 popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
4744 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4745 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4747 popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
4748 popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4749 popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4751 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
4752 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4753 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4755 popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
4756 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4757 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4759 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
4760 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4761 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4763 popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
4764 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4765 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4767 popupMgr()->insert ( action( SMESHOp::OpDeflection2D ), aSubId, -1 );
4768 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), aMeshInVtkHasFaces + " && hasGeomReference", QtxPopupMgr::VisibleRule );
4769 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), "controlMode = 'eDeflection2D'", QtxPopupMgr::ToggleRule );
4771 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4773 popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D ), aSubId, -1 );
4774 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4775 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4777 popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
4778 popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4779 popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4781 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
4782 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4783 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4785 popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
4786 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4787 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4789 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
4790 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4791 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4793 popupMgr()->insert ( action( SMESHOp::OpEqualVolume ), aSubId, -1 );
4794 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4795 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4797 popupMgr()->insert( separator(), anId, -1 );
4799 popupMgr()->insert( action( SMESHOp::OpShowScalarBar ), anId, -1 );
4800 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4801 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone' && isScalarBarVisible", QtxPopupMgr::ToggleRule );
4802 popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
4803 popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4805 popupMgr()->insert( separator(), anId, -1 );
4807 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4809 popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
4810 popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4812 popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
4813 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4814 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isScalarBarVisible && isDistributionVisible", QtxPopupMgr::ToggleRule);
4816 #ifndef DISABLE_PLOT2DVIEWER
4817 popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
4818 popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4821 //-------------------------------------------------
4823 //-------------------------------------------------
4824 popupMgr()->insert( separator(), -1, -1 );
4825 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4826 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4827 popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
4828 popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4830 popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
4831 popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4833 popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
4834 popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4836 popupMgr()->insert( separator(), -1, -1 );
4838 //-------------------------------------------------
4840 //-------------------------------------------------
4841 popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
4842 popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4844 popupMgr()->insert( separator(), -1, -1 );
4846 popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
4847 popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
4848 popupMgr()->insert( separator(), -1, -1 );
4850 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4851 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4853 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4854 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4857 //================================================================================
4859 * \brief Return true if SMESH or GEOM objects are selected.
4860 * Is called form LightApp_Module::activateModule() which clear selection if
4861 * not isSelectionCompatible()
4863 //================================================================================
4865 bool SMESHGUI::isSelectionCompatible()
4867 bool isCompatible = true;
4868 SALOME_ListIO selected;
4869 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4870 Sel->selectedObjects( selected );
4872 SALOME_ListIteratorOfListIO It( selected );
4873 for ( ; isCompatible && It.More(); It.Next())
4875 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4876 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4878 return isCompatible;
4882 bool SMESHGUI::reusableOperation( const int id )
4884 // compute, evaluate and precompute are not reusable operations
4885 return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate ) ? false : SalomeApp_Module::reusableOperation( id );
4888 bool SMESHGUI::activateModule( SUIT_Study* study )
4890 bool res = SalomeApp_Module::activateModule( study );
4892 setMenuShown( true );
4893 setToolShown( true );
4895 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4896 PyGILState_STATE gstate = PyGILState_Ensure();
4897 PyObject* pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4898 if ( !pluginsmanager ) {
4902 PyObject* result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toUtf8().data(),tr("SMESH_PLUGINS_OTHER").toUtf8().data());
4907 PyGILState_Release(gstate);
4908 // end of SMESH plugins loading
4910 // Reset actions accelerator keys
4911 action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
4913 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4914 GetSMESHGen()->UpdateStudy();
4916 // get all view currently opened in the study and connect their signals to
4917 // the corresponding slots of the class.
4918 SUIT_Desktop* aDesk = study->application()->desktop();
4920 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4921 SUIT_ViewWindow* wnd;
4922 foreach ( wnd, wndList )
4926 Py_XDECREF(pluginsmanager);
4930 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4932 setMenuShown( false );
4933 setToolShown( false );
4935 EmitSignalCloseAllDialogs();
4937 // Unset actions accelerator keys
4938 action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
4940 return SalomeApp_Module::deactivateModule( study );
4943 void SMESHGUI::studyClosed( SUIT_Study* s )
4947 SMESH::RemoveVisuData();
4948 SalomeApp_Module::studyClosed( s );
4951 void SMESHGUI::OnGUIEvent()
4953 const QObject* obj = sender();
4954 if ( !obj || !obj->inherits( "QAction" ) )
4956 int id = actionId((QAction*)obj);
4961 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4963 if ( CORBA::is_nil( myComponentSMESH ) )
4965 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4966 return aGUI.myComponentSMESH;
4968 return myComponentSMESH;
4971 QString SMESHGUI::engineIOR() const
4973 CORBA::ORB_var anORB = getApp()->orb();
4974 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4975 return QString( anIOR.in() );
4978 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4980 SalomeApp_Module::contextMenuPopup( client, menu, title );
4982 selectionMgr()->selectedObjects( lst );
4983 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4984 Handle(SALOME_InteractiveObject) io = lst.First();
4985 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4986 _PTR(Study) study = appStudy->studyDS();
4987 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4989 QString aName = QString( SMESH::fromUtf8(obj->GetName()) );
4990 while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4991 aName.remove( (aName.length() - 1), 1 );
4997 LightApp_Selection* SMESHGUI::createSelection() const
4999 return new SMESHGUI_Selection();
5002 void SMESHGUI::windows( QMap<int, int>& aMap ) const
5004 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
5005 aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
5006 #ifndef DISABLE_PYCONSOLE
5007 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
5011 void SMESHGUI::viewManagers( QStringList& list ) const
5013 list.append( SVTK_Viewer::Type() );
5016 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
5018 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
5019 SMESH::UpdateSelectionProp( this );
5021 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
5022 for(int i = 0; i < aViews.count() ; i++){
5023 SUIT_ViewWindow *sf = aViews[i];
5026 EmitSignalActivatedViewManager();
5030 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
5032 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
5033 myClippingPlaneInfoMap.erase( theViewManager );
5036 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
5038 theActor->AddObserver( SMESH::DeleteActorEvent,
5039 myEventCallbackCommand.GetPointer(),
5043 void SMESHGUI::ProcessEvents( vtkObject* theObject,
5044 unsigned long theEvent,
5045 void* theClientData,
5048 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
5049 if( theObject && (int) theEvent == SMESH::DeleteActorEvent ) {
5050 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
5051 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
5052 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
5053 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
5054 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
5055 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
5056 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
5057 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
5058 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
5059 SMESH::TActorList::iterator anIter3 = anActorList.begin();
5060 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
5061 if( anActor == *anIter3 ) {
5062 anActorList.erase( anIter3 );
5073 void SMESHGUI::createPreferences()
5075 // General tab ------------------------------------------------------------------------
5076 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
5078 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
5079 setPreferenceProperty( autoUpdate, "columns", 2 );
5080 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
5081 setPreferenceProperty( lim, "min", 0 );
5082 setPreferenceProperty( lim, "max", 100000000 );
5083 setPreferenceProperty( lim, "step", 1000 );
5084 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5085 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
5087 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
5088 setPreferenceProperty( dispgroup, "columns", 2 );
5090 addPreference( tr( "PREF_FITALL_ON_DISPLAYONLY" ), dispgroup, LightApp_Preferences::Bool, "SMESH", "fitall_on_displayonly" );
5092 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
5094 modes.append( tr("MEN_WIRE") );
5095 modes.append( tr("MEN_SHADE") );
5096 modes.append( tr("MEN_NODES") );
5097 modes.append( tr("MEN_SHRINK") );
5098 QList<QVariant> indices;
5099 indices.append( 0 );
5100 indices.append( 1 );
5101 indices.append( 2 );
5102 indices.append( 3 );
5103 setPreferenceProperty( dispmode, "strings", modes );
5104 setPreferenceProperty( dispmode, "indexes", indices );
5106 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
5107 setPreferenceProperty( arcgroup, "columns", 2 );
5108 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
5109 QStringList quadraticModes;
5110 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
5111 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
5113 indices.append( 0 );
5114 indices.append( 1 );
5115 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
5116 setPreferenceProperty( quadraticmode, "indexes", indices );
5118 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
5119 "SMESH", "max_angle" );
5120 setPreferenceProperty( maxAngle, "min", 1 );
5121 setPreferenceProperty( maxAngle, "max", 90 );
5123 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
5124 setPreferenceProperty( qaGroup, "columns", 2 );
5125 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
5126 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
5127 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
5128 setPreferenceProperty( prec, "min", 0 );
5129 setPreferenceProperty( prec, "max", 100 );
5130 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
5131 setPreferenceProperty( doubleNodesTol, "precision", 10 );
5132 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
5133 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
5134 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
5137 int cinc = addPreference(tr("PREF_CONTROLS_INCREMENT"), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_increment");
5138 setPreferenceProperty( cinc, "min", 0 );
5139 setPreferenceProperty( cinc, "max", 5 );
5142 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
5143 setPreferenceProperty( exportgroup, "columns", 2 );
5144 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
5145 addPreference( tr( "PREF_SHOW_WARN" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "show_warning" );
5146 int zTol = addPreference( tr( "PREF_ZTOLERANCE" ), exportgroup, LightApp_Preferences::DblSpin, "SMESH", "med_ztolerance" );
5147 setPreferenceProperty( zTol, "precision", 10 );
5148 setPreferenceProperty( zTol, "min", 0.0000000001 );
5149 setPreferenceProperty( zTol, "max", 1000000.0 );
5150 setPreferenceProperty( zTol, "step", 1. );
5151 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
5153 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
5154 setPreferenceProperty( computeGroup, "columns", 2 );
5155 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
5157 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5158 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5159 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5161 indices.append( 0 );
5162 indices.append( 1 );
5163 indices.append( 2 );
5164 setPreferenceProperty( notifyMode, "strings", modes );
5165 setPreferenceProperty( notifyMode, "indexes", indices );
5167 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5168 setPreferenceProperty( infoGroup, "columns", 2 );
5169 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5171 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5172 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5174 indices.append( 0 );
5175 indices.append( 1 );
5176 setPreferenceProperty( elemInfo, "strings", modes );
5177 setPreferenceProperty( elemInfo, "indexes", indices );
5178 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5179 setPreferenceProperty( nodesLim, "min", 0 );
5180 setPreferenceProperty( nodesLim, "max", 10000000 );
5181 setPreferenceProperty( nodesLim, "step", 10000 );
5182 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5183 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5184 setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5185 setPreferenceProperty( ctrlLim, "min", 0 );
5186 setPreferenceProperty( ctrlLim, "max", 10000000 );
5187 setPreferenceProperty( ctrlLim, "step", 1000 );
5188 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5189 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5190 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5191 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5192 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5194 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5195 setPreferenceProperty( segGroup, "columns", 2 );
5196 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5197 "SMESH", "segmentation" );
5198 setPreferenceProperty( segLen, "min", 1 );
5199 setPreferenceProperty( segLen, "max", 10000000 );
5200 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5201 "SMESH", "nb_segments_per_edge" );
5202 setPreferenceProperty( nbSeg, "min", 1 );
5203 setPreferenceProperty( nbSeg, "max", 10000000 );
5205 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5206 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5207 "SMESH", "forget_mesh_on_hyp_modif" );
5210 // Quantities with individual precision settings
5211 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5212 setPreferenceProperty( precGroup, "columns", 2 );
5214 const int nbQuantities = 6;
5215 int precs[nbQuantities], ii = 0;
5216 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5217 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5218 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5219 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5220 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5221 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5222 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5223 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5224 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5225 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5226 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5227 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5229 // Set property for precision value for spinboxes
5230 for ( ii = 0; ii < nbQuantities; ii++ ){
5231 setPreferenceProperty( precs[ii], "min", -14 );
5232 setPreferenceProperty( precs[ii], "max", 14 );
5233 setPreferenceProperty( precs[ii], "precision", 2 );
5236 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5237 setPreferenceProperty( previewGroup, "columns", 2 );
5238 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5239 setPreferenceProperty( chunkSize, "min", 1 );
5240 setPreferenceProperty( chunkSize, "max", 1000 );
5241 setPreferenceProperty( chunkSize, "step", 50 );
5243 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5244 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5246 // Mesh tab ------------------------------------------------------------------------
5247 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5248 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5249 setPreferenceProperty( nodeGroup, "columns", 3 );
5251 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5253 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5255 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5256 QList<QVariant> aMarkerTypeIndicesList;
5257 QList<QVariant> aMarkerTypeIconsList;
5258 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5259 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5260 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5261 aMarkerTypeIndicesList << i;
5262 aMarkerTypeIconsList << pixmap;
5264 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5265 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
5267 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5269 QList<QVariant> aMarkerScaleIndicesList;
5270 QStringList aMarkerScaleValuesList;
5271 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5272 aMarkerScaleIndicesList << i;
5273 //aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5274 aMarkerScaleValuesList << QString::number( i );
5276 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5277 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5279 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5280 //setPreferenceProperty( elemGroup, "columns", 2 );
5282 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5283 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5284 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5285 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5286 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5287 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5288 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5289 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5290 addPreference( tr( "PREF_PREVIEW_COLOR" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5293 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5294 setPreferenceProperty( grpGroup, "columns", 2 );
5296 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5297 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5299 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5300 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5301 /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5302 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5303 double ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5304 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5305 double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5306 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5307 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
5308 LightApp_Preferences::IntSpin, "SMESH", "element_width");
5309 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5310 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5311 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5312 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5314 setPreferenceProperty( size0d, "min", 1 );
5315 setPreferenceProperty( size0d, "max", 10 );
5317 // setPreferenceProperty( ballSize, "min", 1 );
5318 // setPreferenceProperty( ballSize, "max", 10 );
5320 setPreferenceProperty( ballDiameter, "min", 1e-7 );
5321 setPreferenceProperty( ballDiameter, "max", 1e9 );
5322 setPreferenceProperty( ballDiameter, "step", 0.1 );
5324 setPreferenceProperty( ballScale, "min", 1e-2 );
5325 setPreferenceProperty( ballScale, "max", 1e7 );
5326 setPreferenceProperty( ballScale, "step", 0.5 );
5328 setPreferenceProperty( elemW, "min", 1 );
5329 setPreferenceProperty( elemW, "max", 5 );
5331 setPreferenceProperty( outW, "min", 1 );
5332 setPreferenceProperty( outW, "max", 5 );
5334 setPreferenceProperty( shrink, "min", 0 );
5335 setPreferenceProperty( shrink, "max", 100 );
5337 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5338 setPreferenceProperty( numGroup, "columns", 2 );
5340 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5341 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5343 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5344 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5346 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5347 setPreferenceProperty( orientGroup, "columns", 1 );
5349 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5350 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5352 setPreferenceProperty( orientScale, "min", 0.05 );
5353 setPreferenceProperty( orientScale, "max", 0.5 );
5354 setPreferenceProperty( orientScale, "step", 0.05 );
5356 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5358 // Selection tab ------------------------------------------------------------------------
5359 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5361 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5362 setPreferenceProperty( selGroup, "columns", 2 );
5364 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5365 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5367 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5368 setPreferenceProperty( preGroup, "columns", 2 );
5370 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5372 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5373 setPreferenceProperty( precSelGroup, "columns", 2 );
5375 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5376 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5377 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5379 int sinc = addPreference(tr("PREF_SELECTION_INCREMENT"), selTab, LightApp_Preferences::IntSpin, "SMESH", "selection_increment");
5380 setPreferenceProperty( sinc, "min", 0 );
5381 setPreferenceProperty( sinc, "max", 5 );
5383 // Scalar Bar tab ------------------------------------------------------------------------
5384 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5385 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5386 setPreferenceProperty( fontGr, "columns", 2 );
5388 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5389 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5391 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5392 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5394 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5395 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5397 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5398 setPreferenceProperty( numcol, "min", 2 );
5399 setPreferenceProperty( numcol, "max", 256 );
5401 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5402 setPreferenceProperty( numlab, "min", 2 );
5403 setPreferenceProperty( numlab, "max", 65 );
5405 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5406 setPreferenceProperty( orientGr, "columns", 2 );
5407 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5408 QStringList orients;
5409 orients.append( tr( "SMESH_VERTICAL" ) );
5410 orients.append( tr( "SMESH_HORIZONTAL" ) );
5411 indices.clear(); indices.append( 0 ); indices.append( 1 );
5412 setPreferenceProperty( orient, "strings", orients );
5413 setPreferenceProperty( orient, "indexes", indices );
5415 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5416 setPreferenceProperty( posVSizeGr, "columns", 2 );
5417 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5418 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5419 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5420 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5421 setPreferenceProperty( xv, "step", 0.1 );
5422 setPreferenceProperty( xv, "min", 0.0 );
5423 setPreferenceProperty( xv, "max", 1.0 );
5424 setPreferenceProperty( yv, "step", 0.1 );
5425 setPreferenceProperty( yv, "min", 0.0 );
5426 setPreferenceProperty( yv, "max", 1.0 );
5427 setPreferenceProperty( wv, "step", 0.1 );
5428 setPreferenceProperty( wv, "min", 0.0 );
5429 setPreferenceProperty( wv, "max", 1.0 );
5430 setPreferenceProperty( hv, "min", 0.0 );
5431 setPreferenceProperty( hv, "max", 1.0 );
5432 setPreferenceProperty( hv, "step", 0.1 );
5434 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5435 setPreferenceProperty( posHSizeGr, "columns", 2 );
5436 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5437 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5438 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5439 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5440 setPreferenceProperty( xv, "min", 0.0 );
5441 setPreferenceProperty( xv, "max", 1.0 );
5442 setPreferenceProperty( xv, "step", 0.1 );
5443 setPreferenceProperty( xh, "min", 0.0 );
5444 setPreferenceProperty( xh, "max", 1.0 );
5445 setPreferenceProperty( xh, "step", 0.1 );
5446 setPreferenceProperty( yh, "min", 0.0 );
5447 setPreferenceProperty( yh, "max", 1.0 );
5448 setPreferenceProperty( yh, "step", 0.1 );
5449 setPreferenceProperty( wh, "min", 0.0 );
5450 setPreferenceProperty( wh, "max", 1.0 );
5451 setPreferenceProperty( wh, "step", 0.1 );
5452 setPreferenceProperty( hh, "min", 0.0 );
5453 setPreferenceProperty( hh, "max", 1.0 );
5454 setPreferenceProperty( hh, "step", 0.1 );
5456 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5457 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5458 setPreferenceProperty( distributionGr, "columns", 3 );
5460 types.append( tr( "SMESH_MONOCOLOR" ) );
5461 types.append( tr( "SMESH_MULTICOLOR" ) );
5462 indices.clear(); indices.append( 0 ); indices.append( 1 );
5463 setPreferenceProperty( coloringType, "strings", types );
5464 setPreferenceProperty( coloringType, "indexes", indices );
5465 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5469 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5471 if ( sect=="SMESH" ) {
5472 float sbX1 = 0.01, sbY1 = 0.01, sbW = 0.08, sbH = 0.08;
5473 float aTol = 1.00000009999999;
5474 std::string aWarning;
5475 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5477 if ( name == "selection_object_color" ||
5478 name == "selection_element_color" ||
5479 name == "highlight_color" ||
5480 name == "selection_precision_node" ||
5481 name == "selection_precision_element" ||
5482 name == "selection_precision_object" ||
5483 name == "selection_increment")
5485 SMESH::UpdateSelectionProp( this );
5487 else if (name == "scalar_bar_vertical_x" || name == "scalar_bar_vertical_width")
5489 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5490 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5491 if ( sbX1+sbW > aTol ) {
5492 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5495 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5496 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5499 else if (name == "scalar_bar_vertical_y" || name == "scalar_bar_vertical_height" )
5501 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5502 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5503 if ( sbY1 + sbH > aTol ) {
5504 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5505 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5506 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5509 else if (name == "scalar_bar_horizontal_x" || name == "scalar_bar_horizontal_width")
5511 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5512 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5513 if ( sbX1 + sbW > aTol ) {
5514 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5517 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5518 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5521 else if (name == "scalar_bar_horizontal_y" || name == "scalar_bar_horizontal_height")
5523 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5524 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5525 if ( sbY1 + sbH > aTol ) {
5526 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5529 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5530 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5533 else if ( name == "segmentation" )
5535 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5536 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5538 else if ( name == "nb_segments_per_edge" )
5540 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5541 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5543 else if ( name == "historical_python_dump" || name == "forget_mesh_on_hyp_modif" || name == "default_grp_color" )
5545 QString val = aResourceMgr->stringValue( "SMESH", name );
5546 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5548 else if ( name == "numbering_node_color" || name == "numbering_node_font" )
5550 SMESH::UpdateFontProp( this );
5552 else if ( name == "numbering_elem_color" || name == "numbering_elem_font" )
5554 SMESH::UpdateFontProp( this );
5557 if ( aWarning.size() != 0 ) {
5558 aWarning += "The default values are applied instead.";
5559 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5560 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5561 QObject::tr(aWarning.c_str()));
5566 //================================================================================
5568 * \brief Update something in accordance with update flags
5569 * \param theFlags - update flags
5571 * Update viewer or/and object browser etc. in accordance with update flags ( see
5572 * LightApp_UpdateFlags enumeration ).
5574 //================================================================================
5575 void SMESHGUI::update( const int flags )
5577 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5578 SMESH::UpdateView();
5580 SalomeApp_Module::update( flags );
5583 //================================================================================
5585 * \brief Set default selection mode
5587 * SLOT called when operation committed. Sets default selection mode
5589 //================================================================================
5590 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5592 SVTK_ViewWindow* vtkWnd =
5593 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5595 vtkWnd->SetSelectionMode( ActorSelection );
5598 //================================================================================
5600 * \brief Set default selection mode
5602 * SLOT called when operation aborted. Sets default selection mode
5604 //================================================================================
5605 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5607 SVTK_ViewWindow* vtkWnd =
5608 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5610 vtkWnd->SetSelectionMode( ActorSelection );
5613 //================================================================================
5615 * \brief Creates operation with given identifier
5616 * \param id - identifier of operation to be started
5617 * \return Pointer on created operation or NULL if operation is not created
5619 * Virtual method redefined from the base class creates operation with given id.
5620 * It is called called automatically from startOperation method of base class.
5622 //================================================================================
5623 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5625 LightApp_Operation* op = 0;
5626 // to do : create operation here
5629 case SMESHOp::OpSplitBiQuadratic:
5630 op = new SMESHGUI_SplitBiQuadOp();
5632 case SMESHOp::OpConvertMeshToQuadratic:
5633 op = new SMESHGUI_ConvToQuadOp();
5635 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5636 op = new SMESHGUI_Make2DFrom3DOp();
5638 case SMESHOp::OpReorientFaces:
5639 op = new SMESHGUI_ReorientFacesOp();
5641 case SMESHOp::OpCreateMesh:
5642 op = new SMESHGUI_MeshOp( true, true );
5644 case SMESHOp::OpCreateSubMesh:
5645 op = new SMESHGUI_MeshOp( true, false );
5647 case SMESHOp::OpEditMeshOrSubMesh:
5648 case SMESHOp::OpEditMesh:
5649 case SMESHOp::OpEditSubMesh:
5650 op = new SMESHGUI_MeshOp( false );
5652 case SMESHOp::OpCompute:
5653 case SMESHOp::OpComputeSubMesh:
5654 op = new SMESHGUI_ComputeOp();
5656 case SMESHOp::OpPreCompute:
5657 op = new SMESHGUI_PrecomputeOp();
5659 case SMESHOp::OpEvaluate:
5660 op = new SMESHGUI_EvaluateOp();
5662 case SMESHOp::OpMeshOrder:
5663 op = new SMESHGUI_MeshOrderOp();
5665 case SMESHOp::OpCreateGeometryGroup:
5666 op = new SMESHGUI_GroupOnShapeOp();
5668 case SMESHOp::OpFindElementByPoint:
5669 op = new SMESHGUI_FindElemByPointOp();
5671 case SMESHOp::OpMoveNode: // Make mesh pass through point
5672 op = new SMESHGUI_MakeNodeAtPointOp();
5674 case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
5675 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5682 op = SalomeApp_Module::createOperation( id );
5686 //================================================================================
5688 * \brief Stops current operations and starts a given one
5689 * \param id - The id of the operation to start
5691 //================================================================================
5693 void SMESHGUI::switchToOperation(int id)
5695 activeStudy()->abortAllOperations();
5696 startOperation( id );
5699 LightApp_Displayer* SMESHGUI::displayer()
5702 myDisplayer = new SMESHGUI_Displayer( getApp() );
5706 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5709 int aTolerance = 64;
5710 int anIterations = 0;
5716 if( anIterations % aPeriod == 0 )
5719 if( aTolerance < 1 )
5723 aHue = (int)( 360.0 * rand() / RAND_MAX );
5726 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5727 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5728 for( ; it != itEnd; ++it )
5730 SALOMEDS::Color anAutoColor = *it;
5731 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5734 aQColor.getHsv( &h, &s, &v );
5735 if( abs( h - aHue ) < aTolerance )
5747 aColor.setHsv( aHue, 255, 255 );
5749 SALOMEDS::Color aSColor;
5750 aSColor.R = aColor.redF();
5751 aSColor.G = aColor.greenF();
5752 aSColor.B = aColor.blueF();
5757 const char* gSeparator = "_"; // character used to separate parameter names
5758 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5759 const char* gPathSep = "|"; // character used to separate paths
5762 * \brief Store visual parameters
5764 * This method is called just before the study document is saved.
5765 * Store visual parameters in AttributeParameter attribute(s)
5767 void SMESHGUI::storeVisualParameters (int savePoint)
5770 Kernel_Utils::Localizer loc;
5772 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5773 if (!appStudy || !appStudy->studyDS())
5775 _PTR(Study) studyDS = appStudy->studyDS();
5777 // componentName is used for encoding of entries when storing them in IParameters
5778 std::string componentName = myComponentSMESH->ComponentDataType();
5779 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5780 //if (!aSComponent) return;
5783 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5784 componentName.c_str(),
5786 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5788 // store custom markers
5789 if( !myMarkerMap.empty() )
5791 VTK::MarkerMap::const_iterator anIter = myMarkerMap.begin();
5792 for( ; anIter != myMarkerMap.end(); anIter++ )
5794 int anId = anIter->first;
5795 VTK::MarkerData aMarkerData = anIter->second;
5796 std::string aMarkerFileName = aMarkerData.first;
5797 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5798 if( aMarkerTexture.size() < 3 )
5799 continue; // should contain at least width, height and the first value
5801 QString aPropertyName( "texture" );
5802 aPropertyName += gSeparator;
5803 aPropertyName += QString::number( anId );
5805 QString aPropertyValue = aMarkerFileName.c_str();
5806 aPropertyValue += gPathSep;
5808 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5809 ushort aWidth = *aTextureIter++;
5810 ushort aHeight = *aTextureIter++;
5811 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5812 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5813 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5814 aPropertyValue += QString::number( *aTextureIter );
5816 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5820 // viewers counters are used for storing view_numbers in IParameters
5823 // main cycle to store parameters of displayed objects
5824 QList<SUIT_ViewManager*> lst;
5825 QList<SUIT_ViewManager*>::Iterator it;
5826 getApp()->viewManagers(lst);
5827 for (it = lst.begin(); it != lst.end(); it++)
5829 SUIT_ViewManager* vman = *it;
5830 QString vType = vman->getType();
5832 // saving VTK actors properties
5833 if (vType == SVTK_Viewer::Type())
5835 // store the clipping planes attached to the view manager
5836 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5837 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5838 if( anIter != myClippingPlaneInfoMap.end() )
5839 aClippingPlaneInfoList = anIter->second;
5841 if( !aClippingPlaneInfoList.empty() ) {
5842 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5843 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5845 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5846 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5848 QString aPropertyName( "ClippingPlane" );
5849 aPropertyName += gSeparator;
5850 aPropertyName += QString::number( vtkViewers );
5851 aPropertyName += gSeparator;
5852 aPropertyName += QString::number( anId );
5854 QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
5855 aPropertyValue += gDigitsSep;
5856 aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
5857 aPropertyValue += gDigitsSep;
5858 if ( aPlane->PlaneMode == SMESH::Absolute ) {
5859 aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
5860 aPropertyValue += gDigitsSep;
5861 aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
5862 aPropertyValue += gDigitsSep;
5863 aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
5864 aPropertyValue += gDigitsSep;
5865 aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
5866 aPropertyValue += gDigitsSep;
5867 aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
5868 aPropertyValue += gDigitsSep;
5869 aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
5870 aPropertyValue += gDigitsSep;
5871 aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
5873 else if ( aPlane->PlaneMode == SMESH::Relative ) {
5874 aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
5875 aPropertyValue += gDigitsSep;
5876 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5877 aPropertyValue += gDigitsSep;
5878 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5879 aPropertyValue += gDigitsSep;
5880 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5883 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5887 QVector<SUIT_ViewWindow*> views = vman->getViews();
5888 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5890 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5892 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5893 vtkActorCollection* allActors = aCopy.GetActors();
5894 allActors->InitTraversal();
5895 while (vtkActor* actor = allActors->GetNextActor())
5897 if (actor->GetVisibility()) // store only visible actors
5899 SMESH_Actor* aSmeshActor = 0;
5900 if (actor->IsA("SMESH_Actor"))
5901 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5902 if (aSmeshActor && aSmeshActor->hasIO())
5904 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5907 // entry is "encoded" = it does NOT contain component address,
5908 // since it is a subject to change on next component loading
5909 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5911 std::string param, vtkParam = vType.toLatin1().data();
5912 vtkParam += gSeparator;
5913 vtkParam += QString::number(vtkViewers).toLatin1().data();
5914 vtkParam += gSeparator;
5917 param = vtkParam + "Visibility";
5918 ip->setParameter(entry, param, "On");
5921 param = vtkParam + "Representation";
5922 ip->setParameter(entry, param, QString::number
5923 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5926 param = vtkParam + "IsShrunk";
5927 ip->setParameter(entry, param, QString::number
5928 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5930 // Displayed entities
5931 unsigned int aMode = aSmeshActor->GetEntityMode();
5932 bool isE = aMode & SMESH_Actor::eEdges;
5933 bool isF = aMode & SMESH_Actor::eFaces;
5934 bool isV = aMode & SMESH_Actor::eVolumes;
5935 bool is0d = aMode & SMESH_Actor::e0DElements;
5936 bool isB = aMode & SMESH_Actor::eBallElem;
5938 QString modeStr ("e");
5939 modeStr += gDigitsSep; modeStr += QString::number(isE);
5940 modeStr += gDigitsSep; modeStr += "f";
5941 modeStr += gDigitsSep; modeStr += QString::number(isF);
5942 modeStr += gDigitsSep; modeStr += "v";
5943 modeStr += gDigitsSep; modeStr += QString::number(isV);
5944 modeStr += gDigitsSep; modeStr += "0d";
5945 modeStr += gDigitsSep; modeStr += QString::number(is0d);
5946 modeStr += gDigitsSep; modeStr += "b";
5947 modeStr += gDigitsSep; modeStr += QString::number(isB);
5949 param = vtkParam + "Entities";
5950 ip->setParameter(entry, param, modeStr.toLatin1().data());
5956 aSmeshActor->GetSufaceColor(r, g, b, delta);
5957 QStringList colorStr;
5958 colorStr << "surface";
5959 colorStr << QString::number(r);
5960 colorStr << QString::number(g);
5961 colorStr << QString::number(b);
5963 colorStr << "backsurface";
5964 colorStr << QString::number(delta);
5966 aSmeshActor->GetVolumeColor(r, g, b, delta);
5967 colorStr << "volume";
5968 colorStr << QString::number(r);
5969 colorStr << QString::number(g);
5970 colorStr << QString::number(b);
5971 colorStr << QString::number(delta);
5973 aSmeshActor->GetEdgeColor(r, g, b);
5975 colorStr << QString::number(r);
5976 colorStr << QString::number(g);
5977 colorStr << QString::number(b);
5979 aSmeshActor->GetNodeColor(r, g, b);
5981 colorStr << QString::number(r);
5982 colorStr << QString::number(g);
5983 colorStr << QString::number(b);
5985 aSmeshActor->GetOutlineColor(r, g, b);
5986 colorStr << "outline";
5987 colorStr << QString::number(r);
5988 colorStr << QString::number(g);
5989 colorStr << QString::number(b);
5991 aSmeshActor->Get0DColor(r, g, b);
5992 colorStr << "elem0d";
5993 colorStr << QString::number(r);
5994 colorStr << QString::number(g);
5995 colorStr << QString::number(b);
5997 aSmeshActor->GetBallColor(r, g, b);
5999 colorStr << QString::number(r);
6000 colorStr << QString::number(g);
6001 colorStr << QString::number(b);
6003 aSmeshActor->GetFacesOrientationColor(r, g, b);
6004 colorStr << "orientation";
6005 colorStr << QString::number(r);
6006 colorStr << QString::number(g);
6007 colorStr << QString::number(b);
6009 param = vtkParam + "Colors";
6010 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
6013 QStringList sizeStr;
6015 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
6016 sizeStr << "outline";
6017 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
6018 sizeStr << "elem0d";
6019 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
6021 //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
6022 sizeStr << QString::number((double)aSmeshActor->GetBallSize());
6023 sizeStr << QString::number((double)aSmeshActor->GetBallScale());
6024 sizeStr << "shrink";
6025 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
6026 sizeStr << "orientation";
6027 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
6028 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
6030 param = vtkParam + "Sizes";
6031 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
6036 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
6037 if( aMarkerType == VTK::MT_USER ) {
6038 markerStr += "custom";
6039 markerStr += gDigitsSep;
6040 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
6044 markerStr += gDigitsSep;
6045 markerStr += QString::number( (int)aMarkerType );
6046 markerStr += gDigitsSep;
6047 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
6050 param = vtkParam + "PointMarker";
6051 ip->setParameter(entry, param, markerStr.toLatin1().data());
6054 param = vtkParam + "Opacity";
6055 ip->setParameter(entry, param,
6056 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
6059 param = vtkParam + "ClippingPlane";
6061 if( !aClippingPlaneInfoList.empty() ) {
6062 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
6063 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
6065 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
6066 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
6067 SMESH::TActorList::iterator anIter2 = anActorList.begin();
6068 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
6069 if( aSmeshActor == *anIter2 ) {
6070 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
6071 QString::number( anId ).toLatin1().constData() );
6078 ip->setParameter( entry, param, "Off" );
6079 } // if (io->hasEntry())
6080 } // SMESH_Actor && hasIO
6082 } // while.. actors traversal
6086 } // if (SVTK view model)
6087 } // for (viewManagers)
6090 // data structures for clipping planes processing
6094 bool isOpenGLClipping;
6095 vtkIdType RelativeOrientation;
6098 int AbsoluteOrientation;
6099 double X, Y, Z, Dx, Dy, Dz;
6101 typedef std::list<TPlaneData> TPlaneDataList;
6102 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
6104 typedef std::list<vtkActor*> TActorList;
6107 TActorList ActorList;
6108 SUIT_ViewManager* ViewManager;
6110 typedef std::list<TPlaneInfo> TPlaneInfoList;
6111 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
6114 * \brief Restore visual parameters
6116 * This method is called after the study document is opened.
6117 * Restore visual parameters from AttributeParameter attribute(s)
6119 void SMESHGUI::restoreVisualParameters (int savePoint)
6122 Kernel_Utils::Localizer loc;
6124 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6125 if (!appStudy || !appStudy->studyDS())
6127 _PTR(Study) studyDS = appStudy->studyDS();
6129 // componentName is used for encoding of entries when storing them in IParameters
6130 std::string componentName = myComponentSMESH->ComponentDataType();
6131 //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
6132 //if (!aSComponent) return;
6135 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6136 componentName.c_str(),
6138 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6140 // restore custom markers and map of clipping planes
6141 TPlaneDataMap aPlaneDataMap;
6143 std::vector<std::string> properties = ip->getProperties();
6144 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
6146 std::string property = *propIt;
6147 QString aPropertyName( property.c_str() );
6148 QString aPropertyValue( ip->getProperty( property ).c_str() );
6150 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
6151 if( aPropertyNameList.isEmpty() )
6154 QString aPropertyType = aPropertyNameList[0];
6155 if( aPropertyType == "texture" )
6157 if( aPropertyNameList.size() != 2 )
6161 int anId = aPropertyNameList[1].toInt( &ok );
6162 if( !ok || anId < 1 )
6165 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
6166 if( aPropertyValueList.size() != 2 )
6169 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
6170 QString aMarkerTextureString = aPropertyValueList[1];
6171 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
6172 if( aMarkerTextureStringList.size() != 3 )
6176 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6181 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6185 VTK::MarkerTexture aMarkerTexture;
6186 aMarkerTexture.push_back( aWidth );
6187 aMarkerTexture.push_back( aHeight );
6189 QString aMarkerTextureData = aMarkerTextureStringList[2];
6190 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6192 QChar aChar = aMarkerTextureData.at( i );
6193 if( aChar.isDigit() )
6194 aMarkerTexture.push_back( aChar.digitValue() );
6197 myMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6199 else if( aPropertyType == "ClippingPlane" )
6201 if( aPropertyNameList.size() != 3 )
6205 int aViewId = aPropertyNameList[1].toInt( &ok );
6206 if( !ok || aViewId < 0 )
6210 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6211 if( !ok || aClippingPlaneId < 0 )
6214 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6215 if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6218 TPlaneData aPlaneData;
6219 aPlaneData.AbsoluteOrientation = false;
6220 aPlaneData.RelativeOrientation = 0;
6221 aPlaneData.Distance = aPlaneData.Angle[0] = aPlaneData.Angle[1] = 0;
6222 aPlaneData.X = aPlaneData.Y = aPlaneData.Z = 0;
6223 aPlaneData.Dx = aPlaneData.Dy = aPlaneData.Dz = 0;
6225 aPlaneData.Id = aClippingPlaneId;
6228 aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6233 aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6237 if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6240 aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6245 aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6250 aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6255 aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6260 aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6265 aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6270 aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6274 else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6276 aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6281 aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6286 aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6291 aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6296 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6297 aPlaneDataList.push_back( aPlaneData );
6301 TPlaneInfoMap aPlaneInfoMap;
6303 std::vector<std::string> entries = ip->getEntries();
6305 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6307 // entry is a normal entry - it should be "decoded" (setting base address of component)
6308 QString entry (ip->decodeEntry(*entIt).c_str());
6310 // Check that the entry corresponds to a real object in the Study
6311 // as the object may be deleted or modified after the visual state is saved.
6312 _PTR(SObject) so = studyDS->FindObjectID(entry.toUtf8().data());
6313 if (!so) continue; //Skip the not existent entry
6315 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6316 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6318 std::vector<std::string>::iterator namesIt = paramNames.begin();
6319 std::vector<std::string>::iterator valuesIt = paramValues.begin();
6321 // actors are stored in a map after displaying of them for
6322 // quicker access in the future: map < viewID to actor >
6323 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6325 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6327 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6328 // '_' is used as separator and should not be used in viewer type or parameter names.
6329 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6330 if (lst.size() != 3)
6333 QString viewerTypStr = lst[0];
6334 QString viewIndexStr = lst[1];
6335 QString paramNameStr = lst[2];
6338 int viewIndex = viewIndexStr.toUInt(&ok);
6339 if (!ok) // bad conversion of view index to integer
6343 if (viewerTypStr == SVTK_Viewer::Type())
6345 SMESH_Actor* aSmeshActor = 0;
6346 if (vtkActors.IsBound(viewIndex))
6347 aSmeshActor = vtkActors.Find(viewIndex);
6349 QList<SUIT_ViewManager*> lst;
6350 getApp()->viewManagers(viewerTypStr, lst);
6352 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6353 SUIT_ViewManager* vman = NULL;
6354 if (viewIndex >= 0 && viewIndex < lst.count())
6355 vman = lst.at(viewIndex);
6357 if (paramNameStr == "Visibility")
6359 if (!aSmeshActor && displayer() && vman)
6361 SUIT_ViewModel* vmodel = vman->getViewModel();
6362 // SVTK view model can be casted to SALOME_View
6363 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6365 // store displayed actor in a temporary map for quicker
6366 // access later when restoring other parameters
6367 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6368 vtkRenderer* Renderer = vtkView->getRenderer();
6369 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6370 vtkActorCollection* theActors = aCopy.GetActors();
6371 theActors->InitTraversal();
6372 bool isFound = false;
6373 vtkActor *ac = theActors->GetNextActor();
6374 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6375 if (ac->IsA("SMESH_Actor")) {
6376 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6377 if (aGeomAc->hasIO()) {
6378 Handle(SALOME_InteractiveObject) io = aGeomAc->getIO();
6379 if (io->hasEntry() && strcmp(io->getEntry(), entry.toUtf8().data()) == 0) {
6381 vtkActors.Bind(viewIndex, aGeomAc);
6387 } // if (paramNameStr == "Visibility")
6390 // the rest properties "work" with SMESH_Actor
6393 QString val ((*valuesIt).c_str());
6396 if (paramNameStr == "Representation") {
6397 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6400 else if (paramNameStr == "IsShrunk") {
6402 if (!aSmeshActor->IsShrunk())
6403 aSmeshActor->SetShrink();
6406 if (aSmeshActor->IsShrunk())
6407 aSmeshActor->UnShrink();
6410 // Displayed entities
6411 else if (paramNameStr == "Entities") {
6412 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6413 int aEntityMode = SMESH_Actor::eAllEntity;
6414 for ( int i = 0; i < mode.count(); i+=2 ) {
6415 if ( i < mode.count()-1 ) {
6416 QString type = mode[i];
6417 bool val = mode[i+1].toInt();
6418 if ( type == "e" && !val )
6419 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6420 else if ( type == "f" && !val )
6421 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6422 else if ( type == "v" && !val )
6423 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6424 else if ( type == "0d" && !val )
6425 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6426 else if ( type == "b" && !val )
6427 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6430 aSmeshActor->SetEntityMode( aEntityMode );
6433 else if (paramNameStr == "Colors") {
6434 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6441 QColor outlineColor;
6442 QColor orientationColor;
6448 // below lines are required to get default values for delta coefficients
6449 // of backface color for faces and color of reversed volumes
6450 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
6451 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6452 for ( int i = 0; i < colors.count(); i++ ) {
6453 QString type = colors[i];
6454 if ( type == "surface" ) {
6455 // face color is set by 3 values r:g:b, where
6456 // - r,g,b - is rgb color components
6457 if ( i+1 >= colors.count() ) break; // format error
6458 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6459 if ( i+2 >= colors.count() ) break; // format error
6460 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6461 if ( i+3 >= colors.count() ) break; // format error
6462 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6463 faceColor.setRgbF( r, g, b );
6466 else if ( type == "backsurface" ) {
6467 // backface color can be defined in several ways
6468 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6469 // - in latest versions, it is set as delta coefficient
6470 bool rgbOk = false, deltaOk;
6471 if ( i+1 >= colors.count() ) break; // format error
6472 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6473 int delta = colors[i+1].toInt( &deltaOk );
6475 if ( i+1 < colors.count() ) // index is shifted to 1
6476 g = colors[i+1].toDouble( &rgbOk );
6477 if ( rgbOk ) i++; // shift index
6478 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6479 b = colors[i+1].toDouble( &rgbOk );
6481 // - as currently there's no way to set directly backsurface color as it was before,
6482 // we ignore old dump where r,g,b triple was set
6483 // - also we check that delta parameter is set properly
6484 if ( !rgbOk && deltaOk )
6487 else if ( type == "volume" ) {
6488 // volume color is set by 4 values r:g:b:delta, where
6489 // - r,g,b - is a normal volume rgb color components
6490 // - delta - is a reversed volume color delta coefficient
6491 if ( i+1 >= colors.count() ) break; // format error
6492 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6493 if ( i+2 >= colors.count() ) break; // format error
6494 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6495 if ( i+3 >= colors.count() ) break; // format error
6496 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6497 if ( i+4 >= colors.count() ) break; // format error
6498 int delta = colors[i+4].toInt( &bOk );
6499 if ( !bOk ) break; // format error
6500 volumeColor.setRgbF( r, g, b );
6504 else if ( type == "edge" ) {
6505 // edge color is set by 3 values r:g:b, where
6506 // - r,g,b - is rgb color components
6507 if ( i+1 >= colors.count() ) break; // format error
6508 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6509 if ( i+2 >= colors.count() ) break; // format error
6510 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6511 if ( i+3 >= colors.count() ) break; // format error
6512 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6513 edgeColor.setRgbF( r, g, b );
6516 else if ( type == "node" ) {
6517 // node color is set by 3 values r:g:b, where
6518 // - r,g,b - is rgb color components
6519 if ( i+1 >= colors.count() ) break; // format error
6520 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6521 if ( i+2 >= colors.count() ) break; // format error
6522 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6523 if ( i+3 >= colors.count() ) break; // format error
6524 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6525 nodeColor.setRgbF( r, g, b );
6528 else if ( type == "elem0d" ) {
6529 // 0d element color is set by 3 values r:g:b, where
6530 // - r,g,b - is rgb color components
6531 if ( i+1 >= colors.count() ) break; // format error
6532 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6533 if ( i+2 >= colors.count() ) break; // format error
6534 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6535 if ( i+3 >= colors.count() ) break; // format error
6536 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6537 elem0dColor.setRgbF( r, g, b );
6540 else if ( type == "ball" ) {
6541 // ball color is set by 3 values r:g:b, where
6542 // - r,g,b - is rgb color components
6543 if ( i+1 >= colors.count() ) break; // format error
6544 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6545 if ( i+2 >= colors.count() ) break; // format error
6546 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6547 if ( i+3 >= colors.count() ) break; // format error
6548 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6549 ballColor.setRgbF( r, g, b );
6552 else if ( type == "outline" ) {
6553 // outline color is set by 3 values r:g:b, where
6554 // - r,g,b - is rgb color components
6555 if ( i+1 >= colors.count() ) break; // format error
6556 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6557 if ( i+2 >= colors.count() ) break; // format error
6558 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6559 if ( i+3 >= colors.count() ) break; // format error
6560 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6561 outlineColor.setRgbF( r, g, b );
6564 else if ( type == "orientation" ) {
6565 // orientation color is set by 3 values r:g:b, where
6566 // - r,g,b - is rgb color components
6567 if ( i+1 >= colors.count() ) break; // format error
6568 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6569 if ( i+2 >= colors.count() ) break; // format error
6570 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6571 if ( i+3 >= colors.count() ) break; // format error
6572 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6573 orientationColor.setRgbF( r, g, b );
6578 if ( nodeColor.isValid() )
6579 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6581 if ( edgeColor.isValid() )
6582 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6584 if ( faceColor.isValid() )
6585 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6587 if ( volumeColor.isValid() )
6588 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6589 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6590 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6592 if ( elem0dColor.isValid() )
6593 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6595 if ( ballColor.isValid() )
6596 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6598 if ( outlineColor.isValid() )
6599 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6600 // orientation color
6601 if ( orientationColor.isValid() )
6602 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6605 else if (paramNameStr == "Sizes") {
6606 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6609 int outlineWidth = -1;
6610 int elem0dSize = -1;
6611 //int ballSize = -1;
6612 double ballDiameter = -1.0;
6613 double ballScale = -1.0;
6614 double shrinkSize = -1;
6615 double orientationSize = -1;
6616 bool orientation3d = false;
6617 for ( int i = 0; i < sizes.count(); i++ ) {
6618 QString type = sizes[i];
6619 if ( type == "line" ) {
6620 // line (wireframe) width is given as single integer value
6621 if ( i+1 >= sizes.count() ) break; // format error
6622 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6626 if ( type == "outline" ) {
6627 // outline width is given as single integer value
6628 if ( i+1 >= sizes.count() ) break; // format error
6629 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6633 else if ( type == "elem0d" ) {
6634 // 0d element size is given as single integer value
6635 if ( i+1 >= sizes.count() ) break; // format error
6636 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6640 else if ( type == "ball" ) {
6641 // balls are specified by two values: size:scale, where
6642 // - size - is a integer value specifying size
6643 // - scale - is a double value specifying scale factor
6644 if ( i+1 >= sizes.count() ) break; // format error
6645 //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6646 double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6647 if ( i+2 >= sizes.count() ) break; // format error
6648 double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6654 else if ( type == "shrink" ) {
6655 // shrink factor is given as single floating point value
6656 if ( i+1 >= sizes.count() ) break; // format error
6657 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6661 else if ( type == "orientation" ) {
6662 // orientation vectors are specified by two values size:3d, where
6663 // - size - is a floating point value specifying scale factor
6664 // - 3d - is a boolean
6665 if ( i+1 >= sizes.count() ) break; // format error
6666 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6667 if ( i+2 >= sizes.count() ) break; // format error
6668 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6669 orientationSize = v1;
6670 orientation3d = (bool)v2;
6674 // line (wireframe) width
6675 if ( lineWidth > 0 )
6676 aSmeshActor->SetLineWidth( lineWidth );
6678 if ( outlineWidth > 0 )
6679 aSmeshActor->SetOutlineWidth( outlineWidth );
6680 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6681 aSmeshActor->SetOutlineWidth( lineWidth );
6683 if ( elem0dSize > 0 )
6684 aSmeshActor->Set0DSize( elem0dSize );
6686 /*if ( ballSize > 0 )
6687 aSmeshActor->SetBallSize( ballSize );*/
6689 if ( ballDiameter > 0 )
6690 aSmeshActor->SetBallSize( ballDiameter );
6692 if ( ballScale > 0.0 )
6693 aSmeshActor->SetBallScale( ballScale );
6695 if ( shrinkSize > 0 )
6696 aSmeshActor->SetShrinkFactor( shrinkSize );
6697 // orientation vectors
6698 if ( orientationSize > 0 ) {
6699 aSmeshActor->SetFacesOrientationScale( orientationSize );
6700 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6704 else if (paramNameStr == "PointMarker") {
6705 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6706 if( data.count() >= 2 ) {
6708 int aParam1 = data[1].toInt( &ok );
6710 if( data[0] == "std" && data.count() == 3 ) {
6711 int aParam2 = data[2].toInt( &ok );
6712 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6714 else if( data[0] == "custom" ) {
6715 VTK::MarkerMap::const_iterator markerIt = myMarkerMap.find( aParam1 );
6716 if( markerIt != myMarkerMap.end() ) {
6717 VTK::MarkerData aMarkerData = markerIt->second;
6718 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6725 else if (paramNameStr == "Opacity") {
6726 aSmeshActor->SetOpacity(val.toFloat());
6729 else if (paramNameStr.startsWith("ClippingPlane")) {
6730 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6731 // old format - val looks like "Off" or "1:0:0:0.5:0:0"
6732 // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
6733 // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
6734 // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
6735 // new format - val looks like "Off" or "0" (plane id)
6736 // (note: in new format "Off" value is used only for consistency,
6737 // so it is processed together with values in old format)
6738 bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
6739 if( anIsOldFormat ) {
6740 if (paramNameStr == "ClippingPlane1" || val == "Off")
6741 aSmeshActor->RemoveAllClippingPlanes();
6743 QList<SUIT_ViewManager*> lst;
6744 getApp()->viewManagers(viewerTypStr, lst);
6745 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6746 if (viewIndex >= 0 && viewIndex < lst.count()) {
6747 SUIT_ViewManager* vman = lst.at(viewIndex);
6748 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6750 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6752 SMESH::TActorList anActorList;
6753 anActorList.push_back( aSmeshActor );
6754 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
6755 aPlane->myViewWindow = vtkView;
6756 SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
6757 aPlane->PlaneMode = aMode;
6758 bool isOpenGLClipping = ( bool )vals[1].toInt();
6759 aPlane->IsOpenGLClipping = isOpenGLClipping;
6760 if ( aMode == SMESH::Absolute ) {
6761 aPlane->myAbsoluteOrientation = vals[2].toInt();
6762 aPlane->X = vals[3].toFloat();
6763 aPlane->Y = vals[4].toFloat();
6764 aPlane->Z = vals[5].toFloat();
6765 aPlane->Dx = vals[6].toFloat();
6766 aPlane->Dy = vals[7].toFloat();
6767 aPlane->Dz = vals[8].toFloat();
6769 else if ( aMode == SMESH::Relative ) {
6770 aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
6771 aPlane->myDistance = vals[3].toFloat();
6772 aPlane->myAngle[0] = vals[4].toFloat();
6773 aPlane->myAngle[1] = vals[5].toFloat();
6777 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6778 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6779 aClippingPlaneInfo.Plane = aPlane;
6780 aClippingPlaneInfo.ActorList = anActorList;
6781 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6789 int aPlaneId = val.toInt( &ok );
6790 if( ok && aPlaneId >= 0 ) {
6791 bool anIsDefinedPlane = false;
6792 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6793 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6794 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6795 TPlaneInfo& aPlaneInfo = *anIter;
6796 if( aPlaneInfo.PlaneId == aPlaneId ) {
6797 aPlaneInfo.ActorList.push_back( aSmeshActor );
6798 anIsDefinedPlane = true;
6802 if( !anIsDefinedPlane ) {
6803 TPlaneInfo aPlaneInfo;
6804 aPlaneInfo.PlaneId = aPlaneId;
6805 aPlaneInfo.ActorList.push_back( aSmeshActor );
6806 aPlaneInfo.ViewManager = vman;
6808 // to make the list sorted by plane id
6809 anIter = aPlaneInfoList.begin();
6810 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6811 const TPlaneInfo& aPlaneInfoRef = *anIter;
6812 if( aPlaneInfoRef.PlaneId > aPlaneId )
6815 aPlaneInfoList.insert( anIter, aPlaneInfo );
6820 } // if (aSmeshActor)
6821 } // other parameters than Visibility
6823 } // for names/parameters iterator
6824 } // for entries iterator
6826 // take into account planes with empty list of actors referred to them
6827 QList<SUIT_ViewManager*> aVMList;
6828 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6830 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6831 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6832 int aViewId = aPlaneDataIter->first;
6833 if( aViewId >= 0 && aViewId < aVMList.count() ) {
6834 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6836 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6838 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6839 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6840 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6841 const TPlaneData& aPlaneData = *anIter2;
6842 int aPlaneId = aPlaneData.Id;
6844 bool anIsFound = false;
6845 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6846 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6847 const TPlaneInfo& aPlaneInfo = *anIter3;
6848 if( aPlaneInfo.PlaneId == aPlaneId ) {
6855 TPlaneInfo aPlaneInfo; // ActorList field is empty
6856 aPlaneInfo.PlaneId = aPlaneId;
6857 aPlaneInfo.ViewManager = aViewManager;
6859 // to make the list sorted by plane id
6860 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6861 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6862 const TPlaneInfo& aPlaneInfoRef = *anIter4;
6863 if( aPlaneInfoRef.PlaneId > aPlaneId )
6866 aPlaneInfoList.insert( anIter4, aPlaneInfo );
6872 // add clipping planes to actors according to the restored parameters
6873 // and update the clipping plane map
6874 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6875 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6876 int aViewId = anIter1->first;
6877 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6879 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6880 if( anIter2 == aPlaneDataMap.end() )
6882 const TPlaneDataList& aPlaneDataList = anIter2->second;
6884 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6885 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6886 const TPlaneInfo& aPlaneInfo = *anIter3;
6887 int aPlaneId = aPlaneInfo.PlaneId;
6888 const TActorList& anActorList = aPlaneInfo.ActorList;
6889 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6893 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6897 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6899 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6900 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6901 const TPlaneData& aPlaneData = *anIter4;
6902 if( aPlaneData.Id == aPlaneId ) {
6903 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
6904 aPlane->myViewWindow = aViewWindow;
6905 aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
6906 aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
6907 if ( aPlane->PlaneMode == SMESH::Absolute ) {
6908 aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
6909 aPlane->X = aPlaneData.X;
6910 aPlane->Y = aPlaneData.Y;
6911 aPlane->Z = aPlaneData.Z;
6912 aPlane->Dx = aPlaneData.Dx;
6913 aPlane->Dy = aPlaneData.Dy;
6914 aPlane->Dz = aPlaneData.Dz;
6916 else if ( aPlane->PlaneMode == SMESH::Relative ) {
6917 aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
6918 aPlane->myDistance = aPlaneData.Distance;
6919 aPlane->myAngle[0] = aPlaneData.Angle[0];
6920 aPlane->myAngle[1] = aPlaneData.Angle[1];
6923 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6924 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6925 aClippingPlaneInfo.Plane = aPlane;
6926 aClippingPlaneInfo.ActorList = anActorList;
6927 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6938 // update all VTK views
6939 QList<SUIT_ViewManager*> lst;
6940 getApp()->viewManagers(lst);
6941 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6942 SUIT_ViewModel* vmodel = (*it)->getViewModel();
6943 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6944 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6945 // set OpenGL clipping planes
6946 VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
6947 vtkActorCollection* anAllActors = aCopy.GetActors();
6948 anAllActors->InitTraversal();
6949 while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
6950 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
6951 anActor->SetOpenGLClippingPlane();
6953 vtkView->getRenderer()->ResetCameraClippingRange();
6960 \brief Adds preferences for dfont of VTK viewer
6962 \param pIf group identifier
6963 \param param parameter
6964 \return identifier of preferences
6966 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
6968 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6970 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6973 fam.append( tr( "SMESH_FONT_ARIAL" ) );
6974 fam.append( tr( "SMESH_FONT_COURIER" ) );
6975 fam.append( tr( "SMESH_FONT_TIMES" ) );
6977 setPreferenceProperty( tfont, "fonts", fam );
6979 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6980 if ( needSize ) f = f | QtxFontEdit::Size;
6981 setPreferenceProperty( tfont, "features", f );
6987 \brief Actions after hypothesis edition
6988 Updates object browser after hypothesis edition
6990 void SMESHGUI::onHypothesisEdit( int result )
6993 SMESHGUI::Modified();
6994 updateObjBrowser( true );
6998 \brief Actions after choosing menu of control modes
6999 Updates control mode actions according to current selection
7001 void SMESHGUI::onUpdateControlActions()
7003 SALOME_ListIO selected;
7004 if ( LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr() )
7005 aSel->selectedObjects( selected );
7007 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
7008 if ( selected.Extent() ) {
7009 if ( selected.First()->hasEntry() ) {
7010 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( selected.First()->getEntry() )) {
7011 aControl = anActor->GetControlMode();
7012 SALOME_ListIteratorOfListIO it(selected);
7013 for ( it.Next(); it.More(); it.Next() ) {
7014 Handle(SALOME_InteractiveObject) anIO = it.Value();
7015 if ( anIO->hasEntry() ) {
7016 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
7017 if ( aControl != anActor->GetControlMode() ) {
7018 aControl = SMESH_Actor::eNone;
7028 int anAction = ActionToControl( aControl, true );
7030 action( anAction )->setChecked( true );
7032 QMenu* send = (QMenu*)sender();
7033 QList<QAction*> actions = send->actions();
7034 for ( int i = 0; i < actions.size(); i++ )
7035 actions[i]->setChecked( false );
7041 \brief Signal handler closing(SUIT_ViewWindow*) of a view
7042 \param pview view being closed
7044 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
7045 #ifndef DISABLE_PLOT2DVIEWER
7046 //Crear all Plot2d Viewers if need.
7047 SMESH::ClearPlot2Viewers(pview);
7049 EmitSignalCloseView();
7052 void SMESHGUI::message( const QString& msg )
7055 QStringList data = msg.split("/");
7056 if ( data.count() > 0 ) {
7057 if ( data.first() == "mesh_loading" ) {
7059 QString entry = data.count() > 1 ? data[1] : QString();
7060 if ( entry.isEmpty() )
7063 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
7065 _PTR(SObject) obj = study->FindObjectID( entry.toUtf8().constData() );
7068 name = SMESH::fromUtf8(obj->GetName());
7069 if ( name.isEmpty() )
7072 if ( data.last() == "stop" )
7073 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
7075 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
7076 QApplication::processEvents();
7082 \brief Connects or disconnects signals about activating and cloning view on the module slots
7083 \param pview view which is connected/disconnected
7085 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
7089 SUIT_ViewManager* viewMgr = pview->getViewManager();
7091 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7092 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7094 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7095 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7100 \brief Return \c true if object can be renamed
7102 bool SMESHGUI::renameAllowed( const QString& entry) const {
7103 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7107 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7111 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
7116 if(appStudy->isComponent(entry) || obj->isReference())
7119 // check type to prevent renaming of inappropriate objects
7120 int aType = SMESHGUI_Selection::type(qPrintable(entry));
7121 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7122 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7123 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7124 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7125 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
7132 Rename object by entry.
7133 \param entry entry of the object
7134 \param name new name of the object
7135 \brief Return \c true if rename operation finished successfully, \c false otherwise.
7137 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
7139 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7143 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7148 _PTR(Study) aStudy = appStudy->studyDS();
7153 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
7155 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
7160 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
7161 _PTR(GenericAttribute) anAttr;
7162 _PTR(AttributeName) aName;
7164 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
7166 // check type to prevent renaming of inappropriate objects
7167 int aType = SMESHGUI_Selection::type( qPrintable(entry));
7168 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7169 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7170 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7171 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7172 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
7173 if ( !name.isEmpty() ) {
7174 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qUtf8Printable(name) );
7176 // update name of group object and its actor
7177 Handle(SALOME_InteractiveObject) IObject =
7178 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
7180 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
7181 if( !aGroupObject->_is_nil() ) {
7182 aGroupObject->SetName( qUtf8Printable(name) );
7183 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
7184 anActor->setName( qUtf8Printable(name) );
7194 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
7196 static QList<QColor> colors;
7198 if ( colors.isEmpty() ) {
7200 for (int s = 0; s < 2 ; s++)
7202 for (int v = 100; v >= 40; v = v - 20)
7204 for (int h = 0; h < 359 ; h = h + 60)
7206 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
7211 static int currentColor = randomize( colors.size() );
7213 SALOMEDS::Color color;
7214 color.R = (double)colors[currentColor].red() / 255.0;
7215 color.G = (double)colors[currentColor].green() / 255.0;
7216 color.B = (double)colors[currentColor].blue() / 255.0;
7218 currentColor = (currentColor+1) % colors.count();