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);
2543 anActor->UpdateFilter();
2547 SMESH::UpdateView();
2550 case SMESHOp::OpScalarBarProperties:
2552 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2555 case SMESHOp::OpShowScalarBar:
2557 // show/hide scalar bar
2558 ::ShowElement(theCommandID);
2561 case SMESHOp::OpSaveDistribution:
2563 // dump control distribution data to the text file
2564 ::SaveDistribution();
2568 case SMESHOp::OpShowDistribution:
2570 // show/hide distribution
2571 ::ShowElement(theCommandID);
2575 #ifndef DISABLE_PLOT2DVIEWER
2576 case SMESHOp::OpPlotDistribution:
2578 // plot distribution
2579 ::PlotDistribution();
2585 case SMESHOp::OpAutoColor:
2589 case SMESHOp::OpDisableAutoColor:
2590 ::DisableAutoColor();
2593 case SMESHOp::OpClipping:
2594 case SMESHOp::OpTransparency:
2595 case SMESHOp::OpProperties: // Display preferences (colors, shrink size, line width, ...)
2598 case SMESHOp::OpDMWireframe:
2599 case SMESHOp::OpDMShading:
2600 case SMESHOp::OpDMNodes:
2601 case SMESHOp::OpDMShrink:
2602 ::SetDisplayMode(theCommandID, myMarkerMap);
2605 //2D quadratic representation
2606 case SMESHOp::OpRepresentationLines:
2607 case SMESHOp::OpRepresentationArcs:
2608 ::SetDisplayMode(theCommandID, myMarkerMap);
2612 case SMESHOp::OpDE0DElements:
2613 case SMESHOp::OpDEEdges:
2614 case SMESHOp::OpDEFaces:
2615 case SMESHOp::OpDEVolumes:
2616 case SMESHOp::OpDEBalls:
2617 case SMESHOp::OpDEAllEntity:
2618 ::SetDisplayEntity(theCommandID);
2621 // Choose entities to be displayed
2622 case SMESHOp::OpDEChoose:
2624 ( new SMESHGUI_DisplayEntitiesDlg( SMESHGUI::desktop() ) )->exec();
2628 case SMESHOp::OpOrientationOnFaces:
2630 SUIT_OverrideCursor wc;
2631 LightApp_SelectionMgr* mgr = selectionMgr();
2632 SALOME_ListIO selected; mgr->selectedObjects( selected );
2634 SALOME_ListIteratorOfListIO it(selected);
2635 for( ; it.More(); it.Next()) {
2636 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2637 if(anIObject->hasEntry()) {
2638 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2639 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2646 case SMESHOp::OpUpdate:
2648 if(isStudyLocked()) break;
2649 SUIT_OverrideCursor wc;
2652 SMESH::UpdateView();
2654 catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2655 SMESH::OnVisuException();
2657 catch (...) { // PAL16774 (Crash after display of many groups)
2658 SMESH::OnVisuException();
2662 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2663 aSel->selectedObjects( l );
2664 aSel->setSelectedObjects( l );
2668 case SMESHOp::OpHide:
2669 case SMESHOp::OpShow:
2670 case SMESHOp::OpShowOnly:
2672 SUIT_OverrideCursor wc;
2673 SMESH::EDisplaing anAction;
2674 switch (theCommandID) {
2675 case SMESHOp::OpHide: anAction = SMESH::eErase; break;
2676 case SMESHOp::OpShow: anAction = SMESH::eDisplay; break;
2677 case SMESHOp::OpShowOnly: anAction = SMESH::eDisplayOnly; break;
2680 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2681 SALOME_ListIO sel_objects, to_process;
2683 aSel->selectedObjects( sel_objects );
2685 if ( theCommandID==SMESHOp::OpShowOnly )
2687 //MESSAGE("anAction = SMESH::eDisplayOnly");
2688 startOperation( myEraseAll );
2691 extractContainers( sel_objects, to_process );
2696 SALOME_ListIteratorOfListIO It( to_process );
2697 for ( ; It.More(); It.Next())
2699 Handle(SALOME_InteractiveObject) IOS = It.Value();
2700 if ( IOS->hasEntry() )
2702 if ( !SMESH::UpdateView( anAction, IOS->getEntry() )) {
2703 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2704 break; // PAL16774 (Crash after display of many groups)
2706 if (anAction == SMESH::eDisplayOnly)
2707 anAction = SMESH::eDisplay;
2712 // PAL13338 + PAL15161 -->
2713 if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !isStudyLocked()) {
2714 SMESH::UpdateView();
2715 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2717 // PAL13338 + PAL15161 <--
2719 catch (...) { // PAL16774 (Crash after display of many groups)
2720 SMESH::OnVisuException();
2723 if (anAction == SMESH::eErase) {
2725 aSel->setSelectedObjects( l1 );
2728 aSel->setSelectedObjects( to_process );
2733 case SMESHOp::OpNode:
2735 if(isStudyLocked()) break;
2738 EmitSignalDeactivateDialog();
2740 ( new SMESHGUI_NodesDlg( this ) )->show();
2743 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"),tr("SMESH_WRN_VIEWER_VTK"));
2748 case SMESHOp::OpCreateMesh:
2749 case SMESHOp::OpCreateSubMesh:
2750 case SMESHOp::OpEditMeshOrSubMesh:
2751 case SMESHOp::OpEditMesh:
2752 case SMESHOp::OpEditSubMesh:
2753 case SMESHOp::OpCompute:
2754 case SMESHOp::OpComputeSubMesh:
2755 case SMESHOp::OpPreCompute:
2756 case SMESHOp::OpEvaluate:
2757 case SMESHOp::OpMeshOrder:
2758 startOperation( theCommandID );
2760 case SMESHOp::OpCopyMesh:
2762 if (isStudyLocked()) break;
2763 EmitSignalDeactivateDialog();
2764 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2767 case SMESHOp::OpBuildCompoundMesh:
2769 if (isStudyLocked()) break;
2770 EmitSignalDeactivateDialog();
2771 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2775 case SMESHOp::OpDiagonalInversion:
2776 case SMESHOp::OpUnionOfTwoTriangle:
2780 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2784 if ( isStudyLocked() )
2787 /*Standard_Boolean aRes;
2788 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2789 if ( aMesh->_is_nil() )
2791 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2792 tr( "SMESH_BAD_SELECTION" ) );
2796 EmitSignalDeactivateDialog();
2797 if ( theCommandID == SMESHOp::OpDiagonalInversion )
2798 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2800 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2803 case SMESHOp::OpOrientation:
2804 case SMESHOp::OpUnionOfTriangles:
2805 case SMESHOp::OpCuttingOfQuadrangles:
2806 case SMESHOp::OpSplitVolumes:
2810 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2814 if ( isStudyLocked() )
2817 EmitSignalDeactivateDialog();
2818 SMESHGUI_MultiEditDlg* aDlg = NULL;
2819 if ( theCommandID == SMESHOp::OpOrientation )
2820 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2821 else if ( theCommandID == SMESHOp::OpUnionOfTriangles )
2822 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2823 else if ( theCommandID == SMESHOp::OpSplitVolumes )
2824 aDlg = new SMESHGUI_SplitVolumesDlg(this);
2826 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2831 case SMESHOp::OpSmoothing:
2833 if(isStudyLocked()) break;
2835 EmitSignalDeactivateDialog();
2836 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2839 SUIT_MessageBox::warning(desktop(), tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2843 case SMESHOp::OpExtrusion:
2845 if (isStudyLocked()) break;
2847 EmitSignalDeactivateDialog();
2848 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2850 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2854 case SMESHOp::OpExtrusionAlongAPath:
2856 if (isStudyLocked()) break;
2858 EmitSignalDeactivateDialog();
2859 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2861 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2865 case SMESHOp::OpRevolution:
2867 if(isStudyLocked()) break;
2869 EmitSignalDeactivateDialog();
2870 ( new SMESHGUI_RevolutionDlg( this ) )->show();
2873 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2877 case SMESHOp::OpPatternMapping:
2879 if ( isStudyLocked() )
2883 EmitSignalDeactivateDialog();
2884 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2887 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2891 case SMESHOp::OpSplitBiQuadratic:
2892 case SMESHOp::OpConvertMeshToQuadratic:
2893 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
2894 case SMESHOp::OpReorientFaces:
2895 case SMESHOp::OpCreateGeometryGroup:
2897 startOperation( theCommandID );
2900 case SMESHOp::OpCreateGroup:
2904 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2908 if(isStudyLocked()) break;
2909 EmitSignalDeactivateDialog();
2910 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2912 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2913 SALOME_ListIO selected;
2915 aSel->selectedObjects( selected );
2917 int nbSel = selected.Extent();
2919 // check if mesh is selected
2920 aMesh = SMESH::GetMeshByIO( selected.First() );
2922 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2927 case SMESHOp::OpConstructGroup:
2931 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2935 if(isStudyLocked()) break;
2936 EmitSignalDeactivateDialog();
2938 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2939 SALOME_ListIO selected;
2941 aSel->selectedObjects( selected );
2943 int nbSel = selected.Extent();
2945 // check if submesh is selected
2946 Handle(SALOME_InteractiveObject) IObject = selected.First();
2947 if (IObject->hasEntry()) {
2948 _PTR(SObject) aSObj = SMESH::getStudy()->FindObjectID(IObject->getEntry());
2950 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2951 if (!aSubMesh->_is_nil()) {
2953 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2954 // get submesh elements list by types
2955 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2956 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2957 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2958 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2959 // create group for each type o elements
2960 QString aName = IObject->getName();
2961 QStringList anEntryList;
2962 if (aNodes->length() > 0) {
2963 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2964 aGroup->Add(aNodes.inout());
2965 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2966 anEntryList.append( aSObject->GetID().c_str() );
2968 if (aEdges->length() > 0) {
2969 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2970 aGroup->Add(aEdges.inout());
2971 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2972 anEntryList.append( aSObject->GetID().c_str() );
2974 if (aFaces->length() > 0) {
2975 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2976 aGroup->Add(aFaces.inout());
2977 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2978 anEntryList.append( aSObject->GetID().c_str() );
2980 if (aVolumes->length() > 0) {
2981 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2982 aGroup->Add(aVolumes.inout());
2983 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2984 anEntryList.append( aSObject->GetID().c_str() );
2987 anApp->browseObjects( anEntryList );
2989 catch(const SALOME::SALOME_Exception & S_ex){
2990 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2997 SUIT_MessageBox::warning(desktop(),
2998 tr("SMESH_WRN_WARNING"),
2999 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
3004 case SMESHOp::OpEditGroup:
3008 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3012 if(isStudyLocked()) break;
3013 EmitSignalDeactivateDialog();
3015 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3016 SALOME_ListIO selected;
3018 aSel->selectedObjects( selected );
3020 SALOME_ListIteratorOfListIO It (selected);
3021 int nbSelectedGroups = 0;
3022 for ( ; It.More(); It.Next() )
3024 SMESH::SMESH_GroupBase_var aGroup =
3025 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
3026 if (!aGroup->_is_nil()) {
3028 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
3032 if (nbSelectedGroups == 0)
3034 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
3040 case SMESHOp::OpAddElemGroupPopup: // Add elements to group
3042 if(isStudyLocked()) break;
3043 if (myState == 800) {
3044 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3045 if (aDlg) aDlg->onAdd();
3050 case SMESHOp::OpRemoveElemGroupPopup: // Remove elements from group
3052 if(isStudyLocked()) break;
3053 if (myState == 800) {
3054 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3055 if (aDlg) aDlg->onRemove();
3060 case SMESHOp::OpEditGeomGroupAsGroup:
3064 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3068 if(isStudyLocked()) break;
3069 EmitSignalDeactivateDialog();
3071 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3072 SALOME_ListIO selected;
3074 aSel->selectedObjects( selected );
3076 SALOME_ListIteratorOfListIO It (selected);
3077 for ( ; It.More(); It.Next() )
3079 SMESH::SMESH_GroupOnGeom_var aGroup =
3080 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
3081 if (!aGroup->_is_nil()) {
3082 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3087 SMESH::SMESH_GroupOnFilter_var aGroup =
3088 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
3089 if (!aGroup->_is_nil()) {
3090 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3098 case SMESHOp::OpUnionGroups:
3099 case SMESHOp::OpIntersectGroups:
3100 case SMESHOp::OpCutGroups:
3104 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3108 if ( isStudyLocked() )
3111 EmitSignalDeactivateDialog();
3113 SMESHGUI_GroupOpDlg* aDlg = 0;
3114 if ( theCommandID == SMESHOp::OpUnionGroups )
3115 aDlg = new SMESHGUI_UnionGroupsDlg( this );
3116 else if ( theCommandID == SMESHOp::OpIntersectGroups )
3117 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3119 aDlg = new SMESHGUI_CutGroupsDlg( this );
3126 case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
3128 if ( isStudyLocked() )
3131 EmitSignalDeactivateDialog();
3132 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3138 case SMESHOp::OpFaceGroupsByEdges: // Create face groups separated by sharp edges
3140 if ( isStudyLocked() )
3143 EmitSignalDeactivateDialog();
3144 SMESHGUI_FaceGroupsSeparatedByEdgesDlg* aDlg = new SMESHGUI_FaceGroupsSeparatedByEdgesDlg( this );
3150 case SMESHOp::OpDeleteGroup: // Delete groups with their contents
3154 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3158 if ( isStudyLocked() )
3161 EmitSignalDeactivateDialog();
3163 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3167 case SMESHOp::OpMeshInformation:
3168 case SMESHOp::OpWhatIs:
3170 int page = theCommandID == SMESHOp::OpMeshInformation ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3171 EmitSignalDeactivateDialog();
3172 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3173 SALOME_ListIO selected;
3175 aSel->selectedObjects( selected );
3177 if ( selected.Extent() > 1 ) { // a dlg for each IO
3178 SALOME_ListIteratorOfListIO It( selected );
3179 for ( ; It.More(); It.Next() ) {
3180 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3181 dlg->showInfo( It.Value() );
3186 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3192 case SMESHOp::OpFindElementByPoint:
3194 startOperation( theCommandID );
3198 case SMESHOp::OpEditHypothesis:
3200 if(isStudyLocked()) break;
3202 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3203 SALOME_ListIO selected;
3205 aSel->selectedObjects( selected );
3207 int nbSel = selected.Extent();
3210 Handle(SALOME_InteractiveObject) anIObject = selected.First();
3211 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3213 if ( !aHypothesis->_is_nil() )
3215 SMESHGUI_GenericHypothesisCreator* aCreator =
3216 SMESH::GetHypothesisCreator( SMESH::toQStr( aHypothesis->GetName() ));
3219 // set geometry of mesh and sub-mesh to aCreator
3220 aSel->selectedObjects( selected, "", /*convertReferences=*/false);
3221 if ( selected.Extent() == 1 )
3223 QString subGeomID, meshGeomID;
3224 Handle(SALOME_InteractiveObject) hypIO = selected.First();
3225 if ( SMESH::GetGeomEntries( hypIO, subGeomID, meshGeomID ))
3227 if ( subGeomID.isEmpty() ) subGeomID = meshGeomID;
3228 aCreator->setShapeEntry( subGeomID );
3229 aCreator->setMainShapeEntry( meshGeomID );
3233 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3243 case SMESHOp::OpUnassign: // REMOVE HYPOTHESIS / ALGORITHMS
3245 if(isStudyLocked()) break;
3246 SUIT_OverrideCursor wc;
3248 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3249 SALOME_ListIO selected;
3251 aSel->selectedObjects( selected, QString::null, false );
3253 SALOME_ListIteratorOfListIO It(selected);
3254 for (int i = 0; It.More(); It.Next(), i++) {
3255 Handle(SALOME_InteractiveObject) IObject = It.Value();
3256 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3259 aSel->setSelectedObjects( l1 );
3264 case SMESHOp::OpElem0D:
3265 case SMESHOp::OpBall:
3266 case SMESHOp::OpEdge:
3267 case SMESHOp::OpTriangle:
3268 case SMESHOp::OpQuadrangle:
3269 case SMESHOp::OpPolygon:
3270 case SMESHOp::OpTetrahedron:
3271 case SMESHOp::OpHexahedron:
3272 case SMESHOp::OpPentahedron:
3273 case SMESHOp::OpPyramid:
3274 case SMESHOp::OpHexagonalPrism:
3276 if(isStudyLocked()) break;
3278 EmitSignalDeactivateDialog();
3279 SMDSAbs_EntityType type = SMDSEntity_Edge;
3280 switch (theCommandID) {
3281 case SMESHOp::OpElem0D: type = SMDSEntity_0D; break;
3282 case SMESHOp::OpBall: type = SMDSEntity_Ball; break;
3283 case SMESHOp::OpTriangle: type = SMDSEntity_Triangle; break;
3284 case SMESHOp::OpQuadrangle: type = SMDSEntity_Quadrangle; break;
3285 case SMESHOp::OpTetrahedron: type = SMDSEntity_Tetra; break;
3286 case SMESHOp::OpPolygon: type = SMDSEntity_Polygon; break;
3287 case SMESHOp::OpHexahedron: type = SMDSEntity_Hexa; break;
3288 case SMESHOp::OpPentahedron: type = SMDSEntity_Penta; break;
3289 case SMESHOp::OpPyramid: type = SMDSEntity_Pyramid; break;
3290 case SMESHOp::OpHexagonalPrism: type = SMDSEntity_Hexagonal_Prism; break;
3293 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3296 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3300 case SMESHOp::OpPolyhedron:
3302 if(isStudyLocked()) break;
3304 EmitSignalDeactivateDialog();
3305 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3308 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3312 case SMESHOp::OpQuadraticEdge:
3313 case SMESHOp::OpQuadraticTriangle:
3314 case SMESHOp::OpBiQuadraticTriangle:
3315 case SMESHOp::OpQuadraticQuadrangle:
3316 case SMESHOp::OpBiQuadraticQuadrangle:
3317 case SMESHOp::OpQuadraticPolygon:
3318 case SMESHOp::OpQuadraticTetrahedron:
3319 case SMESHOp::OpQuadraticPyramid:
3320 case SMESHOp::OpQuadraticPentahedron:
3321 case SMESHOp::OpBiQuadraticPentahedron:
3322 case SMESHOp::OpQuadraticHexahedron:
3323 case SMESHOp::OpTriQuadraticHexahedron:
3325 if(isStudyLocked()) break;
3327 EmitSignalDeactivateDialog();
3328 SMDSAbs_EntityType type = SMDSEntity_Last;
3330 switch (theCommandID) {
3331 case SMESHOp::OpQuadraticEdge: type = SMDSEntity_Quad_Edge; break;
3332 case SMESHOp::OpQuadraticTriangle: type = SMDSEntity_Quad_Triangle; break;
3333 case SMESHOp::OpBiQuadraticTriangle: type = SMDSEntity_BiQuad_Triangle; break;
3334 case SMESHOp::OpQuadraticQuadrangle: type = SMDSEntity_Quad_Quadrangle; break;
3335 case SMESHOp::OpBiQuadraticQuadrangle: type = SMDSEntity_BiQuad_Quadrangle; break;
3336 case SMESHOp::OpQuadraticPolygon: type = SMDSEntity_Quad_Polygon; break;
3337 case SMESHOp::OpQuadraticTetrahedron: type = SMDSEntity_Quad_Tetra; break;
3338 case SMESHOp::OpQuadraticPyramid: type = SMDSEntity_Quad_Pyramid; break;
3339 case SMESHOp::OpQuadraticPentahedron: type = SMDSEntity_Quad_Penta; break;
3340 case SMESHOp::OpBiQuadraticPentahedron: type = SMDSEntity_BiQuad_Penta; break;
3341 case SMESHOp::OpQuadraticHexahedron: type = SMDSEntity_Quad_Hexa; break;
3342 case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
3345 if ( type != SMDSEntity_Last )
3346 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3349 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3350 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3354 case SMESHOp::OpRemoveNodes:
3356 if(isStudyLocked()) break;
3358 EmitSignalDeactivateDialog();
3359 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3362 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3363 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3367 case SMESHOp::OpRemoveElements: // REMOVES ELEMENTS
3369 if(isStudyLocked()) break;
3371 EmitSignalDeactivateDialog();
3372 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3376 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3377 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3381 case SMESHOp::OpClearMesh: {
3383 if(isStudyLocked()) break;
3385 SALOME_ListIO selected;
3386 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3387 aSel->selectedObjects( selected );
3389 SUIT_OverrideCursor wc;
3390 SALOME_ListIteratorOfListIO It (selected);
3391 for ( ; It.More(); It.Next() )
3393 Handle(SALOME_InteractiveObject) IOS = It.Value();
3394 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3395 if ( aMesh->_is_nil()) continue;
3398 if ( aMesh->NbNodes() == 0 ) // imported mesh is not empty
3399 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3400 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3401 // hide groups and submeshes
3402 _PTR(ChildIterator) anIter =
3403 SMESH::getStudy()->NewChildIterator( aMeshSObj );
3404 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3406 _PTR(SObject) so = anIter->Value();
3407 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3410 catch (const SALOME::SALOME_Exception& S_ex){
3412 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3416 SMESH::UpdateView();
3420 case SMESHOp::OpRemoveOrphanNodes:
3422 if(isStudyLocked()) break;
3423 SALOME_ListIO selected;
3424 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3425 aSel->selectedObjects( selected );
3426 if ( selected.Extent() == 1 ) {
3427 Handle(SALOME_InteractiveObject) anIO = selected.First();
3428 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3429 if ( !aMesh->_is_nil() ) {
3430 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3431 tr( "SMESH_WARNING" ),
3432 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3433 SUIT_MessageBox::Yes |
3434 SUIT_MessageBox::No,
3435 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3438 SUIT_OverrideCursor wc;
3439 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3440 int removed = aMeshEditor->RemoveOrphanNodes();
3441 SUIT_MessageBox::information(SMESHGUI::desktop(),
3442 tr("SMESH_INFORMATION"),
3443 tr("NB_NODES_REMOVED").arg(removed));
3444 if ( removed > 0 ) {
3445 SMESH::UpdateView();
3446 SMESHGUI::Modified();
3449 catch (const SALOME::SALOME_Exception& S_ex) {
3450 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3459 case SMESHOp::OpRenumberingNodes:
3461 if(isStudyLocked()) break;
3463 EmitSignalDeactivateDialog();
3464 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3468 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3469 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3473 case SMESHOp::OpRenumberingElements:
3475 if(isStudyLocked()) break;
3477 EmitSignalDeactivateDialog();
3478 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3482 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3483 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3487 case SMESHOp::OpTranslation:
3489 if(isStudyLocked()) break;
3491 EmitSignalDeactivateDialog();
3492 ( new SMESHGUI_TranslationDlg( this ) )->show();
3495 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3496 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3500 case SMESHOp::OpRotation:
3502 if(isStudyLocked()) break;
3504 EmitSignalDeactivateDialog();
3505 ( new SMESHGUI_RotationDlg( this ) )->show();
3508 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3509 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3513 case SMESHOp::OpSymmetry:
3515 if(isStudyLocked()) break;
3517 EmitSignalDeactivateDialog();
3518 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3521 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3522 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3526 case SMESHOp::OpScale:
3528 if(isStudyLocked()) break;
3530 EmitSignalDeactivateDialog();
3531 ( new SMESHGUI_ScaleDlg( this ) )->show();
3534 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3535 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3540 case SMESHOp::OpOffset:
3542 if(isStudyLocked()) break;
3544 EmitSignalDeactivateDialog();
3545 ( new SMESHGUI_OffsetDlg( this ) )->show();
3548 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3549 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3554 case SMESHOp::OpSewing:
3556 if(isStudyLocked()) break;
3558 EmitSignalDeactivateDialog();
3559 ( new SMESHGUI_SewingDlg( this ) )->show();
3562 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3563 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3567 case SMESHOp::OpMergeNodes:
3569 if(isStudyLocked()) break;
3571 EmitSignalDeactivateDialog();
3572 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3575 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3576 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3580 case SMESHOp::OpMergeElements:
3582 if (isStudyLocked()) break;
3584 EmitSignalDeactivateDialog();
3585 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3587 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3588 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3593 case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
3594 startOperation( SMESHOp::OpMoveNode );
3597 case SMESHOp::OpDuplicateNodes:
3599 if(isStudyLocked()) break;
3601 EmitSignalDeactivateDialog();
3602 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3605 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3606 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3611 case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
3612 startOperation( SMESHOp::OpElem0DOnElemNodes );
3615 case SMESHOp::OpSelectFiltersLibrary: // Library of selection filters
3617 static QList<int> aTypes;
3618 if ( aTypes.isEmpty() )
3620 aTypes.append( SMESH::NODE );
3621 aTypes.append( SMESH::EDGE );
3622 aTypes.append( SMESH::FACE );
3623 aTypes.append( SMESH::VOLUME );
3625 if (!myFilterLibraryDlg)
3626 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3627 else if (myFilterLibraryDlg->isHidden())
3628 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3629 myFilterLibraryDlg->raise();
3633 case SMESHOp::OpFreeNode:
3634 case SMESHOp::OpEqualNode:
3635 case SMESHOp::OpNodeConnectivityNb:
3636 case SMESHOp::OpFreeEdge:
3637 case SMESHOp::OpFreeBorder:
3638 case SMESHOp::OpLength:
3639 case SMESHOp::OpConnection:
3640 case SMESHOp::OpEqualEdge:
3641 case SMESHOp::OpFreeFace:
3642 case SMESHOp::OpBareBorderFace:
3643 case SMESHOp::OpOverConstrainedFace:
3644 case SMESHOp::OpLength2D:
3645 case SMESHOp::OpDeflection2D:
3646 case SMESHOp::OpConnection2D:
3647 case SMESHOp::OpArea:
3648 case SMESHOp::OpTaper:
3649 case SMESHOp::OpAspectRatio:
3650 case SMESHOp::OpMinimumAngle:
3651 case SMESHOp::OpWarpingAngle:
3652 case SMESHOp::OpSkew:
3653 case SMESHOp::OpMaxElementLength2D:
3654 case SMESHOp::OpEqualFace:
3655 case SMESHOp::OpAspectRatio3D:
3656 case SMESHOp::OpVolume:
3657 case SMESHOp::OpMaxElementLength3D:
3658 case SMESHOp::OpBareBorderVolume:
3659 case SMESHOp::OpOverConstrainedVolume:
3660 case SMESHOp::OpEqualVolume:
3663 LightApp_SelectionMgr* mgr = selectionMgr();
3664 SALOME_ListIO selected; mgr->selectedObjects( selected );
3666 if( !selected.IsEmpty() ) {
3667 SUIT_OverrideCursor wc;
3668 ::Control( theCommandID );
3671 SUIT_MessageBox::warning(desktop(),
3672 tr( "SMESH_WRN_WARNING" ),
3673 tr( "SMESH_BAD_SELECTION" ) );
3677 SUIT_MessageBox::warning(desktop(),
3678 tr( "SMESH_WRN_WARNING" ),
3679 tr( "NOT_A_VTK_VIEWER" ) );
3682 case SMESHOp::OpOverallMeshQuality:
3683 OverallMeshQuality();
3685 case SMESHOp::OpNumberingNodes:
3687 SUIT_OverrideCursor wc;
3688 LightApp_SelectionMgr* mgr = selectionMgr();
3689 SALOME_ListIO selected; mgr->selectedObjects( selected );
3691 SALOME_ListIteratorOfListIO it(selected);
3692 for( ; it.More(); it.Next()) {
3693 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3694 if(anIObject->hasEntry()) {
3695 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3696 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3702 case SMESHOp::OpNumberingElements:
3704 SUIT_OverrideCursor wc;
3705 LightApp_SelectionMgr* mgr = selectionMgr();
3706 SALOME_ListIO selected; mgr->selectedObjects( selected );
3708 SALOME_ListIteratorOfListIO it(selected);
3709 for( ; it.More(); it.Next()) {
3710 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3711 if(anIObject->hasEntry())
3712 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3713 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3718 case SMESHOp::OpPropertiesLength:
3719 case SMESHOp::OpPropertiesArea:
3720 case SMESHOp::OpPropertiesVolume:
3721 case SMESHOp::OpMinimumDistance:
3722 case SMESHOp::OpBoundingBox:
3723 case SMESHOp::OpAngle:
3725 int page = SMESHGUI_MeasureDlg::MinDistance;
3726 if ( theCommandID == SMESHOp::OpBoundingBox )
3727 page = SMESHGUI_MeasureDlg::BoundingBox;
3728 else if ( theCommandID == SMESHOp::OpPropertiesLength )
3729 page = SMESHGUI_MeasureDlg::Length;
3730 else if ( theCommandID == SMESHOp::OpPropertiesArea )
3731 page = SMESHGUI_MeasureDlg::Area;
3732 else if ( theCommandID == SMESHOp::OpPropertiesVolume )
3733 page = SMESHGUI_MeasureDlg::Volume;
3734 else if ( theCommandID == SMESHOp::OpAngle )
3735 page = SMESHGUI_MeasureDlg::Angle;
3737 EmitSignalDeactivateDialog();
3738 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3742 case SMESHOp::OpSortChild:
3748 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3749 //updateObjBrowser();
3753 //=============================================================================
3757 //=============================================================================
3758 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3763 //=============================================================================
3767 //=============================================================================
3768 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3773 //=============================================================================
3777 //=============================================================================
3778 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3783 //=============================================================================
3784 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3785 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3787 //=============================================================================
3788 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3789 SUIT_ViewWindow* wnd )
3791 if(theIO->hasEntry()){
3792 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3793 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3797 //=======================================================================
3798 // function : createSMESHAction
3800 //=======================================================================
3801 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3802 const int key, const bool toggle, const QString& shortcutAction )
3805 QWidget* parent = application()->desktop();
3806 SUIT_ResourceMgr* resMgr = resourceMgr();
3808 if ( !icon_id.isEmpty() )
3809 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3811 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3812 if ( !pix.isNull() )
3813 icon = QIcon( pix );
3815 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3816 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3817 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3819 createAction( id, tooltip, icon, menu, status_bar, key, parent,
3820 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3823 //=======================================================================
3824 // function : createPopupItem
3826 //=======================================================================
3827 void SMESHGUI::createPopupItem( const int id,
3828 const QString& clients,
3829 const QString& types,
3830 const QString& theRule,
3833 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3834 popupMgr()->insert( action( id ), pId, 0 );
3836 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3837 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
3838 QString rule = "(%1) and (%2) and (%3)";
3839 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3840 if( clients.isEmpty() )
3841 rule = rule.arg( QString( "true" ) );
3843 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3844 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3847 bool cont = myRules.contains( id );
3849 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3851 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3852 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3855 //=======================================================================
3856 // function : initialize
3858 //=======================================================================
3859 void SMESHGUI::initialize( CAM_Application* app )
3861 SalomeApp_Module::initialize( app );
3863 // SUIT_ResourceMgr* mgr = app->resourceMgr();
3865 /* Automatic Update flag */
3866 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3868 // ----- create actions --------------
3870 //createSMESHAction( SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
3871 createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_I) );
3872 createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
3873 createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL" );
3875 createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
3877 createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
3878 createSMESHAction( SMESHOp::OpImportGMF, "IMPORT_GMF" );
3879 createSMESHAction( SMESHOp::OpPopupImportUNV, "IMPORT_UNV");
3880 createSMESHAction( SMESHOp::OpPopupImportMED, "IMPORT_MED");
3881 createSMESHAction( SMESHOp::OpPopupImportSTL, "IMPORT_STL" );
3883 createSMESHAction( SMESHOp::OpPopupImportCGNS, "IMPORT_CGNS" );
3885 createSMESHAction( SMESHOp::OpPopupImportSAUV, "IMPORT_SAUV" );
3886 createSMESHAction( SMESHOp::OpPopupImportGMF, "IMPORT_GMF" );
3888 createSMESHAction( SMESHOp::OpExportDAT, "DAT" );
3889 createSMESHAction( SMESHOp::OpExportMED, "MED" );
3890 createSMESHAction( SMESHOp::OpExportUNV, "UNV" );
3891 createSMESHAction( SMESHOp::OpExportSTL, "STL" );
3893 createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
3895 createSMESHAction( SMESHOp::OpExportSAUV, "SAUV");
3896 createSMESHAction( SMESHOp::OpExportGMF, "GMF" );
3897 createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
3898 createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
3899 createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
3900 createSMESHAction( SMESHOp::OpPopupExportSTL, "STL" );
3902 createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
3904 createSMESHAction( SMESHOp::OpPopupExportSAUV, "SAUV");
3905 createSMESHAction( SMESHOp::OpPopupExportGMF, "GMF" );
3906 createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
3907 createSMESHAction( SMESHOp::OpDelete, "DELETE", "ICON_DELETE", Qt::Key_Delete );
3908 createSMESHAction( SMESHOp::OpSelectFiltersLibrary, "SEL_FILTER_LIB" );
3909 createSMESHAction( SMESHOp::OpCreateMesh, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
3910 createSMESHAction( SMESHOp::OpCreateSubMesh, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
3911 createSMESHAction( SMESHOp::OpEditMeshOrSubMesh, "EDIT_MESHSUBMESH", "ICON_DLG_EDIT_MESH" );
3912 createSMESHAction( SMESHOp::OpEditMesh, "EDIT_MESH", "ICON_DLG_EDIT_MESH" );
3913 createSMESHAction( SMESHOp::OpEditSubMesh, "EDIT_SUBMESH", "ICON_DLG_EDIT_MESH" );
3914 createSMESHAction( SMESHOp::OpBuildCompoundMesh, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
3915 createSMESHAction( SMESHOp::OpCopyMesh, "COPY_MESH", "ICON_COPY_MESH" );
3916 createSMESHAction( SMESHOp::OpCompute, "COMPUTE", "ICON_COMPUTE" );
3917 createSMESHAction( SMESHOp::OpComputeSubMesh, "COMPUTE_SUBMESH", "ICON_COMPUTE" );
3918 createSMESHAction( SMESHOp::OpPreCompute, "PRECOMPUTE", "ICON_PRECOMPUTE" );
3919 createSMESHAction( SMESHOp::OpEvaluate, "EVALUATE", "ICON_EVALUATE" );
3920 createSMESHAction( SMESHOp::OpMeshOrder, "MESH_ORDER", "ICON_MESH_ORDER");
3921 createSMESHAction( SMESHOp::OpCreateGroup, "CREATE_GROUP", "ICON_CREATE_GROUP" );
3922 createSMESHAction( SMESHOp::OpCreateGeometryGroup, "CREATE_GEO_GROUP", "ICON_CREATE_GEO_GROUP" );
3923 createSMESHAction( SMESHOp::OpConstructGroup, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
3924 createSMESHAction( SMESHOp::OpEditGroup, "EDIT_GROUP", "ICON_EDIT_GROUP" );
3925 createSMESHAction( SMESHOp::OpEditGeomGroupAsGroup, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3926 createSMESHAction( SMESHOp::OpUnionGroups, "UN_GROUP", "ICON_UNION" );
3927 createSMESHAction( SMESHOp::OpIntersectGroups, "INT_GROUP", "ICON_INTERSECT" );
3928 createSMESHAction( SMESHOp::OpCutGroups, "CUT_GROUP", "ICON_CUT" );
3929 createSMESHAction( SMESHOp::OpGroupUnderlyingElem, "UNDERLYING_ELEMS", "ICON_UNDERLYING_ELEMS" );
3930 createSMESHAction( SMESHOp::OpFaceGroupsByEdges, "FACE_GROUPS_BY_EDGES", "ICON_FACE_GROUPS_BY_EDGES" );
3931 createSMESHAction( SMESHOp::OpAddElemGroupPopup, "ADD_TO_GROUP" );
3932 createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE_FROM_GROUP" );
3933 createSMESHAction( SMESHOp::OpDeleteGroup, "DEL_GROUP", "ICON_DEL_GROUP" );
3934 createSMESHAction( SMESHOp::OpMeshInformation , "ADV_INFO", "ICON_ADV_INFO" );
3935 //createSMESHAction( SMESHOp::OpStdInfo, "STD_INFO", "ICON_STD_INFO" );
3936 //createSMESHAction( SMESHOp::OpWhatIs, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3937 createSMESHAction( SMESHOp::OpFindElementByPoint, "FIND_ELEM", "ICON_FIND_ELEM" );
3939 createSMESHAction( SMESHOp::OpFreeNode, "FREE_NODE", "ICON_FREE_NODE", 0, true );
3940 createSMESHAction( SMESHOp::OpEqualNode, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
3941 createSMESHAction( SMESHOp::OpNodeConnectivityNb, "NODE_CONNECTIVITY_NB", "ICON_NODE_CONN_NB", 0, true );
3942 createSMESHAction( SMESHOp::OpFreeEdge, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
3943 createSMESHAction( SMESHOp::OpFreeBorder, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
3944 createSMESHAction( SMESHOp::OpLength, "LENGTH", "ICON_LENGTH", 0, true );
3945 createSMESHAction( SMESHOp::OpConnection, "CONNECTION", "ICON_CONNECTION", 0, true );
3946 createSMESHAction( SMESHOp::OpEqualEdge, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
3947 createSMESHAction( SMESHOp::OpFreeFace, "FREE_FACES", "ICON_FREE_FACES", 0, true );
3948 createSMESHAction( SMESHOp::OpBareBorderFace, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
3949 createSMESHAction( SMESHOp::OpOverConstrainedFace, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
3950 createSMESHAction( SMESHOp::OpLength2D, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
3951 createSMESHAction( SMESHOp::OpDeflection2D, "DEFLECTION_2D", "ICON_DEFLECTION_2D", 0, true );
3952 createSMESHAction( SMESHOp::OpConnection2D, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
3953 createSMESHAction( SMESHOp::OpArea, "AREA", "ICON_AREA", 0, true );
3954 createSMESHAction( SMESHOp::OpTaper, "TAPER", "ICON_TAPER", 0, true );
3955 createSMESHAction( SMESHOp::OpAspectRatio, "ASPECT", "ICON_ASPECT", 0, true );
3956 createSMESHAction( SMESHOp::OpMinimumAngle, "MIN_ANG", "ICON_ANGLE", 0, true );
3957 createSMESHAction( SMESHOp::OpWarpingAngle, "WARP", "ICON_WARP", 0, true );
3958 createSMESHAction( SMESHOp::OpSkew, "SKEW", "ICON_SKEW", 0, true );
3959 createSMESHAction( SMESHOp::OpMaxElementLength2D, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
3960 createSMESHAction( SMESHOp::OpEqualFace, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
3961 createSMESHAction( SMESHOp::OpAspectRatio3D, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
3962 createSMESHAction( SMESHOp::OpVolume, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
3963 createSMESHAction( SMESHOp::OpMaxElementLength3D, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
3964 createSMESHAction( SMESHOp::OpBareBorderVolume, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
3965 createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
3966 createSMESHAction( SMESHOp::OpEqualVolume, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
3967 createSMESHAction( SMESHOp::OpOverallMeshQuality, "OVERALL_MESH_QUALITY", "ICON_OVL_MESH_QUALITY" );
3969 createSMESHAction( SMESHOp::OpNode, "NODE", "ICON_DLG_NODE" );
3970 createSMESHAction( SMESHOp::OpElem0D, "ELEM0D", "ICON_DLG_ELEM0D" );
3971 createSMESHAction( SMESHOp::OpElem0DOnElemNodes, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
3972 createSMESHAction( SMESHOp::OpBall, "BALL", "ICON_DLG_BALL" );
3973 createSMESHAction( SMESHOp::OpEdge, "EDGE", "ICON_DLG_EDGE" );
3974 createSMESHAction( SMESHOp::OpTriangle, "TRIANGLE", "ICON_DLG_TRIANGLE" );
3975 createSMESHAction( SMESHOp::OpQuadrangle, "QUAD", "ICON_DLG_QUADRANGLE" );
3976 createSMESHAction( SMESHOp::OpPolygon, "POLYGON", "ICON_DLG_POLYGON" );
3977 createSMESHAction( SMESHOp::OpTetrahedron, "TETRA", "ICON_DLG_TETRAS" );
3978 createSMESHAction( SMESHOp::OpHexahedron, "HEXA", "ICON_DLG_HEXAS" );
3979 createSMESHAction( SMESHOp::OpPentahedron, "PENTA", "ICON_DLG_PENTA" );
3980 createSMESHAction( SMESHOp::OpPyramid , "PYRAMID", "ICON_DLG_PYRAMID" );
3981 createSMESHAction( SMESHOp::OpHexagonalPrism, "OCTA", "ICON_DLG_OCTA" );
3982 createSMESHAction( SMESHOp::OpPolyhedron, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
3983 createSMESHAction( SMESHOp::OpQuadraticEdge, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
3984 createSMESHAction( SMESHOp::OpQuadraticTriangle, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
3985 createSMESHAction( SMESHOp::OpBiQuadraticTriangle, "BIQUADRATIC_TRIANGLE", "ICON_DLG_BIQUADRATIC_TRIANGLE" );
3986 createSMESHAction( SMESHOp::OpQuadraticQuadrangle, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
3987 createSMESHAction( SMESHOp::OpBiQuadraticQuadrangle, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
3988 createSMESHAction( SMESHOp::OpQuadraticPolygon, "QUADRATIC_POLYGON", "ICON_DLG_QUADRATIC_POLYGON" );
3989 createSMESHAction( SMESHOp::OpQuadraticTetrahedron, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
3990 createSMESHAction( SMESHOp::OpQuadraticPyramid, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
3991 createSMESHAction( SMESHOp::OpQuadraticPentahedron, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
3992 createSMESHAction( SMESHOp::OpBiQuadraticPentahedron, "BIQUADRATIC_PENTAHEDRON", "ICON_DLG_BIQUADRATIC_PENTAHEDRON" );
3993 createSMESHAction( SMESHOp::OpQuadraticHexahedron, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
3994 createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
3996 createSMESHAction( SMESHOp::OpRemoveNodes, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
3997 createSMESHAction( SMESHOp::OpRemoveElements, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
3998 createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
3999 createSMESHAction( SMESHOp::OpClearMesh, "CLEAR_MESH", "ICON_CLEAR_MESH" );
4001 //createSMESHAction( SMESHOp::OpRenumberingNodes, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
4002 //createSMESHAction( SMESHOp::OpRenumberingElements, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
4004 createSMESHAction( SMESHOp::OpTranslation, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
4005 createSMESHAction( SMESHOp::OpRotation, "ROT", "ICON_DLG_MESH_ROTATION" );
4006 createSMESHAction( SMESHOp::OpSymmetry, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
4007 createSMESHAction( SMESHOp::OpScale, "SCALE", "ICON_DLG_MESH_SCALE" );
4008 createSMESHAction( SMESHOp::OpOffset, "OFFSET", "ICON_DLG_MESH_OFFSET" );
4009 createSMESHAction( SMESHOp::OpSewing, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
4010 createSMESHAction( SMESHOp::OpMergeNodes, "MERGE", "ICON_SMESH_MERGE_NODES" );
4011 createSMESHAction( SMESHOp::OpMergeElements, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
4012 createSMESHAction( SMESHOp::OpMoveNode, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
4013 createSMESHAction( SMESHOp::OpDuplicateNodes, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
4014 createSMESHAction( SMESHOp::OpDiagonalInversion, "INV", "ICON_DLG_MESH_DIAGONAL" );
4015 createSMESHAction( SMESHOp::OpUnionOfTwoTriangle, "UNION2", "ICON_UNION2TRI" );
4016 createSMESHAction( SMESHOp::OpOrientation, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
4017 createSMESHAction( SMESHOp::OpReorientFaces, "REORIENT_2D", "ICON_REORIENT_2D" );
4018 createSMESHAction( SMESHOp::OpUnionOfTriangles, "UNION", "ICON_UNIONTRI" );
4019 createSMESHAction( SMESHOp::OpCuttingOfQuadrangles, "CUT", "ICON_CUTQUAD" );
4020 createSMESHAction( SMESHOp::OpSplitVolumes, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
4021 createSMESHAction( SMESHOp::OpSplitBiQuadratic, "SPLIT_BIQUAD", "ICON_SPLIT_BIQUAD" );
4022 createSMESHAction( SMESHOp::OpSmoothing, "SMOOTH", "ICON_DLG_SMOOTHING" );
4023 createSMESHAction( SMESHOp::OpExtrusion, "EXTRUSION", "ICON_EXTRUSION" );
4024 createSMESHAction( SMESHOp::OpExtrusionAlongAPath, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
4025 createSMESHAction( SMESHOp::OpRevolution, "REVOLUTION", "ICON_REVOLUTION" );
4026 createSMESHAction( SMESHOp::OpPatternMapping, "MAP", "ICON_MAP" );
4027 createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
4028 createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D", "ICON_2D_FROM_3D" );
4030 createSMESHAction( SMESHOp::OpReset, "RESET" );
4031 createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
4032 createSMESHAction( SMESHOp::OpShowScalarBar, "SHOW_SCALAR_BAR","",0, true );
4033 createSMESHAction( SMESHOp::OpSaveDistribution, "SAVE_DISTRIBUTION" );
4034 createSMESHAction( SMESHOp::OpShowDistribution, "SHOW_DISTRIBUTION","",0, true );
4035 #ifndef DISABLE_PLOT2DVIEWER
4036 createSMESHAction( SMESHOp::OpPlotDistribution, "PLOT_DISTRIBUTION" );
4038 createSMESHAction( SMESHOp::OpDMWireframe, "WIRE", "ICON_WIRE", 0, true );
4039 createSMESHAction( SMESHOp::OpDMShading, "SHADE", "ICON_SHADE", 0, true );
4040 createSMESHAction( SMESHOp::OpDMNodes, "NODES", "ICON_POINTS", 0, true );
4041 createSMESHAction( SMESHOp::OpDMShrink, "SHRINK", "ICON_SHRINK", 0, true );
4042 createSMESHAction( SMESHOp::OpUpdate, "UPDATE", "ICON_UPDATE" );
4043 createSMESHAction( SMESHOp::OpDE0DElements, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
4044 createSMESHAction( SMESHOp::OpDEEdges, "EDGES", "ICON_DLG_EDGE", 0, true );
4045 createSMESHAction( SMESHOp::OpDEFaces, "FACES", "ICON_DLG_TRIANGLE", 0, true );
4046 createSMESHAction( SMESHOp::OpDEVolumes, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
4047 createSMESHAction( SMESHOp::OpDEBalls, "BALLS", "ICON_DLG_BALL", 0, true );
4048 createSMESHAction( SMESHOp::OpDEChoose, "CHOOSE", "ICON_DLG_CHOOSE", 0, false );
4049 createSMESHAction( SMESHOp::OpDEAllEntity, "ALL", "ICON_DLG_CHOOSE_ALL", 0, false );
4050 createSMESHAction( SMESHOp::OpOrientationOnFaces, "FACE_ORIENTATION", "", 0, true );
4052 createSMESHAction( SMESHOp::OpRepresentationLines, "LINE_REPRESENTATION", "", 0, true );
4053 createSMESHAction( SMESHOp::OpRepresentationArcs, "ARC_REPRESENTATION", "", 0, true );
4055 createSMESHAction( SMESHOp::OpEditHypothesis, "EDIT_HYPO" );
4056 createSMESHAction( SMESHOp::OpUnassign, "UNASSIGN" );
4057 createSMESHAction( SMESHOp::OpNumberingNodes, "NUM_NODES", "", 0, true );
4058 createSMESHAction( SMESHOp::OpNumberingElements, "NUM_ELEMENTS", "", 0, true );
4059 createSMESHAction( SMESHOp::OpProperties, "COLORS" );
4060 createSMESHAction( SMESHOp::OpTransparency, "TRANSP" );
4061 createSMESHAction( SMESHOp::OpClipping, "CLIP" );
4062 createSMESHAction( SMESHOp::OpAutoColor, "AUTO_COLOR" );
4063 createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
4065 createSMESHAction( SMESHOp::OpMinimumDistance, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
4066 createSMESHAction( SMESHOp::OpBoundingBox, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
4067 createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH", "ICON_MEASURE_LENGTH" );
4068 createSMESHAction( SMESHOp::OpPropertiesArea, "MEASURE_AREA", "ICON_MEASURE_AREA" );
4069 createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME", "ICON_MEASURE_VOLUME" );
4070 createSMESHAction( SMESHOp::OpAngle, "MEASURE_ANGLE", "ICON_MEASURE_ANGLE" );
4072 createSMESHAction( SMESHOp::OpHide, "HIDE", "ICON_HIDE" );
4073 createSMESHAction( SMESHOp::OpShow, "SHOW", "ICON_SHOW" );
4074 createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
4076 createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
4078 QList<int> aCtrlActions;
4079 aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode
4080 << SMESHOp::OpNodeConnectivityNb // node controls
4081 << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
4082 << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge // edge controls
4083 << SMESHOp::OpDeflection2D
4084 << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
4085 << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
4086 << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
4087 << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
4088 << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace // face controls
4089 << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
4090 << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
4091 << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume; // volume controls
4092 QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
4093 aCtrlGroup->setExclusive( true );
4094 for( int i = 0; i < aCtrlActions.size(); i++ )
4095 aCtrlGroup->addAction( action( aCtrlActions[i] ) );
4097 // ----- create menu --------------
4098 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
4099 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
4100 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
4101 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
4102 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
4103 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
4104 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
4105 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
4107 createMenu( separator(), fileId );
4109 QMenu* nodeMenu = new QMenu(); QMenu* edgeMenu = new QMenu();
4110 QMenu* faceMenu = new QMenu(); QMenu* volumeMenu = new QMenu();
4111 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
4112 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
4113 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10, -1, nodeMenu ),
4114 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10, -1, edgeMenu ),
4115 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10, -1, faceMenu ),
4116 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10, -1, volumeMenu ),
4117 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
4118 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
4119 //renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
4120 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
4121 basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
4123 //createMenu( SMESHOp::OpImportDAT, importId, -1 );
4124 createMenu( SMESHOp::OpImportUNV, importId, -1 );
4125 createMenu( SMESHOp::OpImportMED, importId, -1 );
4126 createMenu( SMESHOp::OpImportSTL, importId, -1 );
4128 createMenu( SMESHOp::OpImportCGNS, importId, -1 );
4130 createMenu( SMESHOp::OpImportSAUV, importId, -1 );
4131 createMenu( SMESHOp::OpImportGMF, importId, -1 );
4132 createMenu( SMESHOp::OpExportDAT, exportId, -1 );
4133 createMenu( SMESHOp::OpExportMED, exportId, -1 );
4134 createMenu( SMESHOp::OpExportUNV, exportId, -1 );
4135 createMenu( SMESHOp::OpExportSTL, exportId, -1 );
4137 createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
4139 createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
4140 createMenu( SMESHOp::OpExportGMF, exportId, -1 );
4141 createMenu( separator(), fileId, 10 );
4143 createMenu( SMESHOp::OpDelete, editId, -1 );
4145 createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
4147 createMenu( SMESHOp::OpCreateMesh, meshId, -1 ); // "Mesh" menu
4148 createMenu( SMESHOp::OpCreateSubMesh, meshId, -1 );
4149 createMenu( SMESHOp::OpEditMeshOrSubMesh, meshId, -1 );
4150 createMenu( SMESHOp::OpBuildCompoundMesh, meshId, -1 );
4151 createMenu( SMESHOp::OpCopyMesh, meshId, -1 );
4152 createMenu( separator(), meshId, -1 );
4153 createMenu( SMESHOp::OpCompute, meshId, -1 );
4154 createMenu( SMESHOp::OpPreCompute, meshId, -1 );
4155 createMenu( SMESHOp::OpEvaluate, meshId, -1 );
4156 createMenu( SMESHOp::OpMeshOrder, meshId, -1 );
4157 createMenu( separator(), meshId, -1 );
4158 createMenu( SMESHOp::OpCreateGroup, meshId, -1 );
4159 createMenu( SMESHOp::OpCreateGeometryGroup, meshId, -1 );
4160 createMenu( SMESHOp::OpConstructGroup, meshId, -1 );
4161 createMenu( SMESHOp::OpEditGroup, meshId, -1 );
4162 createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4163 createMenu( separator(), meshId, -1 );
4164 createMenu( SMESHOp::OpUnionGroups, meshId, -1 );
4165 createMenu( SMESHOp::OpIntersectGroups, meshId, -1 );
4166 createMenu( SMESHOp::OpCutGroups, meshId, -1 );
4167 createMenu( separator(), meshId, -1 );
4168 createMenu( SMESHOp::OpGroupUnderlyingElem, meshId, -1 );
4169 createMenu( SMESHOp::OpFaceGroupsByEdges, meshId, -1 );
4170 createMenu( separator(), meshId, -1 );
4171 createMenu( SMESHOp::OpMeshInformation, meshId, -1 );
4172 //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4173 //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4174 createMenu( SMESHOp::OpFindElementByPoint, meshId, -1 );
4175 createMenu( separator(), meshId, -1 );
4177 createMenu( SMESHOp::OpFreeNode, nodeId, -1 );
4178 createMenu( SMESHOp::OpEqualNode, nodeId, -1 );
4179 //createMenu( SMESHOp::OpNodeConnectivityNb, nodeId, -1 );
4180 createMenu( SMESHOp::OpFreeBorder, edgeId, -1 );
4181 createMenu( SMESHOp::OpLength, edgeId, -1 );
4182 createMenu( SMESHOp::OpConnection, edgeId, -1 );
4183 createMenu( SMESHOp::OpEqualEdge, edgeId, -1 );
4184 createMenu( SMESHOp::OpFreeEdge, faceId, -1 );
4185 createMenu( SMESHOp::OpFreeFace, faceId, -1 );
4186 createMenu( SMESHOp::OpBareBorderFace, faceId, -1 );
4187 createMenu( SMESHOp::OpOverConstrainedFace, faceId, -1 );
4188 createMenu( SMESHOp::OpLength2D, faceId, -1 );
4189 createMenu( SMESHOp::OpConnection2D, faceId, -1 );
4190 createMenu( SMESHOp::OpArea, faceId, -1 );
4191 createMenu( SMESHOp::OpTaper, faceId, -1 );
4192 createMenu( SMESHOp::OpAspectRatio, faceId, -1 );
4193 createMenu( SMESHOp::OpMinimumAngle, faceId, -1 );
4194 createMenu( SMESHOp::OpWarpingAngle, faceId, -1 );
4195 createMenu( SMESHOp::OpSkew, faceId, -1 );
4196 createMenu( SMESHOp::OpMaxElementLength2D, faceId, -1 );
4197 createMenu( SMESHOp::OpEqualFace, faceId, -1 );
4198 createMenu( SMESHOp::OpDeflection2D, faceId, -1 );
4199 createMenu( SMESHOp::OpAspectRatio3D, volumeId, -1 );
4200 createMenu( SMESHOp::OpVolume, volumeId, -1 );
4201 createMenu( SMESHOp::OpMaxElementLength3D, volumeId, -1 );
4202 createMenu( SMESHOp::OpBareBorderVolume, volumeId, -1 );
4203 createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4204 createMenu( SMESHOp::OpEqualVolume, volumeId, -1 );
4205 createMenu( separator(), ctrlId, -1 );
4206 createMenu( SMESHOp::OpReset, ctrlId, -1 );
4207 createMenu( separator(), ctrlId, -1 );
4208 createMenu( SMESHOp::OpOverallMeshQuality, ctrlId, -1 );
4210 createMenu( SMESHOp::OpNode, addId, -1 );
4211 createMenu( SMESHOp::OpElem0D, addId, -1 );
4212 createMenu( SMESHOp::OpElem0DOnElemNodes, addId, -1 );
4213 createMenu( SMESHOp::OpBall, addId, -1 );
4214 createMenu( SMESHOp::OpEdge, addId, -1 );
4215 createMenu( SMESHOp::OpTriangle, addId, -1 );
4216 createMenu( SMESHOp::OpQuadrangle, addId, -1 );
4217 createMenu( SMESHOp::OpPolygon, addId, -1 );
4218 createMenu( SMESHOp::OpTetrahedron, addId, -1 );
4219 createMenu( SMESHOp::OpHexahedron, addId, -1 );
4220 createMenu( SMESHOp::OpPentahedron, addId, -1 );
4221 createMenu( SMESHOp::OpPyramid, addId, -1 );
4222 createMenu( SMESHOp::OpHexagonalPrism, addId, -1 );
4223 createMenu( SMESHOp::OpPolyhedron, addId, -1 );
4224 createMenu( separator(), addId, -1 );
4225 createMenu( SMESHOp::OpQuadraticEdge, addId, -1 );
4226 createMenu( SMESHOp::OpQuadraticTriangle, addId, -1 );
4227 createMenu( SMESHOp::OpBiQuadraticTriangle , addId, -1 );
4228 createMenu( SMESHOp::OpQuadraticQuadrangle, addId, -1 );
4229 createMenu( SMESHOp::OpBiQuadraticQuadrangle, addId, -1 );
4230 createMenu( SMESHOp::OpQuadraticPolygon, addId, -1 );
4231 createMenu( SMESHOp::OpQuadraticTetrahedron, addId, -1 );
4232 createMenu( SMESHOp::OpQuadraticPyramid, addId, -1 );
4233 createMenu( SMESHOp::OpQuadraticPentahedron, addId, -1 );
4234 createMenu( SMESHOp::OpBiQuadraticPentahedron, addId, -1 );
4235 createMenu( SMESHOp::OpQuadraticHexahedron, addId, -1 );
4236 createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4238 createMenu( SMESHOp::OpRemoveNodes, removeId, -1 );
4239 createMenu( SMESHOp::OpRemoveElements, removeId, -1 );
4240 createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4241 createMenu( separator(), removeId, -1 );
4242 createMenu( SMESHOp::OpDeleteGroup, removeId, -1 );
4243 createMenu( separator(), removeId, -1 );
4244 createMenu( SMESHOp::OpClearMesh, removeId, -1 );
4246 //createMenu( SMESHOp::OpRenumberingNodes, renumId, -1 );
4247 //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4249 createMenu( SMESHOp::OpMergeNodes, transfId, -1 );
4250 createMenu( SMESHOp::OpMergeElements, transfId, -1 );
4251 createMenu( SMESHOp::OpTranslation, transfId, -1 );
4252 createMenu( SMESHOp::OpRotation, transfId, -1 );
4253 createMenu( SMESHOp::OpSymmetry, transfId, -1 );
4254 createMenu( SMESHOp::OpScale, transfId, -1 );
4255 createMenu( SMESHOp::OpOffset, transfId, -1 );
4256 createMenu( SMESHOp::OpSewing, transfId, -1 );
4257 createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4259 createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4260 createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4261 createMenu( SMESHOp::OpExtrusion, modifyId, -1 );
4262 createMenu( SMESHOp::OpExtrusionAlongAPath, modifyId, -1 );
4263 createMenu( SMESHOp::OpRevolution, modifyId, -1 );
4264 createMenu( SMESHOp::OpOrientation, modifyId, -1 );
4265 createMenu( SMESHOp::OpReorientFaces, modifyId, -1 );
4266 createMenu( SMESHOp::OpMoveNode, modifyId, -1 );
4267 createMenu( SMESHOp::OpDiagonalInversion, modifyId, -1 );
4268 createMenu( SMESHOp::OpUnionOfTwoTriangle, modifyId, -1 );
4269 createMenu( SMESHOp::OpUnionOfTriangles, modifyId, -1 );
4270 createMenu( SMESHOp::OpCuttingOfQuadrangles, modifyId, -1 );
4271 createMenu( SMESHOp::OpSplitVolumes, modifyId, -1 );
4272 createMenu( SMESHOp::OpSplitBiQuadratic, modifyId, -1 );
4273 createMenu( SMESHOp::OpSmoothing, modifyId, -1 );
4274 createMenu( SMESHOp::OpPatternMapping, modifyId, -1 );
4276 createMenu( SMESHOp::OpMinimumDistance, measureId, -1 );
4277 createMenu( SMESHOp::OpBoundingBox, measureId, -1 );
4278 createMenu( SMESHOp::OpAngle, measureId, -1 );
4279 createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4280 createMenu( SMESHOp::OpPropertiesArea, basicPropId, -1 );
4281 createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4282 createMenu( SMESHOp::OpUpdate, viewId, -1 );
4284 connect( nodeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4285 connect( edgeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4286 connect( faceMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4287 connect( volumeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4289 // ----- create toolbars --------------
4290 int meshTb = createTool( tr( "TB_MESH" ), QString( "SMESHMeshToolbar" ) ),
4291 info = createTool( tr( "TB_INFO" ), QString( "SMESHInformationToolbar" ) ),
4292 groupTb = createTool( tr( "TB_GROUP" ), QString( "SMESHGroupToolbar" ) ),
4293 ctrl0dTb = createTool( tr( "TB_CTRL0D" ), QString( "SMESHNodeControlsToolbar" ) ),
4294 ctrl1dTb = createTool( tr( "TB_CTRL1D" ), QString( "SMESHEdgeControlsToolbar" ) ),
4295 ctrl2dTb = createTool( tr( "TB_CTRL2D" ), QString( "SMESHFaceControlsToolbar" ) ),
4296 ctrl3dTb = createTool( tr( "TB_CTRL3D" ), QString( "SMESHVolumeControlsToolbar" ) ),
4297 addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ),
4298 addNonElemTb = createTool( tr( "TB_ADDNON" ), QString( "SMESHAddElementToolbar" ) ),
4299 remTb = createTool( tr( "TB_REM" ), QString( "SMESHRemoveToolbar" ) ),
4300 //renumbTb = createTool( tr( "TB_RENUMBER" ), QString( "SMESHRenumberingToolbar" ) ),
4301 transformTb = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ),
4302 modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ),
4303 measuremTb = createTool( tr( "TB_MEASUREM" ), QString( "SMESHMeasurementsToolbar" ) ),
4304 dispModeTb = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4306 createTool( SMESHOp::OpCreateMesh, meshTb );
4307 createTool( SMESHOp::OpCreateSubMesh, meshTb );
4308 createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4309 createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4310 createTool( SMESHOp::OpCopyMesh, meshTb );
4311 createTool( separator(), meshTb );
4312 createTool( SMESHOp::OpCompute, meshTb );
4313 createTool( SMESHOp::OpPreCompute, meshTb );
4314 createTool( SMESHOp::OpEvaluate, meshTb );
4315 createTool( SMESHOp::OpMeshOrder, meshTb );
4317 createTool( SMESHOp::OpCreateGroup, groupTb );
4318 createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4319 createTool( SMESHOp::OpConstructGroup, groupTb );
4320 createTool( SMESHOp::OpEditGroup, groupTb );
4322 createTool( SMESHOp::OpMeshInformation, info );
4323 //createTool( SMESHOp::OpStdInfo, meshTb );
4324 //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4325 createTool( SMESHOp::OpFindElementByPoint, info );
4327 createTool( SMESHOp::OpFreeNode, ctrl0dTb );
4328 createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4329 //createTool( SMESHOp::OpNodeConnectivityNb, ctrl0dTb );
4331 createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4332 createTool( SMESHOp::OpLength, ctrl1dTb );
4333 createTool( SMESHOp::OpConnection, ctrl1dTb );
4334 createTool( SMESHOp::OpEqualEdge, ctrl1dTb );
4336 createTool( SMESHOp::OpFreeEdge, ctrl2dTb );
4337 createTool( SMESHOp::OpFreeFace, ctrl2dTb );
4338 createTool( SMESHOp::OpBareBorderFace, ctrl2dTb );
4339 createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4340 createTool( SMESHOp::OpLength2D, ctrl2dTb );
4341 createTool( SMESHOp::OpConnection2D, ctrl2dTb );
4342 createTool( SMESHOp::OpArea, ctrl2dTb );
4343 createTool( SMESHOp::OpTaper, ctrl2dTb );
4344 createTool( SMESHOp::OpAspectRatio, ctrl2dTb );
4345 createTool( SMESHOp::OpMinimumAngle, ctrl2dTb );
4346 createTool( SMESHOp::OpWarpingAngle, ctrl2dTb );
4347 createTool( SMESHOp::OpSkew, ctrl2dTb );
4348 createTool( SMESHOp::OpMaxElementLength2D, ctrl2dTb );
4349 createTool( SMESHOp::OpEqualFace, ctrl2dTb );
4350 createTool( SMESHOp::OpDeflection2D, ctrl2dTb );
4352 createTool( SMESHOp::OpAspectRatio3D, ctrl3dTb );
4353 createTool( SMESHOp::OpVolume, ctrl3dTb );
4354 createTool( SMESHOp::OpMaxElementLength3D, ctrl3dTb );
4355 createTool( SMESHOp::OpBareBorderVolume, ctrl3dTb );
4356 createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
4357 createTool( SMESHOp::OpEqualVolume, ctrl3dTb );
4359 createTool( SMESHOp::OpNode, addElemTb );
4360 createTool( SMESHOp::OpElem0D, addElemTb );
4361 createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4362 createTool( SMESHOp::OpBall, addElemTb );
4363 createTool( SMESHOp::OpEdge, addElemTb );
4364 createTool( SMESHOp::OpTriangle, addElemTb );
4365 createTool( SMESHOp::OpQuadrangle, addElemTb );
4366 createTool( SMESHOp::OpPolygon, addElemTb );
4367 createTool( SMESHOp::OpTetrahedron, addElemTb );
4368 createTool( SMESHOp::OpHexahedron, addElemTb );
4369 createTool( SMESHOp::OpPentahedron, addElemTb );
4370 createTool( SMESHOp::OpPyramid, addElemTb );
4371 createTool( SMESHOp::OpHexagonalPrism, addElemTb );
4372 createTool( SMESHOp::OpPolyhedron, addElemTb );
4374 createTool( SMESHOp::OpQuadraticEdge, addNonElemTb );
4375 createTool( SMESHOp::OpQuadraticTriangle, addNonElemTb );
4376 createTool( SMESHOp::OpBiQuadraticTriangle, addNonElemTb );
4377 createTool( SMESHOp::OpQuadraticQuadrangle, addNonElemTb );
4378 createTool( SMESHOp::OpBiQuadraticQuadrangle, addNonElemTb );
4379 createTool( SMESHOp::OpQuadraticPolygon, addNonElemTb );
4380 createTool( SMESHOp::OpQuadraticTetrahedron, addNonElemTb );
4381 createTool( SMESHOp::OpQuadraticPyramid, addNonElemTb );
4382 createTool( SMESHOp::OpQuadraticPentahedron, addNonElemTb );
4383 createTool( SMESHOp::OpBiQuadraticPentahedron, addNonElemTb );
4384 createTool( SMESHOp::OpQuadraticHexahedron, addNonElemTb );
4385 createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4387 createTool( SMESHOp::OpRemoveNodes, remTb );
4388 createTool( SMESHOp::OpRemoveElements, remTb );
4389 createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4390 createTool( SMESHOp::OpClearMesh, remTb );
4392 //createTool( SMESHOp::OpRenumberingNodes, renumbTb );
4393 //createTool( SMESHOp::OpRenumberingElements, renumbTb );
4395 createTool( SMESHOp::OpMergeNodes, transformTb );
4396 createTool( SMESHOp::OpMergeElements, transformTb );
4397 createTool( SMESHOp::OpTranslation, transformTb );
4398 createTool( SMESHOp::OpRotation, transformTb );
4399 createTool( SMESHOp::OpSymmetry, transformTb );
4400 createTool( SMESHOp::OpScale, transformTb );
4401 createTool( SMESHOp::OpOffset, transformTb );
4402 createTool( SMESHOp::OpSewing, transformTb );
4403 createTool( SMESHOp::OpDuplicateNodes, transformTb );
4405 createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4406 createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4407 createTool( SMESHOp::OpExtrusion, modifyTb );
4408 createTool( SMESHOp::OpExtrusionAlongAPath, modifyTb );
4409 createTool( SMESHOp::OpRevolution, modifyTb );
4410 createTool( SMESHOp::OpOrientation, modifyTb );
4411 createTool( SMESHOp::OpReorientFaces, modifyTb );
4412 createTool( SMESHOp::OpMoveNode, modifyTb );
4413 createTool( SMESHOp::OpDiagonalInversion, modifyTb );
4414 createTool( SMESHOp::OpUnionOfTwoTriangle, modifyTb );
4415 createTool( SMESHOp::OpUnionOfTriangles, modifyTb );
4416 createTool( SMESHOp::OpCuttingOfQuadrangles, modifyTb );
4417 createTool( SMESHOp::OpSplitVolumes, modifyTb );
4418 createTool( SMESHOp::OpSplitBiQuadratic, modifyTb );
4419 createTool( SMESHOp::OpSmoothing, modifyTb );
4420 createTool( SMESHOp::OpPatternMapping, modifyTb );
4422 createTool( SMESHOp::OpMinimumDistance, measuremTb );
4424 createTool( SMESHOp::OpUpdate, dispModeTb );
4426 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4427 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4431 OB = "'ObjectBrowser'",
4432 View = "'" + SVTK_Viewer::Type() + "'",
4434 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4435 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4436 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4437 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4438 smesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::COMPONENT ) ),
4439 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4440 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4441 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4442 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4443 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4444 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4445 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4447 mesh_part = mesh + " " + subMesh + " " + group,
4448 mesh_group = mesh + " " + group,
4449 mesh_submesh = mesh + " " + subMesh,
4450 hyp_alg = hypo + " " + algo;
4452 // popup for object browser
4454 isInvisible("not( isVisible )"),
4455 isEmpty("numberOfNodes = 0"),
4456 isNotEmpty("numberOfNodes <> 0"),
4458 // has nodes, edges, etc in VISIBLE! actor
4459 hasNodes("(numberOfNodes > 0 ) && hasActor"),
4460 hasElems("(count( elemTypes ) > 0)"),
4461 hasDifferentElems("(count( elemTypes ) > 1)"),
4462 hasDifferentObjElems("(count( objElemTypes ) > 1)"),
4463 hasBalls("({'BallElem'} in elemTypes)"),
4464 hasElems0d("({'Elem0d'} in elemTypes)"),
4465 hasEdges("({'Edge'} in elemTypes)"),
4466 hasFaces("({'Face'} in elemTypes)"),
4467 hasVolumes("({'Volume'} in elemTypes)"),
4468 hasFacesOrVolumes("(({'Face'} in elemTypes) || ({'Volume'} in elemTypes)) ");
4470 createPopupItem( SMESHOp::OpFileInformation, OB, mesh, "&& selcount=1 && isImported" );
4471 createPopupItem( SMESHOp::OpCreateSubMesh, OB, mesh, "&& hasGeomReference");
4472 createPopupItem( SMESHOp::OpEditMesh, OB, mesh, "&& selcount=1" );
4473 createPopupItem( SMESHOp::OpEditSubMesh, OB, subMesh, "&& selcount=1 && hasGeomReference" );
4474 createPopupItem( SMESHOp::OpEditGroup, OB, group );
4475 createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4477 popupMgr()->insert( separator(), -1, 0 );
4478 createPopupItem( SMESHOp::OpCompute, OB, mesh, "&& selcount=1 && isComputable" );
4479 createPopupItem( SMESHOp::OpComputeSubMesh, OB, subMesh, "&& selcount=1 && isComputable" );
4480 createPopupItem( SMESHOp::OpPreCompute, OB, mesh, "&& selcount=1 && isPreComputable" );
4481 createPopupItem( SMESHOp::OpEvaluate, OB, mesh, "&& selcount=1 && isComputable" );
4482 createPopupItem( SMESHOp::OpMeshOrder, OB, mesh, "&& selcount=1 && isComputable && hasGeomReference" );
4483 createPopupItem( SMESHOp::OpUpdate, OB, mesh_part );
4484 createPopupItem( SMESHOp::OpMeshInformation, OB, mesh_part );
4485 createPopupItem( SMESHOp::OpFindElementByPoint,OB, mesh_group, "&& selcount=1" );
4486 createPopupItem( SMESHOp::OpOverallMeshQuality,OB, mesh_part );
4487 popupMgr()->insert( separator(), -1, 0 );
4488 createPopupItem( SMESHOp::OpCreateGroup, OB, mesh, "&& selcount=1" );
4489 createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh, "&& selcount=1 && hasGeomReference" );
4490 createPopupItem( SMESHOp::OpConstructGroup, OB, subMesh );
4491 popupMgr()->insert( separator(), -1, 0 );
4492 createPopupItem( SMESHOp::OpEditHypothesis, OB, hypo, "&& isEditableHyp");
4493 createPopupItem( SMESHOp::OpUnassign, OB, hyp_alg );
4494 popupMgr()->insert( separator(), -1, 0 );
4495 createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh_submesh );
4496 createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh_group, "&& selcount=1 && dim>=2");
4497 popupMgr()->insert( separator(), -1, 0 );
4498 createPopupItem( SMESHOp::OpClearMesh, OB, mesh );
4499 //popupMgr()->insert( separator(), -1, 0 );
4501 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4502 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4503 QString only_one_2D = only_one_non_empty + " && dim>1";
4505 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4506 createPopupItem( SMESHOp::OpPopupExportMED, OB, mesh_group, multiple_non_empty, anId );
4507 createPopupItem( SMESHOp::OpPopupExportUNV, OB, mesh_group, only_one_non_empty, anId );
4508 createPopupItem( SMESHOp::OpPopupExportSTL, OB, mesh_group, only_one_2D, anId );
4510 createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4512 createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, only_one_non_empty, anId );
4513 createPopupItem( SMESHOp::OpPopupExportGMF, OB, mesh_group, only_one_non_empty, anId );
4514 createPopupItem( SMESHOp::OpPopupExportDAT, OB, mesh_group, only_one_non_empty, anId );
4515 createPopupItem( SMESHOp::OpDelete, OB, mesh_part + " " + hyp_alg );
4516 createPopupItem( SMESHOp::OpDeleteGroup, OB, group );
4518 anId = popupMgr()->insert( tr( "MEN_IMPORT" ), -1, -1 ); // IMPORT submenu
4519 createPopupItem( SMESHOp::OpPopupImportMED, OB, smesh, "", anId );
4520 createPopupItem( SMESHOp::OpPopupImportUNV, OB, smesh, "", anId );
4521 createPopupItem( SMESHOp::OpPopupImportSTL, OB, smesh, "", anId );
4523 createPopupItem( SMESHOp::OpPopupImportCGNS, OB, smesh, "", anId );
4525 createPopupItem( SMESHOp::OpPopupImportSAUV, OB, smesh, "", anId );
4526 createPopupItem( SMESHOp::OpPopupImportGMF, OB, smesh, "", anId );
4527 createPopupItem( SMESHOp::OpPopupImportDAT, OB, smesh, "", anId );
4528 popupMgr()->insert( separator(), -1, 0 );
4531 createPopupItem( SMESHOp::OpEditGroup, View, group );
4532 createPopupItem( SMESHOp::OpAddElemGroupPopup, View, elems, "&& guiState = 800" );
4533 createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems, "&& guiState = 800" );
4535 popupMgr()->insert( separator(), -1, 0 );
4536 createPopupItem( SMESHOp::OpUpdate, View, mesh_part );
4537 createPopupItem( SMESHOp::OpMeshInformation, View, mesh_part );
4538 createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4539 createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh );
4540 popupMgr()->insert( separator(), -1, 0 );
4542 createPopupItem( SMESHOp::OpAutoColor, OB + " " + View, mesh, "&& (not isAutoColor)" );
4543 createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4544 popupMgr()->insert( separator(), -1, 0 );
4546 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4547 QString aType = QString( "%1type in {%2}" ).arg( lc );
4548 aType = aType.arg( mesh_part );
4549 QString aMeshInVTK = aClient + "&&" + aType;
4551 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4552 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4553 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4555 //-------------------------------------------------
4557 //-------------------------------------------------
4558 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4560 popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4561 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4562 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4564 popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4565 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4566 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4568 popupMgr()->insert( separator(), -1, -1 );
4570 //-------------------------------------------------
4572 //-------------------------------------------------
4573 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4575 popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4576 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4577 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4579 popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4580 popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4581 popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4583 popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4584 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4585 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4587 popupMgr()->insert( separator(), anId, -1 );
4589 popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4590 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4591 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4593 //-------------------------------------------------
4595 //-------------------------------------------------
4596 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4598 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4600 popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4601 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4602 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4604 popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4605 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4606 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4608 popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4609 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4610 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4612 popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4613 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4614 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4616 popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4617 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4618 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4620 popupMgr()->insert( separator(), anId, -1 );
4622 popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4623 popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&& $type in {" + mesh + "} &&" + hasDifferentObjElems, QtxPopupMgr::VisibleRule );
4625 popupMgr()->insert( separator(), anId, -1 );
4627 popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4628 popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4631 //-------------------------------------------------
4632 // Representation of the 2D Quadratic elements
4633 //-------------------------------------------------
4634 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4635 popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4636 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "&& isVisible && isQuadratic",QtxPopupMgr::VisibleRule );
4637 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4639 popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4640 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "&& isVisible && isQuadratic", QtxPopupMgr::VisibleRule );
4641 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4643 //-------------------------------------------------
4644 // Orientation of faces
4645 //-------------------------------------------------
4646 popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4647 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4648 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4650 //-------------------------------------------------
4652 //-------------------------------------------------
4653 popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4654 popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4656 //-------------------------------------------------
4658 //-------------------------------------------------
4659 popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4660 popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4662 //-------------------------------------------------
4664 //-------------------------------------------------
4666 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4667 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4668 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4669 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4671 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4673 popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4674 popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4676 popupMgr()->insert( separator(), anId, -1 );
4678 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4680 popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4681 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4682 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4684 popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4685 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4686 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4688 // popupMgr()->insert( action( SMESHOp::OpNodeConnectivityNb ), aSubId, -1 );
4689 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4690 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), "controlMode = 'eNodeConnectivityNb'", QtxPopupMgr::ToggleRule );
4692 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4694 popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4695 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVTK + "&&" + hasEdges + "&&" + hasFacesOrVolumes, QtxPopupMgr::VisibleRule );
4696 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4698 popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4699 popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4700 popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4702 popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4703 popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4704 popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4705 popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4706 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4707 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4709 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4711 popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4712 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4713 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4715 popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4716 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4717 QtxPopupMgr::VisibleRule );
4718 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4720 popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4721 popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4722 popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4724 popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4725 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4726 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4728 popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
4729 popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4730 popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4732 popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
4733 popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4734 popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4736 popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
4737 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4738 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4740 popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
4741 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4742 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4744 popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
4745 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4746 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4748 popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
4749 popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4750 popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4752 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
4753 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4754 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4756 popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
4757 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4758 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4760 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
4761 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4762 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4764 popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
4765 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4766 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4768 popupMgr()->insert ( action( SMESHOp::OpDeflection2D ), aSubId, -1 );
4769 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), aMeshInVtkHasFaces + " && hasGeomReference", QtxPopupMgr::VisibleRule );
4770 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), "controlMode = 'eDeflection2D'", QtxPopupMgr::ToggleRule );
4772 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4774 popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D ), aSubId, -1 );
4775 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4776 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4778 popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
4779 popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4780 popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4782 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
4783 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4784 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4786 popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
4787 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4788 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4790 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
4791 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4792 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4794 popupMgr()->insert ( action( SMESHOp::OpEqualVolume ), aSubId, -1 );
4795 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4796 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4798 popupMgr()->insert( separator(), anId, -1 );
4800 popupMgr()->insert( action( SMESHOp::OpShowScalarBar ), anId, -1 );
4801 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4802 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone' && isScalarBarVisible", QtxPopupMgr::ToggleRule );
4803 popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
4804 popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4806 popupMgr()->insert( separator(), anId, -1 );
4808 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4810 popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
4811 popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4813 popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
4814 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4815 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isScalarBarVisible && isDistributionVisible", QtxPopupMgr::ToggleRule);
4817 #ifndef DISABLE_PLOT2DVIEWER
4818 popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
4819 popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4822 //-------------------------------------------------
4824 //-------------------------------------------------
4825 popupMgr()->insert( separator(), -1, -1 );
4826 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4827 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4828 popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
4829 popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4831 popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
4832 popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4834 popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
4835 popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4837 popupMgr()->insert( separator(), -1, -1 );
4839 //-------------------------------------------------
4841 //-------------------------------------------------
4842 popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
4843 popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4845 popupMgr()->insert( separator(), -1, -1 );
4847 popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
4848 popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
4849 popupMgr()->insert( separator(), -1, -1 );
4851 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4852 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4854 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4855 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4858 //================================================================================
4860 * \brief Return true if SMESH or GEOM objects are selected.
4861 * Is called form LightApp_Module::activateModule() which clear selection if
4862 * not isSelectionCompatible()
4864 //================================================================================
4866 bool SMESHGUI::isSelectionCompatible()
4868 bool isCompatible = true;
4869 SALOME_ListIO selected;
4870 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4871 Sel->selectedObjects( selected );
4873 SALOME_ListIteratorOfListIO It( selected );
4874 for ( ; isCompatible && It.More(); It.Next())
4876 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4877 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4879 return isCompatible;
4883 bool SMESHGUI::reusableOperation( const int id )
4885 // compute, evaluate and precompute are not reusable operations
4886 return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate ) ? false : SalomeApp_Module::reusableOperation( id );
4889 bool SMESHGUI::activateModule( SUIT_Study* study )
4891 bool res = SalomeApp_Module::activateModule( study );
4893 setMenuShown( true );
4894 setToolShown( true );
4896 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4897 PyGILState_STATE gstate = PyGILState_Ensure();
4898 PyObject* pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4899 if ( !pluginsmanager ) {
4903 PyObject* result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toUtf8().data(),tr("SMESH_PLUGINS_OTHER").toUtf8().data());
4908 PyGILState_Release(gstate);
4909 // end of SMESH plugins loading
4911 // Reset actions accelerator keys
4912 action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
4914 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4915 GetSMESHGen()->UpdateStudy();
4917 // get all view currently opened in the study and connect their signals to
4918 // the corresponding slots of the class.
4919 SUIT_Desktop* aDesk = study->application()->desktop();
4921 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4922 SUIT_ViewWindow* wnd;
4923 foreach ( wnd, wndList )
4927 Py_XDECREF(pluginsmanager);
4931 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4933 setMenuShown( false );
4934 setToolShown( false );
4936 EmitSignalCloseAllDialogs();
4938 // Unset actions accelerator keys
4939 action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
4941 return SalomeApp_Module::deactivateModule( study );
4944 void SMESHGUI::studyClosed( SUIT_Study* s )
4948 SMESH::RemoveVisuData();
4949 SalomeApp_Module::studyClosed( s );
4952 void SMESHGUI::OnGUIEvent()
4954 const QObject* obj = sender();
4955 if ( !obj || !obj->inherits( "QAction" ) )
4957 int id = actionId((QAction*)obj);
4962 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4964 if ( CORBA::is_nil( myComponentSMESH ) )
4966 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4967 return aGUI.myComponentSMESH;
4969 return myComponentSMESH;
4972 QString SMESHGUI::engineIOR() const
4974 CORBA::ORB_var anORB = getApp()->orb();
4975 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4976 return QString( anIOR.in() );
4979 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4981 SalomeApp_Module::contextMenuPopup( client, menu, title );
4983 selectionMgr()->selectedObjects( lst );
4984 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4985 Handle(SALOME_InteractiveObject) io = lst.First();
4986 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4987 _PTR(Study) study = appStudy->studyDS();
4988 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4990 QString aName = QString( SMESH::fromUtf8(obj->GetName()) );
4991 while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4992 aName.remove( (aName.length() - 1), 1 );
4998 LightApp_Selection* SMESHGUI::createSelection() const
5000 return new SMESHGUI_Selection();
5003 void SMESHGUI::windows( QMap<int, int>& aMap ) const
5005 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
5006 aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
5007 #ifndef DISABLE_PYCONSOLE
5008 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
5012 void SMESHGUI::viewManagers( QStringList& list ) const
5014 list.append( SVTK_Viewer::Type() );
5017 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
5019 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
5020 SMESH::UpdateSelectionProp( this );
5022 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
5023 for(int i = 0; i < aViews.count() ; i++){
5024 SUIT_ViewWindow *sf = aViews[i];
5027 EmitSignalActivatedViewManager();
5031 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
5033 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
5034 myClippingPlaneInfoMap.erase( theViewManager );
5037 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
5039 theActor->AddObserver( SMESH::DeleteActorEvent,
5040 myEventCallbackCommand.GetPointer(),
5044 void SMESHGUI::ProcessEvents( vtkObject* theObject,
5045 unsigned long theEvent,
5046 void* theClientData,
5049 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
5050 if( theObject && (int) theEvent == SMESH::DeleteActorEvent ) {
5051 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
5052 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
5053 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
5054 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
5055 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
5056 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
5057 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
5058 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
5059 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
5060 SMESH::TActorList::iterator anIter3 = anActorList.begin();
5061 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
5062 if( anActor == *anIter3 ) {
5063 anActorList.erase( anIter3 );
5074 void SMESHGUI::createPreferences()
5076 // General tab ------------------------------------------------------------------------
5077 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
5079 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
5080 setPreferenceProperty( autoUpdate, "columns", 2 );
5081 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
5082 setPreferenceProperty( lim, "min", 0 );
5083 setPreferenceProperty( lim, "max", 100000000 );
5084 setPreferenceProperty( lim, "step", 1000 );
5085 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5086 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
5088 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
5089 setPreferenceProperty( dispgroup, "columns", 2 );
5091 addPreference( tr( "PREF_FITALL_ON_DISPLAYONLY" ), dispgroup, LightApp_Preferences::Bool, "SMESH", "fitall_on_displayonly" );
5093 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
5095 modes.append( tr("MEN_WIRE") );
5096 modes.append( tr("MEN_SHADE") );
5097 modes.append( tr("MEN_NODES") );
5098 modes.append( tr("MEN_SHRINK") );
5099 QList<QVariant> indices;
5100 indices.append( 0 );
5101 indices.append( 1 );
5102 indices.append( 2 );
5103 indices.append( 3 );
5104 setPreferenceProperty( dispmode, "strings", modes );
5105 setPreferenceProperty( dispmode, "indexes", indices );
5107 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
5108 setPreferenceProperty( arcgroup, "columns", 2 );
5109 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
5110 QStringList quadraticModes;
5111 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
5112 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
5114 indices.append( 0 );
5115 indices.append( 1 );
5116 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
5117 setPreferenceProperty( quadraticmode, "indexes", indices );
5119 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
5120 "SMESH", "max_angle" );
5121 setPreferenceProperty( maxAngle, "min", 1 );
5122 setPreferenceProperty( maxAngle, "max", 90 );
5124 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
5125 setPreferenceProperty( qaGroup, "columns", 2 );
5126 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
5127 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
5128 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
5129 setPreferenceProperty( prec, "min", 0 );
5130 setPreferenceProperty( prec, "max", 100 );
5131 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
5132 setPreferenceProperty( doubleNodesTol, "precision", 10 );
5133 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
5134 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
5135 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
5138 int cinc = addPreference(tr("PREF_CONTROLS_INCREMENT"), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_increment");
5139 setPreferenceProperty( cinc, "min", 0 );
5140 setPreferenceProperty( cinc, "max", 5 );
5143 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
5144 setPreferenceProperty( exportgroup, "columns", 2 );
5145 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
5146 addPreference( tr( "PREF_SHOW_WARN" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "show_warning" );
5147 int zTol = addPreference( tr( "PREF_ZTOLERANCE" ), exportgroup, LightApp_Preferences::DblSpin, "SMESH", "med_ztolerance" );
5148 setPreferenceProperty( zTol, "precision", 10 );
5149 setPreferenceProperty( zTol, "min", 0.0000000001 );
5150 setPreferenceProperty( zTol, "max", 1000000.0 );
5151 setPreferenceProperty( zTol, "step", 1. );
5152 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
5154 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
5155 setPreferenceProperty( computeGroup, "columns", 2 );
5156 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
5158 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5159 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5160 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5162 indices.append( 0 );
5163 indices.append( 1 );
5164 indices.append( 2 );
5165 setPreferenceProperty( notifyMode, "strings", modes );
5166 setPreferenceProperty( notifyMode, "indexes", indices );
5168 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5169 setPreferenceProperty( infoGroup, "columns", 2 );
5170 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5172 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5173 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5175 indices.append( 0 );
5176 indices.append( 1 );
5177 setPreferenceProperty( elemInfo, "strings", modes );
5178 setPreferenceProperty( elemInfo, "indexes", indices );
5179 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5180 setPreferenceProperty( nodesLim, "min", 0 );
5181 setPreferenceProperty( nodesLim, "max", 10000000 );
5182 setPreferenceProperty( nodesLim, "step", 10000 );
5183 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5184 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5185 setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5186 setPreferenceProperty( ctrlLim, "min", 0 );
5187 setPreferenceProperty( ctrlLim, "max", 10000000 );
5188 setPreferenceProperty( ctrlLim, "step", 1000 );
5189 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5190 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5191 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5192 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5193 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5195 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5196 setPreferenceProperty( segGroup, "columns", 2 );
5197 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5198 "SMESH", "segmentation" );
5199 setPreferenceProperty( segLen, "min", 1 );
5200 setPreferenceProperty( segLen, "max", 10000000 );
5201 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5202 "SMESH", "nb_segments_per_edge" );
5203 setPreferenceProperty( nbSeg, "min", 1 );
5204 setPreferenceProperty( nbSeg, "max", 10000000 );
5206 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5207 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5208 "SMESH", "forget_mesh_on_hyp_modif" );
5211 // Quantities with individual precision settings
5212 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5213 setPreferenceProperty( precGroup, "columns", 2 );
5215 const int nbQuantities = 6;
5216 int precs[nbQuantities], ii = 0;
5217 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5218 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5219 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5220 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5221 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5222 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5223 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5224 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5225 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5226 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5227 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5228 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5230 // Set property for precision value for spinboxes
5231 for ( ii = 0; ii < nbQuantities; ii++ ){
5232 setPreferenceProperty( precs[ii], "min", -14 );
5233 setPreferenceProperty( precs[ii], "max", 14 );
5234 setPreferenceProperty( precs[ii], "precision", 2 );
5237 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5238 setPreferenceProperty( previewGroup, "columns", 2 );
5239 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5240 setPreferenceProperty( chunkSize, "min", 1 );
5241 setPreferenceProperty( chunkSize, "max", 1000 );
5242 setPreferenceProperty( chunkSize, "step", 50 );
5244 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5245 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5247 // Mesh tab ------------------------------------------------------------------------
5248 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5249 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5250 setPreferenceProperty( nodeGroup, "columns", 3 );
5252 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5254 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5256 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5257 QList<QVariant> aMarkerTypeIndicesList;
5258 QList<QVariant> aMarkerTypeIconsList;
5259 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5260 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5261 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5262 aMarkerTypeIndicesList << i;
5263 aMarkerTypeIconsList << pixmap;
5265 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5266 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
5268 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5270 QList<QVariant> aMarkerScaleIndicesList;
5271 QStringList aMarkerScaleValuesList;
5272 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5273 aMarkerScaleIndicesList << i;
5274 //aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5275 aMarkerScaleValuesList << QString::number( i );
5277 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5278 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5280 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5281 //setPreferenceProperty( elemGroup, "columns", 2 );
5283 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5284 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5285 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5286 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5287 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5288 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5289 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5290 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5291 addPreference( tr( "PREF_PREVIEW_COLOR" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5294 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5295 setPreferenceProperty( grpGroup, "columns", 2 );
5297 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5298 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5300 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5301 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5302 /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5303 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5304 double ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5305 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5306 double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5307 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5308 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
5309 LightApp_Preferences::IntSpin, "SMESH", "element_width");
5310 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5311 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5312 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5313 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5315 setPreferenceProperty( size0d, "min", 1 );
5316 setPreferenceProperty( size0d, "max", 10 );
5318 // setPreferenceProperty( ballSize, "min", 1 );
5319 // setPreferenceProperty( ballSize, "max", 10 );
5321 setPreferenceProperty( ballDiameter, "min", 1e-7 );
5322 setPreferenceProperty( ballDiameter, "max", 1e9 );
5323 setPreferenceProperty( ballDiameter, "step", 0.1 );
5325 setPreferenceProperty( ballScale, "min", 1e-2 );
5326 setPreferenceProperty( ballScale, "max", 1e7 );
5327 setPreferenceProperty( ballScale, "step", 0.5 );
5329 setPreferenceProperty( elemW, "min", 1 );
5330 setPreferenceProperty( elemW, "max", 5 );
5332 setPreferenceProperty( outW, "min", 1 );
5333 setPreferenceProperty( outW, "max", 5 );
5335 setPreferenceProperty( shrink, "min", 0 );
5336 setPreferenceProperty( shrink, "max", 100 );
5338 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5339 setPreferenceProperty( numGroup, "columns", 2 );
5341 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5342 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5344 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5345 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5347 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5348 setPreferenceProperty( orientGroup, "columns", 1 );
5350 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5351 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5353 setPreferenceProperty( orientScale, "min", 0.05 );
5354 setPreferenceProperty( orientScale, "max", 0.5 );
5355 setPreferenceProperty( orientScale, "step", 0.05 );
5357 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5359 // Selection tab ------------------------------------------------------------------------
5360 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5362 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5363 setPreferenceProperty( selGroup, "columns", 2 );
5365 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5366 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5368 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5369 setPreferenceProperty( preGroup, "columns", 2 );
5371 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5373 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5374 setPreferenceProperty( precSelGroup, "columns", 2 );
5376 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5377 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5378 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5380 int sinc = addPreference(tr("PREF_SELECTION_INCREMENT"), selTab, LightApp_Preferences::IntSpin, "SMESH", "selection_increment");
5381 setPreferenceProperty( sinc, "min", 0 );
5382 setPreferenceProperty( sinc, "max", 5 );
5384 // Scalar Bar tab ------------------------------------------------------------------------
5385 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5386 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5387 setPreferenceProperty( fontGr, "columns", 2 );
5389 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5390 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5392 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5393 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5395 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5396 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5398 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5399 setPreferenceProperty( numcol, "min", 2 );
5400 setPreferenceProperty( numcol, "max", 256 );
5402 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5403 setPreferenceProperty( numlab, "min", 2 );
5404 setPreferenceProperty( numlab, "max", 65 );
5406 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5407 setPreferenceProperty( orientGr, "columns", 2 );
5408 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5409 QStringList orients;
5410 orients.append( tr( "SMESH_VERTICAL" ) );
5411 orients.append( tr( "SMESH_HORIZONTAL" ) );
5412 indices.clear(); indices.append( 0 ); indices.append( 1 );
5413 setPreferenceProperty( orient, "strings", orients );
5414 setPreferenceProperty( orient, "indexes", indices );
5416 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5417 setPreferenceProperty( posVSizeGr, "columns", 2 );
5418 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5419 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5420 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5421 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5422 setPreferenceProperty( xv, "step", 0.1 );
5423 setPreferenceProperty( xv, "min", 0.0 );
5424 setPreferenceProperty( xv, "max", 1.0 );
5425 setPreferenceProperty( yv, "step", 0.1 );
5426 setPreferenceProperty( yv, "min", 0.0 );
5427 setPreferenceProperty( yv, "max", 1.0 );
5428 setPreferenceProperty( wv, "step", 0.1 );
5429 setPreferenceProperty( wv, "min", 0.0 );
5430 setPreferenceProperty( wv, "max", 1.0 );
5431 setPreferenceProperty( hv, "min", 0.0 );
5432 setPreferenceProperty( hv, "max", 1.0 );
5433 setPreferenceProperty( hv, "step", 0.1 );
5435 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5436 setPreferenceProperty( posHSizeGr, "columns", 2 );
5437 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5438 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5439 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5440 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5441 setPreferenceProperty( xv, "min", 0.0 );
5442 setPreferenceProperty( xv, "max", 1.0 );
5443 setPreferenceProperty( xv, "step", 0.1 );
5444 setPreferenceProperty( xh, "min", 0.0 );
5445 setPreferenceProperty( xh, "max", 1.0 );
5446 setPreferenceProperty( xh, "step", 0.1 );
5447 setPreferenceProperty( yh, "min", 0.0 );
5448 setPreferenceProperty( yh, "max", 1.0 );
5449 setPreferenceProperty( yh, "step", 0.1 );
5450 setPreferenceProperty( wh, "min", 0.0 );
5451 setPreferenceProperty( wh, "max", 1.0 );
5452 setPreferenceProperty( wh, "step", 0.1 );
5453 setPreferenceProperty( hh, "min", 0.0 );
5454 setPreferenceProperty( hh, "max", 1.0 );
5455 setPreferenceProperty( hh, "step", 0.1 );
5457 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5458 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5459 setPreferenceProperty( distributionGr, "columns", 3 );
5461 types.append( tr( "SMESH_MONOCOLOR" ) );
5462 types.append( tr( "SMESH_MULTICOLOR" ) );
5463 indices.clear(); indices.append( 0 ); indices.append( 1 );
5464 setPreferenceProperty( coloringType, "strings", types );
5465 setPreferenceProperty( coloringType, "indexes", indices );
5466 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5470 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5472 if ( sect=="SMESH" ) {
5473 float sbX1 = 0.01, sbY1 = 0.01, sbW = 0.08, sbH = 0.08;
5474 float aTol = 1.00000009999999;
5475 std::string aWarning;
5476 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5478 if ( name == "selection_object_color" ||
5479 name == "selection_element_color" ||
5480 name == "highlight_color" ||
5481 name == "selection_precision_node" ||
5482 name == "selection_precision_element" ||
5483 name == "selection_precision_object" ||
5484 name == "selection_increment")
5486 SMESH::UpdateSelectionProp( this );
5488 else if (name == "scalar_bar_vertical_x" || name == "scalar_bar_vertical_width")
5490 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5491 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5492 if ( sbX1+sbW > aTol ) {
5493 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5496 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5497 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5500 else if (name == "scalar_bar_vertical_y" || name == "scalar_bar_vertical_height" )
5502 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5503 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5504 if ( sbY1 + sbH > aTol ) {
5505 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5506 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5507 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5510 else if (name == "scalar_bar_horizontal_x" || name == "scalar_bar_horizontal_width")
5512 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5513 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5514 if ( sbX1 + sbW > aTol ) {
5515 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5518 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5519 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5522 else if (name == "scalar_bar_horizontal_y" || name == "scalar_bar_horizontal_height")
5524 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5525 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5526 if ( sbY1 + sbH > aTol ) {
5527 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5530 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5531 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5534 else if ( name == "segmentation" )
5536 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5537 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5539 else if ( name == "nb_segments_per_edge" )
5541 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5542 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5544 else if ( name == "historical_python_dump" || name == "forget_mesh_on_hyp_modif" || name == "default_grp_color" )
5546 QString val = aResourceMgr->stringValue( "SMESH", name );
5547 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5549 else if ( name == "numbering_node_color" || name == "numbering_node_font" )
5551 SMESH::UpdateFontProp( this );
5553 else if ( name == "numbering_elem_color" || name == "numbering_elem_font" )
5555 SMESH::UpdateFontProp( this );
5558 if ( aWarning.size() != 0 ) {
5559 aWarning += "The default values are applied instead.";
5560 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5561 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5562 QObject::tr(aWarning.c_str()));
5567 //================================================================================
5569 * \brief Update something in accordance with update flags
5570 * \param theFlags - update flags
5572 * Update viewer or/and object browser etc. in accordance with update flags ( see
5573 * LightApp_UpdateFlags enumeration ).
5575 //================================================================================
5576 void SMESHGUI::update( const int flags )
5578 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5579 SMESH::UpdateView();
5581 SalomeApp_Module::update( flags );
5584 //================================================================================
5586 * \brief Set default selection mode
5588 * SLOT called when operation committed. Sets default selection mode
5590 //================================================================================
5591 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5593 SVTK_ViewWindow* vtkWnd =
5594 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5596 vtkWnd->SetSelectionMode( ActorSelection );
5599 //================================================================================
5601 * \brief Set default selection mode
5603 * SLOT called when operation aborted. Sets default selection mode
5605 //================================================================================
5606 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5608 SVTK_ViewWindow* vtkWnd =
5609 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5611 vtkWnd->SetSelectionMode( ActorSelection );
5614 //================================================================================
5616 * \brief Creates operation with given identifier
5617 * \param id - identifier of operation to be started
5618 * \return Pointer on created operation or NULL if operation is not created
5620 * Virtual method redefined from the base class creates operation with given id.
5621 * It is called called automatically from startOperation method of base class.
5623 //================================================================================
5624 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5626 LightApp_Operation* op = 0;
5627 // to do : create operation here
5630 case SMESHOp::OpSplitBiQuadratic:
5631 op = new SMESHGUI_SplitBiQuadOp();
5633 case SMESHOp::OpConvertMeshToQuadratic:
5634 op = new SMESHGUI_ConvToQuadOp();
5636 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5637 op = new SMESHGUI_Make2DFrom3DOp();
5639 case SMESHOp::OpReorientFaces:
5640 op = new SMESHGUI_ReorientFacesOp();
5642 case SMESHOp::OpCreateMesh:
5643 op = new SMESHGUI_MeshOp( true, true );
5645 case SMESHOp::OpCreateSubMesh:
5646 op = new SMESHGUI_MeshOp( true, false );
5648 case SMESHOp::OpEditMeshOrSubMesh:
5649 case SMESHOp::OpEditMesh:
5650 case SMESHOp::OpEditSubMesh:
5651 op = new SMESHGUI_MeshOp( false );
5653 case SMESHOp::OpCompute:
5654 case SMESHOp::OpComputeSubMesh:
5655 op = new SMESHGUI_ComputeOp();
5657 case SMESHOp::OpPreCompute:
5658 op = new SMESHGUI_PrecomputeOp();
5660 case SMESHOp::OpEvaluate:
5661 op = new SMESHGUI_EvaluateOp();
5663 case SMESHOp::OpMeshOrder:
5664 op = new SMESHGUI_MeshOrderOp();
5666 case SMESHOp::OpCreateGeometryGroup:
5667 op = new SMESHGUI_GroupOnShapeOp();
5669 case SMESHOp::OpFindElementByPoint:
5670 op = new SMESHGUI_FindElemByPointOp();
5672 case SMESHOp::OpMoveNode: // Make mesh pass through point
5673 op = new SMESHGUI_MakeNodeAtPointOp();
5675 case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
5676 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5683 op = SalomeApp_Module::createOperation( id );
5687 //================================================================================
5689 * \brief Stops current operations and starts a given one
5690 * \param id - The id of the operation to start
5692 //================================================================================
5694 void SMESHGUI::switchToOperation(int id)
5696 activeStudy()->abortAllOperations();
5697 startOperation( id );
5700 LightApp_Displayer* SMESHGUI::displayer()
5703 myDisplayer = new SMESHGUI_Displayer( getApp() );
5707 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5710 int aTolerance = 64;
5711 int anIterations = 0;
5717 if( anIterations % aPeriod == 0 )
5720 if( aTolerance < 1 )
5724 aHue = (int)( 360.0 * rand() / RAND_MAX );
5727 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5728 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5729 for( ; it != itEnd; ++it )
5731 SALOMEDS::Color anAutoColor = *it;
5732 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5735 aQColor.getHsv( &h, &s, &v );
5736 if( abs( h - aHue ) < aTolerance )
5748 aColor.setHsv( aHue, 255, 255 );
5750 SALOMEDS::Color aSColor;
5751 aSColor.R = aColor.redF();
5752 aSColor.G = aColor.greenF();
5753 aSColor.B = aColor.blueF();
5758 const char* gSeparator = "_"; // character used to separate parameter names
5759 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5760 const char* gPathSep = "|"; // character used to separate paths
5763 * \brief Store visual parameters
5765 * This method is called just before the study document is saved.
5766 * Store visual parameters in AttributeParameter attribute(s)
5768 void SMESHGUI::storeVisualParameters (int savePoint)
5771 Kernel_Utils::Localizer loc;
5773 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5774 if (!appStudy || !appStudy->studyDS())
5776 _PTR(Study) studyDS = appStudy->studyDS();
5778 // componentName is used for encoding of entries when storing them in IParameters
5779 std::string componentName = myComponentSMESH->ComponentDataType();
5780 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5781 //if (!aSComponent) return;
5784 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5785 componentName.c_str(),
5787 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5789 // store custom markers
5790 if( !myMarkerMap.empty() )
5792 VTK::MarkerMap::const_iterator anIter = myMarkerMap.begin();
5793 for( ; anIter != myMarkerMap.end(); anIter++ )
5795 int anId = anIter->first;
5796 VTK::MarkerData aMarkerData = anIter->second;
5797 std::string aMarkerFileName = aMarkerData.first;
5798 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5799 if( aMarkerTexture.size() < 3 )
5800 continue; // should contain at least width, height and the first value
5802 QString aPropertyName( "texture" );
5803 aPropertyName += gSeparator;
5804 aPropertyName += QString::number( anId );
5806 QString aPropertyValue = aMarkerFileName.c_str();
5807 aPropertyValue += gPathSep;
5809 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5810 ushort aWidth = *aTextureIter++;
5811 ushort aHeight = *aTextureIter++;
5812 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5813 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5814 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5815 aPropertyValue += QString::number( *aTextureIter );
5817 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5821 // viewers counters are used for storing view_numbers in IParameters
5824 // main cycle to store parameters of displayed objects
5825 QList<SUIT_ViewManager*> lst;
5826 QList<SUIT_ViewManager*>::Iterator it;
5827 getApp()->viewManagers(lst);
5828 for (it = lst.begin(); it != lst.end(); it++)
5830 SUIT_ViewManager* vman = *it;
5831 QString vType = vman->getType();
5833 // saving VTK actors properties
5834 if (vType == SVTK_Viewer::Type())
5836 // store the clipping planes attached to the view manager
5837 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5838 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5839 if( anIter != myClippingPlaneInfoMap.end() )
5840 aClippingPlaneInfoList = anIter->second;
5842 if( !aClippingPlaneInfoList.empty() ) {
5843 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5844 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5846 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5847 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5849 QString aPropertyName( "ClippingPlane" );
5850 aPropertyName += gSeparator;
5851 aPropertyName += QString::number( vtkViewers );
5852 aPropertyName += gSeparator;
5853 aPropertyName += QString::number( anId );
5855 QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
5856 aPropertyValue += gDigitsSep;
5857 aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
5858 aPropertyValue += gDigitsSep;
5859 if ( aPlane->PlaneMode == SMESH::Absolute ) {
5860 aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
5861 aPropertyValue += gDigitsSep;
5862 aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
5863 aPropertyValue += gDigitsSep;
5864 aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
5865 aPropertyValue += gDigitsSep;
5866 aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
5867 aPropertyValue += gDigitsSep;
5868 aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
5869 aPropertyValue += gDigitsSep;
5870 aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
5871 aPropertyValue += gDigitsSep;
5872 aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
5874 else if ( aPlane->PlaneMode == SMESH::Relative ) {
5875 aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
5876 aPropertyValue += gDigitsSep;
5877 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5878 aPropertyValue += gDigitsSep;
5879 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5880 aPropertyValue += gDigitsSep;
5881 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5884 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5888 QVector<SUIT_ViewWindow*> views = vman->getViews();
5889 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5891 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5893 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5894 vtkActorCollection* allActors = aCopy.GetActors();
5895 allActors->InitTraversal();
5896 while (vtkActor* actor = allActors->GetNextActor())
5898 if (actor->GetVisibility()) // store only visible actors
5900 SMESH_Actor* aSmeshActor = 0;
5901 if (actor->IsA("SMESH_Actor"))
5902 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5903 if (aSmeshActor && aSmeshActor->hasIO())
5905 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5908 // entry is "encoded" = it does NOT contain component address,
5909 // since it is a subject to change on next component loading
5910 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5912 std::string param, vtkParam = vType.toLatin1().data();
5913 vtkParam += gSeparator;
5914 vtkParam += QString::number(vtkViewers).toLatin1().data();
5915 vtkParam += gSeparator;
5918 param = vtkParam + "Visibility";
5919 ip->setParameter(entry, param, "On");
5922 param = vtkParam + "Representation";
5923 ip->setParameter(entry, param, QString::number
5924 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5927 param = vtkParam + "IsShrunk";
5928 ip->setParameter(entry, param, QString::number
5929 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5931 // Displayed entities
5932 unsigned int aMode = aSmeshActor->GetEntityMode();
5933 bool isE = aMode & SMESH_Actor::eEdges;
5934 bool isF = aMode & SMESH_Actor::eFaces;
5935 bool isV = aMode & SMESH_Actor::eVolumes;
5936 bool is0d = aMode & SMESH_Actor::e0DElements;
5937 bool isB = aMode & SMESH_Actor::eBallElem;
5939 QString modeStr ("e");
5940 modeStr += gDigitsSep; modeStr += QString::number(isE);
5941 modeStr += gDigitsSep; modeStr += "f";
5942 modeStr += gDigitsSep; modeStr += QString::number(isF);
5943 modeStr += gDigitsSep; modeStr += "v";
5944 modeStr += gDigitsSep; modeStr += QString::number(isV);
5945 modeStr += gDigitsSep; modeStr += "0d";
5946 modeStr += gDigitsSep; modeStr += QString::number(is0d);
5947 modeStr += gDigitsSep; modeStr += "b";
5948 modeStr += gDigitsSep; modeStr += QString::number(isB);
5950 param = vtkParam + "Entities";
5951 ip->setParameter(entry, param, modeStr.toLatin1().data());
5957 aSmeshActor->GetSufaceColor(r, g, b, delta);
5958 QStringList colorStr;
5959 colorStr << "surface";
5960 colorStr << QString::number(r);
5961 colorStr << QString::number(g);
5962 colorStr << QString::number(b);
5964 colorStr << "backsurface";
5965 colorStr << QString::number(delta);
5967 aSmeshActor->GetVolumeColor(r, g, b, delta);
5968 colorStr << "volume";
5969 colorStr << QString::number(r);
5970 colorStr << QString::number(g);
5971 colorStr << QString::number(b);
5972 colorStr << QString::number(delta);
5974 aSmeshActor->GetEdgeColor(r, g, b);
5976 colorStr << QString::number(r);
5977 colorStr << QString::number(g);
5978 colorStr << QString::number(b);
5980 aSmeshActor->GetNodeColor(r, g, b);
5982 colorStr << QString::number(r);
5983 colorStr << QString::number(g);
5984 colorStr << QString::number(b);
5986 aSmeshActor->GetOutlineColor(r, g, b);
5987 colorStr << "outline";
5988 colorStr << QString::number(r);
5989 colorStr << QString::number(g);
5990 colorStr << QString::number(b);
5992 aSmeshActor->Get0DColor(r, g, b);
5993 colorStr << "elem0d";
5994 colorStr << QString::number(r);
5995 colorStr << QString::number(g);
5996 colorStr << QString::number(b);
5998 aSmeshActor->GetBallColor(r, g, b);
6000 colorStr << QString::number(r);
6001 colorStr << QString::number(g);
6002 colorStr << QString::number(b);
6004 aSmeshActor->GetFacesOrientationColor(r, g, b);
6005 colorStr << "orientation";
6006 colorStr << QString::number(r);
6007 colorStr << QString::number(g);
6008 colorStr << QString::number(b);
6010 param = vtkParam + "Colors";
6011 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
6014 QStringList sizeStr;
6016 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
6017 sizeStr << "outline";
6018 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
6019 sizeStr << "elem0d";
6020 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
6022 //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
6023 sizeStr << QString::number((double)aSmeshActor->GetBallSize());
6024 sizeStr << QString::number((double)aSmeshActor->GetBallScale());
6025 sizeStr << "shrink";
6026 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
6027 sizeStr << "orientation";
6028 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
6029 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
6031 param = vtkParam + "Sizes";
6032 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
6037 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
6038 if( aMarkerType == VTK::MT_USER ) {
6039 markerStr += "custom";
6040 markerStr += gDigitsSep;
6041 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
6045 markerStr += gDigitsSep;
6046 markerStr += QString::number( (int)aMarkerType );
6047 markerStr += gDigitsSep;
6048 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
6051 param = vtkParam + "PointMarker";
6052 ip->setParameter(entry, param, markerStr.toLatin1().data());
6055 param = vtkParam + "Opacity";
6056 ip->setParameter(entry, param,
6057 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
6060 param = vtkParam + "ClippingPlane";
6062 if( !aClippingPlaneInfoList.empty() ) {
6063 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
6064 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
6066 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
6067 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
6068 SMESH::TActorList::iterator anIter2 = anActorList.begin();
6069 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
6070 if( aSmeshActor == *anIter2 ) {
6071 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
6072 QString::number( anId ).toLatin1().constData() );
6079 ip->setParameter( entry, param, "Off" );
6080 } // if (io->hasEntry())
6081 } // SMESH_Actor && hasIO
6083 } // while.. actors traversal
6087 } // if (SVTK view model)
6088 } // for (viewManagers)
6091 // data structures for clipping planes processing
6095 bool isOpenGLClipping;
6096 vtkIdType RelativeOrientation;
6099 int AbsoluteOrientation;
6100 double X, Y, Z, Dx, Dy, Dz;
6102 typedef std::list<TPlaneData> TPlaneDataList;
6103 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
6105 typedef std::list<vtkActor*> TActorList;
6108 TActorList ActorList;
6109 SUIT_ViewManager* ViewManager;
6111 typedef std::list<TPlaneInfo> TPlaneInfoList;
6112 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
6115 * \brief Restore visual parameters
6117 * This method is called after the study document is opened.
6118 * Restore visual parameters from AttributeParameter attribute(s)
6120 void SMESHGUI::restoreVisualParameters (int savePoint)
6123 Kernel_Utils::Localizer loc;
6125 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6126 if (!appStudy || !appStudy->studyDS())
6128 _PTR(Study) studyDS = appStudy->studyDS();
6130 // componentName is used for encoding of entries when storing them in IParameters
6131 std::string componentName = myComponentSMESH->ComponentDataType();
6132 //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
6133 //if (!aSComponent) return;
6136 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6137 componentName.c_str(),
6139 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6141 // restore custom markers and map of clipping planes
6142 TPlaneDataMap aPlaneDataMap;
6144 std::vector<std::string> properties = ip->getProperties();
6145 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
6147 std::string property = *propIt;
6148 QString aPropertyName( property.c_str() );
6149 QString aPropertyValue( ip->getProperty( property ).c_str() );
6151 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
6152 if( aPropertyNameList.isEmpty() )
6155 QString aPropertyType = aPropertyNameList[0];
6156 if( aPropertyType == "texture" )
6158 if( aPropertyNameList.size() != 2 )
6162 int anId = aPropertyNameList[1].toInt( &ok );
6163 if( !ok || anId < 1 )
6166 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
6167 if( aPropertyValueList.size() != 2 )
6170 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
6171 QString aMarkerTextureString = aPropertyValueList[1];
6172 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
6173 if( aMarkerTextureStringList.size() != 3 )
6177 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6182 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6186 VTK::MarkerTexture aMarkerTexture;
6187 aMarkerTexture.push_back( aWidth );
6188 aMarkerTexture.push_back( aHeight );
6190 QString aMarkerTextureData = aMarkerTextureStringList[2];
6191 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6193 QChar aChar = aMarkerTextureData.at( i );
6194 if( aChar.isDigit() )
6195 aMarkerTexture.push_back( aChar.digitValue() );
6198 myMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6200 else if( aPropertyType == "ClippingPlane" )
6202 if( aPropertyNameList.size() != 3 )
6206 int aViewId = aPropertyNameList[1].toInt( &ok );
6207 if( !ok || aViewId < 0 )
6211 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6212 if( !ok || aClippingPlaneId < 0 )
6215 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6216 if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6219 TPlaneData aPlaneData;
6220 aPlaneData.AbsoluteOrientation = false;
6221 aPlaneData.RelativeOrientation = 0;
6222 aPlaneData.Distance = aPlaneData.Angle[0] = aPlaneData.Angle[1] = 0;
6223 aPlaneData.X = aPlaneData.Y = aPlaneData.Z = 0;
6224 aPlaneData.Dx = aPlaneData.Dy = aPlaneData.Dz = 0;
6226 aPlaneData.Id = aClippingPlaneId;
6229 aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6234 aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6238 if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6241 aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6246 aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6251 aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6256 aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6261 aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6266 aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6271 aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6275 else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6277 aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6282 aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6287 aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6292 aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6297 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6298 aPlaneDataList.push_back( aPlaneData );
6302 TPlaneInfoMap aPlaneInfoMap;
6304 std::vector<std::string> entries = ip->getEntries();
6306 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6308 // entry is a normal entry - it should be "decoded" (setting base address of component)
6309 QString entry (ip->decodeEntry(*entIt).c_str());
6311 // Check that the entry corresponds to a real object in the Study
6312 // as the object may be deleted or modified after the visual state is saved.
6313 _PTR(SObject) so = studyDS->FindObjectID(entry.toUtf8().data());
6314 if (!so) continue; //Skip the not existent entry
6316 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6317 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6319 std::vector<std::string>::iterator namesIt = paramNames.begin();
6320 std::vector<std::string>::iterator valuesIt = paramValues.begin();
6322 // actors are stored in a map after displaying of them for
6323 // quicker access in the future: map < viewID to actor >
6324 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6326 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6328 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6329 // '_' is used as separator and should not be used in viewer type or parameter names.
6330 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6331 if (lst.size() != 3)
6334 QString viewerTypStr = lst[0];
6335 QString viewIndexStr = lst[1];
6336 QString paramNameStr = lst[2];
6339 int viewIndex = viewIndexStr.toUInt(&ok);
6340 if (!ok) // bad conversion of view index to integer
6344 if (viewerTypStr == SVTK_Viewer::Type())
6346 SMESH_Actor* aSmeshActor = 0;
6347 if (vtkActors.IsBound(viewIndex))
6348 aSmeshActor = vtkActors.Find(viewIndex);
6350 QList<SUIT_ViewManager*> lst;
6351 getApp()->viewManagers(viewerTypStr, lst);
6353 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6354 SUIT_ViewManager* vman = NULL;
6355 if (viewIndex >= 0 && viewIndex < lst.count())
6356 vman = lst.at(viewIndex);
6358 if (paramNameStr == "Visibility")
6360 if (!aSmeshActor && displayer() && vman)
6362 SUIT_ViewModel* vmodel = vman->getViewModel();
6363 // SVTK view model can be casted to SALOME_View
6364 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6366 // store displayed actor in a temporary map for quicker
6367 // access later when restoring other parameters
6368 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6369 vtkRenderer* Renderer = vtkView->getRenderer();
6370 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6371 vtkActorCollection* theActors = aCopy.GetActors();
6372 theActors->InitTraversal();
6373 bool isFound = false;
6374 vtkActor *ac = theActors->GetNextActor();
6375 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6376 if (ac->IsA("SMESH_Actor")) {
6377 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6378 if (aGeomAc->hasIO()) {
6379 Handle(SALOME_InteractiveObject) io = aGeomAc->getIO();
6380 if (io->hasEntry() && strcmp(io->getEntry(), entry.toUtf8().data()) == 0) {
6382 vtkActors.Bind(viewIndex, aGeomAc);
6388 } // if (paramNameStr == "Visibility")
6391 // the rest properties "work" with SMESH_Actor
6394 QString val ((*valuesIt).c_str());
6397 if (paramNameStr == "Representation") {
6398 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6401 else if (paramNameStr == "IsShrunk") {
6403 if (!aSmeshActor->IsShrunk())
6404 aSmeshActor->SetShrink();
6407 if (aSmeshActor->IsShrunk())
6408 aSmeshActor->UnShrink();
6411 // Displayed entities
6412 else if (paramNameStr == "Entities") {
6413 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6414 int aEntityMode = SMESH_Actor::eAllEntity;
6415 for ( int i = 0; i < mode.count(); i+=2 ) {
6416 if ( i < mode.count()-1 ) {
6417 QString type = mode[i];
6418 bool val = mode[i+1].toInt();
6419 if ( type == "e" && !val )
6420 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6421 else if ( type == "f" && !val )
6422 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6423 else if ( type == "v" && !val )
6424 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6425 else if ( type == "0d" && !val )
6426 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6427 else if ( type == "b" && !val )
6428 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6431 aSmeshActor->SetEntityMode( aEntityMode );
6434 else if (paramNameStr == "Colors") {
6435 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6442 QColor outlineColor;
6443 QColor orientationColor;
6449 // below lines are required to get default values for delta coefficients
6450 // of backface color for faces and color of reversed volumes
6451 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
6452 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6453 for ( int i = 0; i < colors.count(); i++ ) {
6454 QString type = colors[i];
6455 if ( type == "surface" ) {
6456 // face color is set by 3 values r:g:b, where
6457 // - r,g,b - is rgb color components
6458 if ( i+1 >= colors.count() ) break; // format error
6459 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6460 if ( i+2 >= colors.count() ) break; // format error
6461 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6462 if ( i+3 >= colors.count() ) break; // format error
6463 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6464 faceColor.setRgbF( r, g, b );
6467 else if ( type == "backsurface" ) {
6468 // backface color can be defined in several ways
6469 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6470 // - in latest versions, it is set as delta coefficient
6471 bool rgbOk = false, deltaOk;
6472 if ( i+1 >= colors.count() ) break; // format error
6473 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6474 int delta = colors[i+1].toInt( &deltaOk );
6476 if ( i+1 < colors.count() ) // index is shifted to 1
6477 g = colors[i+1].toDouble( &rgbOk );
6478 if ( rgbOk ) i++; // shift index
6479 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6480 b = colors[i+1].toDouble( &rgbOk );
6482 // - as currently there's no way to set directly backsurface color as it was before,
6483 // we ignore old dump where r,g,b triple was set
6484 // - also we check that delta parameter is set properly
6485 if ( !rgbOk && deltaOk )
6488 else if ( type == "volume" ) {
6489 // volume color is set by 4 values r:g:b:delta, where
6490 // - r,g,b - is a normal volume rgb color components
6491 // - delta - is a reversed volume color delta coefficient
6492 if ( i+1 >= colors.count() ) break; // format error
6493 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6494 if ( i+2 >= colors.count() ) break; // format error
6495 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6496 if ( i+3 >= colors.count() ) break; // format error
6497 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6498 if ( i+4 >= colors.count() ) break; // format error
6499 int delta = colors[i+4].toInt( &bOk );
6500 if ( !bOk ) break; // format error
6501 volumeColor.setRgbF( r, g, b );
6505 else if ( type == "edge" ) {
6506 // edge color is set by 3 values r:g:b, where
6507 // - r,g,b - is rgb color components
6508 if ( i+1 >= colors.count() ) break; // format error
6509 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6510 if ( i+2 >= colors.count() ) break; // format error
6511 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6512 if ( i+3 >= colors.count() ) break; // format error
6513 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6514 edgeColor.setRgbF( r, g, b );
6517 else if ( type == "node" ) {
6518 // node color is set by 3 values r:g:b, where
6519 // - r,g,b - is rgb color components
6520 if ( i+1 >= colors.count() ) break; // format error
6521 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6522 if ( i+2 >= colors.count() ) break; // format error
6523 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6524 if ( i+3 >= colors.count() ) break; // format error
6525 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6526 nodeColor.setRgbF( r, g, b );
6529 else if ( type == "elem0d" ) {
6530 // 0d element color is set by 3 values r:g:b, where
6531 // - r,g,b - is rgb color components
6532 if ( i+1 >= colors.count() ) break; // format error
6533 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6534 if ( i+2 >= colors.count() ) break; // format error
6535 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6536 if ( i+3 >= colors.count() ) break; // format error
6537 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6538 elem0dColor.setRgbF( r, g, b );
6541 else if ( type == "ball" ) {
6542 // ball color is set by 3 values r:g:b, where
6543 // - r,g,b - is rgb color components
6544 if ( i+1 >= colors.count() ) break; // format error
6545 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6546 if ( i+2 >= colors.count() ) break; // format error
6547 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6548 if ( i+3 >= colors.count() ) break; // format error
6549 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6550 ballColor.setRgbF( r, g, b );
6553 else if ( type == "outline" ) {
6554 // outline color is set by 3 values r:g:b, where
6555 // - r,g,b - is rgb color components
6556 if ( i+1 >= colors.count() ) break; // format error
6557 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6558 if ( i+2 >= colors.count() ) break; // format error
6559 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6560 if ( i+3 >= colors.count() ) break; // format error
6561 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6562 outlineColor.setRgbF( r, g, b );
6565 else if ( type == "orientation" ) {
6566 // orientation color is set by 3 values r:g:b, where
6567 // - r,g,b - is rgb color components
6568 if ( i+1 >= colors.count() ) break; // format error
6569 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6570 if ( i+2 >= colors.count() ) break; // format error
6571 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6572 if ( i+3 >= colors.count() ) break; // format error
6573 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6574 orientationColor.setRgbF( r, g, b );
6579 if ( nodeColor.isValid() )
6580 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6582 if ( edgeColor.isValid() )
6583 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6585 if ( faceColor.isValid() )
6586 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6588 if ( volumeColor.isValid() )
6589 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6590 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6591 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6593 if ( elem0dColor.isValid() )
6594 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6596 if ( ballColor.isValid() )
6597 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6599 if ( outlineColor.isValid() )
6600 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6601 // orientation color
6602 if ( orientationColor.isValid() )
6603 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6606 else if (paramNameStr == "Sizes") {
6607 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6610 int outlineWidth = -1;
6611 int elem0dSize = -1;
6612 //int ballSize = -1;
6613 double ballDiameter = -1.0;
6614 double ballScale = -1.0;
6615 double shrinkSize = -1;
6616 double orientationSize = -1;
6617 bool orientation3d = false;
6618 for ( int i = 0; i < sizes.count(); i++ ) {
6619 QString type = sizes[i];
6620 if ( type == "line" ) {
6621 // line (wireframe) width is given as single integer value
6622 if ( i+1 >= sizes.count() ) break; // format error
6623 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6627 if ( type == "outline" ) {
6628 // outline width is given as single integer value
6629 if ( i+1 >= sizes.count() ) break; // format error
6630 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6634 else if ( type == "elem0d" ) {
6635 // 0d element size is given as single integer value
6636 if ( i+1 >= sizes.count() ) break; // format error
6637 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6641 else if ( type == "ball" ) {
6642 // balls are specified by two values: size:scale, where
6643 // - size - is a integer value specifying size
6644 // - scale - is a double value specifying scale factor
6645 if ( i+1 >= sizes.count() ) break; // format error
6646 //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6647 double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6648 if ( i+2 >= sizes.count() ) break; // format error
6649 double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6655 else if ( type == "shrink" ) {
6656 // shrink factor is given as single floating point value
6657 if ( i+1 >= sizes.count() ) break; // format error
6658 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6662 else if ( type == "orientation" ) {
6663 // orientation vectors are specified by two values size:3d, where
6664 // - size - is a floating point value specifying scale factor
6665 // - 3d - is a boolean
6666 if ( i+1 >= sizes.count() ) break; // format error
6667 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6668 if ( i+2 >= sizes.count() ) break; // format error
6669 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6670 orientationSize = v1;
6671 orientation3d = (bool)v2;
6675 // line (wireframe) width
6676 if ( lineWidth > 0 )
6677 aSmeshActor->SetLineWidth( lineWidth );
6679 if ( outlineWidth > 0 )
6680 aSmeshActor->SetOutlineWidth( outlineWidth );
6681 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6682 aSmeshActor->SetOutlineWidth( lineWidth );
6684 if ( elem0dSize > 0 )
6685 aSmeshActor->Set0DSize( elem0dSize );
6687 /*if ( ballSize > 0 )
6688 aSmeshActor->SetBallSize( ballSize );*/
6690 if ( ballDiameter > 0 )
6691 aSmeshActor->SetBallSize( ballDiameter );
6693 if ( ballScale > 0.0 )
6694 aSmeshActor->SetBallScale( ballScale );
6696 if ( shrinkSize > 0 )
6697 aSmeshActor->SetShrinkFactor( shrinkSize );
6698 // orientation vectors
6699 if ( orientationSize > 0 ) {
6700 aSmeshActor->SetFacesOrientationScale( orientationSize );
6701 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6705 else if (paramNameStr == "PointMarker") {
6706 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6707 if( data.count() >= 2 ) {
6709 int aParam1 = data[1].toInt( &ok );
6711 if( data[0] == "std" && data.count() == 3 ) {
6712 int aParam2 = data[2].toInt( &ok );
6713 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6715 else if( data[0] == "custom" ) {
6716 VTK::MarkerMap::const_iterator markerIt = myMarkerMap.find( aParam1 );
6717 if( markerIt != myMarkerMap.end() ) {
6718 VTK::MarkerData aMarkerData = markerIt->second;
6719 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6726 else if (paramNameStr == "Opacity") {
6727 aSmeshActor->SetOpacity(val.toFloat());
6730 else if (paramNameStr.startsWith("ClippingPlane")) {
6731 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6732 // old format - val looks like "Off" or "1:0:0:0.5:0:0"
6733 // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
6734 // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
6735 // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
6736 // new format - val looks like "Off" or "0" (plane id)
6737 // (note: in new format "Off" value is used only for consistency,
6738 // so it is processed together with values in old format)
6739 bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
6740 if( anIsOldFormat ) {
6741 if (paramNameStr == "ClippingPlane1" || val == "Off")
6742 aSmeshActor->RemoveAllClippingPlanes();
6744 QList<SUIT_ViewManager*> lst;
6745 getApp()->viewManagers(viewerTypStr, lst);
6746 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6747 if (viewIndex >= 0 && viewIndex < lst.count()) {
6748 SUIT_ViewManager* vman = lst.at(viewIndex);
6749 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6751 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6753 SMESH::TActorList anActorList;
6754 anActorList.push_back( aSmeshActor );
6755 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
6756 aPlane->myViewWindow = vtkView;
6757 SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
6758 aPlane->PlaneMode = aMode;
6759 bool isOpenGLClipping = ( bool )vals[1].toInt();
6760 aPlane->IsOpenGLClipping = isOpenGLClipping;
6761 if ( aMode == SMESH::Absolute ) {
6762 aPlane->myAbsoluteOrientation = vals[2].toInt();
6763 aPlane->X = vals[3].toFloat();
6764 aPlane->Y = vals[4].toFloat();
6765 aPlane->Z = vals[5].toFloat();
6766 aPlane->Dx = vals[6].toFloat();
6767 aPlane->Dy = vals[7].toFloat();
6768 aPlane->Dz = vals[8].toFloat();
6770 else if ( aMode == SMESH::Relative ) {
6771 aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
6772 aPlane->myDistance = vals[3].toFloat();
6773 aPlane->myAngle[0] = vals[4].toFloat();
6774 aPlane->myAngle[1] = vals[5].toFloat();
6778 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6779 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6780 aClippingPlaneInfo.Plane = aPlane;
6781 aClippingPlaneInfo.ActorList = anActorList;
6782 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6790 int aPlaneId = val.toInt( &ok );
6791 if( ok && aPlaneId >= 0 ) {
6792 bool anIsDefinedPlane = false;
6793 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6794 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6795 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6796 TPlaneInfo& aPlaneInfo = *anIter;
6797 if( aPlaneInfo.PlaneId == aPlaneId ) {
6798 aPlaneInfo.ActorList.push_back( aSmeshActor );
6799 anIsDefinedPlane = true;
6803 if( !anIsDefinedPlane ) {
6804 TPlaneInfo aPlaneInfo;
6805 aPlaneInfo.PlaneId = aPlaneId;
6806 aPlaneInfo.ActorList.push_back( aSmeshActor );
6807 aPlaneInfo.ViewManager = vman;
6809 // to make the list sorted by plane id
6810 anIter = aPlaneInfoList.begin();
6811 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6812 const TPlaneInfo& aPlaneInfoRef = *anIter;
6813 if( aPlaneInfoRef.PlaneId > aPlaneId )
6816 aPlaneInfoList.insert( anIter, aPlaneInfo );
6821 } // if (aSmeshActor)
6822 } // other parameters than Visibility
6824 } // for names/parameters iterator
6825 } // for entries iterator
6827 // take into account planes with empty list of actors referred to them
6828 QList<SUIT_ViewManager*> aVMList;
6829 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6831 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6832 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6833 int aViewId = aPlaneDataIter->first;
6834 if( aViewId >= 0 && aViewId < aVMList.count() ) {
6835 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6837 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6839 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6840 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6841 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6842 const TPlaneData& aPlaneData = *anIter2;
6843 int aPlaneId = aPlaneData.Id;
6845 bool anIsFound = false;
6846 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6847 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6848 const TPlaneInfo& aPlaneInfo = *anIter3;
6849 if( aPlaneInfo.PlaneId == aPlaneId ) {
6856 TPlaneInfo aPlaneInfo; // ActorList field is empty
6857 aPlaneInfo.PlaneId = aPlaneId;
6858 aPlaneInfo.ViewManager = aViewManager;
6860 // to make the list sorted by plane id
6861 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6862 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6863 const TPlaneInfo& aPlaneInfoRef = *anIter4;
6864 if( aPlaneInfoRef.PlaneId > aPlaneId )
6867 aPlaneInfoList.insert( anIter4, aPlaneInfo );
6873 // add clipping planes to actors according to the restored parameters
6874 // and update the clipping plane map
6875 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6876 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6877 int aViewId = anIter1->first;
6878 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6880 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6881 if( anIter2 == aPlaneDataMap.end() )
6883 const TPlaneDataList& aPlaneDataList = anIter2->second;
6885 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6886 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6887 const TPlaneInfo& aPlaneInfo = *anIter3;
6888 int aPlaneId = aPlaneInfo.PlaneId;
6889 const TActorList& anActorList = aPlaneInfo.ActorList;
6890 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6894 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6898 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6900 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6901 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6902 const TPlaneData& aPlaneData = *anIter4;
6903 if( aPlaneData.Id == aPlaneId ) {
6904 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
6905 aPlane->myViewWindow = aViewWindow;
6906 aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
6907 aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
6908 if ( aPlane->PlaneMode == SMESH::Absolute ) {
6909 aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
6910 aPlane->X = aPlaneData.X;
6911 aPlane->Y = aPlaneData.Y;
6912 aPlane->Z = aPlaneData.Z;
6913 aPlane->Dx = aPlaneData.Dx;
6914 aPlane->Dy = aPlaneData.Dy;
6915 aPlane->Dz = aPlaneData.Dz;
6917 else if ( aPlane->PlaneMode == SMESH::Relative ) {
6918 aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
6919 aPlane->myDistance = aPlaneData.Distance;
6920 aPlane->myAngle[0] = aPlaneData.Angle[0];
6921 aPlane->myAngle[1] = aPlaneData.Angle[1];
6924 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6925 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6926 aClippingPlaneInfo.Plane = aPlane;
6927 aClippingPlaneInfo.ActorList = anActorList;
6928 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6939 // update all VTK views
6940 QList<SUIT_ViewManager*> lst;
6941 getApp()->viewManagers(lst);
6942 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6943 SUIT_ViewModel* vmodel = (*it)->getViewModel();
6944 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6945 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6946 // set OpenGL clipping planes
6947 VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
6948 vtkActorCollection* anAllActors = aCopy.GetActors();
6949 anAllActors->InitTraversal();
6950 while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
6951 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
6952 anActor->SetOpenGLClippingPlane();
6954 vtkView->getRenderer()->ResetCameraClippingRange();
6961 \brief Adds preferences for dfont of VTK viewer
6963 \param pIf group identifier
6964 \param param parameter
6965 \return identifier of preferences
6967 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
6969 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6971 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6974 fam.append( tr( "SMESH_FONT_ARIAL" ) );
6975 fam.append( tr( "SMESH_FONT_COURIER" ) );
6976 fam.append( tr( "SMESH_FONT_TIMES" ) );
6978 setPreferenceProperty( tfont, "fonts", fam );
6980 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6981 if ( needSize ) f = f | QtxFontEdit::Size;
6982 setPreferenceProperty( tfont, "features", f );
6988 \brief Actions after hypothesis edition
6989 Updates object browser after hypothesis edition
6991 void SMESHGUI::onHypothesisEdit( int result )
6994 SMESHGUI::Modified();
6995 updateObjBrowser( true );
6999 \brief Actions after choosing menu of control modes
7000 Updates control mode actions according to current selection
7002 void SMESHGUI::onUpdateControlActions()
7004 SALOME_ListIO selected;
7005 if ( LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr() )
7006 aSel->selectedObjects( selected );
7008 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
7009 if ( selected.Extent() ) {
7010 if ( selected.First()->hasEntry() ) {
7011 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( selected.First()->getEntry() )) {
7012 aControl = anActor->GetControlMode();
7013 SALOME_ListIteratorOfListIO it(selected);
7014 for ( it.Next(); it.More(); it.Next() ) {
7015 Handle(SALOME_InteractiveObject) anIO = it.Value();
7016 if ( anIO->hasEntry() ) {
7017 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
7018 if ( aControl != anActor->GetControlMode() ) {
7019 aControl = SMESH_Actor::eNone;
7029 int anAction = ActionToControl( aControl, true );
7031 action( anAction )->setChecked( true );
7033 QMenu* send = (QMenu*)sender();
7034 QList<QAction*> actions = send->actions();
7035 for ( int i = 0; i < actions.size(); i++ )
7036 actions[i]->setChecked( false );
7042 \brief Signal handler closing(SUIT_ViewWindow*) of a view
7043 \param pview view being closed
7045 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
7046 #ifndef DISABLE_PLOT2DVIEWER
7047 //Crear all Plot2d Viewers if need.
7048 SMESH::ClearPlot2Viewers(pview);
7050 EmitSignalCloseView();
7053 void SMESHGUI::message( const QString& msg )
7056 QStringList data = msg.split("/");
7057 if ( data.count() > 0 ) {
7058 if ( data.first() == "mesh_loading" ) {
7060 QString entry = data.count() > 1 ? data[1] : QString();
7061 if ( entry.isEmpty() )
7064 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
7066 _PTR(SObject) obj = study->FindObjectID( entry.toUtf8().constData() );
7069 name = SMESH::fromUtf8(obj->GetName());
7070 if ( name.isEmpty() )
7073 if ( data.last() == "stop" )
7074 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
7076 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
7077 QApplication::processEvents();
7083 \brief Connects or disconnects signals about activating and cloning view on the module slots
7084 \param pview view which is connected/disconnected
7086 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
7090 SUIT_ViewManager* viewMgr = pview->getViewManager();
7092 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7093 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7095 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7096 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7101 \brief Return \c true if object can be renamed
7103 bool SMESHGUI::renameAllowed( const QString& entry) const {
7104 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7108 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7112 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
7117 if(appStudy->isComponent(entry) || obj->isReference())
7120 // check type to prevent renaming of inappropriate objects
7121 int aType = SMESHGUI_Selection::type(qPrintable(entry));
7122 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7123 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7124 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7125 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7126 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
7133 Rename object by entry.
7134 \param entry entry of the object
7135 \param name new name of the object
7136 \brief Return \c true if rename operation finished successfully, \c false otherwise.
7138 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
7140 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7144 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7149 _PTR(Study) aStudy = appStudy->studyDS();
7154 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
7156 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
7161 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
7162 _PTR(GenericAttribute) anAttr;
7163 _PTR(AttributeName) aName;
7165 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
7167 // check type to prevent renaming of inappropriate objects
7168 int aType = SMESHGUI_Selection::type( qPrintable(entry));
7169 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7170 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7171 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7172 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7173 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
7174 if ( !name.isEmpty() ) {
7175 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qUtf8Printable(name) );
7177 // update name of group object and its actor
7178 Handle(SALOME_InteractiveObject) IObject =
7179 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
7181 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
7182 if( !aGroupObject->_is_nil() ) {
7183 aGroupObject->SetName( qUtf8Printable(name) );
7184 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
7185 anActor->setName( qUtf8Printable(name) );
7195 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
7197 static QList<QColor> colors;
7199 if ( colors.isEmpty() ) {
7201 for (int s = 0; s < 2 ; s++)
7203 for (int v = 100; v >= 40; v = v - 20)
7205 for (int h = 0; h < 359 ; h = h + 60)
7207 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
7212 static int currentColor = randomize( colors.size() );
7214 SALOMEDS::Color color;
7215 color.R = (double)colors[currentColor].red() / 255.0;
7216 color.G = (double)colors[currentColor].green() / 255.0;
7217 color.B = (double)colors[currentColor].blue() / 255.0;
7219 currentColor = (currentColor+1) % colors.count();