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_FieldSelectorWdg.h"
49 #include "SMESHGUI_FileInfoDlg.h"
50 #include "SMESHGUI_FileValidator.h"
51 #include "SMESHGUI_FilterDlg.h"
52 #include "SMESHGUI_FilterLibraryDlg.h"
53 #include "SMESHGUI_FilterUtils.h"
54 #include "SMESHGUI_FindElemByPointDlg.h"
55 #include "SMESHGUI_GEOMGenUtils.h"
56 #include "SMESHGUI_GroupDlg.h"
57 #include "SMESHGUI_GroupOnShapeDlg.h"
58 #include "SMESHGUI_GroupOpDlg.h"
59 #include "SMESHGUI_GroupUtils.h"
60 #include "SMESHGUI_Hypotheses.h"
61 #include "SMESHGUI_HypothesesUtils.h"
62 #include "SMESHGUI_Make2DFrom3DOp.h"
63 #include "SMESHGUI_MakeNodeAtPointDlg.h"
64 #include "SMESHGUI_Measurements.h"
65 #include "SMESHGUI_MergeDlg.h"
66 #include "SMESHGUI_MeshInfo.h"
67 #include "SMESHGUI_MeshOp.h"
68 #include "SMESHGUI_MeshOrderOp.h"
69 #include "SMESHGUI_MeshPatternDlg.h"
70 #include "SMESHGUI_MeshUtils.h"
71 #include "SMESHGUI_MultiEditDlg.h"
72 #include "SMESHGUI_NodesDlg.h"
73 #include "SMESHGUI_OffsetDlg.h"
74 #include "SMESHGUI_Operations.h"
75 #include "SMESHGUI_PatternUtils.h"
76 #include "SMESHGUI_Preferences_ScalarBarDlg.h"
77 #include "SMESHGUI_PropertiesDlg.h"
78 #include "SMESHGUI_RemoveElementsDlg.h"
79 #include "SMESHGUI_RemoveNodesDlg.h"
80 #include "SMESHGUI_RenumberingDlg.h"
81 #include "SMESHGUI_ReorientFacesDlg.h"
82 #include "SMESHGUI_RevolutionDlg.h"
83 #include "SMESHGUI_RotationDlg.h"
84 #include "SMESHGUI_ScaleDlg.h"
85 #include "SMESHGUI_Selection.h"
86 #include "SMESHGUI_SewingDlg.h"
87 #include "SMESHGUI_SingleEditDlg.h"
88 #include "SMESHGUI_SmoothingDlg.h"
89 #include "SMESHGUI_SpinBox.h"
90 #include "SMESHGUI_SplitBiQuad.h"
91 #include "SMESHGUI_SymmetryDlg.h"
92 #include "SMESHGUI_TranslationDlg.h"
93 #include "SMESHGUI_TransparencyDlg.h"
94 #include "SMESHGUI_Utils.h"
95 #include "SMESHGUI_VTKUtils.h"
97 #include "SMESH_version.h"
99 #include "SMESH_ControlsDef.hxx"
100 #include "SMESH_Actor.h"
101 #include "SMESH_ActorUtils.h"
102 #include "SMESH_Client.hxx"
103 #include "SMESH_ScalarBarActor.h"
104 #include <SMESH_Comment.hxx>
105 #include "SMESH_TypeFilter.hxx"
107 // SALOME GUI includes
108 #include <LightApp_DataOwner.h>
109 #include <LightApp_NameDlg.h>
110 #include <LightApp_Preferences.h>
111 #include <LightApp_SelectionMgr.h>
112 #include <LightApp_UpdateFlags.h>
113 #include <QtxFontEdit.h>
114 #include <QtxPopupMgr.h>
115 #include <SALOME_ListIO.hxx>
116 #include <SUIT_Desktop.h>
117 #include <SUIT_FileDlg.h>
118 #include <SUIT_MessageBox.h>
119 #include <SUIT_OverrideCursor.h>
120 #include <SUIT_ResourceMgr.h>
121 #include <SUIT_Session.h>
122 #include <SVTK_ViewManager.h>
123 #include <SVTK_ViewModel.h>
124 #include <SVTK_ViewWindow.h>
125 #include <SalomeApp_Application.h>
126 #include <SalomeApp_CheckFileDlg.h>
127 #include <SalomeApp_DataObject.h>
128 #include <SalomeApp_Study.h>
129 #include <SalomeApp_Tools.h>
130 #include <VTKViewer_Algorithm.h>
132 #ifndef DISABLE_PLOT2DVIEWER
133 #include <SPlot2d_ViewModel.h>
134 #include <SPlot2d_Histogram.h>
138 #include <SALOMEconfig.h>
139 #include CORBA_CLIENT_HEADER(SALOMEDS_Attributes)
140 #include CORBA_CLIENT_HEADER(SMESH_MeshEditor)
141 #include CORBA_CLIENT_HEADER(SMESH_Measurements)
142 #include CORBA_CLIENT_HEADER(SMESH_Mesh)
145 // #define INCLUDE_MENUITEM_DEF // VSR commented ????????
146 #include <QApplication>
148 #include <QDialogButtonBox>
152 #include <QTextStream>
156 #include <boost/shared_ptr.hpp>
159 #include <vtkCallbackCommand.h>
160 #include <vtkCamera.h>
161 #include <vtkLookupTable.h>
162 #include <vtkPlane.h>
163 #include <vtkRenderer.h>
165 // SALOME KERNEL includes
166 #include <SALOMEDSClient_ClientFactory.hxx>
167 #include <SALOMEDSClient_IParameters.hxx>
168 #include <SALOMEDSClient_SComponent.hxx>
169 #include <SALOMEDSClient_StudyBuilder.hxx>
170 #include <SALOMEDS_Study.hxx>
171 #include <SALOMEDS_SObject.hxx>
172 #include "utilities.h"
175 #include <Standard_ErrorHandler.hxx>
176 #include <NCollection_DataMap.hxx>
177 #include <NCollection_DoubleMap.hxx>
179 #include <Basics_Utils.hxx>
181 // Below macro, when uncommented, switches on simplified (more performant) algorithm
182 // of auto-color picking up
183 #define SIMPLE_AUTOCOLOR
188 //=============================================================
189 void ImportMeshesFromFile(SMESH::SMESH_Gen_ptr theComponentMesh,
192 void ExportMeshToFile(int theCommandID);
194 void SetDisplayMode(int theCommandID, VTK::MarkerMap& theMarkerMap);
196 void SetDisplayEntity(int theCommandID);
198 int ActionToControl( int theID, bool theReversed = false );
200 void Control( int theCommandID );
203 //================================================================================
205 * \brief Reads meshes from file
207 //================================================================================
209 void ImportMeshesFromFile( SMESH::SMESH_Gen_ptr theComponentMesh,
213 std::string myExtension;
215 if ( theCommandID == SMESHOp::OpImportMED ||
216 theCommandID == SMESHOp::OpPopupImportMED ) {
217 filter.append( QObject::tr( "MED_FILES_FILTER" ) + " (*.*med)" );
218 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
220 else if ( theCommandID == SMESHOp::OpImportUNV ||
221 theCommandID == SMESHOp::OpPopupImportUNV ) {
222 filter.append( QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)" );
224 else if ( theCommandID == SMESHOp::OpImportDAT ||
225 theCommandID == SMESHOp::OpPopupImportDAT ) {
226 filter.append( QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)" );
228 else if ( theCommandID == SMESHOp::OpImportSTL ||
229 theCommandID == SMESHOp::OpPopupImportSTL ) {
230 filter.append( QObject::tr( "STL_FILES_FILTER" ) + " (*.stl)" );
232 else if ( theCommandID == SMESHOp::OpImportCGNS ||
233 theCommandID == SMESHOp::OpPopupImportCGNS ) {
234 filter.append( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
236 else if ( theCommandID == SMESHOp::OpImportSAUV ||
237 theCommandID == SMESHOp::OpPopupImportSAUV ) {
238 filter.append( QObject::tr( "SAUV_FILES_FILTER" ) + " (*.sauv *.sauve)" );
239 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
241 else if ( theCommandID == SMESHOp::OpImportGMF ||
242 theCommandID == SMESHOp::OpPopupImportGMF ) {
243 filter.append( QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" );
244 filter.append( QObject::tr( "GMF_BINARY_FILES_FILTER") + " (*.meshb)" );
247 QString anInitialPath = "";
248 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
249 anInitialPath = QDir::currentPath();
251 QStringList filenames;
252 bool toCreateGroups = true;
254 // if ( theCommandID == SMESHOp::OpImportGMF ) { // GMF
255 // SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg
256 // ( SMESHGUI::desktop(), true, QObject::tr("SMESH_REQUIRED_GROUPS"), true, true );
257 // fd->setWindowTitle( QObject::tr( "SMESH_IMPORT_MESH" ) );
258 // fd->setNameFilters( filter );
259 // fd->SetChecked( true );
261 // filenames << fd->selectedFile();
262 // toCreateGroups = fd->IsChecked();
268 filenames = SUIT_FileDlg::getOpenFileNames( SMESHGUI::desktop(),
271 QObject::tr( "SMESH_IMPORT_MESH" ) );
273 if ( filenames.count() > 0 )
275 SUIT_OverrideCursor wc;
276 _PTR(Study) aStudy = SMESH::getStudy();
279 QStringList anEntryList;
280 bool isEmpty = false;
281 for ( QStringList::ConstIterator it = filenames.begin(); it != filenames.end(); ++it )
283 QString filename = *it;
284 SMESH::mesh_array_var aMeshes = new SMESH::mesh_array;
286 switch ( theCommandID ) {
287 case SMESHOp::OpImportDAT:
288 case SMESHOp::OpPopupImportDAT:
290 // DAT format (currently unsupported)
291 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
292 arg( QObject::tr( "SMESH_ERR_NOT_SUPPORTED_FORMAT" ) ) );
295 case SMESHOp::OpImportUNV:
296 case SMESHOp::OpPopupImportUNV:
299 aMeshes->length( 1 );
300 aMeshes[0] = theComponentMesh->CreateMeshesFromUNV( filename.toUtf8().constData() );
301 if ( aMeshes[0]->_is_nil() )
302 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
303 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
306 case SMESHOp::OpImportMED:
307 case SMESHOp::OpPopupImportMED:
310 SMESH::DriverMED_ReadStatus res;
311 aMeshes = theComponentMesh->CreateMeshesFromMED( filename.toUtf8().constData(), res );
312 if ( res != SMESH::DRS_OK ) {
313 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
314 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
318 case SMESHOp::OpImportSTL:
319 case SMESHOp::OpPopupImportSTL:
322 aMeshes->length( 1 );
323 aMeshes[0] = theComponentMesh->CreateMeshesFromSTL( filename.toUtf8().constData() );
324 if ( aMeshes[0]->_is_nil() ) {
325 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
326 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
330 case SMESHOp::OpImportCGNS:
331 case SMESHOp::OpPopupImportCGNS:
334 SMESH::DriverMED_ReadStatus res;
335 aMeshes = theComponentMesh->CreateMeshesFromCGNS( filename.toUtf8().constData(), res );
336 if ( res != SMESH::DRS_OK ) {
337 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
338 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
342 case SMESHOp::OpImportSAUV:
343 case SMESHOp::OpPopupImportSAUV:
346 SMESH::DriverMED_ReadStatus res;
347 aMeshes = theComponentMesh->CreateMeshesFromSAUV( filename.toUtf8().constData(), res );
348 if ( res != SMESH::DRS_OK ) {
349 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
350 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
354 case SMESHOp::OpImportGMF:
355 case SMESHOp::OpPopupImportGMF:
358 SMESH::ComputeError_var res;
359 aMeshes->length( 1 );
360 aMeshes[0] = theComponentMesh->CreateMeshesFromGMF( filename.toUtf8().constData(),
363 if ( res->code != SMESH::DRS_OK ) {
364 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
365 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res->code ).toLatin1().data() ) ) );
366 if ( strlen( res->comment.in() ) > 0 ) {
367 errors.back() += ": ";
368 errors.back() += res->comment.in();
375 catch ( const SALOME::SALOME_Exception& S_ex ) {
376 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
377 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
380 for ( int i = 0, iEnd = aMeshes->length(); i < iEnd; i++ )
382 _PTR(SObject) aMeshSO = SMESH::FindSObject( aMeshes[i] );
384 _PTR(StudyBuilder) aBuilder = aStudy->NewBuilder();
385 _PTR(AttributePixMap) aPixmap = aBuilder->FindOrCreateAttribute( aMeshSO, "AttributePixMap" );
386 aPixmap->SetPixMap( "ICON_SMESH_TREE_MESH_IMPORTED" );
387 if ( theCommandID == SMESHOp::OpImportUNV ) // mesh names aren't taken from the file for UNV import
388 SMESH::SetName( aMeshSO, QFileInfo(filename).fileName() );
390 anEntryList.append( aMeshSO->GetID().c_str() );
398 // update Object browser
399 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
401 // browse to the published meshes
402 if( LightApp_Application* anApp =
403 dynamic_cast<LightApp_Application*>( SUIT_Session::session()->activeApplication() ) )
404 anApp->browseObjects( anEntryList );
406 // show Error message box if there were errors
407 if ( errors.count() > 0 ) {
408 SUIT_MessageBox::critical( SMESHGUI::desktop(),
409 QObject::tr( "SMESH_ERROR" ),
410 QObject::tr( "SMESH_IMPORT_ERRORS" ) + "\n" + errors.join( "\n" ) );
413 // show warning message box, if some imported mesh is empty
415 SUIT_MessageBox::warning( SMESHGUI::desktop(),
416 QObject::tr( "SMESH_WRN_WARNING" ),
417 QObject::tr( "SMESH_DRS_SOME_EMPTY" ) );
422 //================================================================================
424 * \brief Export selected meshes or groups into a file
426 //================================================================================
428 void ExportMeshToFile( int theCommandID )
430 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
431 SALOME_ListIO selected;
433 aSel->selectedObjects( selected );
435 const bool isDAT = ( theCommandID == SMESHOp::OpExportDAT ||
436 theCommandID == SMESHOp::OpPopupExportDAT );
437 const bool isMED = ( theCommandID == SMESHOp::OpExportMED ||
438 theCommandID == SMESHOp::OpPopupExportMED );
439 const bool isUNV = ( theCommandID == SMESHOp::OpExportUNV ||
440 theCommandID == SMESHOp::OpPopupExportUNV );
441 const bool isSTL = ( theCommandID == SMESHOp::OpExportSTL ||
442 theCommandID == SMESHOp::OpPopupExportSTL );
443 const bool isCGNS= ( theCommandID == SMESHOp::OpExportCGNS ||
444 theCommandID == SMESHOp::OpPopupExportCGNS );
445 const bool isSAUV= ( theCommandID == SMESHOp::OpExportSAUV ||
446 theCommandID == SMESHOp::OpPopupExportSAUV );
447 const bool isGMF = ( theCommandID == SMESHOp::OpExportGMF ||
448 theCommandID == SMESHOp::OpPopupExportGMF );
450 const bool multiMeshSupported = ( isMED || isCGNS ); // file can hold several meshes
451 if ( selected.Extent() == 0 || ( selected.Extent() > 1 && !multiMeshSupported ))
453 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
454 bool aCheckWarn = true;
456 aCheckWarn = resMgr->booleanValue( "SMESH", "show_warning", false );
457 // get mesh object from selection and check duplication of their names
458 bool hasDuplicatedMeshNames = false;
459 QList< QPair< SMESH::SMESH_IDSource_var, QString > > aMeshList;
460 QList< QPair< SMESH::SMESH_IDSource_var, QString > >::iterator aMeshIter;
461 SALOME_ListIteratorOfListIO It( selected );
462 for( ; It.More(); It.Next() )
464 Handle(SALOME_InteractiveObject) anIObject = It.Value();
465 SMESH::SMESH_IDSource_var aMeshItem =
466 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIObject);
467 if ( aMeshItem->_is_nil() ) {
468 SUIT_MessageBox::warning( SMESHGUI::desktop(),
469 QObject::tr( "SMESH_WRN_WARNING" ),
470 QObject::tr( "SMESH_BAD_MESH_SELECTION" ));
473 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( aMeshItem );
474 if ( aCheckWarn && !aGroup->_is_nil() )
476 QMessageBox msgBox(SUIT_MessageBox::Warning,
477 QObject::tr("SMESH_WRN_WARNING"),
478 QObject::tr("SMESH_EXPORT_ONLY_GPOUP"),
479 QMessageBox::StandardButton::NoButton,
480 SMESHGUI::desktop());
481 QCheckBox dontShowCheckBox(QObject::tr("SMESH_WRN_SHOW_DLG_CHECKBOX"));
482 msgBox.addButton(QMessageBox::Ok);
483 msgBox.addButton(QMessageBox::Cancel);
484 msgBox.setDefaultButton(QMessageBox::Cancel);
485 QGridLayout* lt = qobject_cast<QGridLayout*>(msgBox.layout());
486 QDialogButtonBox* btnbox = msgBox.findChild<QDialogButtonBox*>();
487 lt->addWidget(&dontShowCheckBox, lt->rowCount(), lt->columnCount()-1, lt->rowCount(), lt->columnCount());
488 lt->addWidget(btnbox, lt->rowCount(), 0, lt->rowCount(), lt->columnCount());
489 if ( msgBox.exec() != QMessageBox::Ok )
492 if ( dontShowCheckBox.checkState() == Qt::Checked && resMgr )
493 resMgr->setValue( "SMESH", "show_warning", false);
496 QString aMeshName = anIObject->getName();
498 // check for name duplications
499 if ( !hasDuplicatedMeshNames )
500 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
501 if( aMeshName == (*aMeshIter).second ) {
502 hasDuplicatedMeshNames = true;
507 aMeshList.append( QPair< SMESH::SMESH_IDSource_var, QString >( aMeshItem, aMeshName ) );
510 if( hasDuplicatedMeshNames && isMED ) {
511 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
512 QObject::tr("SMESH_WRN_WARNING"),
513 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_MESH_NAMES"),
514 QObject::tr("SMESH_BUT_YES"),
515 QObject::tr("SMESH_BUT_NO"), 0, 1);
520 aMeshIter = aMeshList.begin();
521 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
522 SMESH::SMESH_Mesh_var aMesh = aMeshOrGroup->GetMesh();
523 QString aMeshName = (*aMeshIter).second;
525 if ( isMED || isCGNS || isSAUV ) // formats where group names must be unique
527 // check for equal group names within each mesh
528 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
529 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
530 if ( !aMeshItem->_is_nil() && aMeshItem->HasDuplicatedGroupNamesMED()) {
531 int aRet = SUIT_MessageBox::warning
532 (SMESHGUI::desktop(),
533 QObject::tr("SMESH_WRN_WARNING"),
534 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_GRP").arg((*aMeshIter).second),
535 QObject::tr("SMESH_BUT_YES"),
536 QObject::tr("SMESH_BUT_NO"), 0, 1);
543 // Warn the user about presence of not supported elements
545 std::vector< SMESH::EntityType > notSupportedElemTypes, presentNotSupported;
549 notSupportedElemTypes.push_back( SMESH::Entity_0D );
550 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
555 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
556 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
557 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
558 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
559 notSupportedElemTypes.push_back( SMESH::Entity_Pyramid );
560 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
561 notSupportedElemTypes.push_back( SMESH::Entity_0D );
562 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
567 notSupportedElemTypes.push_back( SMESH::Entity_Edge );
568 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Edge );
569 notSupportedElemTypes.push_back( SMESH::Entity_0D );
570 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
575 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
580 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
581 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Triangle );
582 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Quadrangle );
583 notSupportedElemTypes.push_back( SMESH::Entity_TriQuad_Hexa );
584 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
585 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
586 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
587 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
592 notSupportedElemTypes.push_back( SMESH::Entity_0D );
593 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
594 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
595 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Pyramid );
596 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Penta );
597 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Penta );
598 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
599 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
600 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
601 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
603 if ( ! notSupportedElemTypes.empty() )
605 SMESH::long_array_var nbElems = aMeshOrGroup->GetMeshInfo();
606 for ( size_t iType = 0; iType < notSupportedElemTypes.size(); ++iType )
607 if ( nbElems[ notSupportedElemTypes[ iType ]] > 0 )
608 presentNotSupported.push_back( notSupportedElemTypes[ iType ]);
610 if ( !presentNotSupported.empty() )
613 const char* typeMsg[] = {
614 "SMESH_NODES", "SMESH_ELEMS0D","SMESH_EDGES","SMESH_QUADRATIC_EDGES",
615 "SMESH_TRIANGLES", "SMESH_QUADRATIC_TRIANGLES", "SMESH_BIQUADRATIC_TRIANGLES",
616 "SMESH_QUADRANGLES","SMESH_QUADRATIC_QUADRANGLES", "SMESH_BIQUADRATIC_QUADRANGLES",
617 "SMESH_POLYGONS","SMESH_QUADRATIC_POLYGONS",
618 "SMESH_TETRAHEDRA","SMESH_QUADRATIC_TETRAHEDRONS","SMESH_PYRAMIDS",
619 "SMESH_QUADRATIC_PYRAMIDS","SMESH_HEXAHEDRA","SMESH_QUADRATIC_HEXAHEDRONS",
620 "SMESH_TRIQUADRATIC_HEXAHEDRONS","SMESH_PENTAHEDRA","SMESH_QUADRATIC_PENTAHEDRONS",
621 "SMESH_BIQUADRATIC_PENTAHEDRONS",
622 "SMESH_OCTAHEDRA","SMESH_POLYEDRONS","SMESH_QUADRATIC_POLYEDRONS","SMESH_BALLS"
624 // is typeMsg complete? (compilation failure mains that enum SMDSAbs_EntityType changed)
625 const int nbTypes = sizeof( typeMsg ) / sizeof( const char* );
626 int _assert[( nbTypes == SMESH::Entity_Last ) ? 2 : -1 ]; _assert[0]=_assert[1]=0;
628 QString andStr = " " + QObject::tr("SMESH_AND") + " ", comma(", ");
629 for ( size_t iType = 0; iType < presentNotSupported.size(); ++iType ) {
630 typeNames += QObject::tr( typeMsg[ presentNotSupported[ iType ]]);
631 if ( iType != presentNotSupported.size() - 1 )
632 typeNames += ( iType == presentNotSupported.size() - 2 ) ? andStr : comma;
634 int aRet = SUIT_MessageBox::warning
635 (SMESHGUI::desktop(),
636 QObject::tr("SMESH_WRN_WARNING"),
637 QObject::tr("EXPORT_NOT_SUPPORTED").arg(aMeshName).arg(format).arg(typeNames),
638 QObject::tr("SMESH_BUT_YES"),
639 QObject::tr("SMESH_BUT_NO"), 0, 1);
644 // Get parameters of export operation
647 int aFormat =-1; // for MED version used for write
648 bool isOkToWrite = true; // to check MED file version compatibility before adding a mesh in an existing file
650 // Init the parameters with the default values
651 bool aIsASCII_STL = true;
652 bool toCreateGroups = false;
654 toCreateGroups = resMgr->booleanValue( "SMESH", "auto_groups", false );
655 bool toOverwrite = true;
656 bool toFindOutDim = true;
657 double zTol = resMgr ? resMgr->doubleValue( "SMESH", "med_ztolerance", 0. ) : 0.;
659 QString aFilter, aTitle = QObject::tr("SMESH_EXPORT_MESH");
660 QString anInitialPath = "";
661 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
662 anInitialPath = QDir::currentPath();
664 QList< QPair< GEOM::ListOfFields_var, QString > > aFieldList;
666 // Get a file name to write in and additional options
667 if ( isUNV || isDAT || isGMF ) // Export w/o options
670 aFilter = QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)";
672 aFilter = QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)";
674 aFilter = QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" +
675 ";;" + QObject::tr( "GMF_BINARY_FILES_FILTER" ) + " (*.meshb)";
676 if ( anInitialPath.isEmpty() ) anInitialPath = SUIT_FileDlg::getLastVisitedPath();
677 aFilename = SUIT_FileDlg::getFileName(SMESHGUI::desktop(),
678 anInitialPath + QString("/") + aMeshName,
679 aFilter, aTitle, false);
681 else if ( isCGNS )// Export to CGNS
683 const char* theByTypeResource = "cgns_group_elems_by_type";
684 toCreateGroups = SMESHGUI::resourceMgr()->booleanValue( "SMESH", theByTypeResource, false );
686 QStringList checkBoxes;
687 checkBoxes << QObject::tr("CGNS_EXPORT_ELEMS_BY_TYPE");
689 SalomeApp_CheckFileDlg* fd =
690 new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true );
691 fd->setWindowTitle( aTitle );
692 fd->setNameFilter( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
693 if ( !anInitialPath.isEmpty() )
694 fd->setDirectory( anInitialPath );
695 fd->selectFile(aMeshName);
696 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
697 fd->setValidator( fv );
698 fd->SetChecked( toCreateGroups, 0 );
701 aFilename = fd->selectedFile();
702 toOverwrite = fv->isOverwrite(aFilename);
703 toCreateGroups = fd->IsChecked(0);
704 SMESHGUI::resourceMgr()->setValue("SMESH", theByTypeResource, toCreateGroups );
708 else if ( isSTL ) // Export to STL
710 QMap<QString, int> aFilterMap;
711 aFilterMap.insert( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)", 1 );
712 aFilterMap.insert( QObject::tr( "STL_BIN_FILES_FILTER" ) + " (*.stl)", 0 );
715 QMap<QString, int>::const_iterator it = aFilterMap.begin();
716 for ( ; it != aFilterMap.end(); ++it )
717 filters.push_back( it.key() );
719 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
720 fd->setWindowTitle( aTitle );
721 fd->setNameFilters( filters );
722 fd->selectNameFilter( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
723 if ( !anInitialPath.isEmpty() )
724 fd->setDirectory( anInitialPath );
725 fd->selectFile(aMeshName);
729 aFilename = fd->selectedFile();
730 aIsASCII_STL = (aFilterMap[fd->selectedNameFilter()]) == 1 ? true: false;
735 else if ( isMED || isSAUV ) // Export to MED or SAUV
737 int defaultVersion = 0;
738 QMap<QString, int> aFilterMap;
740 //filters << QObject::tr( "MED_FILES_FILTER" ) + " (*.med)";
741 //QString vmed (aMesh->GetVersionString(-1, 2));
742 SMESH::long_array_var mvok = aMesh->GetMEDVersionsCompatibleForAppend();
743 if ( mvok->length() > 0)
744 defaultVersion = mvok[0]; // the current version to set the default filter on it
745 for ( CORBA::ULong i = 0; i < mvok->length(); ++i )
747 QString vs = (char*)( SMESH_Comment( mvok[i]/10 ) << "." << mvok[i]%10 );
748 MESSAGE("MED version: " << vs.toStdString());
749 aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( vs ) + " (*.med)", mvok[i]);
753 aFilterMap.insert("All files (*)", -1 );
754 aFilterMap.insert("SAUV files (*.sauv)", defaultVersion ); // 0 = default filter (defaultVersion)
755 aFilterMap.insert("SAUV files (*.sauve)", -1 );
758 QMap<QString, int>::const_iterator it = aFilterMap.begin();
759 QString aDefaultFilter = it.key();
760 for ( ; it != aFilterMap.end(); ++it ) {
761 filters.push_back( it.key() );
762 if (it.value() == defaultVersion) // explicit default for MED = current MED version
763 aDefaultFilter = it.key();
765 QStringList checkBoxes;
766 checkBoxes << QObject::tr("SMESH_AUTO_GROUPS") << QObject::tr("SMESH_AUTO_DIM");
768 SMESHGUI_FieldSelectorWdg* fieldSelWdg = new SMESHGUI_FieldSelectorWdg();
769 QList< QWidget* > wdgList;
770 if ( fieldSelWdg->GetAllFields( aMeshList, aFieldList ))
771 wdgList.append( fieldSelWdg );
773 QWidget* zTolWdg = new QWidget();
774 QCheckBox* zTolCheck = new QCheckBox( QObject::tr( "SMESH_ZTOLERANCE" ), zTolWdg );
775 SMESHGUI_SpinBox* zTolSpin = new SMESHGUI_SpinBox( zTolWdg );
776 QHBoxLayout* zTolLayout = new QHBoxLayout( zTolWdg );
777 zTolLayout->addWidget( zTolCheck );
778 zTolLayout->addWidget( zTolSpin );
779 zTolLayout->setMargin( 0 );
780 zTolSpin->RangeStepAndValidator( 0, 1e+100, 1., "length_precision" );
781 zTolSpin->setValue( zTol );
782 //QObject::connect( zTolCheck, SIGNAL( stateChanged(int)), zTolSpin, SLOT( setEnabled(bool)));
783 zTolCheck->setChecked( resMgr->booleanValue( "SMESH", "enable_ztolerance", false ));
784 wdgList.append( zTolWdg );
786 SalomeApp_CheckFileDlg* fd =
787 new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true, wdgList );
788 fd->setWindowTitle( aTitle );
789 fd->setNameFilters( filters );
790 fd->selectNameFilter( aDefaultFilter );
791 fd->SetChecked( toCreateGroups, 0 );
792 fd->SetChecked( toFindOutDim, 1 );
793 if ( !anInitialPath.isEmpty() )
794 fd->setDirectory( anInitialPath );
795 fd->selectFile(aMeshName);
798 QListView *lview = fd->findChild<QListView*>("listView");
800 lview->setMinimumHeight(200);
802 QTreeView *tview = fd->findChild<QTreeView*>("treeView");
804 tview->setMinimumHeight(200);
807 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
808 fd->setValidator( fv );
813 //MESSAGE("******* Loop on file dialog ***********");
816 aFilename = fd->selectedFile();
818 aFilename = QString::null;
821 aFormat = aFilterMap[fd->selectedNameFilter()];
822 //MESSAGE("selected version: " << aFormat << " file: " << aFilename.toUtf8().constData());
823 toOverwrite = fv->isOverwrite(aFilename);
824 //MESSAGE("toOverwrite:" << toOverwrite);
826 if ( !aFilename.isEmpty() ) {
828 // append is only possible if the existing file format is compatible
829 bool isVersionOk = SMESHGUI::GetSMESHGen()->CheckWriteCompatibility( aFilename.toUtf8().constData() );
830 MESSAGE("Append check, isVersionOk:" << isVersionOk);
831 if ( !isVersionOk ) {
832 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
833 QObject::tr("SMESH_WRN_WARNING"),
834 QObject::tr("SMESH_EXPORT_MED_VERSION_COLLISION").arg(aFilename),
835 QObject::tr("SMESH_BUT_YES"),
836 QObject::tr("SMESH_BUT_NO"), 0, 1);
840 //MESSAGE("incompatible MED file version for add, overwrite accepted");
846 //MESSAGE("incompatible MED file version for add, overwrite refused");
849 QStringList aMeshNamesCollisionList;
850 SMESH::string_array_var aMeshNames = SMESHGUI::GetSMESHGen()->GetMeshNames( aFilename.toUtf8().constData() );
851 for( int i = 0, n = aMeshNames->length(); i < n; i++ ) {
852 QString anExistingMeshName( aMeshNames[ i ] );
853 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
854 QString anExportMeshName = (*aMeshIter).second;
855 if( anExportMeshName == anExistingMeshName ) {
856 aMeshNamesCollisionList.append( anExportMeshName );
861 if( !aMeshNamesCollisionList.isEmpty() ) {
863 QString aMeshNamesCollisionString = aMeshNamesCollisionList.join( ", " );
864 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
865 QObject::tr("SMESH_WRN_WARNING"),
866 QObject::tr("SMESH_EXPORT_MED_MESH_NAMES_COLLISION").arg(aMeshNamesCollisionString),
867 QObject::tr("SMESH_BUT_YES"),
868 QObject::tr("SMESH_BUT_NO"),
869 QObject::tr("SMESH_BUT_CANCEL"), 0, 2);
870 MESSAGE("answer collision name " << aRet);
881 toCreateGroups = fd->IsChecked(0);
882 toFindOutDim = fd->IsChecked(1);
883 zTol = zTolCheck->isChecked() ? zTolSpin->value() : -1;
884 fieldSelWdg->GetSelectedFields();
885 if ( resMgr ) resMgr->setValue( "SMESH", "enable_ztolerance", zTolCheck->isChecked() );
887 if ( !fieldSelWdg->parent() )
889 if ( !zTolWdg->parent() )
900 if ( !aFilename.isEmpty() ) {
901 // Check whether the file already exists and delete it if yes
902 QFile aFile( aFilename );
903 if ( aFile.exists() && toOverwrite )
905 SUIT_OverrideCursor wc;
908 // Renumbering is not needed since SMDS redesign in V6.2.0 (Nov 2010)
909 // bool Renumber = false;
910 // // PAL 14172 : Check of we have to renumber or not from the preferences before export
912 // Renumber= resMgr->booleanValue("renumbering");
914 // SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
915 // aMeshEditor->RenumberNodes();
916 // aMeshEditor->RenumberElements();
917 // if ( SMESHGUI::automaticUpdate() )
918 // SMESH::UpdateView();
920 if ( isMED && isOkToWrite)
922 MESSAGE("OK to write MED file "<< aFilename.toUtf8().constData());
923 aMeshIter = aMeshList.begin();
924 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
926 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
927 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
928 const GEOM::ListOfFields& fields = aFieldList[ aMeshIndex ].first.in();
929 const QString& geoAssFields = aFieldList[ aMeshIndex ].second;
930 const bool hasFields = ( fields.length() || !geoAssFields.isEmpty() );
931 if ( !hasFields && aMeshOrGroup->_is_equivalent( aMeshItem ) && zTol < 0 )
932 aMeshItem->ExportMED( aFilename.toUtf8().data(), toCreateGroups, aFormat,
933 toOverwrite && aMeshIndex == 0, toFindOutDim );
935 aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toUtf8().data(),
936 toCreateGroups, aFormat,
937 toOverwrite && aMeshIndex == 0, toFindOutDim,
938 fields, geoAssFields.toLatin1().data(), zTol );
943 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ )
945 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
946 if( !aMeshItem->_is_nil() )
947 aMeshItem->ExportSAUV( aFilename.toUtf8().data(), toCreateGroups );
952 if ( aMeshOrGroup->_is_equivalent( aMesh ))
953 aMesh->ExportDAT( aFilename.toUtf8().data() );
955 aMesh->ExportPartToDAT( aMeshOrGroup, aFilename.toUtf8().data() );
959 if ( aMeshOrGroup->_is_equivalent( aMesh ))
960 aMesh->ExportUNV( aFilename.toUtf8().data() );
962 aMesh->ExportPartToUNV( aMeshOrGroup, aFilename.toUtf8().data() );
966 if ( aMeshOrGroup->_is_equivalent( aMesh ))
967 aMesh->ExportSTL( aFilename.toUtf8().data(), aIsASCII_STL );
969 aMesh->ExportPartToSTL( aMeshOrGroup, aFilename.toUtf8().data(), aIsASCII_STL );
973 aMeshIter = aMeshList.begin();
974 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
976 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
977 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
978 aMeshItem->ExportCGNS( aMeshOrGroup,
979 aFilename.toUtf8().data(),
980 toOverwrite && aMeshIndex == 0,
986 toCreateGroups = true;
987 aMesh->ExportGMF( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups );
990 catch (const SALOME::SALOME_Exception& S_ex){
992 SUIT_MessageBox::warning(SMESHGUI::desktop(),
993 QObject::tr("SMESH_WRN_WARNING"),
994 QObject::tr("SMESH_EXPORT_FAILED") + SalomeApp_Tools::ExceptionToString(S_ex));
1000 inline void InverseEntityMode(unsigned int& theOutputMode,
1001 unsigned int theMode)
1003 bool anIsNotPresent = ~theOutputMode & theMode;
1005 theOutputMode |= theMode;
1007 theOutputMode &= ~theMode;
1010 void SetDisplayEntity(int theCommandID)
1012 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1013 SALOME_ListIO selected;
1015 aSel->selectedObjects( selected );
1017 if ( selected.Extent() >= 1 ) {
1018 SUIT_OverrideCursor wc;
1019 SALOME_ListIteratorOfListIO It( selected );
1020 for( ; It.More(); It.Next()){
1021 Handle(SALOME_InteractiveObject) IObject = It.Value();
1022 if(IObject->hasEntry()){
1023 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1024 unsigned int aMode = anActor->GetEntityMode();
1025 switch(theCommandID){
1026 case SMESHOp::OpDE0DElements: InverseEntityMode(aMode,SMESH_Actor::e0DElements); break;
1027 case SMESHOp::OpDEEdges: InverseEntityMode(aMode,SMESH_Actor::eEdges); break;
1028 case SMESHOp::OpDEFaces: InverseEntityMode(aMode,SMESH_Actor::eFaces); break;
1029 case SMESHOp::OpDEVolumes: InverseEntityMode(aMode,SMESH_Actor::eVolumes); break;
1030 case SMESHOp::OpDEBalls: InverseEntityMode(aMode,SMESH_Actor::eBallElem); break;
1031 case SMESHOp::OpDEAllEntity: aMode = SMESH_Actor::eAllEntity; break;
1034 anActor->SetEntityMode(aMode);
1043 SalomeApp_Application* app =
1044 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1048 LightApp_SelectionMgr* aSel = app->selectionMgr();
1049 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1050 if ( !aSel || !appStudy )
1053 SALOME_ListIO selected;
1054 aSel->selectedObjects( selected );
1055 if ( selected.IsEmpty() )
1058 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1060 _PTR(Study) aStudy = appStudy->studyDS();
1061 _PTR(SObject) aMainSObject = aStudy->FindObjectID( anIObject->getEntry() );
1062 SMESH::SMESH_Mesh_var aMainObject = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1063 if ( aMainObject->_is_nil() )
1066 SUIT_OverrideCursor wc;
1068 aMainObject->SetAutoColor( true ); // mesh groups are re-colored here
1070 QList<SALOMEDS::Color> aReservedColors;
1072 SMESH::ListOfGroups aListOfGroups = *aMainObject->GetGroups();
1073 for ( int i = 0, n = aListOfGroups.length(); i < n; i++ )
1075 SMESH::SMESH_GroupBase_var aGroupObject = aListOfGroups[i];
1077 #ifdef SIMPLE_AUTOCOLOR // simplified algorithm for auto-colors
1078 SALOMEDS::Color aColor = SMESHGUI::getPredefinedUniqueColor();
1079 #else // old algorithm for auto-colors
1080 SALOMEDS::Color aColor = SMESHGUI::getUniqueColor( aReservedColors );
1081 aReservedColors.append( aColor );
1082 #endif // SIMPLE_AUTOCOLOR
1083 aGroupObject->SetColor( aColor );
1085 _PTR(SObject) aGroupSObject = SMESH::FindSObject(aGroupObject);
1086 if ( aGroupSObject ) {
1089 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry(aGroupSObject->GetID().c_str())) {
1090 switch ( aGroupObject->GetType ()) {
1092 anActor->SetNodeColor( aColor.R, aColor.G, aColor.B ); break;
1094 anActor->SetEdgeColor( aColor.R, aColor.G, aColor.B ); break;
1096 anActor->Set0DColor( aColor.R, aColor.G, aColor.B ); break;
1098 anActor->SetBallColor( aColor.R, aColor.G, aColor.B ); break;
1100 SMESH::GetColor("SMESH", "volume_color", c, delta, "255,0,170|-100");
1101 anActor->SetVolumeColor( aColor.R, aColor.G, aColor.B, delta ); break;
1104 SMESH::GetColor("SMESH", "fill_color", c, delta, "0,170,255|-100");
1105 anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B, delta );
1111 SMESH::RepaintCurrentView();
1114 void OverallMeshQuality()
1116 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1117 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1118 SALOME_ListIO selected;
1120 aSel->selectedObjects( selected );
1122 if ( selected.IsEmpty() ) return;
1123 SALOME_ListIteratorOfListIO It( selected );
1124 for ( ; It.More(); It.Next() ) {
1125 SMESHGUI_CtrlInfoDlg* ctrlDlg = new SMESHGUI_CtrlInfoDlg( SMESHGUI::desktop() );
1126 ctrlDlg->showInfo( It.Value() );
1131 QString functorToString( SMESH::Controls::FunctorPtr f )
1133 QString type = QObject::tr( "UNKNOWN_CONTROL" );
1134 if ( dynamic_cast< SMESH::Controls::Volume* >( f.get() ) )
1135 type = QObject::tr( "VOLUME_3D_ELEMENTS" );
1136 else if ( dynamic_cast< SMESH::Controls::MaxElementLength2D* >( f.get() ) )
1137 type = QObject::tr( "MAX_ELEMENT_LENGTH_2D" );
1138 else if ( dynamic_cast< SMESH::Controls::MaxElementLength3D* >( f.get() ) )
1139 type = QObject::tr( "MAX_ELEMENT_LENGTH_3D" );
1140 else if ( dynamic_cast< SMESH::Controls::MinimumAngle* >( f.get() ) )
1141 type = QObject::tr( "MINIMUMANGLE_ELEMENTS" );
1142 else if ( dynamic_cast< SMESH::Controls::AspectRatio* >( f.get() ) )
1143 type = QObject::tr( "ASPECTRATIO_ELEMENTS" );
1144 else if ( dynamic_cast< SMESH::Controls::AspectRatio3D* >( f.get() ) )
1145 type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" );
1146 else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) )
1147 type = QObject::tr( "WARP_ELEMENTS" );
1148 else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) )
1149 type = QObject::tr( "TAPER_ELEMENTS" );
1150 else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) )
1151 type = QObject::tr( "SKEW_ELEMENTS" );
1152 else if ( dynamic_cast< SMESH::Controls::Area* >( f.get() ) )
1153 type = QObject::tr( "AREA_ELEMENTS" );
1154 else if ( dynamic_cast< SMESH::Controls::Length* >( f.get() ) )
1155 type = QObject::tr( "LENGTH_EDGES" );
1156 else if ( dynamic_cast< SMESH::Controls::Length2D* >( f.get() ) )
1157 type = QObject::tr( "LENGTH2D_EDGES" );
1158 else if ( dynamic_cast< SMESH::Controls::Deflection2D* >( f.get() ) )
1159 type = QObject::tr( "DEFLECTION2D_FACES" );
1160 else if ( dynamic_cast< SMESH::Controls::MultiConnection* >( f.get() ) )
1161 type = QObject::tr( "MULTI_BORDERS" );
1162 else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) )
1163 type = QObject::tr( "MULTI2D_BORDERS" );
1164 else if ( dynamic_cast< SMESH::Controls::FreeNodes* >( f.get() ) )
1165 type = QObject::tr( "FREE_NODES" );
1166 else if ( dynamic_cast< SMESH::Controls::FreeEdges* >( f.get() ) )
1167 type = QObject::tr( "FREE_EDGES" );
1168 else if ( dynamic_cast< SMESH::Controls::FreeBorders* >( f.get() ) )
1169 type = QObject::tr( "FREE_BORDERS" );
1170 else if ( dynamic_cast< SMESH::Controls::FreeFaces* >( f.get() ) )
1171 type = QObject::tr( "FREE_FACES" );
1172 else if ( dynamic_cast< SMESH::Controls::BareBorderVolume* >( f.get() ) )
1173 type = QObject::tr( "BARE_BORDER_VOLUME" );
1174 else if ( dynamic_cast< SMESH::Controls::BareBorderFace* >( f.get() ) )
1175 type = QObject::tr( "BARE_BORDER_FACE" );
1176 else if ( dynamic_cast< SMESH::Controls::OverConstrainedVolume* >( f.get() ) )
1177 type = QObject::tr( "OVER_CONSTRAINED_VOLUME" );
1178 else if ( dynamic_cast< SMESH::Controls::OverConstrainedFace* >( f.get() ) )
1179 type = QObject::tr( "OVER_CONSTRAINED_FACE" );
1180 else if ( dynamic_cast< SMESH::Controls::CoincidentNodes* >( f.get() ) )
1181 type = QObject::tr( "EQUAL_NODE" );
1182 else if ( dynamic_cast< SMESH::Controls::CoincidentElements1D* >( f.get() ) )
1183 type = QObject::tr( "EQUAL_EDGE" );
1184 else if ( dynamic_cast< SMESH::Controls::CoincidentElements2D* >( f.get() ) )
1185 type = QObject::tr( "EQUAL_FACE" );
1186 else if ( dynamic_cast< SMESH::Controls::CoincidentElements3D* >( f.get() ) )
1187 type = QObject::tr( "EQUAL_VOLUME" );
1188 else if ( dynamic_cast< SMESH::Controls::NodeConnectivityNumber* >( f.get() ) )
1189 type = QObject::tr( "NODE_CONNECTIVITY_NB" );
1193 void SaveDistribution()
1195 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1196 SALOME_ListIO selected;
1198 aSel->selectedObjects( selected );
1200 if ( selected.Extent() == 1 ) {
1201 Handle(SALOME_InteractiveObject) anIO = selected.First();
1202 if ( anIO->hasEntry() ) {
1203 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1205 anActor->GetScalarBarActor() &&
1206 anActor->GetControlMode() != SMESH_Actor::eNone )
1208 SMESH_ScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor();
1209 SMESH::Controls::FunctorPtr aFunctor = anActor->GetFunctor();
1210 if ( aScalarBarActor && aFunctor ) {
1211 SMESH::Controls::NumericalFunctor* aNumFun =
1212 dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
1214 std::vector<int> elements;
1215 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
1216 if ( mesh->_is_nil() ) {
1217 SMESH::SMESH_IDSource_var idSource =
1218 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
1219 if ( !idSource->_is_nil() )
1221 SMESH::long_array_var ids = idSource->GetIDs();
1222 elements.resize( ids->length() );
1223 for ( unsigned i = 0; i < elements.size(); ++i )
1224 elements[i] = ids[i];
1227 int nbIntervals = aScalarBarActor->GetMaximumNumberOfColors();
1228 vtkLookupTable* lookupTable =
1229 static_cast<vtkLookupTable*>(aScalarBarActor->GetLookupTable());
1230 double * minmax = lookupTable->GetRange();
1231 bool isLogarithmic = lookupTable->GetScale() == VTK_SCALE_LOG10;
1232 std::vector<int> nbEvents;
1233 std::vector<double> funValues;
1234 aNumFun->GetHistogram( nbIntervals, nbEvents, funValues,
1235 elements, minmax, isLogarithmic );
1236 QString anInitialPath = "";
1237 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
1238 anInitialPath = QDir::currentPath();
1239 QString aMeshName = anIO->getName();
1241 filter.append( QObject::tr( "TEXT_FILES_FILTER" ) + " (*.txt)" );
1242 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
1243 QString aFilename = anInitialPath + "/" + aMeshName + "_" +
1244 functorToString( aFunctor ).toLower().simplified().replace( QRegExp( " |-" ), "_" ) + ".txt";
1245 aFilename = SUIT_FileDlg::getFileName( SMESHGUI::desktop(),
1248 QObject::tr( "SMESH_SAVE_DISTRIBUTION" ),
1250 if ( !aFilename.isEmpty() ) {
1251 QFile f( aFilename );
1252 if ( f.open( QFile::WriteOnly | QFile::Truncate ) ) {
1253 QTextStream out( &f );
1254 out << "# Mesh: " << aMeshName << endl;
1255 out << "# Control: " << functorToString( aFunctor ) << endl;
1257 out.setFieldWidth( 10 );
1258 for ( int i = 0; i < (int)qMin( nbEvents.size(), funValues.size()-1 ); i++ )
1259 out << funValues[i] << "\t" << funValues[i+1] << "\t" << nbEvents[i] << endl;
1270 void ShowElement( int theCommandID )
1272 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1273 SALOME_ListIO selected;
1275 aSel->selectedObjects( selected );
1277 if ( selected.Extent() == 1 ) {
1278 Handle(SALOME_InteractiveObject) anIO = selected.First();
1279 if ( anIO->hasEntry() ) {
1280 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1282 anActor->GetScalarBarActor() &&
1283 anActor->GetControlMode() != SMESH_Actor::eNone )
1285 SMESH_ScalarBarActor *aScalarBarActor = anActor->GetScalarBarActor();
1286 if ( theCommandID == SMESHOp::OpShowDistribution ) {
1287 aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility());
1289 else if ( theCommandID == SMESHOp::OpShowScalarBar ) {
1290 aScalarBarActor->SetVisibility( !aScalarBarActor->GetVisibility());
1297 #ifndef DISABLE_PLOT2DVIEWER
1298 void PlotDistribution()
1300 SalomeApp_Application* app =
1301 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1305 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1306 SALOME_ListIO selected;
1308 aSel->selectedObjects( selected );
1310 if ( selected.Extent() == 1 ) {
1311 Handle(SALOME_InteractiveObject) anIO = selected.First();
1312 if ( anIO->hasEntry() ) {
1313 //Find Actor by entry before getting Plot2d viewer,
1314 //because after call getViewManager( Plot2d_Viewer::Type(), true ) active window is Plot2d Viewer
1315 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1317 SUIT_ViewManager* aViewManager =
1318 app->getViewManager( Plot2d_Viewer::Type(), true ); // create if necessary
1322 SPlot2d_Viewer* aView = dynamic_cast<SPlot2d_Viewer*>(aViewManager->getViewModel());
1326 Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
1330 if ( anActor && anActor->GetControlMode() != SMESH_Actor::eNone )
1332 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1333 QString functorName = functorToString( anActor->GetFunctor());
1334 QString aHistogramName("%1 : %2");
1335 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1336 aHistogram->setName(aHistogramName);
1337 aHistogram->setHorTitle(functorName);
1338 aHistogram->setVerTitle(QObject::tr("DISTRIBUTION_NB_ENT"));
1339 aPlot->displayObject(aHistogram, true);
1344 #endif //DISABLE_PLOT2DVIEWER
1346 void DisableAutoColor()
1348 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1349 SALOME_ListIO selected;
1351 aSel->selectedObjects( selected );
1353 if ( selected.Extent() ) {
1354 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1355 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1356 if ( !aMesh->_is_nil() ) {
1357 aMesh->SetAutoColor( false );
1364 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1365 SALOME_ListIO selected;
1367 aSel->selectedObjects( selected );
1368 if ( selected.Extent() )
1370 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1371 _PTR(Study) aStudy = SMESH::getStudy();
1372 _PTR(SObject) aSObj = aStudy->FindObjectID(anIObject->getEntry());
1374 if ( aStudy->GetUseCaseBuilder()->SortChildren( aSObj, true/*AscendingOrder*/ ) ) {
1375 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1382 void SetDisplayMode(int theCommandID, VTK::MarkerMap& theMarkerMap)
1384 SALOME_ListIO selected;
1385 SalomeApp_Application* app =
1386 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1390 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1391 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1392 if ( !aSel || !appStudy )
1395 if ( theCommandID == SMESHOp::OpClipping ) { // Clipping dialog can be activated without selection
1396 if ( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
1397 aModule->EmitSignalDeactivateDialog();
1398 if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
1399 (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
1404 aSel->selectedObjects( selected );
1406 if ( selected.Extent() >= 1 )
1408 switch ( theCommandID ) {
1409 case SMESHOp::OpTransparency:
1411 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1412 (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
1415 case SMESHOp::OpProperties:
1418 QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
1419 QColor orientationColor, outlineColor, volumeColor;
1420 int deltaF = 0, deltaV = 0;
1423 double ballScale = 1.0;
1425 int outlineWidth = 1;
1426 double shrinkCoef = 0.0;
1427 double orientationScale = 0.0;
1428 bool orientation3d = false;
1429 VTK::MarkerType markerType = VTK::MT_NONE;
1430 VTK::MarkerScale markerScale = VTK::MS_NONE;
1432 bool hasNodes = false;
1433 int presentEntities = 0;
1434 bool firstTime = true;
1436 SALOME_ListIteratorOfListIO It( selected );
1437 for ( ; It.More(); It.Next() ) {
1438 Handle(SALOME_InteractiveObject) IObject = It.Value();
1439 if ( !IObject->hasEntry() ) continue;
1440 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1441 if ( !anActor || !anActor->GetObject() ) continue;
1444 // nodes: color, marker
1445 anActor->GetNodeColor( color[0], color[1], color[2] );
1446 nodeColor.setRgbF( color[0], color[1], color[2] );
1447 markerType = anActor->GetMarkerType();
1448 markerScale = anActor->GetMarkerScale();
1449 markerId = anActor->GetMarkerTexture();
1450 // edges: color, width
1451 anActor->GetEdgeColor( color[0], color[1], color[2] );
1452 edgeColor.setRgbF( color[0], color[1], color[2] );
1453 edgeWidth = qMax( (int)anActor->GetLineWidth(), 1 ); // minimum allowed width is 1
1454 // faces: front color, back color (delta)
1455 anActor->GetSufaceColor( color[0], color[1], color[2], deltaF );
1456 faceColor.setRgbF( color[0], color[1], color[2] );
1457 // faces: front color, back color (delta)
1458 anActor->GetVolumeColor( color[0], color[1], color[2], deltaV );
1459 volumeColor.setRgbF( color[0], color[1], color[2] );
1460 // 0d elements: color, size
1461 anActor->Get0DColor( color[0], color[1], color[2] );
1462 elem0dColor.setRgbF( color[0], color[1], color[2] );
1463 elem0dSize = qMax( (int)anActor->Get0DSize(), 1 ); // minimum allowed size is 1
1464 // balls: color, size
1465 anActor->GetBallColor( color[0], color[1], color[2] );
1466 ballColor.setRgbF( color[0], color[1], color[2] );
1467 //ballSize = qMax( (int)anActor->GetBallSize(), 1 ); // minimum allowed size is 1
1468 ballScale = qMax( (double)anActor->GetBallScale(), 1e-2 ); // minimum allowed scale is 1e-2
1470 anActor->GetOutlineColor( color[0], color[1], color[2] );
1471 outlineColor.setRgbF( color[0], color[1], color[2] );
1472 outlineWidth = qMax( (int)anActor->GetOutlineWidth(), 1 ); // minimum allowed width is 1
1473 // orientation vectors: color, scale, 3d flag
1474 anActor->GetFacesOrientationColor( color[0], color[1], color[2] );
1475 orientationColor.setRgbF( color[0], color[1], color[2] );
1476 orientationScale = anActor->GetFacesOrientationScale();
1477 orientation3d = anActor->GetFacesOrientation3DVectors();
1479 shrinkCoef = anActor->GetShrinkFactor();
1482 firstTime = false; // we only take properties from first object (for performance reasons)
1485 hasNodes = anActor->GetObject()->GetNbEntities( SMDSAbs_Node );
1486 if ( !(presentEntities & SMESH_Actor::eEdges) && anActor->GetObject()->GetNbEntities( SMDSAbs_Edge ) )
1487 presentEntities = presentEntities | SMESH_Actor::eEdges;
1488 if ( !(presentEntities & SMESH_Actor::eFaces) && anActor->GetObject()->GetNbEntities( SMDSAbs_Face ) )
1489 presentEntities = presentEntities | SMESH_Actor::eFaces;
1490 if ( !(presentEntities & SMESH_Actor::eVolumes) && anActor->GetObject()->GetNbEntities( SMDSAbs_Volume ) )
1491 presentEntities = presentEntities | SMESH_Actor::eVolumes;
1492 if ( !(presentEntities & SMESH_Actor::e0DElements) && anActor->GetObject()->GetNbEntities( SMDSAbs_0DElement ) )
1493 presentEntities = presentEntities | SMESH_Actor::e0DElements;
1494 if ( !(presentEntities & SMESH_Actor::eBallElem) && anActor->GetObject()->GetNbEntities( SMDSAbs_Ball ) )
1495 presentEntities = presentEntities | SMESH_Actor::eBallElem;
1497 // as we know that all types of elements are present, we can exit the loop
1498 if ( presentEntities == SMESH_Actor::eAllEntity )
1502 SMESHGUI_PropertiesDlg dlg( theMarkerMap, SMESHGUI::desktop() );
1503 // nodes: color, marker
1504 dlg.setNodeColor( nodeColor );
1505 if( markerType != VTK::MT_USER )
1506 dlg.setNodeMarker( markerType, markerScale );
1508 dlg.setNodeCustomMarker( markerId );
1509 // edges: color, line width
1510 dlg.setEdgeColor( edgeColor );
1511 dlg.setEdgeWidth( edgeWidth );
1512 // faces: front color, back color
1513 dlg.setFaceColor( faceColor, deltaF );
1514 // volumes: normal color, reversed color
1515 dlg.setVolumeColor( volumeColor, deltaV );
1516 // outlines: color, line width
1517 dlg.setOutlineColor( outlineColor );
1518 dlg.setOutlineWidth( outlineWidth );
1519 // 0d elements: color, size
1520 dlg.setElem0dColor( elem0dColor );
1521 dlg.setElem0dSize( elem0dSize );
1522 // balls: color, size
1523 dlg.setBallColor( ballColor );
1524 //dlg.setBallSize( ballSize );
1525 dlg.setBallScale( ballScale );
1526 // orientation: color, scale, 3d flag
1527 dlg.setOrientationColor( orientationColor );
1528 dlg.setOrientationSize( int( orientationScale * 100. ) );
1529 dlg.setOrientation3d( orientation3d );
1530 // shrink: scale factor
1531 dlg.setShrinkCoef( int( shrinkCoef * 100. ) );
1532 // hide unused controls
1533 dlg.showControls( presentEntities, hasNodes );
1536 nodeColor = dlg.nodeColor();
1537 markerType = dlg.nodeMarkerType();
1538 markerScale = dlg.nodeMarkerScale();
1539 markerId = dlg.nodeMarkerId();
1540 edgeColor = dlg.edgeColor();
1541 edgeWidth = dlg.edgeWidth();
1542 faceColor = dlg.faceColor();
1543 deltaF = dlg.faceColorDelta();
1544 volumeColor = dlg.volumeColor();
1545 deltaV = dlg.volumeColorDelta();
1546 outlineColor = dlg.outlineColor();
1547 outlineWidth = dlg.outlineWidth();
1548 elem0dColor = dlg.elem0dColor();
1549 elem0dSize = dlg.elem0dSize();
1550 ballColor = dlg.ballColor();
1551 // ballSize = dlg.ballSize();
1552 ballScale = dlg.ballScale();
1553 orientationColor = dlg.orientationColor();
1554 orientationScale = dlg.orientationSize() / 100.;
1555 orientation3d = dlg.orientation3d();
1556 shrinkCoef = dlg.shrinkCoef() / 100.;
1558 // store point markers that might be changed by the user
1559 theMarkerMap = dlg.customMarkers();
1561 // set properties from dialog box to the presentations
1562 SALOME_ListIteratorOfListIO It( selected );
1563 for ( ; It.More(); It.Next() ) {
1564 Handle(SALOME_InteractiveObject) IObject = It.Value();
1565 if ( !IObject->hasEntry() ) continue;
1566 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1567 if ( !anActor ) continue;
1569 // nodes: color, marker
1570 anActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
1571 if ( markerType != VTK::MT_USER ) {
1572 anActor->SetMarkerStd( markerType, markerScale );
1575 VTK::MarkerMap::const_iterator iter = theMarkerMap.find( markerId );
1576 if ( iter != theMarkerMap.end() )
1577 anActor->SetMarkerTexture( markerId, iter->second.second );
1579 // volumes: normal color, reversed color (delta)
1580 anActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
1581 // faces: front color, back color (delta)
1582 anActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
1583 // edges: color, width
1584 anActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
1585 anActor->SetLineWidth( edgeWidth );
1587 anActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
1588 anActor->SetOutlineWidth( outlineWidth );
1589 // 0D elements: color, size
1590 anActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
1591 anActor->Set0DSize( elem0dSize );
1592 // balls: color, size
1593 anActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
1594 // anActor->SetBallSize( ballSize );
1595 anActor->SetBallScale( ballScale );
1596 // orientation: color, scale, 3d flag
1597 anActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
1598 anActor->SetFacesOrientationScale( orientationScale );
1599 anActor->SetFacesOrientation3DVectors( orientation3d );
1601 anActor->SetShrinkFactor( shrinkCoef );
1603 // for groups, set also proper color
1604 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1605 if ( !aGroupObject->_is_nil() ) {
1606 SMESH::ElementType anElementType = aGroupObject->GetType();
1608 switch( anElementType ) {
1610 aColor = nodeColor; break;
1612 aColor = edgeColor; break;
1614 aColor = faceColor; break;
1616 aColor = volumeColor; break;
1618 aColor = elem0dColor; break;
1620 aColor = ballColor; break;
1624 if ( aColor.isValid() ) {
1625 SALOMEDS::Color aGroupColor;
1626 aGroupColor.R = aColor.redF();
1627 aGroupColor.G = aColor.greenF();
1628 aGroupColor.B = aColor.blueF();
1629 aGroupObject->SetColor( aGroupColor );
1631 } // if ( !aGroupObject->_is_nil() )
1632 } // for ( ; It.More(); It.Next() )
1633 SMESH::RepaintCurrentView();
1634 } // if ( dlg.exec() )
1636 } // case SMESHOp::OpProperties:
1637 } // switch(theCommandID)
1638 SUIT_OverrideCursor wc;
1639 SALOME_ListIteratorOfListIO It( selected );
1640 for( ; It.More(); It.Next()){
1641 Handle(SALOME_InteractiveObject) IObject = It.Value();
1642 if(IObject->hasEntry()){
1643 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1644 switch(theCommandID){
1645 case SMESHOp::OpDMWireframe:
1646 anActor->SetRepresentation(SMESH_Actor::eEdge);
1648 case SMESHOp::OpDMShading:
1649 anActor->SetRepresentation(SMESH_Actor::eSurface);
1651 case SMESHOp::OpDMShrink:
1652 if(anActor->IsShrunk())
1653 anActor->UnShrink();
1655 anActor->SetShrink();
1657 case SMESHOp::OpDMNodes:
1658 anActor->SetRepresentation(SMESH_Actor::ePoint);
1660 case SMESHOp::OpRepresentationLines:
1661 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1662 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1664 case SMESHOp::OpRepresentationArcs:
1665 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1666 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1672 SMESH::RepaintCurrentView();
1676 int ActionToControl( int theID, bool theReversed )
1678 NCollection_DoubleMap<int,int> ActionControl;
1679 ActionControl.Bind( 0, SMESH_Actor::eNone );
1680 ActionControl.Bind( SMESHOp::OpFreeNode, SMESH_Actor::eFreeNodes );
1681 ActionControl.Bind( SMESHOp::OpEqualNode, SMESH_Actor::eCoincidentNodes );
1682 ActionControl.Bind( SMESHOp::OpNodeConnectivityNb, SMESH_Actor::eNodeConnectivityNb );
1683 ActionControl.Bind( SMESHOp::OpFreeEdge, SMESH_Actor::eFreeEdges );
1684 ActionControl.Bind( SMESHOp::OpFreeBorder, SMESH_Actor::eFreeBorders );
1685 ActionControl.Bind( SMESHOp::OpLength, SMESH_Actor::eLength );
1686 ActionControl.Bind( SMESHOp::OpConnection, SMESH_Actor::eMultiConnection );
1687 ActionControl.Bind( SMESHOp::OpEqualEdge, SMESH_Actor::eCoincidentElems1D );
1688 ActionControl.Bind( SMESHOp::OpFreeFace, SMESH_Actor::eFreeFaces );
1689 ActionControl.Bind( SMESHOp::OpBareBorderFace, SMESH_Actor::eBareBorderFace );
1690 ActionControl.Bind( SMESHOp::OpOverConstrainedFace, SMESH_Actor::eOverConstrainedFace );
1691 ActionControl.Bind( SMESHOp::OpLength2D, SMESH_Actor::eLength2D );
1692 ActionControl.Bind( SMESHOp::OpDeflection2D, SMESH_Actor::eDeflection2D );
1693 ActionControl.Bind( SMESHOp::OpConnection2D, SMESH_Actor::eMultiConnection2D );
1694 ActionControl.Bind( SMESHOp::OpArea, SMESH_Actor::eArea );
1695 ActionControl.Bind( SMESHOp::OpTaper, SMESH_Actor::eTaper );
1696 ActionControl.Bind( SMESHOp::OpAspectRatio, SMESH_Actor::eAspectRatio );
1697 ActionControl.Bind( SMESHOp::OpMinimumAngle, SMESH_Actor::eMinimumAngle );
1698 ActionControl.Bind( SMESHOp::OpWarpingAngle, SMESH_Actor::eWarping );
1699 ActionControl.Bind( SMESHOp::OpSkew, SMESH_Actor::eSkew );
1700 ActionControl.Bind( SMESHOp::OpMaxElementLength2D, SMESH_Actor::eMaxElementLength2D );
1701 ActionControl.Bind( SMESHOp::OpEqualFace, SMESH_Actor::eCoincidentElems2D );
1702 ActionControl.Bind( SMESHOp::OpAspectRatio3D, SMESH_Actor::eAspectRatio3D );
1703 ActionControl.Bind( SMESHOp::OpVolume, SMESH_Actor::eVolume3D );
1704 ActionControl.Bind( SMESHOp::OpMaxElementLength3D, SMESH_Actor::eMaxElementLength3D );
1705 ActionControl.Bind( SMESHOp::OpBareBorderVolume, SMESH_Actor::eBareBorderVolume );
1706 ActionControl.Bind( SMESHOp::OpOverConstrainedVolume, SMESH_Actor::eOverConstrainedVolume );
1707 ActionControl.Bind( SMESHOp::OpEqualVolume, SMESH_Actor::eCoincidentElems3D );
1710 return ActionControl.IsBound2( theID ) ? ActionControl.Find2( theID ) : 0;
1711 return ActionControl.IsBound1( theID ) ? ActionControl.Find1( theID ) : 0;
1714 void Control( int theCommandID )
1716 SMESH_Actor::eControl aControl = SMESH_Actor::eControl( ActionToControl( theCommandID ));
1717 _PTR(Study) aStudy = SMESH::getStudy();
1719 SALOME_ListIO selected;
1720 if ( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
1721 aSel->selectedObjects( selected );
1723 if ( !selected.IsEmpty() ) {
1724 SALOME_ListIteratorOfListIO It(selected);
1725 for ( ; It.More(); It.Next())
1727 Handle(SALOME_InteractiveObject) anIO = It.Value();
1728 if ( !anIO.IsNull() ) {
1729 _PTR(SObject) SO = aStudy->FindObjectID( It.Value()->getEntry() );
1731 CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
1732 SMESH::SMESH_IDSource_var anIDSrc = SMESH::SMESH_IDSource::_narrow( aObject );
1733 if ( !anIDSrc->_is_nil() ) {
1734 SMESH_Actor *anActor = SMESH::FindActorByEntry( anIO->getEntry());
1735 if (( !anActor && selected.Extent() == 1 ) &&
1736 ( anActor = SMESH::CreateActor( anIO->getEntry() )))
1738 anActor->SetControlMode( aControl );
1739 SMESH::DisplayActor( SMESH::GetCurrentVtkView(), anActor );
1740 SMESH::UpdateView ( SMESH::eDisplay, anIO->getEntry() );
1744 if ( anActor->GetControlMode() != aControl )
1745 anActor->SetControlMode( aControl );
1746 QString functorName = functorToString( anActor->GetFunctor() );
1747 int anEntitiesCount = anActor->GetNumberControlEntities();
1748 if (anEntitiesCount >= 0)
1749 functorName = functorName + ": " + QString::number(anEntitiesCount);
1750 anActor->GetScalarBarActor()->SetTitle( functorName.toLatin1().constData() );
1751 SMESH::RepaintCurrentView();
1752 #ifndef DISABLE_PLOT2DVIEWER
1753 if ( anActor->GetPlot2Histogram() ) {
1754 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1755 QString aHistogramName("%1 : %2");
1756 aHistogramName = aHistogramName.arg( anIO->getName() ).arg( functorName );
1757 aHistogram->setName( aHistogramName );
1758 aHistogram->setHorTitle( functorName );
1759 SMESH::ProcessIn2DViewers( anActor );
1771 bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1772 SMESH::MeshObjectType theType,
1773 const QString theInTypeName,
1774 QString & theOutTypeName)
1776 SMESH_TypeFilter aTypeFilter( theType );
1778 if ( !theIO.IsNull() )
1780 entry = theIO->getEntry();
1781 LightApp_DataOwner owner( entry );
1782 if ( aTypeFilter.isOk( &owner )) {
1783 theOutTypeName = theInTypeName;
1791 QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1793 _PTR(Study) aStudy = SMESH::getStudy();
1794 _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1796 _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1797 CORBA::String_var anID = aSComp->GetID().c_str();
1798 if ( !strcmp(anID.in(),theIO->getEntry()) )
1804 CheckOIType ( theIO, SMESH::HYPOTHESIS, "Hypothesis", aTypeName ) ||
1805 CheckOIType ( theIO, SMESH::ALGORITHM, "Algorithm", aTypeName ) ||
1806 CheckOIType ( theIO, SMESH::MESH, "Mesh", aTypeName ) ||
1807 CheckOIType ( theIO, SMESH::SUBMESH, "SubMesh", aTypeName ) ||
1808 CheckOIType ( theIO, SMESH::GROUP, "Group", aTypeName )
1816 // QString CheckHomogeneousSelection()
1818 // LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1819 // SALOME_ListIO selected;
1821 // aSel->selectedObjects( selected );
1823 // QString RefType = CheckTypeObject(selected.First());
1824 // SALOME_ListIteratorOfListIO It(selected);
1825 // for ( ; It.More(); It.Next())
1827 // Handle(SALOME_InteractiveObject) IObject = It.Value();
1828 // QString Type = CheckTypeObject(IObject);
1829 // if ( Type.compare(RefType) != 0 )
1830 // return "Heterogeneous Selection";
1836 uint randomize( uint size )
1838 static bool initialized = false;
1839 if ( !initialized ) {
1840 qsrand( QDateTime::currentDateTime().toTime_t() );
1844 v = uint( (double)( v ) / RAND_MAX * size );
1845 v = qMax( uint(0), qMin ( v, size-1 ) );
1851 void SMESHGUI::OnEditDelete()
1853 // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1854 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1855 SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1857 _PTR(Study) aStudy = SMESH::getStudy();
1858 _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1859 _PTR(GenericAttribute) anAttr;
1860 _PTR(AttributeIOR) anIOR;
1862 const int objectCountLimit = 30; // PAL23599
1863 int objectCount = 0;
1865 QString aParentComponent = QString::null;
1867 for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1869 Handle(SALOME_InteractiveObject) anIO = anIt.Value();
1870 if ( anIO.IsNull() ) continue;
1872 QString father = "unknown", name;
1874 _PTR(SObject) aSO = aStudy->FindObjectID( anIO->getEntry() );
1876 father = QString::fromStdString( aSO->GetFatherComponent()->ComponentDataType() );
1877 // check if object is reference
1878 _PTR(SObject) aRefSObj;
1879 if ( aSO->ReferencedObject( aRefSObj ) ) {
1880 name = QString::fromStdString ( aRefSObj->GetName() );
1881 father = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1884 name = anIO->getName();
1887 if ( objectCount < objectCountLimit ) { // avoid occupying the whole screen
1888 aNameList.append("\n - ");
1889 aNameList.append( name );
1892 if( aParentComponent.isNull() )
1893 aParentComponent = father;
1894 else if( !aParentComponent.isEmpty() && aParentComponent!=father )
1895 aParentComponent = "";
1897 if ( objectCount >= objectCountLimit )
1898 aNameList.append("\n - ...");
1900 if ( objectCount == 0 )
1901 return; // No Valid Objects Selected
1903 if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
1904 SUIT_MessageBox::warning( SMESHGUI::desktop(),
1905 QObject::tr("ERR_ERROR"),
1906 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
1909 // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
1910 if (SUIT_MessageBox::warning
1911 (SMESHGUI::desktop(),
1912 QObject::tr("SMESH_WRN_WARNING"),
1913 QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
1914 SUIT_MessageBox::Yes | SUIT_MessageBox::No,
1915 SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
1918 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1920 // Put the whole hierarchy of sub-objects of the selected SO's into a list and
1921 // then treat them all starting from the deepest objects (at list back)
1922 std::list< _PTR(SObject) > listSO;
1923 SALOME_ListIteratorOfListIO It(selected);
1924 for( ; It.More(); It.Next()) // loop on selected IO's
1926 Handle(SALOME_InteractiveObject) IObject = It.Value();
1927 if(IObject->hasEntry()) {
1928 _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
1930 // disable removal of "SMESH" component object
1931 if(aSO->FindAttribute(anAttr, "AttributeIOR")){
1933 if ( engineIOR() == anIOR->Value().c_str() )
1936 //Check the referenced object
1937 _PTR(SObject) aRefSObject;
1938 if ( aSO && aSO->ReferencedObject( aRefSObject ) )
1939 aSO = aRefSObject; // Delete main Object instead of reference
1941 listSO.push_back( aSO );
1942 std::list< _PTR(SObject) >::iterator itSO = --listSO.end();
1943 for ( ; itSO != listSO.end(); ++itSO ) {
1944 _PTR(ChildIterator) it = aStudy->NewChildIterator( *itSO );
1945 for (it->InitEx(false); it->More(); it->Next())
1946 listSO.push_back( it->Value() );
1950 // Check if none of objects to delete is referred from outside
1951 std::list< _PTR(SObject) >::reverse_iterator ritSO;
1952 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1954 _PTR(SObject) SO = *ritSO;
1955 if ( !SO ) continue;
1956 std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( *ritSO );
1957 for (size_t i = 0; i < aReferences.size(); i++) {
1958 _PTR(SComponent) aComponent = aReferences[i]->GetFatherComponent();
1959 std::string type = aComponent->ComponentDataType();
1960 if ( type != "SMESH" )
1962 SUIT_MessageBox::warning( anApp->desktop(),
1963 QObject::tr("WRN_WARNING"),
1964 QObject::tr("DEP_OBJECT") );
1965 return; // outside SMESH, there is an object depending on a SMESH object
1970 // Call mesh->Clear() to prevent loading mesh from file caused by hypotheses removal
1971 for( It.Initialize( selected ); It.More(); It.Next()) // loop on selected IO's
1973 Handle(SALOME_InteractiveObject) IObject = It.Value();
1974 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface< SMESH::SMESH_Mesh >( IObject );
1975 if ( !mesh->_is_nil() )
1979 // Treat SO's in the list starting from the back
1980 aStudyBuilder->NewCommand(); // There is a transaction
1981 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1983 _PTR(SObject) SO = *ritSO;
1984 if ( !SO ) continue;
1985 std::string anEntry = SO->GetID();
1987 /** Erase graphical object and remove all its data **/
1988 if(SO->FindAttribute(anAttr, "AttributeIOR")) {
1989 SMESH::RemoveVisualObjectWithActors( anEntry.c_str(), true);
1991 /** Remove an object from data structures **/
1992 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
1993 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
1994 if ( !aGroup->_is_nil() ) { // DELETE GROUP
1995 SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
1996 aMesh->RemoveGroup( aGroup );
1998 else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
1999 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2000 aMesh->RemoveSubMesh( aSubMesh );
2003 Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
2004 ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
2005 QString objType = CheckTypeObject(IObject);
2006 if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
2007 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
2008 aStudyBuilder->RemoveObjectWithChildren( SO );
2010 else {// default action: remove SObject from the study
2011 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
2012 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
2014 aStudyBuilder->RemoveObjectWithChildren( SO );
2018 } /* listSO back loop */
2020 aStudyBuilder->CommitCommand();
2022 /* Clear any previous selection */
2024 aSel->setSelectedObjects( l1 );
2026 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
2030 SMESHGUI_EXPORT CAM_Module* createModule()
2032 return new SMESHGUI();
2035 SMESHGUI_EXPORT char* getModuleVersion() {
2036 return (char*)SMESH_VERSION_STR;
2040 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
2042 //=============================================================================
2046 //=============================================================================
2047 SMESHGUI::SMESHGUI() :
2048 SalomeApp_Module( "SMESH" )
2050 if ( CORBA::is_nil( myComponentSMESH ) )
2052 CORBA::Boolean anIsEmbeddedMode;
2053 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
2054 //MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
2056 // 0019923: EDF 765 SMESH : default values of hypothesis
2057 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
2058 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
2059 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
2060 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
2061 myComponentSMESH->SetDefaultNbSegments( nbSeg );
2063 const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif", "default_grp_color" };
2064 for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
2065 if ( aResourceMgr->hasValue( "SMESH", options[i] ))
2067 QString val = aResourceMgr->stringValue( "SMESH", options[i] );
2068 myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
2072 myActiveDialogBox = 0;
2073 myFilterLibraryDlg = 0;
2077 myEventCallbackCommand = vtkCallbackCommand::New();
2078 myEventCallbackCommand->Delete();
2079 myEventCallbackCommand->SetClientData( this );
2080 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
2083 /* load resources for all available meshers */
2084 SMESH::InitAvailableHypotheses();
2087 //=============================================================================
2091 //=============================================================================
2092 SMESHGUI::~SMESHGUI()
2096 //=============================================================================
2100 //=============================================================================
2101 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
2103 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2105 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
2110 //=============================================================================
2114 //=============================================================================
2115 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
2117 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2121 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2122 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2123 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2124 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2125 return autoUpdate && !exceeded;
2128 //=============================================================================
2132 //=============================================================================
2133 bool SMESHGUI::automaticUpdate( SMESH::SMESH_IDSource_ptr theMesh,
2134 int* entities, bool* limitExceeded, int* hidden, long* nbElements )
2136 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2140 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2141 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2142 bool incrementalLimit = resMgr->booleanValue( "SMESH", "incremental_limit", false );
2144 SMESH::long_array_var info = theMesh->GetMeshInfo();
2145 long nbOdElems = info[SMDSEntity_0D];
2146 long nbEdges = info[SMDSEntity_Edge] + info[SMDSEntity_Quad_Edge];
2147 long nbFaces = info[SMDSEntity_Triangle] + info[SMDSEntity_Quad_Triangle] + info[SMDSEntity_BiQuad_Triangle] +
2148 info[SMDSEntity_Quadrangle] + info[SMDSEntity_Quad_Quadrangle] + info[SMDSEntity_BiQuad_Quadrangle] +
2149 info[SMDSEntity_Polygon] + info[SMDSEntity_Quad_Polygon];
2150 long nbVolumes = info[SMDSEntity_Tetra] + info[SMDSEntity_Quad_Tetra] +
2151 info[SMDSEntity_Hexa] + info[SMDSEntity_Quad_Hexa] + info[SMDSEntity_TriQuad_Hexa] +
2152 info[SMDSEntity_Pyramid] + info[SMDSEntity_Quad_Pyramid] +
2153 info[SMDSEntity_Penta] + info[SMDSEntity_Quad_Penta] + info[SMDSEntity_BiQuad_Penta] +
2154 info[SMDSEntity_Polyhedra] +
2155 info[SMDSEntity_Hexagonal_Prism];
2156 long nbBalls = info[SMDSEntity_Ball];
2158 long requestedSize = nbOdElems + nbBalls + nbEdges + nbFaces + nbVolumes;
2159 *nbElements = requestedSize;
2161 *entities = SMESH_Actor::eAllEntity;
2164 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2166 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2168 if ( incrementalLimit ) {
2171 if ( nbOdElems > 0 ) {
2172 if ( total + nbOdElems > updateLimit ) {
2173 *entities = *entities & ~SMESH_Actor::e0DElements;
2174 *hidden = *hidden | SMESH_Actor::e0DElements;
2181 if ( nbEdges > 0 ) {
2182 if ( total + nbEdges > updateLimit ) {
2183 *entities = *entities & ~SMESH_Actor::eEdges;
2184 *hidden = *hidden | SMESH_Actor::eEdges;
2191 if ( nbFaces > 0 ) {
2192 if ( total + nbFaces > updateLimit ) {
2193 *entities = *entities & ~SMESH_Actor::eFaces;
2194 *hidden = *hidden | SMESH_Actor::eFaces;
2201 if ( nbVolumes > 0 ) {
2202 if ( total + nbVolumes > updateLimit ) {
2203 *entities = *entities & ~SMESH_Actor::eVolumes;
2204 *hidden = *hidden | SMESH_Actor::eVolumes;
2211 if ( nbBalls > 0 ) {
2212 if ( total + nbBalls > updateLimit ) {
2213 *entities = *entities & ~SMESH_Actor::eBallElem;
2214 *hidden = *hidden | SMESH_Actor::eBallElem;
2222 return autoUpdate && !exceeded;
2225 //=============================================================================
2229 //=============================================================================
2230 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
2232 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
2235 //=============================================================================
2239 //=============================================================================
2240 SMESHGUI* SMESHGUI::GetSMESHGUI()
2242 SMESHGUI* smeshMod = 0;
2243 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
2246 CAM_Module* module = app->module( "Mesh" );
2247 smeshMod = dynamic_cast<SMESHGUI*>( module );
2255 Standard_EXPORT SMESHGUI* GetComponentGUI()
2257 return SMESHGUI::GetSMESHGUI();
2261 //=============================================================================
2265 //=============================================================================
2266 void SMESHGUI::SetState(int aState)
2271 //=============================================================================
2275 //=============================================================================
2276 void SMESHGUI::ResetState()
2281 //=============================================================================
2285 //=============================================================================
2286 void SMESHGUI::EmitSignalDeactivateDialog()
2288 emit SignalDeactivateActiveDialog();
2291 //=============================================================================
2295 //=============================================================================
2296 void SMESHGUI::EmitSignalStudyFrameChanged()
2298 emit SignalStudyFrameChanged();
2301 //=============================================================================
2305 //=============================================================================
2306 void SMESHGUI::EmitSignalCloseAllDialogs()
2308 emit SignalCloseAllDialogs();
2311 //=============================================================================
2315 //=============================================================================
2316 void SMESHGUI::EmitSignalVisibilityChanged()
2318 emit SignalVisibilityChanged();
2321 //=============================================================================
2325 //=============================================================================
2326 void SMESHGUI::EmitSignalCloseView()
2328 emit SignalCloseView();
2331 //=============================================================================
2335 //=============================================================================
2336 void SMESHGUI::EmitSignalActivatedViewManager()
2338 emit SignalActivatedViewManager();
2341 //=============================================================================
2345 //=============================================================================
2346 QDialog *SMESHGUI::GetActiveDialogBox()
2348 return myActiveDialogBox;
2351 //=============================================================================
2355 //=============================================================================
2356 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2358 myActiveDialogBox = (QDialog *) aDlg;
2362 //=============================================================================
2366 //=============================================================================
2367 SUIT_Desktop* SMESHGUI::desktop()
2369 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2371 return app->desktop();
2376 //=============================================================================
2380 //=============================================================================
2381 SalomeApp_Study* SMESHGUI::activeStudy()
2383 SUIT_Application* app = SUIT_Session::session()->activeApplication();
2385 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2390 //=============================================================================
2394 //=============================================================================
2395 void SMESHGUI::Modified( bool theIsUpdateActions )
2397 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2398 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2399 appStudy->Modified();
2400 if( theIsUpdateActions )
2401 app->updateActions();
2406 //=============================================================================
2410 //=============================================================================
2411 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2413 /* Here the position is on the bottom right corner - 10 */
2414 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2416 SUIT_Desktop *PP = desktop();
2417 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2418 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2423 * \brief Verifies whether study of operation is locked
2424 * \param theMess - specifies whether message box must be shown if study is locked
2425 * \return State of study.
2427 * Verifies whether study of operation is locked. If second parameter is TRUE and study
2428 * is locked when corresponding message box appears
2430 bool SMESHGUI::isStudyLocked( bool theMessage )
2432 if ( SMESH::getStudy()->GetProperties()->IsLocked() )
2435 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2436 QObject::tr( "WRN_WARNING" ),
2437 QObject::tr( "WRN_STUDY_LOCKED" ) );
2443 //=============================================================================
2447 //=============================================================================
2448 bool SMESHGUI::OnGUIEvent( int theCommandID )
2450 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2454 SUIT_ResourceMgr* mgr = resourceMgr();
2458 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2459 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2461 //QAction* act = action( theCommandID );
2463 switch (theCommandID) {
2464 case SMESHOp::OpDelete:
2465 if(isStudyLocked()) break;
2468 case SMESHOp::OpImportDAT:
2469 case SMESHOp::OpImportUNV:
2470 case SMESHOp::OpImportMED:
2471 case SMESHOp::OpImportSTL:
2472 case SMESHOp::OpImportCGNS:
2473 case SMESHOp::OpImportSAUV:
2474 case SMESHOp::OpImportGMF:
2475 case SMESHOp::OpPopupImportDAT:
2476 case SMESHOp::OpPopupImportUNV:
2477 case SMESHOp::OpPopupImportMED:
2478 case SMESHOp::OpPopupImportSTL:
2479 case SMESHOp::OpPopupImportCGNS:
2480 case SMESHOp::OpPopupImportSAUV:
2481 case SMESHOp::OpPopupImportGMF:
2483 if(isStudyLocked()) break;
2484 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2488 case SMESHOp::OpFileInformation:
2490 SALOME_ListIO selected;
2491 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2493 aSel->selectedObjects( selected );
2494 if( selected.Extent() )
2496 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2497 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2498 if ( !aMesh->_is_nil() )
2500 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2506 case SMESHOp::OpExportDAT:
2507 case SMESHOp::OpExportMED:
2508 case SMESHOp::OpExportUNV:
2509 case SMESHOp::OpExportSTL:
2510 case SMESHOp::OpExportCGNS:
2511 case SMESHOp::OpExportSAUV:
2512 case SMESHOp::OpExportGMF:
2513 case SMESHOp::OpPopupExportDAT:
2514 case SMESHOp::OpPopupExportMED:
2515 case SMESHOp::OpPopupExportUNV:
2516 case SMESHOp::OpPopupExportSTL:
2517 case SMESHOp::OpPopupExportCGNS:
2518 case SMESHOp::OpPopupExportSAUV:
2519 case SMESHOp::OpPopupExportGMF:
2521 ::ExportMeshToFile(theCommandID);
2525 case SMESHOp::OpReset: // SCALAR BAR
2527 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2528 SALOME_ListIO selected;
2530 aSel->selectedObjects( selected );
2532 SALOME_ListIteratorOfListIO it(selected);
2533 for( ; it.More(); it.Next()) {
2534 Handle(SALOME_InteractiveObject) anIO = it.Value();
2535 if( anIO->hasEntry() ) {
2536 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2537 anActor->SetControlMode( SMESH_Actor::eNone );
2538 #ifndef DISABLE_PLOT2DVIEWER
2539 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2544 SMESH::UpdateView();
2547 case SMESHOp::OpScalarBarProperties:
2549 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2552 case SMESHOp::OpShowScalarBar:
2554 // show/hide scalar bar
2555 ::ShowElement(theCommandID);
2558 case SMESHOp::OpSaveDistribution:
2560 // dump control distribution data to the text file
2561 ::SaveDistribution();
2565 case SMESHOp::OpShowDistribution:
2567 // show/hide distribution
2568 ::ShowElement(theCommandID);
2572 #ifndef DISABLE_PLOT2DVIEWER
2573 case SMESHOp::OpPlotDistribution:
2575 // plot distribution
2576 ::PlotDistribution();
2582 case SMESHOp::OpAutoColor:
2586 case SMESHOp::OpDisableAutoColor:
2587 ::DisableAutoColor();
2590 case SMESHOp::OpClipping:
2591 case SMESHOp::OpTransparency:
2592 case SMESHOp::OpProperties: // Display preferences (colors, shrink size, line width, ...)
2595 case SMESHOp::OpDMWireframe:
2596 case SMESHOp::OpDMShading:
2597 case SMESHOp::OpDMNodes:
2598 case SMESHOp::OpDMShrink:
2599 ::SetDisplayMode(theCommandID, myMarkerMap);
2602 //2D quadratic representation
2603 case SMESHOp::OpRepresentationLines:
2604 case SMESHOp::OpRepresentationArcs:
2605 ::SetDisplayMode(theCommandID, myMarkerMap);
2609 case SMESHOp::OpDE0DElements:
2610 case SMESHOp::OpDEEdges:
2611 case SMESHOp::OpDEFaces:
2612 case SMESHOp::OpDEVolumes:
2613 case SMESHOp::OpDEBalls:
2614 case SMESHOp::OpDEAllEntity:
2615 ::SetDisplayEntity(theCommandID);
2618 // Choose entities to be displayed
2619 case SMESHOp::OpDEChoose:
2621 ( new SMESHGUI_DisplayEntitiesDlg( SMESHGUI::desktop() ) )->exec();
2625 case SMESHOp::OpOrientationOnFaces:
2627 SUIT_OverrideCursor wc;
2628 LightApp_SelectionMgr* mgr = selectionMgr();
2629 SALOME_ListIO selected; mgr->selectedObjects( selected );
2631 SALOME_ListIteratorOfListIO it(selected);
2632 for( ; it.More(); it.Next()) {
2633 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2634 if(anIObject->hasEntry()) {
2635 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2636 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2643 case SMESHOp::OpUpdate:
2645 if(isStudyLocked()) break;
2646 SUIT_OverrideCursor wc;
2649 SMESH::UpdateView();
2651 catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2652 SMESH::OnVisuException();
2654 catch (...) { // PAL16774 (Crash after display of many groups)
2655 SMESH::OnVisuException();
2659 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2660 aSel->selectedObjects( l );
2661 aSel->setSelectedObjects( l );
2665 case SMESHOp::OpHide:
2666 case SMESHOp::OpShow:
2667 case SMESHOp::OpShowOnly:
2669 SUIT_OverrideCursor wc;
2670 SMESH::EDisplaing anAction;
2671 switch (theCommandID) {
2672 case SMESHOp::OpHide: anAction = SMESH::eErase; break;
2673 case SMESHOp::OpShow: anAction = SMESH::eDisplay; break;
2674 case SMESHOp::OpShowOnly: anAction = SMESH::eDisplayOnly; break;
2677 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2678 SALOME_ListIO sel_objects, to_process;
2680 aSel->selectedObjects( sel_objects );
2682 if ( theCommandID==SMESHOp::OpShowOnly )
2684 //MESSAGE("anAction = SMESH::eDisplayOnly");
2685 startOperation( myEraseAll );
2688 extractContainers( sel_objects, to_process );
2693 SALOME_ListIteratorOfListIO It( to_process );
2694 for ( ; It.More(); It.Next())
2696 Handle(SALOME_InteractiveObject) IOS = It.Value();
2697 if ( IOS->hasEntry() )
2699 if ( !SMESH::UpdateView( anAction, IOS->getEntry() )) {
2700 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2701 break; // PAL16774 (Crash after display of many groups)
2703 if (anAction == SMESH::eDisplayOnly)
2704 anAction = SMESH::eDisplay;
2709 // PAL13338 + PAL15161 -->
2710 if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !isStudyLocked()) {
2711 SMESH::UpdateView();
2712 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2714 // PAL13338 + PAL15161 <--
2716 catch (...) { // PAL16774 (Crash after display of many groups)
2717 SMESH::OnVisuException();
2720 if (anAction == SMESH::eErase) {
2722 aSel->setSelectedObjects( l1 );
2725 aSel->setSelectedObjects( to_process );
2730 case SMESHOp::OpNode:
2732 if(isStudyLocked()) break;
2735 EmitSignalDeactivateDialog();
2737 ( new SMESHGUI_NodesDlg( this ) )->show();
2740 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"),tr("SMESH_WRN_VIEWER_VTK"));
2745 case SMESHOp::OpCreateMesh:
2746 case SMESHOp::OpCreateSubMesh:
2747 case SMESHOp::OpEditMeshOrSubMesh:
2748 case SMESHOp::OpEditMesh:
2749 case SMESHOp::OpEditSubMesh:
2750 case SMESHOp::OpCompute:
2751 case SMESHOp::OpComputeSubMesh:
2752 case SMESHOp::OpPreCompute:
2753 case SMESHOp::OpEvaluate:
2754 case SMESHOp::OpMeshOrder:
2755 startOperation( theCommandID );
2757 case SMESHOp::OpCopyMesh:
2759 if (isStudyLocked()) break;
2760 EmitSignalDeactivateDialog();
2761 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2764 case SMESHOp::OpBuildCompoundMesh:
2766 if (isStudyLocked()) break;
2767 EmitSignalDeactivateDialog();
2768 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2772 case SMESHOp::OpDiagonalInversion:
2773 case SMESHOp::OpUnionOfTwoTriangle:
2777 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2781 if ( isStudyLocked() )
2784 /*Standard_Boolean aRes;
2785 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2786 if ( aMesh->_is_nil() )
2788 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2789 tr( "SMESH_BAD_SELECTION" ) );
2793 EmitSignalDeactivateDialog();
2794 if ( theCommandID == SMESHOp::OpDiagonalInversion )
2795 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2797 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2800 case SMESHOp::OpOrientation:
2801 case SMESHOp::OpUnionOfTriangles:
2802 case SMESHOp::OpCuttingOfQuadrangles:
2803 case SMESHOp::OpSplitVolumes:
2807 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2811 if ( isStudyLocked() )
2814 EmitSignalDeactivateDialog();
2815 SMESHGUI_MultiEditDlg* aDlg = NULL;
2816 if ( theCommandID == SMESHOp::OpOrientation )
2817 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2818 else if ( theCommandID == SMESHOp::OpUnionOfTriangles )
2819 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2820 else if ( theCommandID == SMESHOp::OpSplitVolumes )
2821 aDlg = new SMESHGUI_SplitVolumesDlg(this);
2823 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2828 case SMESHOp::OpSmoothing:
2830 if(isStudyLocked()) break;
2832 EmitSignalDeactivateDialog();
2833 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2836 SUIT_MessageBox::warning(desktop(), tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2840 case SMESHOp::OpExtrusion:
2842 if (isStudyLocked()) break;
2844 EmitSignalDeactivateDialog();
2845 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2847 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2851 case SMESHOp::OpExtrusionAlongAPath:
2853 if (isStudyLocked()) break;
2855 EmitSignalDeactivateDialog();
2856 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2858 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2862 case SMESHOp::OpRevolution:
2864 if(isStudyLocked()) break;
2866 EmitSignalDeactivateDialog();
2867 ( new SMESHGUI_RevolutionDlg( this ) )->show();
2870 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2874 case SMESHOp::OpPatternMapping:
2876 if ( isStudyLocked() )
2880 EmitSignalDeactivateDialog();
2881 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2884 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2888 case SMESHOp::OpSplitBiQuadratic:
2889 case SMESHOp::OpConvertMeshToQuadratic:
2890 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
2891 case SMESHOp::OpReorientFaces:
2892 case SMESHOp::OpCreateGeometryGroup:
2894 startOperation( theCommandID );
2897 case SMESHOp::OpCreateGroup:
2901 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2905 if(isStudyLocked()) break;
2906 EmitSignalDeactivateDialog();
2907 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2909 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2910 SALOME_ListIO selected;
2912 aSel->selectedObjects( selected );
2914 int nbSel = selected.Extent();
2916 // check if mesh is selected
2917 aMesh = SMESH::GetMeshByIO( selected.First() );
2919 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2924 case SMESHOp::OpConstructGroup:
2928 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2932 if(isStudyLocked()) break;
2933 EmitSignalDeactivateDialog();
2935 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2936 SALOME_ListIO selected;
2938 aSel->selectedObjects( selected );
2940 int nbSel = selected.Extent();
2942 // check if submesh is selected
2943 Handle(SALOME_InteractiveObject) IObject = selected.First();
2944 if (IObject->hasEntry()) {
2945 _PTR(SObject) aSObj = SMESH::getStudy()->FindObjectID(IObject->getEntry());
2947 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2948 if (!aSubMesh->_is_nil()) {
2950 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2951 // get submesh elements list by types
2952 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2953 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2954 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2955 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2956 // create group for each type o elements
2957 QString aName = IObject->getName();
2958 QStringList anEntryList;
2959 if (aNodes->length() > 0) {
2960 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2961 aGroup->Add(aNodes.inout());
2962 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2963 anEntryList.append( aSObject->GetID().c_str() );
2965 if (aEdges->length() > 0) {
2966 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2967 aGroup->Add(aEdges.inout());
2968 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2969 anEntryList.append( aSObject->GetID().c_str() );
2971 if (aFaces->length() > 0) {
2972 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2973 aGroup->Add(aFaces.inout());
2974 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2975 anEntryList.append( aSObject->GetID().c_str() );
2977 if (aVolumes->length() > 0) {
2978 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2979 aGroup->Add(aVolumes.inout());
2980 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2981 anEntryList.append( aSObject->GetID().c_str() );
2984 anApp->browseObjects( anEntryList );
2986 catch(const SALOME::SALOME_Exception & S_ex){
2987 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2994 SUIT_MessageBox::warning(desktop(),
2995 tr("SMESH_WRN_WARNING"),
2996 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
3001 case SMESHOp::OpEditGroup:
3005 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3009 if(isStudyLocked()) break;
3010 EmitSignalDeactivateDialog();
3012 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3013 SALOME_ListIO selected;
3015 aSel->selectedObjects( selected );
3017 SALOME_ListIteratorOfListIO It (selected);
3018 int nbSelectedGroups = 0;
3019 for ( ; It.More(); It.Next() )
3021 SMESH::SMESH_GroupBase_var aGroup =
3022 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
3023 if (!aGroup->_is_nil()) {
3025 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
3029 if (nbSelectedGroups == 0)
3031 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
3037 case SMESHOp::OpAddElemGroupPopup: // Add elements to group
3039 if(isStudyLocked()) break;
3040 if (myState == 800) {
3041 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3042 if (aDlg) aDlg->onAdd();
3047 case SMESHOp::OpRemoveElemGroupPopup: // Remove elements from group
3049 if(isStudyLocked()) break;
3050 if (myState == 800) {
3051 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3052 if (aDlg) aDlg->onRemove();
3057 case SMESHOp::OpEditGeomGroupAsGroup:
3061 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3065 if(isStudyLocked()) break;
3066 EmitSignalDeactivateDialog();
3068 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3069 SALOME_ListIO selected;
3071 aSel->selectedObjects( selected );
3073 SALOME_ListIteratorOfListIO It (selected);
3074 for ( ; It.More(); It.Next() )
3076 SMESH::SMESH_GroupOnGeom_var aGroup =
3077 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
3078 if (!aGroup->_is_nil()) {
3079 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3084 SMESH::SMESH_GroupOnFilter_var aGroup =
3085 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
3086 if (!aGroup->_is_nil()) {
3087 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3095 case SMESHOp::OpUnionGroups:
3096 case SMESHOp::OpIntersectGroups:
3097 case SMESHOp::OpCutGroups:
3101 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3105 if ( isStudyLocked() )
3108 EmitSignalDeactivateDialog();
3110 SMESHGUI_GroupOpDlg* aDlg = 0;
3111 if ( theCommandID == SMESHOp::OpUnionGroups )
3112 aDlg = new SMESHGUI_UnionGroupsDlg( this );
3113 else if ( theCommandID == SMESHOp::OpIntersectGroups )
3114 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3116 aDlg = new SMESHGUI_CutGroupsDlg( this );
3123 case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
3125 if ( isStudyLocked() )
3128 EmitSignalDeactivateDialog();
3129 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3135 case SMESHOp::OpDeleteGroup: // Delete groups with their contents
3139 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3143 if ( isStudyLocked() )
3146 EmitSignalDeactivateDialog();
3148 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3152 case SMESHOp::OpMeshInformation:
3153 case SMESHOp::OpWhatIs:
3155 int page = theCommandID == SMESHOp::OpMeshInformation ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3156 EmitSignalDeactivateDialog();
3157 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3158 SALOME_ListIO selected;
3160 aSel->selectedObjects( selected );
3162 if ( selected.Extent() > 1 ) { // a dlg for each IO
3163 SALOME_ListIteratorOfListIO It( selected );
3164 for ( ; It.More(); It.Next() ) {
3165 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3166 dlg->showInfo( It.Value() );
3171 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3177 case SMESHOp::OpFindElementByPoint:
3179 startOperation( theCommandID );
3183 case SMESHOp::OpEditHypothesis:
3185 if(isStudyLocked()) break;
3187 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3188 SALOME_ListIO selected;
3190 aSel->selectedObjects( selected );
3192 int nbSel = selected.Extent();
3195 Handle(SALOME_InteractiveObject) anIObject = selected.First();
3196 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3198 if ( !aHypothesis->_is_nil() )
3200 SMESHGUI_GenericHypothesisCreator* aCreator =
3201 SMESH::GetHypothesisCreator( SMESH::toQStr( aHypothesis->GetName() ));
3204 // set geometry of mesh and sub-mesh to aCreator
3205 aSel->selectedObjects( selected, "", /*convertReferences=*/false);
3206 if ( selected.Extent() == 1 )
3208 QString subGeomID, meshGeomID;
3209 Handle(SALOME_InteractiveObject) hypIO = selected.First();
3210 if ( SMESH::GetGeomEntries( hypIO, subGeomID, meshGeomID ))
3212 if ( subGeomID.isEmpty() ) subGeomID = meshGeomID;
3213 aCreator->setShapeEntry( subGeomID );
3214 aCreator->setMainShapeEntry( meshGeomID );
3218 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3228 case SMESHOp::OpUnassign: // REMOVE HYPOTHESIS / ALGORITHMS
3230 if(isStudyLocked()) break;
3231 SUIT_OverrideCursor wc;
3233 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3234 SALOME_ListIO selected;
3236 aSel->selectedObjects( selected, QString::null, false );
3238 SALOME_ListIteratorOfListIO It(selected);
3239 for (int i = 0; It.More(); It.Next(), i++) {
3240 Handle(SALOME_InteractiveObject) IObject = It.Value();
3241 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3244 aSel->setSelectedObjects( l1 );
3249 case SMESHOp::OpElem0D:
3250 case SMESHOp::OpBall:
3251 case SMESHOp::OpEdge:
3252 case SMESHOp::OpTriangle:
3253 case SMESHOp::OpQuadrangle:
3254 case SMESHOp::OpPolygon:
3255 case SMESHOp::OpTetrahedron:
3256 case SMESHOp::OpHexahedron:
3257 case SMESHOp::OpPentahedron:
3258 case SMESHOp::OpPyramid:
3259 case SMESHOp::OpHexagonalPrism:
3261 if(isStudyLocked()) break;
3263 EmitSignalDeactivateDialog();
3264 SMDSAbs_EntityType type = SMDSEntity_Edge;
3265 switch (theCommandID) {
3266 case SMESHOp::OpElem0D: type = SMDSEntity_0D; break;
3267 case SMESHOp::OpBall: type = SMDSEntity_Ball; break;
3268 case SMESHOp::OpTriangle: type = SMDSEntity_Triangle; break;
3269 case SMESHOp::OpQuadrangle: type = SMDSEntity_Quadrangle; break;
3270 case SMESHOp::OpTetrahedron: type = SMDSEntity_Tetra; break;
3271 case SMESHOp::OpPolygon: type = SMDSEntity_Polygon; break;
3272 case SMESHOp::OpHexahedron: type = SMDSEntity_Hexa; break;
3273 case SMESHOp::OpPentahedron: type = SMDSEntity_Penta; break;
3274 case SMESHOp::OpPyramid: type = SMDSEntity_Pyramid; break;
3275 case SMESHOp::OpHexagonalPrism: type = SMDSEntity_Hexagonal_Prism; break;
3278 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3281 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3285 case SMESHOp::OpPolyhedron:
3287 if(isStudyLocked()) break;
3289 EmitSignalDeactivateDialog();
3290 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3293 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3297 case SMESHOp::OpQuadraticEdge:
3298 case SMESHOp::OpQuadraticTriangle:
3299 case SMESHOp::OpBiQuadraticTriangle:
3300 case SMESHOp::OpQuadraticQuadrangle:
3301 case SMESHOp::OpBiQuadraticQuadrangle:
3302 case SMESHOp::OpQuadraticPolygon:
3303 case SMESHOp::OpQuadraticTetrahedron:
3304 case SMESHOp::OpQuadraticPyramid:
3305 case SMESHOp::OpQuadraticPentahedron:
3306 case SMESHOp::OpBiQuadraticPentahedron:
3307 case SMESHOp::OpQuadraticHexahedron:
3308 case SMESHOp::OpTriQuadraticHexahedron:
3310 if(isStudyLocked()) break;
3312 EmitSignalDeactivateDialog();
3313 SMDSAbs_EntityType type = SMDSEntity_Last;
3315 switch (theCommandID) {
3316 case SMESHOp::OpQuadraticEdge: type = SMDSEntity_Quad_Edge; break;
3317 case SMESHOp::OpQuadraticTriangle: type = SMDSEntity_Quad_Triangle; break;
3318 case SMESHOp::OpBiQuadraticTriangle: type = SMDSEntity_BiQuad_Triangle; break;
3319 case SMESHOp::OpQuadraticQuadrangle: type = SMDSEntity_Quad_Quadrangle; break;
3320 case SMESHOp::OpBiQuadraticQuadrangle: type = SMDSEntity_BiQuad_Quadrangle; break;
3321 case SMESHOp::OpQuadraticPolygon: type = SMDSEntity_Quad_Polygon; break;
3322 case SMESHOp::OpQuadraticTetrahedron: type = SMDSEntity_Quad_Tetra; break;
3323 case SMESHOp::OpQuadraticPyramid: type = SMDSEntity_Quad_Pyramid; break;
3324 case SMESHOp::OpQuadraticPentahedron: type = SMDSEntity_Quad_Penta; break;
3325 case SMESHOp::OpBiQuadraticPentahedron: type = SMDSEntity_BiQuad_Penta; break;
3326 case SMESHOp::OpQuadraticHexahedron: type = SMDSEntity_Quad_Hexa; break;
3327 case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
3330 if ( type != SMDSEntity_Last )
3331 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3334 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3335 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3339 case SMESHOp::OpRemoveNodes:
3341 if(isStudyLocked()) break;
3343 EmitSignalDeactivateDialog();
3344 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3347 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3348 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3352 case SMESHOp::OpRemoveElements: // REMOVES ELEMENTS
3354 if(isStudyLocked()) break;
3356 EmitSignalDeactivateDialog();
3357 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3361 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3362 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3366 case SMESHOp::OpClearMesh: {
3368 if(isStudyLocked()) break;
3370 SALOME_ListIO selected;
3371 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3372 aSel->selectedObjects( selected );
3374 SUIT_OverrideCursor wc;
3375 SALOME_ListIteratorOfListIO It (selected);
3376 for ( ; It.More(); It.Next() )
3378 Handle(SALOME_InteractiveObject) IOS = It.Value();
3379 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3380 if ( aMesh->_is_nil()) continue;
3383 if ( aMesh->NbNodes() == 0 ) // imported mesh is not empty
3384 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3385 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3386 // hide groups and submeshes
3387 _PTR(ChildIterator) anIter =
3388 SMESH::getStudy()->NewChildIterator( aMeshSObj );
3389 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3391 _PTR(SObject) so = anIter->Value();
3392 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3395 catch (const SALOME::SALOME_Exception& S_ex){
3397 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3401 SMESH::UpdateView();
3405 case SMESHOp::OpRemoveOrphanNodes:
3407 if(isStudyLocked()) break;
3408 SALOME_ListIO selected;
3409 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3410 aSel->selectedObjects( selected );
3411 if ( selected.Extent() == 1 ) {
3412 Handle(SALOME_InteractiveObject) anIO = selected.First();
3413 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3414 if ( !aMesh->_is_nil() ) {
3415 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3416 tr( "SMESH_WARNING" ),
3417 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3418 SUIT_MessageBox::Yes |
3419 SUIT_MessageBox::No,
3420 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3423 SUIT_OverrideCursor wc;
3424 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3425 int removed = aMeshEditor->RemoveOrphanNodes();
3426 SUIT_MessageBox::information(SMESHGUI::desktop(),
3427 tr("SMESH_INFORMATION"),
3428 tr("NB_NODES_REMOVED").arg(removed));
3429 if ( removed > 0 ) {
3430 SMESH::UpdateView();
3431 SMESHGUI::Modified();
3434 catch (const SALOME::SALOME_Exception& S_ex) {
3435 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3444 case SMESHOp::OpRenumberingNodes:
3446 if(isStudyLocked()) break;
3448 EmitSignalDeactivateDialog();
3449 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3453 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3454 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3458 case SMESHOp::OpRenumberingElements:
3460 if(isStudyLocked()) break;
3462 EmitSignalDeactivateDialog();
3463 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3467 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3468 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3472 case SMESHOp::OpTranslation:
3474 if(isStudyLocked()) break;
3476 EmitSignalDeactivateDialog();
3477 ( new SMESHGUI_TranslationDlg( this ) )->show();
3480 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3481 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3485 case SMESHOp::OpRotation:
3487 if(isStudyLocked()) break;
3489 EmitSignalDeactivateDialog();
3490 ( new SMESHGUI_RotationDlg( this ) )->show();
3493 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3494 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3498 case SMESHOp::OpSymmetry:
3500 if(isStudyLocked()) break;
3502 EmitSignalDeactivateDialog();
3503 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3506 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3507 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3511 case SMESHOp::OpScale:
3513 if(isStudyLocked()) break;
3515 EmitSignalDeactivateDialog();
3516 ( new SMESHGUI_ScaleDlg( this ) )->show();
3519 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3520 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3525 case SMESHOp::OpOffset:
3527 if(isStudyLocked()) break;
3529 EmitSignalDeactivateDialog();
3530 ( new SMESHGUI_OffsetDlg( this ) )->show();
3533 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3534 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3539 case SMESHOp::OpSewing:
3541 if(isStudyLocked()) break;
3543 EmitSignalDeactivateDialog();
3544 ( new SMESHGUI_SewingDlg( this ) )->show();
3547 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3548 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3552 case SMESHOp::OpMergeNodes:
3554 if(isStudyLocked()) break;
3556 EmitSignalDeactivateDialog();
3557 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3560 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3561 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3565 case SMESHOp::OpMergeElements:
3567 if (isStudyLocked()) break;
3569 EmitSignalDeactivateDialog();
3570 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3572 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3573 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3578 case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
3579 startOperation( SMESHOp::OpMoveNode );
3582 case SMESHOp::OpDuplicateNodes:
3584 if(isStudyLocked()) break;
3586 EmitSignalDeactivateDialog();
3587 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3590 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3591 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3596 case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
3597 startOperation( SMESHOp::OpElem0DOnElemNodes );
3600 case SMESHOp::OpSelectFiltersLibrary: // Library of selection filters
3602 static QList<int> aTypes;
3603 if ( aTypes.isEmpty() )
3605 aTypes.append( SMESH::NODE );
3606 aTypes.append( SMESH::EDGE );
3607 aTypes.append( SMESH::FACE );
3608 aTypes.append( SMESH::VOLUME );
3610 if (!myFilterLibraryDlg)
3611 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3612 else if (myFilterLibraryDlg->isHidden())
3613 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3614 myFilterLibraryDlg->raise();
3618 case SMESHOp::OpFreeNode:
3619 case SMESHOp::OpEqualNode:
3620 case SMESHOp::OpNodeConnectivityNb:
3621 case SMESHOp::OpFreeEdge:
3622 case SMESHOp::OpFreeBorder:
3623 case SMESHOp::OpLength:
3624 case SMESHOp::OpConnection:
3625 case SMESHOp::OpEqualEdge:
3626 case SMESHOp::OpFreeFace:
3627 case SMESHOp::OpBareBorderFace:
3628 case SMESHOp::OpOverConstrainedFace:
3629 case SMESHOp::OpLength2D:
3630 case SMESHOp::OpDeflection2D:
3631 case SMESHOp::OpConnection2D:
3632 case SMESHOp::OpArea:
3633 case SMESHOp::OpTaper:
3634 case SMESHOp::OpAspectRatio:
3635 case SMESHOp::OpMinimumAngle:
3636 case SMESHOp::OpWarpingAngle:
3637 case SMESHOp::OpSkew:
3638 case SMESHOp::OpMaxElementLength2D:
3639 case SMESHOp::OpEqualFace:
3640 case SMESHOp::OpAspectRatio3D:
3641 case SMESHOp::OpVolume:
3642 case SMESHOp::OpMaxElementLength3D:
3643 case SMESHOp::OpBareBorderVolume:
3644 case SMESHOp::OpOverConstrainedVolume:
3645 case SMESHOp::OpEqualVolume:
3648 LightApp_SelectionMgr* mgr = selectionMgr();
3649 SALOME_ListIO selected; mgr->selectedObjects( selected );
3651 if( !selected.IsEmpty() ) {
3652 SUIT_OverrideCursor wc;
3653 ::Control( theCommandID );
3656 SUIT_MessageBox::warning(desktop(),
3657 tr( "SMESH_WRN_WARNING" ),
3658 tr( "SMESH_BAD_SELECTION" ) );
3662 SUIT_MessageBox::warning(desktop(),
3663 tr( "SMESH_WRN_WARNING" ),
3664 tr( "NOT_A_VTK_VIEWER" ) );
3667 case SMESHOp::OpOverallMeshQuality:
3668 OverallMeshQuality();
3670 case SMESHOp::OpNumberingNodes:
3672 SUIT_OverrideCursor wc;
3673 LightApp_SelectionMgr* mgr = selectionMgr();
3674 SALOME_ListIO selected; mgr->selectedObjects( selected );
3676 SALOME_ListIteratorOfListIO it(selected);
3677 for( ; it.More(); it.Next()) {
3678 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3679 if(anIObject->hasEntry()) {
3680 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3681 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3687 case SMESHOp::OpNumberingElements:
3689 SUIT_OverrideCursor wc;
3690 LightApp_SelectionMgr* mgr = selectionMgr();
3691 SALOME_ListIO selected; mgr->selectedObjects( selected );
3693 SALOME_ListIteratorOfListIO it(selected);
3694 for( ; it.More(); it.Next()) {
3695 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3696 if(anIObject->hasEntry())
3697 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3698 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3703 case SMESHOp::OpPropertiesLength:
3704 case SMESHOp::OpPropertiesArea:
3705 case SMESHOp::OpPropertiesVolume:
3706 case SMESHOp::OpMinimumDistance:
3707 case SMESHOp::OpBoundingBox:
3709 int page = SMESHGUI_MeasureDlg::MinDistance;
3710 if ( theCommandID == SMESHOp::OpBoundingBox )
3711 page = SMESHGUI_MeasureDlg::BoundingBox;
3712 else if ( theCommandID == SMESHOp::OpPropertiesLength )
3713 page = SMESHGUI_MeasureDlg::Length;
3714 else if ( theCommandID == SMESHOp::OpPropertiesArea )
3715 page = SMESHGUI_MeasureDlg::Area;
3716 else if ( theCommandID == SMESHOp::OpPropertiesVolume )
3717 page = SMESHGUI_MeasureDlg::Volume;
3719 EmitSignalDeactivateDialog();
3720 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3724 case SMESHOp::OpSortChild:
3730 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3731 //updateObjBrowser();
3735 //=============================================================================
3739 //=============================================================================
3740 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3745 //=============================================================================
3749 //=============================================================================
3750 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3755 //=============================================================================
3759 //=============================================================================
3760 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3765 //=============================================================================
3766 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3767 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3769 //=============================================================================
3770 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3771 SUIT_ViewWindow* wnd )
3773 if(theIO->hasEntry()){
3774 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3775 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3779 //=======================================================================
3780 // function : createSMESHAction
3782 //=======================================================================
3783 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3784 const int key, const bool toggle, const QString& shortcutAction )
3787 QWidget* parent = application()->desktop();
3788 SUIT_ResourceMgr* resMgr = resourceMgr();
3790 if ( !icon_id.isEmpty() )
3791 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3793 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3794 if ( !pix.isNull() )
3795 icon = QIcon( pix );
3797 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3798 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3799 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3801 createAction( id, tooltip, icon, menu, status_bar, key, parent,
3802 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3805 //=======================================================================
3806 // function : createPopupItem
3808 //=======================================================================
3809 void SMESHGUI::createPopupItem( const int id,
3810 const QString& clients,
3811 const QString& types,
3812 const QString& theRule,
3815 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3816 popupMgr()->insert( action( id ), pId, 0 );
3818 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3819 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
3820 QString rule = "(%1) and (%2) and (%3)";
3821 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3822 if( clients.isEmpty() )
3823 rule = rule.arg( QString( "true" ) );
3825 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3826 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3829 bool cont = myRules.contains( id );
3831 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3833 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3834 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3837 //=======================================================================
3838 // function : initialize
3840 //=======================================================================
3841 void SMESHGUI::initialize( CAM_Application* app )
3843 SalomeApp_Module::initialize( app );
3845 // SUIT_ResourceMgr* mgr = app->resourceMgr();
3847 /* Automatic Update flag */
3848 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3850 // ----- create actions --------------
3852 //createSMESHAction( SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
3853 createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_I) );
3854 createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
3855 createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL" );
3857 createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
3859 createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
3860 createSMESHAction( SMESHOp::OpImportGMF, "IMPORT_GMF" );
3861 createSMESHAction( SMESHOp::OpPopupImportUNV, "IMPORT_UNV");
3862 createSMESHAction( SMESHOp::OpPopupImportMED, "IMPORT_MED");
3863 createSMESHAction( SMESHOp::OpPopupImportSTL, "IMPORT_STL" );
3865 createSMESHAction( SMESHOp::OpPopupImportCGNS, "IMPORT_CGNS" );
3867 createSMESHAction( SMESHOp::OpPopupImportSAUV, "IMPORT_SAUV" );
3868 createSMESHAction( SMESHOp::OpPopupImportGMF, "IMPORT_GMF" );
3870 createSMESHAction( SMESHOp::OpExportDAT, "DAT" );
3871 createSMESHAction( SMESHOp::OpExportMED, "MED" );
3872 createSMESHAction( SMESHOp::OpExportUNV, "UNV" );
3873 createSMESHAction( SMESHOp::OpExportSTL, "STL" );
3875 createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
3877 createSMESHAction( SMESHOp::OpExportSAUV, "SAUV");
3878 createSMESHAction( SMESHOp::OpExportGMF, "GMF" );
3879 createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
3880 createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
3881 createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
3882 createSMESHAction( SMESHOp::OpPopupExportSTL, "STL" );
3884 createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
3886 createSMESHAction( SMESHOp::OpPopupExportSAUV, "SAUV");
3887 createSMESHAction( SMESHOp::OpPopupExportGMF, "GMF" );
3888 createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
3889 createSMESHAction( SMESHOp::OpDelete, "DELETE", "ICON_DELETE", Qt::Key_Delete );
3890 createSMESHAction( SMESHOp::OpSelectFiltersLibrary, "SEL_FILTER_LIB" );
3891 createSMESHAction( SMESHOp::OpCreateMesh, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
3892 createSMESHAction( SMESHOp::OpCreateSubMesh, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
3893 createSMESHAction( SMESHOp::OpEditMeshOrSubMesh, "EDIT_MESHSUBMESH", "ICON_DLG_EDIT_MESH" );
3894 createSMESHAction( SMESHOp::OpEditMesh, "EDIT_MESH", "ICON_DLG_EDIT_MESH" );
3895 createSMESHAction( SMESHOp::OpEditSubMesh, "EDIT_SUBMESH", "ICON_DLG_EDIT_MESH" );
3896 createSMESHAction( SMESHOp::OpBuildCompoundMesh, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
3897 createSMESHAction( SMESHOp::OpCopyMesh, "COPY_MESH", "ICON_COPY_MESH" );
3898 createSMESHAction( SMESHOp::OpCompute, "COMPUTE", "ICON_COMPUTE" );
3899 createSMESHAction( SMESHOp::OpComputeSubMesh, "COMPUTE_SUBMESH", "ICON_COMPUTE" );
3900 createSMESHAction( SMESHOp::OpPreCompute, "PRECOMPUTE", "ICON_PRECOMPUTE" );
3901 createSMESHAction( SMESHOp::OpEvaluate, "EVALUATE", "ICON_EVALUATE" );
3902 createSMESHAction( SMESHOp::OpMeshOrder, "MESH_ORDER", "ICON_MESH_ORDER");
3903 createSMESHAction( SMESHOp::OpCreateGroup, "CREATE_GROUP", "ICON_CREATE_GROUP" );
3904 createSMESHAction( SMESHOp::OpCreateGeometryGroup, "CREATE_GEO_GROUP", "ICON_CREATE_GEO_GROUP" );
3905 createSMESHAction( SMESHOp::OpConstructGroup, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
3906 createSMESHAction( SMESHOp::OpEditGroup, "EDIT_GROUP", "ICON_EDIT_GROUP" );
3907 createSMESHAction( SMESHOp::OpEditGeomGroupAsGroup, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3908 createSMESHAction( SMESHOp::OpUnionGroups, "UN_GROUP", "ICON_UNION" );
3909 createSMESHAction( SMESHOp::OpIntersectGroups, "INT_GROUP", "ICON_INTERSECT" );
3910 createSMESHAction( SMESHOp::OpCutGroups, "CUT_GROUP", "ICON_CUT" );
3911 createSMESHAction( SMESHOp::OpGroupUnderlyingElem, "UNDERLYING_ELEMS", "ICON_UNDERLYING_ELEMS" );
3912 createSMESHAction( SMESHOp::OpAddElemGroupPopup, "ADD_TO_GROUP" );
3913 createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE_FROM_GROUP" );
3914 createSMESHAction( SMESHOp::OpDeleteGroup, "DEL_GROUP", "ICON_DEL_GROUP" );
3915 createSMESHAction( SMESHOp::OpMeshInformation , "ADV_INFO", "ICON_ADV_INFO" );
3916 //createSMESHAction( SMESHOp::OpStdInfo, "STD_INFO", "ICON_STD_INFO" );
3917 //createSMESHAction( SMESHOp::OpWhatIs, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3918 createSMESHAction( SMESHOp::OpFindElementByPoint, "FIND_ELEM", "ICON_FIND_ELEM" );
3920 createSMESHAction( SMESHOp::OpFreeNode, "FREE_NODE", "ICON_FREE_NODE", 0, true );
3921 createSMESHAction( SMESHOp::OpEqualNode, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
3922 createSMESHAction( SMESHOp::OpNodeConnectivityNb, "NODE_CONNECTIVITY_NB", "ICON_NODE_CONN_NB", 0, true );
3923 createSMESHAction( SMESHOp::OpFreeEdge, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
3924 createSMESHAction( SMESHOp::OpFreeBorder, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
3925 createSMESHAction( SMESHOp::OpLength, "LENGTH", "ICON_LENGTH", 0, true );
3926 createSMESHAction( SMESHOp::OpConnection, "CONNECTION", "ICON_CONNECTION", 0, true );
3927 createSMESHAction( SMESHOp::OpEqualEdge, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
3928 createSMESHAction( SMESHOp::OpFreeFace, "FREE_FACES", "ICON_FREE_FACES", 0, true );
3929 createSMESHAction( SMESHOp::OpBareBorderFace, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
3930 createSMESHAction( SMESHOp::OpOverConstrainedFace, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
3931 createSMESHAction( SMESHOp::OpLength2D, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
3932 createSMESHAction( SMESHOp::OpDeflection2D, "DEFLECTION_2D", "ICON_DEFLECTION_2D", 0, true );
3933 createSMESHAction( SMESHOp::OpConnection2D, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
3934 createSMESHAction( SMESHOp::OpArea, "AREA", "ICON_AREA", 0, true );
3935 createSMESHAction( SMESHOp::OpTaper, "TAPER", "ICON_TAPER", 0, true );
3936 createSMESHAction( SMESHOp::OpAspectRatio, "ASPECT", "ICON_ASPECT", 0, true );
3937 createSMESHAction( SMESHOp::OpMinimumAngle, "MIN_ANG", "ICON_ANGLE", 0, true );
3938 createSMESHAction( SMESHOp::OpWarpingAngle, "WARP", "ICON_WARP", 0, true );
3939 createSMESHAction( SMESHOp::OpSkew, "SKEW", "ICON_SKEW", 0, true );
3940 createSMESHAction( SMESHOp::OpMaxElementLength2D, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
3941 createSMESHAction( SMESHOp::OpEqualFace, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
3942 createSMESHAction( SMESHOp::OpAspectRatio3D, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
3943 createSMESHAction( SMESHOp::OpVolume, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
3944 createSMESHAction( SMESHOp::OpMaxElementLength3D, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
3945 createSMESHAction( SMESHOp::OpBareBorderVolume, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
3946 createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
3947 createSMESHAction( SMESHOp::OpEqualVolume, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
3948 createSMESHAction( SMESHOp::OpOverallMeshQuality, "OVERALL_MESH_QUALITY", "ICON_OVL_MESH_QUALITY" );
3950 createSMESHAction( SMESHOp::OpNode, "NODE", "ICON_DLG_NODE" );
3951 createSMESHAction( SMESHOp::OpElem0D, "ELEM0D", "ICON_DLG_ELEM0D" );
3952 createSMESHAction( SMESHOp::OpElem0DOnElemNodes, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
3953 createSMESHAction( SMESHOp::OpBall, "BALL", "ICON_DLG_BALL" );
3954 createSMESHAction( SMESHOp::OpEdge, "EDGE", "ICON_DLG_EDGE" );
3955 createSMESHAction( SMESHOp::OpTriangle, "TRIANGLE", "ICON_DLG_TRIANGLE" );
3956 createSMESHAction( SMESHOp::OpQuadrangle, "QUAD", "ICON_DLG_QUADRANGLE" );
3957 createSMESHAction( SMESHOp::OpPolygon, "POLYGON", "ICON_DLG_POLYGON" );
3958 createSMESHAction( SMESHOp::OpTetrahedron, "TETRA", "ICON_DLG_TETRAS" );
3959 createSMESHAction( SMESHOp::OpHexahedron, "HEXA", "ICON_DLG_HEXAS" );
3960 createSMESHAction( SMESHOp::OpPentahedron, "PENTA", "ICON_DLG_PENTA" );
3961 createSMESHAction( SMESHOp::OpPyramid , "PYRAMID", "ICON_DLG_PYRAMID" );
3962 createSMESHAction( SMESHOp::OpHexagonalPrism, "OCTA", "ICON_DLG_OCTA" );
3963 createSMESHAction( SMESHOp::OpPolyhedron, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
3964 createSMESHAction( SMESHOp::OpQuadraticEdge, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
3965 createSMESHAction( SMESHOp::OpQuadraticTriangle, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
3966 createSMESHAction( SMESHOp::OpBiQuadraticTriangle, "BIQUADRATIC_TRIANGLE", "ICON_DLG_BIQUADRATIC_TRIANGLE" );
3967 createSMESHAction( SMESHOp::OpQuadraticQuadrangle, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
3968 createSMESHAction( SMESHOp::OpBiQuadraticQuadrangle, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
3969 createSMESHAction( SMESHOp::OpQuadraticPolygon, "QUADRATIC_POLYGON", "ICON_DLG_QUADRATIC_POLYGON" );
3970 createSMESHAction( SMESHOp::OpQuadraticTetrahedron, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
3971 createSMESHAction( SMESHOp::OpQuadraticPyramid, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
3972 createSMESHAction( SMESHOp::OpQuadraticPentahedron, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
3973 createSMESHAction( SMESHOp::OpBiQuadraticPentahedron, "BIQUADRATIC_PENTAHEDRON", "ICON_DLG_BIQUADRATIC_PENTAHEDRON" );
3974 createSMESHAction( SMESHOp::OpQuadraticHexahedron, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
3975 createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
3977 createSMESHAction( SMESHOp::OpRemoveNodes, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
3978 createSMESHAction( SMESHOp::OpRemoveElements, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
3979 createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
3980 createSMESHAction( SMESHOp::OpClearMesh, "CLEAR_MESH", "ICON_CLEAR_MESH" );
3982 //createSMESHAction( SMESHOp::OpRenumberingNodes, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
3983 //createSMESHAction( SMESHOp::OpRenumberingElements, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
3985 createSMESHAction( SMESHOp::OpTranslation, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
3986 createSMESHAction( SMESHOp::OpRotation, "ROT", "ICON_DLG_MESH_ROTATION" );
3987 createSMESHAction( SMESHOp::OpSymmetry, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
3988 createSMESHAction( SMESHOp::OpScale, "SCALE", "ICON_DLG_MESH_SCALE" );
3989 createSMESHAction( SMESHOp::OpOffset, "OFFSET", "ICON_DLG_MESH_OFFSET" );
3990 createSMESHAction( SMESHOp::OpSewing, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
3991 createSMESHAction( SMESHOp::OpMergeNodes, "MERGE", "ICON_SMESH_MERGE_NODES" );
3992 createSMESHAction( SMESHOp::OpMergeElements, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
3993 createSMESHAction( SMESHOp::OpMoveNode, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
3994 createSMESHAction( SMESHOp::OpDuplicateNodes, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
3995 createSMESHAction( SMESHOp::OpDiagonalInversion, "INV", "ICON_DLG_MESH_DIAGONAL" );
3996 createSMESHAction( SMESHOp::OpUnionOfTwoTriangle, "UNION2", "ICON_UNION2TRI" );
3997 createSMESHAction( SMESHOp::OpOrientation, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
3998 createSMESHAction( SMESHOp::OpReorientFaces, "REORIENT_2D", "ICON_REORIENT_2D" );
3999 createSMESHAction( SMESHOp::OpUnionOfTriangles, "UNION", "ICON_UNIONTRI" );
4000 createSMESHAction( SMESHOp::OpCuttingOfQuadrangles, "CUT", "ICON_CUTQUAD" );
4001 createSMESHAction( SMESHOp::OpSplitVolumes, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
4002 createSMESHAction( SMESHOp::OpSplitBiQuadratic, "SPLIT_BIQUAD", "ICON_SPLIT_BIQUAD" );
4003 createSMESHAction( SMESHOp::OpSmoothing, "SMOOTH", "ICON_DLG_SMOOTHING" );
4004 createSMESHAction( SMESHOp::OpExtrusion, "EXTRUSION", "ICON_EXTRUSION" );
4005 createSMESHAction( SMESHOp::OpExtrusionAlongAPath, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
4006 createSMESHAction( SMESHOp::OpRevolution, "REVOLUTION", "ICON_REVOLUTION" );
4007 createSMESHAction( SMESHOp::OpPatternMapping, "MAP", "ICON_MAP" );
4008 createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
4009 createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D", "ICON_2D_FROM_3D" );
4011 createSMESHAction( SMESHOp::OpReset, "RESET" );
4012 createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
4013 createSMESHAction( SMESHOp::OpShowScalarBar, "SHOW_SCALAR_BAR","",0, true );
4014 createSMESHAction( SMESHOp::OpSaveDistribution, "SAVE_DISTRIBUTION" );
4015 createSMESHAction( SMESHOp::OpShowDistribution, "SHOW_DISTRIBUTION","",0, true );
4016 #ifndef DISABLE_PLOT2DVIEWER
4017 createSMESHAction( SMESHOp::OpPlotDistribution, "PLOT_DISTRIBUTION" );
4019 createSMESHAction( SMESHOp::OpDMWireframe, "WIRE", "ICON_WIRE", 0, true );
4020 createSMESHAction( SMESHOp::OpDMShading, "SHADE", "ICON_SHADE", 0, true );
4021 createSMESHAction( SMESHOp::OpDMNodes, "NODES", "ICON_POINTS", 0, true );
4022 createSMESHAction( SMESHOp::OpDMShrink, "SHRINK", "ICON_SHRINK", 0, true );
4023 createSMESHAction( SMESHOp::OpUpdate, "UPDATE", "ICON_UPDATE" );
4024 createSMESHAction( SMESHOp::OpDE0DElements, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
4025 createSMESHAction( SMESHOp::OpDEEdges, "EDGES", "ICON_DLG_EDGE", 0, true );
4026 createSMESHAction( SMESHOp::OpDEFaces, "FACES", "ICON_DLG_TRIANGLE", 0, true );
4027 createSMESHAction( SMESHOp::OpDEVolumes, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
4028 createSMESHAction( SMESHOp::OpDEBalls, "BALLS", "ICON_DLG_BALL", 0, true );
4029 createSMESHAction( SMESHOp::OpDEChoose, "CHOOSE", "ICON_DLG_CHOOSE", 0, false );
4030 createSMESHAction( SMESHOp::OpDEAllEntity, "ALL", "ICON_DLG_CHOOSE_ALL", 0, false );
4031 createSMESHAction( SMESHOp::OpOrientationOnFaces, "FACE_ORIENTATION", "", 0, true );
4033 createSMESHAction( SMESHOp::OpRepresentationLines, "LINE_REPRESENTATION", "", 0, true );
4034 createSMESHAction( SMESHOp::OpRepresentationArcs, "ARC_REPRESENTATION", "", 0, true );
4036 createSMESHAction( SMESHOp::OpEditHypothesis, "EDIT_HYPO" );
4037 createSMESHAction( SMESHOp::OpUnassign, "UNASSIGN" );
4038 createSMESHAction( SMESHOp::OpNumberingNodes, "NUM_NODES", "", 0, true );
4039 createSMESHAction( SMESHOp::OpNumberingElements, "NUM_ELEMENTS", "", 0, true );
4040 createSMESHAction( SMESHOp::OpProperties, "COLORS" );
4041 createSMESHAction( SMESHOp::OpTransparency, "TRANSP" );
4042 createSMESHAction( SMESHOp::OpClipping, "CLIP" );
4043 createSMESHAction( SMESHOp::OpAutoColor, "AUTO_COLOR" );
4044 createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
4046 createSMESHAction( SMESHOp::OpMinimumDistance, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
4047 createSMESHAction( SMESHOp::OpBoundingBox, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
4048 createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH", "ICON_MEASURE_LENGTH" );
4049 createSMESHAction( SMESHOp::OpPropertiesArea, "MEASURE_AREA", "ICON_MEASURE_AREA" );
4050 createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME", "ICON_MEASURE_VOLUME" );
4052 createSMESHAction( SMESHOp::OpHide, "HIDE", "ICON_HIDE" );
4053 createSMESHAction( SMESHOp::OpShow, "SHOW", "ICON_SHOW" );
4054 createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
4056 createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
4058 QList<int> aCtrlActions;
4059 aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode
4060 << SMESHOp::OpNodeConnectivityNb // node controls
4061 << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
4062 << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge // edge controls
4063 << SMESHOp::OpDeflection2D
4064 << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
4065 << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
4066 << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
4067 << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
4068 << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace // face controls
4069 << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
4070 << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
4071 << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume; // volume controls
4072 QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
4073 aCtrlGroup->setExclusive( true );
4074 for( int i = 0; i < aCtrlActions.size(); i++ )
4075 aCtrlGroup->addAction( action( aCtrlActions[i] ) );
4077 // ----- create menu --------------
4078 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
4079 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
4080 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
4081 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
4082 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
4083 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
4084 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
4085 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
4087 createMenu( separator(), fileId );
4089 QMenu* nodeMenu = new QMenu(); QMenu* edgeMenu = new QMenu();
4090 QMenu* faceMenu = new QMenu(); QMenu* volumeMenu = new QMenu();
4091 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
4092 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
4093 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10, -1, nodeMenu ),
4094 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10, -1, edgeMenu ),
4095 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10, -1, faceMenu ),
4096 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10, -1, volumeMenu ),
4097 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
4098 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
4099 //renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
4100 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
4101 basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
4103 //createMenu( SMESHOp::OpImportDAT, importId, -1 );
4104 createMenu( SMESHOp::OpImportUNV, importId, -1 );
4105 createMenu( SMESHOp::OpImportMED, importId, -1 );
4106 createMenu( SMESHOp::OpImportSTL, importId, -1 );
4108 createMenu( SMESHOp::OpImportCGNS, importId, -1 );
4110 createMenu( SMESHOp::OpImportSAUV, importId, -1 );
4111 createMenu( SMESHOp::OpImportGMF, importId, -1 );
4112 createMenu( SMESHOp::OpExportDAT, exportId, -1 );
4113 createMenu( SMESHOp::OpExportMED, exportId, -1 );
4114 createMenu( SMESHOp::OpExportUNV, exportId, -1 );
4115 createMenu( SMESHOp::OpExportSTL, exportId, -1 );
4117 createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
4119 createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
4120 createMenu( SMESHOp::OpExportGMF, exportId, -1 );
4121 createMenu( separator(), fileId, 10 );
4123 createMenu( SMESHOp::OpDelete, editId, -1 );
4125 createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
4127 createMenu( SMESHOp::OpCreateMesh, meshId, -1 ); // "Mesh" menu
4128 createMenu( SMESHOp::OpCreateSubMesh, meshId, -1 );
4129 createMenu( SMESHOp::OpEditMeshOrSubMesh, meshId, -1 );
4130 createMenu( SMESHOp::OpBuildCompoundMesh, meshId, -1 );
4131 createMenu( SMESHOp::OpCopyMesh, meshId, -1 );
4132 createMenu( separator(), meshId, -1 );
4133 createMenu( SMESHOp::OpCompute, meshId, -1 );
4134 createMenu( SMESHOp::OpPreCompute, meshId, -1 );
4135 createMenu( SMESHOp::OpEvaluate, meshId, -1 );
4136 createMenu( SMESHOp::OpMeshOrder, meshId, -1 );
4137 createMenu( separator(), meshId, -1 );
4138 createMenu( SMESHOp::OpCreateGroup, meshId, -1 );
4139 createMenu( SMESHOp::OpCreateGeometryGroup, meshId, -1 );
4140 createMenu( SMESHOp::OpConstructGroup, meshId, -1 );
4141 createMenu( SMESHOp::OpEditGroup, meshId, -1 );
4142 createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4143 createMenu( separator(), meshId, -1 );
4144 createMenu( SMESHOp::OpUnionGroups, meshId, -1 );
4145 createMenu( SMESHOp::OpIntersectGroups, meshId, -1 );
4146 createMenu( SMESHOp::OpCutGroups, meshId, -1 );
4147 createMenu( separator(), meshId, -1 );
4148 createMenu( SMESHOp::OpGroupUnderlyingElem, meshId, -1 );
4149 createMenu( separator(), meshId, -1 );
4150 createMenu( SMESHOp::OpMeshInformation, meshId, -1 );
4151 //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4152 //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4153 createMenu( SMESHOp::OpFindElementByPoint, meshId, -1 );
4154 createMenu( separator(), meshId, -1 );
4156 createMenu( SMESHOp::OpFreeNode, nodeId, -1 );
4157 createMenu( SMESHOp::OpEqualNode, nodeId, -1 );
4158 //createMenu( SMESHOp::OpNodeConnectivityNb, nodeId, -1 );
4159 createMenu( SMESHOp::OpFreeBorder, edgeId, -1 );
4160 createMenu( SMESHOp::OpLength, edgeId, -1 );
4161 createMenu( SMESHOp::OpConnection, edgeId, -1 );
4162 createMenu( SMESHOp::OpEqualEdge, edgeId, -1 );
4163 createMenu( SMESHOp::OpFreeEdge, faceId, -1 );
4164 createMenu( SMESHOp::OpFreeFace, faceId, -1 );
4165 createMenu( SMESHOp::OpBareBorderFace, faceId, -1 );
4166 createMenu( SMESHOp::OpOverConstrainedFace, faceId, -1 );
4167 createMenu( SMESHOp::OpLength2D, faceId, -1 );
4168 createMenu( SMESHOp::OpConnection2D, faceId, -1 );
4169 createMenu( SMESHOp::OpArea, faceId, -1 );
4170 createMenu( SMESHOp::OpTaper, faceId, -1 );
4171 createMenu( SMESHOp::OpAspectRatio, faceId, -1 );
4172 createMenu( SMESHOp::OpMinimumAngle, faceId, -1 );
4173 createMenu( SMESHOp::OpWarpingAngle, faceId, -1 );
4174 createMenu( SMESHOp::OpSkew, faceId, -1 );
4175 createMenu( SMESHOp::OpMaxElementLength2D, faceId, -1 );
4176 createMenu( SMESHOp::OpEqualFace, faceId, -1 );
4177 createMenu( SMESHOp::OpDeflection2D, faceId, -1 );
4178 createMenu( SMESHOp::OpAspectRatio3D, volumeId, -1 );
4179 createMenu( SMESHOp::OpVolume, volumeId, -1 );
4180 createMenu( SMESHOp::OpMaxElementLength3D, volumeId, -1 );
4181 createMenu( SMESHOp::OpBareBorderVolume, volumeId, -1 );
4182 createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4183 createMenu( SMESHOp::OpEqualVolume, volumeId, -1 );
4184 createMenu( separator(), ctrlId, -1 );
4185 createMenu( SMESHOp::OpReset, ctrlId, -1 );
4186 createMenu( separator(), ctrlId, -1 );
4187 createMenu( SMESHOp::OpOverallMeshQuality, ctrlId, -1 );
4189 createMenu( SMESHOp::OpNode, addId, -1 );
4190 createMenu( SMESHOp::OpElem0D, addId, -1 );
4191 createMenu( SMESHOp::OpElem0DOnElemNodes, addId, -1 );
4192 createMenu( SMESHOp::OpBall, addId, -1 );
4193 createMenu( SMESHOp::OpEdge, addId, -1 );
4194 createMenu( SMESHOp::OpTriangle, addId, -1 );
4195 createMenu( SMESHOp::OpQuadrangle, addId, -1 );
4196 createMenu( SMESHOp::OpPolygon, addId, -1 );
4197 createMenu( SMESHOp::OpTetrahedron, addId, -1 );
4198 createMenu( SMESHOp::OpHexahedron, addId, -1 );
4199 createMenu( SMESHOp::OpPentahedron, addId, -1 );
4200 createMenu( SMESHOp::OpPyramid, addId, -1 );
4201 createMenu( SMESHOp::OpHexagonalPrism, addId, -1 );
4202 createMenu( SMESHOp::OpPolyhedron, addId, -1 );
4203 createMenu( separator(), addId, -1 );
4204 createMenu( SMESHOp::OpQuadraticEdge, addId, -1 );
4205 createMenu( SMESHOp::OpQuadraticTriangle, addId, -1 );
4206 createMenu( SMESHOp::OpBiQuadraticTriangle , addId, -1 );
4207 createMenu( SMESHOp::OpQuadraticQuadrangle, addId, -1 );
4208 createMenu( SMESHOp::OpBiQuadraticQuadrangle, addId, -1 );
4209 createMenu( SMESHOp::OpQuadraticPolygon, addId, -1 );
4210 createMenu( SMESHOp::OpQuadraticTetrahedron, addId, -1 );
4211 createMenu( SMESHOp::OpQuadraticPyramid, addId, -1 );
4212 createMenu( SMESHOp::OpQuadraticPentahedron, addId, -1 );
4213 createMenu( SMESHOp::OpBiQuadraticPentahedron, addId, -1 );
4214 createMenu( SMESHOp::OpQuadraticHexahedron, addId, -1 );
4215 createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4217 createMenu( SMESHOp::OpRemoveNodes, removeId, -1 );
4218 createMenu( SMESHOp::OpRemoveElements, removeId, -1 );
4219 createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4220 createMenu( separator(), removeId, -1 );
4221 createMenu( SMESHOp::OpDeleteGroup, removeId, -1 );
4222 createMenu( separator(), removeId, -1 );
4223 createMenu( SMESHOp::OpClearMesh, removeId, -1 );
4225 //createMenu( SMESHOp::OpRenumberingNodes, renumId, -1 );
4226 //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4228 createMenu( SMESHOp::OpMergeNodes, transfId, -1 );
4229 createMenu( SMESHOp::OpMergeElements, transfId, -1 );
4230 createMenu( SMESHOp::OpTranslation, transfId, -1 );
4231 createMenu( SMESHOp::OpRotation, transfId, -1 );
4232 createMenu( SMESHOp::OpSymmetry, transfId, -1 );
4233 createMenu( SMESHOp::OpScale, transfId, -1 );
4234 createMenu( SMESHOp::OpOffset, transfId, -1 );
4235 createMenu( SMESHOp::OpSewing, transfId, -1 );
4236 createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4238 createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4239 createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4240 createMenu( SMESHOp::OpExtrusion, modifyId, -1 );
4241 createMenu( SMESHOp::OpExtrusionAlongAPath, modifyId, -1 );
4242 createMenu( SMESHOp::OpRevolution, modifyId, -1 );
4243 createMenu( SMESHOp::OpOrientation, modifyId, -1 );
4244 createMenu( SMESHOp::OpReorientFaces, modifyId, -1 );
4245 createMenu( SMESHOp::OpMoveNode, modifyId, -1 );
4246 createMenu( SMESHOp::OpDiagonalInversion, modifyId, -1 );
4247 createMenu( SMESHOp::OpUnionOfTwoTriangle, modifyId, -1 );
4248 createMenu( SMESHOp::OpUnionOfTriangles, modifyId, -1 );
4249 createMenu( SMESHOp::OpCuttingOfQuadrangles, modifyId, -1 );
4250 createMenu( SMESHOp::OpSplitVolumes, modifyId, -1 );
4251 createMenu( SMESHOp::OpSplitBiQuadratic, modifyId, -1 );
4252 createMenu( SMESHOp::OpSmoothing, modifyId, -1 );
4253 createMenu( SMESHOp::OpPatternMapping, modifyId, -1 );
4255 createMenu( SMESHOp::OpMinimumDistance, measureId, -1 );
4256 createMenu( SMESHOp::OpBoundingBox, measureId, -1 );
4257 createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4258 createMenu( SMESHOp::OpPropertiesArea, basicPropId, -1 );
4259 createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4260 createMenu( SMESHOp::OpUpdate, viewId, -1 );
4262 connect( nodeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4263 connect( edgeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4264 connect( faceMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4265 connect( volumeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4267 // ----- create toolbars --------------
4268 int meshTb = createTool( tr( "TB_MESH" ), QString( "SMESHMeshToolbar" ) ),
4269 info = createTool( tr( "TB_INFO" ), QString( "SMESHInformationToolbar" ) ),
4270 groupTb = createTool( tr( "TB_GROUP" ), QString( "SMESHGroupToolbar" ) ),
4271 ctrl0dTb = createTool( tr( "TB_CTRL0D" ), QString( "SMESHNodeControlsToolbar" ) ),
4272 ctrl1dTb = createTool( tr( "TB_CTRL1D" ), QString( "SMESHEdgeControlsToolbar" ) ),
4273 ctrl2dTb = createTool( tr( "TB_CTRL2D" ), QString( "SMESHFaceControlsToolbar" ) ),
4274 ctrl3dTb = createTool( tr( "TB_CTRL3D" ), QString( "SMESHVolumeControlsToolbar" ) ),
4275 addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ),
4276 addNonElemTb = createTool( tr( "TB_ADDNON" ), QString( "SMESHAddElementToolbar" ) ),
4277 remTb = createTool( tr( "TB_REM" ), QString( "SMESHRemoveToolbar" ) ),
4278 //renumbTb = createTool( tr( "TB_RENUMBER" ), QString( "SMESHRenumberingToolbar" ) ),
4279 transformTb = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ),
4280 modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ),
4281 measuremTb = createTool( tr( "TB_MEASUREM" ), QString( "SMESHMeasurementsToolbar" ) ),
4282 dispModeTb = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4284 createTool( SMESHOp::OpCreateMesh, meshTb );
4285 createTool( SMESHOp::OpCreateSubMesh, meshTb );
4286 createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4287 createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4288 createTool( SMESHOp::OpCopyMesh, meshTb );
4289 createTool( separator(), meshTb );
4290 createTool( SMESHOp::OpCompute, meshTb );
4291 createTool( SMESHOp::OpPreCompute, meshTb );
4292 createTool( SMESHOp::OpEvaluate, meshTb );
4293 createTool( SMESHOp::OpMeshOrder, meshTb );
4295 createTool( SMESHOp::OpCreateGroup, groupTb );
4296 createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4297 createTool( SMESHOp::OpConstructGroup, groupTb );
4298 createTool( SMESHOp::OpEditGroup, groupTb );
4300 createTool( SMESHOp::OpMeshInformation, info );
4301 //createTool( SMESHOp::OpStdInfo, meshTb );
4302 //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4303 createTool( SMESHOp::OpFindElementByPoint, info );
4305 createTool( SMESHOp::OpFreeNode, ctrl0dTb );
4306 createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4307 //createTool( SMESHOp::OpNodeConnectivityNb, ctrl0dTb );
4309 createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4310 createTool( SMESHOp::OpLength, ctrl1dTb );
4311 createTool( SMESHOp::OpConnection, ctrl1dTb );
4312 createTool( SMESHOp::OpEqualEdge, ctrl1dTb );
4314 createTool( SMESHOp::OpFreeEdge, ctrl2dTb );
4315 createTool( SMESHOp::OpFreeFace, ctrl2dTb );
4316 createTool( SMESHOp::OpBareBorderFace, ctrl2dTb );
4317 createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4318 createTool( SMESHOp::OpLength2D, ctrl2dTb );
4319 createTool( SMESHOp::OpConnection2D, ctrl2dTb );
4320 createTool( SMESHOp::OpArea, ctrl2dTb );
4321 createTool( SMESHOp::OpTaper, ctrl2dTb );
4322 createTool( SMESHOp::OpAspectRatio, ctrl2dTb );
4323 createTool( SMESHOp::OpMinimumAngle, ctrl2dTb );
4324 createTool( SMESHOp::OpWarpingAngle, ctrl2dTb );
4325 createTool( SMESHOp::OpSkew, ctrl2dTb );
4326 createTool( SMESHOp::OpMaxElementLength2D, ctrl2dTb );
4327 createTool( SMESHOp::OpEqualFace, ctrl2dTb );
4328 createTool( SMESHOp::OpDeflection2D, ctrl2dTb );
4330 createTool( SMESHOp::OpAspectRatio3D, ctrl3dTb );
4331 createTool( SMESHOp::OpVolume, ctrl3dTb );
4332 createTool( SMESHOp::OpMaxElementLength3D, ctrl3dTb );
4333 createTool( SMESHOp::OpBareBorderVolume, ctrl3dTb );
4334 createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
4335 createTool( SMESHOp::OpEqualVolume, ctrl3dTb );
4337 createTool( SMESHOp::OpNode, addElemTb );
4338 createTool( SMESHOp::OpElem0D, addElemTb );
4339 createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4340 createTool( SMESHOp::OpBall, addElemTb );
4341 createTool( SMESHOp::OpEdge, addElemTb );
4342 createTool( SMESHOp::OpTriangle, addElemTb );
4343 createTool( SMESHOp::OpQuadrangle, addElemTb );
4344 createTool( SMESHOp::OpPolygon, addElemTb );
4345 createTool( SMESHOp::OpTetrahedron, addElemTb );
4346 createTool( SMESHOp::OpHexahedron, addElemTb );
4347 createTool( SMESHOp::OpPentahedron, addElemTb );
4348 createTool( SMESHOp::OpPyramid, addElemTb );
4349 createTool( SMESHOp::OpHexagonalPrism, addElemTb );
4350 createTool( SMESHOp::OpPolyhedron, addElemTb );
4352 createTool( SMESHOp::OpQuadraticEdge, addNonElemTb );
4353 createTool( SMESHOp::OpQuadraticTriangle, addNonElemTb );
4354 createTool( SMESHOp::OpBiQuadraticTriangle, addNonElemTb );
4355 createTool( SMESHOp::OpQuadraticQuadrangle, addNonElemTb );
4356 createTool( SMESHOp::OpBiQuadraticQuadrangle, addNonElemTb );
4357 createTool( SMESHOp::OpQuadraticPolygon, addNonElemTb );
4358 createTool( SMESHOp::OpQuadraticTetrahedron, addNonElemTb );
4359 createTool( SMESHOp::OpQuadraticPyramid, addNonElemTb );
4360 createTool( SMESHOp::OpQuadraticPentahedron, addNonElemTb );
4361 createTool( SMESHOp::OpBiQuadraticPentahedron, addNonElemTb );
4362 createTool( SMESHOp::OpQuadraticHexahedron, addNonElemTb );
4363 createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4365 createTool( SMESHOp::OpRemoveNodes, remTb );
4366 createTool( SMESHOp::OpRemoveElements, remTb );
4367 createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4368 createTool( SMESHOp::OpClearMesh, remTb );
4370 //createTool( SMESHOp::OpRenumberingNodes, renumbTb );
4371 //createTool( SMESHOp::OpRenumberingElements, renumbTb );
4373 createTool( SMESHOp::OpMergeNodes, transformTb );
4374 createTool( SMESHOp::OpMergeElements, transformTb );
4375 createTool( SMESHOp::OpTranslation, transformTb );
4376 createTool( SMESHOp::OpRotation, transformTb );
4377 createTool( SMESHOp::OpSymmetry, transformTb );
4378 createTool( SMESHOp::OpScale, transformTb );
4379 createTool( SMESHOp::OpOffset, transformTb );
4380 createTool( SMESHOp::OpSewing, transformTb );
4381 createTool( SMESHOp::OpDuplicateNodes, transformTb );
4383 createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4384 createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4385 createTool( SMESHOp::OpExtrusion, modifyTb );
4386 createTool( SMESHOp::OpExtrusionAlongAPath, modifyTb );
4387 createTool( SMESHOp::OpRevolution, modifyTb );
4388 createTool( SMESHOp::OpOrientation, modifyTb );
4389 createTool( SMESHOp::OpReorientFaces, modifyTb );
4390 createTool( SMESHOp::OpMoveNode, modifyTb );
4391 createTool( SMESHOp::OpDiagonalInversion, modifyTb );
4392 createTool( SMESHOp::OpUnionOfTwoTriangle, modifyTb );
4393 createTool( SMESHOp::OpUnionOfTriangles, modifyTb );
4394 createTool( SMESHOp::OpCuttingOfQuadrangles, modifyTb );
4395 createTool( SMESHOp::OpSplitVolumes, modifyTb );
4396 createTool( SMESHOp::OpSplitBiQuadratic, modifyTb );
4397 createTool( SMESHOp::OpSmoothing, modifyTb );
4398 createTool( SMESHOp::OpPatternMapping, modifyTb );
4400 createTool( SMESHOp::OpMinimumDistance, measuremTb );
4402 createTool( SMESHOp::OpUpdate, dispModeTb );
4404 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4405 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4409 OB = "'ObjectBrowser'",
4410 View = "'" + SVTK_Viewer::Type() + "'",
4412 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4413 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4414 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4415 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4416 smesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::COMPONENT ) ),
4417 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4418 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4419 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4420 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4421 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4422 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4423 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4425 mesh_part = mesh + " " + subMesh + " " + group,
4426 mesh_group = mesh + " " + group,
4427 mesh_submesh = mesh + " " + subMesh,
4428 hyp_alg = hypo + " " + algo;
4430 // popup for object browser
4432 isInvisible("not( isVisible )"),
4433 isEmpty("numberOfNodes = 0"),
4434 isNotEmpty("numberOfNodes <> 0"),
4436 // has nodes, edges, etc in VISIBLE! actor
4437 hasNodes("(numberOfNodes > 0 ) && hasActor"),
4438 hasElems("(count( elemTypes ) > 0)"),
4439 hasDifferentElems("(count( elemTypes ) > 1)"),
4440 hasDifferentObjElems("(count( objElemTypes ) > 1)"),
4441 hasBalls("({'BallElem'} in elemTypes)"),
4442 hasElems0d("({'Elem0d'} in elemTypes)"),
4443 hasEdges("({'Edge'} in elemTypes)"),
4444 hasFaces("({'Face'} in elemTypes)"),
4445 hasVolumes("({'Volume'} in elemTypes)"),
4446 hasFacesOrVolumes("(({'Face'} in elemTypes) || ({'Volume'} in elemTypes)) ");
4448 createPopupItem( SMESHOp::OpFileInformation, OB, mesh, "&& selcount=1 && isImported" );
4449 createPopupItem( SMESHOp::OpCreateSubMesh, OB, mesh, "&& hasGeomReference");
4450 createPopupItem( SMESHOp::OpEditMesh, OB, mesh, "&& selcount=1" );
4451 createPopupItem( SMESHOp::OpEditSubMesh, OB, subMesh, "&& selcount=1 && hasGeomReference" );
4452 createPopupItem( SMESHOp::OpEditGroup, OB, group );
4453 createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4455 popupMgr()->insert( separator(), -1, 0 );
4456 createPopupItem( SMESHOp::OpCompute, OB, mesh, "&& selcount=1 && isComputable" );
4457 createPopupItem( SMESHOp::OpComputeSubMesh, OB, subMesh, "&& selcount=1 && isComputable" );
4458 createPopupItem( SMESHOp::OpPreCompute, OB, mesh, "&& selcount=1 && isPreComputable" );
4459 createPopupItem( SMESHOp::OpEvaluate, OB, mesh, "&& selcount=1 && isComputable" );
4460 createPopupItem( SMESHOp::OpMeshOrder, OB, mesh, "&& selcount=1 && isComputable && hasGeomReference" );
4461 createPopupItem( SMESHOp::OpUpdate, OB, mesh_part );
4462 createPopupItem( SMESHOp::OpMeshInformation, OB, mesh_part );
4463 createPopupItem( SMESHOp::OpFindElementByPoint,OB, mesh_group, "&& selcount=1" );
4464 createPopupItem( SMESHOp::OpOverallMeshQuality,OB, mesh_part );
4465 popupMgr()->insert( separator(), -1, 0 );
4466 createPopupItem( SMESHOp::OpCreateGroup, OB, mesh, "&& selcount=1" );
4467 createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh, "&& selcount=1 && hasGeomReference" );
4468 createPopupItem( SMESHOp::OpConstructGroup, OB, subMesh );
4469 popupMgr()->insert( separator(), -1, 0 );
4470 createPopupItem( SMESHOp::OpEditHypothesis, OB, hypo, "&& isEditableHyp");
4471 createPopupItem( SMESHOp::OpUnassign, OB, hyp_alg );
4472 popupMgr()->insert( separator(), -1, 0 );
4473 createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh_submesh );
4474 createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh_group, "&& selcount=1 && dim>=2");
4475 popupMgr()->insert( separator(), -1, 0 );
4476 createPopupItem( SMESHOp::OpClearMesh, OB, mesh );
4477 //popupMgr()->insert( separator(), -1, 0 );
4479 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4480 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4481 QString only_one_2D = only_one_non_empty + " && dim>1";
4483 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4484 createPopupItem( SMESHOp::OpPopupExportMED, OB, mesh_group, multiple_non_empty, anId );
4485 createPopupItem( SMESHOp::OpPopupExportUNV, OB, mesh_group, only_one_non_empty, anId );
4486 createPopupItem( SMESHOp::OpPopupExportSTL, OB, mesh_group, only_one_2D, anId );
4488 createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4490 createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, only_one_non_empty, anId );
4491 createPopupItem( SMESHOp::OpPopupExportGMF, OB, mesh_group, only_one_non_empty, anId );
4492 createPopupItem( SMESHOp::OpPopupExportDAT, OB, mesh_group, only_one_non_empty, anId );
4493 createPopupItem( SMESHOp::OpDelete, OB, mesh_part + " " + hyp_alg );
4494 createPopupItem( SMESHOp::OpDeleteGroup, OB, group );
4496 anId = popupMgr()->insert( tr( "MEN_IMPORT" ), -1, -1 ); // IMPORT submenu
4497 createPopupItem( SMESHOp::OpPopupImportMED, OB, smesh, "", anId );
4498 createPopupItem( SMESHOp::OpPopupImportUNV, OB, smesh, "", anId );
4499 createPopupItem( SMESHOp::OpPopupImportSTL, OB, smesh, "", anId );
4501 createPopupItem( SMESHOp::OpPopupImportCGNS, OB, smesh, "", anId );
4503 createPopupItem( SMESHOp::OpPopupImportSAUV, OB, smesh, "", anId );
4504 createPopupItem( SMESHOp::OpPopupImportGMF, OB, smesh, "", anId );
4505 createPopupItem( SMESHOp::OpPopupImportDAT, OB, smesh, "", anId );
4506 popupMgr()->insert( separator(), -1, 0 );
4509 createPopupItem( SMESHOp::OpEditGroup, View, group );
4510 createPopupItem( SMESHOp::OpAddElemGroupPopup, View, elems, "&& guiState = 800" );
4511 createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems, "&& guiState = 800" );
4513 popupMgr()->insert( separator(), -1, 0 );
4514 createPopupItem( SMESHOp::OpUpdate, View, mesh_part );
4515 createPopupItem( SMESHOp::OpMeshInformation, View, mesh_part );
4516 createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4517 createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh );
4518 popupMgr()->insert( separator(), -1, 0 );
4520 createPopupItem( SMESHOp::OpAutoColor, OB + " " + View, mesh, "&& (not isAutoColor)" );
4521 createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4522 popupMgr()->insert( separator(), -1, 0 );
4524 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4525 QString aType = QString( "%1type in {%2}" ).arg( lc );
4526 aType = aType.arg( mesh_part );
4527 QString aMeshInVTK = aClient + "&&" + aType;
4529 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4530 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4531 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4533 //-------------------------------------------------
4535 //-------------------------------------------------
4536 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4538 popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4539 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4540 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4542 popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4543 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4544 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4546 popupMgr()->insert( separator(), -1, -1 );
4548 //-------------------------------------------------
4550 //-------------------------------------------------
4551 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4553 popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4554 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4555 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4557 popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4558 popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4559 popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4561 popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4562 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4563 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4565 popupMgr()->insert( separator(), anId, -1 );
4567 popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4568 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4569 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4571 //-------------------------------------------------
4573 //-------------------------------------------------
4574 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4576 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4578 popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4579 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4580 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4582 popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4583 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4584 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4586 popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4587 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4588 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4590 popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4591 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4592 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4594 popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4595 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4596 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4598 popupMgr()->insert( separator(), anId, -1 );
4600 popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4601 popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&& $type in {" + mesh + "} &&" + hasDifferentObjElems, QtxPopupMgr::VisibleRule );
4603 popupMgr()->insert( separator(), anId, -1 );
4605 popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4606 popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4609 //-------------------------------------------------
4610 // Representation of the 2D Quadratic elements
4611 //-------------------------------------------------
4612 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4613 popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4614 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "&& isVisible && isQuadratic",QtxPopupMgr::VisibleRule );
4615 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4617 popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4618 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "&& isVisible && isQuadratic", QtxPopupMgr::VisibleRule );
4619 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4621 //-------------------------------------------------
4622 // Orientation of faces
4623 //-------------------------------------------------
4624 popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4625 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4626 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4628 //-------------------------------------------------
4630 //-------------------------------------------------
4631 popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4632 popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4634 //-------------------------------------------------
4636 //-------------------------------------------------
4637 popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4638 popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4640 //-------------------------------------------------
4642 //-------------------------------------------------
4644 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4645 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4646 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4647 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4649 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4651 popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4652 popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4654 popupMgr()->insert( separator(), anId, -1 );
4656 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4658 popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4659 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4660 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4662 popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4663 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4664 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4666 // popupMgr()->insert( action( SMESHOp::OpNodeConnectivityNb ), aSubId, -1 );
4667 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4668 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), "controlMode = 'eNodeConnectivityNb'", QtxPopupMgr::ToggleRule );
4670 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4672 popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4673 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVTK + "&&" + hasEdges + "&&" + hasFacesOrVolumes, QtxPopupMgr::VisibleRule );
4674 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4676 popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4677 popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4678 popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4680 popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4681 popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4682 popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4683 popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4684 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4685 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4687 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4689 popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4690 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4691 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4693 popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4694 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4695 QtxPopupMgr::VisibleRule );
4696 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4698 popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4699 popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4700 popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4702 popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4703 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4704 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4706 popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
4707 popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4708 popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4710 popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
4711 popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4712 popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4714 popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
4715 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4716 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4718 popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
4719 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4720 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4722 popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
4723 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4724 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4726 popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
4727 popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4728 popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4730 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
4731 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4732 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4734 popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
4735 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4736 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4738 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
4739 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4740 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4742 popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
4743 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4744 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4746 popupMgr()->insert ( action( SMESHOp::OpDeflection2D ), aSubId, -1 );
4747 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), aMeshInVtkHasFaces + " && hasGeomReference", QtxPopupMgr::VisibleRule );
4748 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), "controlMode = 'eDeflection2D'", QtxPopupMgr::ToggleRule );
4750 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4752 popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D ), aSubId, -1 );
4753 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4754 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4756 popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
4757 popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4758 popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4760 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
4761 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4762 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4764 popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
4765 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4766 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4768 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
4769 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4770 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4772 popupMgr()->insert ( action( SMESHOp::OpEqualVolume ), aSubId, -1 );
4773 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4774 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4776 popupMgr()->insert( separator(), anId, -1 );
4778 popupMgr()->insert( action( SMESHOp::OpShowScalarBar ), anId, -1 );
4779 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4780 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone' && isScalarBarVisible", QtxPopupMgr::ToggleRule );
4781 popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
4782 popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4784 popupMgr()->insert( separator(), anId, -1 );
4786 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4788 popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
4789 popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4791 popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
4792 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4793 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isScalarBarVisible && isDistributionVisible", QtxPopupMgr::ToggleRule);
4795 #ifndef DISABLE_PLOT2DVIEWER
4796 popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
4797 popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4800 //-------------------------------------------------
4802 //-------------------------------------------------
4803 popupMgr()->insert( separator(), -1, -1 );
4804 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4805 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4806 popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
4807 popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4809 popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
4810 popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4812 popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
4813 popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4815 popupMgr()->insert( separator(), -1, -1 );
4817 //-------------------------------------------------
4819 //-------------------------------------------------
4820 popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
4821 popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4823 popupMgr()->insert( separator(), -1, -1 );
4825 popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
4826 popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
4827 popupMgr()->insert( separator(), -1, -1 );
4829 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4830 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4832 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4833 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4836 //================================================================================
4838 * \brief Return true if SMESH or GEOM objects are selected.
4839 * Is called form LightApp_Module::activateModule() which clear selection if
4840 * not isSelectionCompatible()
4842 //================================================================================
4844 bool SMESHGUI::isSelectionCompatible()
4846 bool isCompatible = true;
4847 SALOME_ListIO selected;
4848 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4849 Sel->selectedObjects( selected );
4851 SALOME_ListIteratorOfListIO It( selected );
4852 for ( ; isCompatible && It.More(); It.Next())
4854 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4855 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4857 return isCompatible;
4861 bool SMESHGUI::reusableOperation( const int id )
4863 // compute, evaluate and precompute are not reusable operations
4864 return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate ) ? false : SalomeApp_Module::reusableOperation( id );
4867 bool SMESHGUI::activateModule( SUIT_Study* study )
4869 bool res = SalomeApp_Module::activateModule( study );
4871 setMenuShown( true );
4872 setToolShown( true );
4874 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4875 PyGILState_STATE gstate = PyGILState_Ensure();
4876 PyObject* pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4877 if ( !pluginsmanager ) {
4881 PyObject* result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toUtf8().data(),tr("SMESH_PLUGINS_OTHER").toUtf8().data());
4886 PyGILState_Release(gstate);
4887 // end of SMESH plugins loading
4889 // Reset actions accelerator keys
4890 action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
4892 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4893 GetSMESHGen()->UpdateStudy();
4895 // get all view currently opened in the study and connect their signals to
4896 // the corresponding slots of the class.
4897 SUIT_Desktop* aDesk = study->application()->desktop();
4899 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4900 SUIT_ViewWindow* wnd;
4901 foreach ( wnd, wndList )
4905 Py_XDECREF(pluginsmanager);
4909 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4911 setMenuShown( false );
4912 setToolShown( false );
4914 EmitSignalCloseAllDialogs();
4916 // Unset actions accelerator keys
4917 action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
4919 return SalomeApp_Module::deactivateModule( study );
4922 void SMESHGUI::studyClosed( SUIT_Study* s )
4926 SMESH::RemoveVisuData();
4927 SalomeApp_Module::studyClosed( s );
4930 void SMESHGUI::OnGUIEvent()
4932 const QObject* obj = sender();
4933 if ( !obj || !obj->inherits( "QAction" ) )
4935 int id = actionId((QAction*)obj);
4940 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4942 if ( CORBA::is_nil( myComponentSMESH ) )
4944 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4945 return aGUI.myComponentSMESH;
4947 return myComponentSMESH;
4950 QString SMESHGUI::engineIOR() const
4952 CORBA::ORB_var anORB = getApp()->orb();
4953 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4954 return QString( anIOR.in() );
4957 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4959 SalomeApp_Module::contextMenuPopup( client, menu, title );
4961 selectionMgr()->selectedObjects( lst );
4962 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4963 Handle(SALOME_InteractiveObject) io = lst.First();
4964 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4965 _PTR(Study) study = appStudy->studyDS();
4966 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4968 QString aName = QString( SMESH::fromUtf8(obj->GetName()) );
4969 while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4970 aName.remove( (aName.length() - 1), 1 );
4976 LightApp_Selection* SMESHGUI::createSelection() const
4978 return new SMESHGUI_Selection();
4981 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4983 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4984 aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
4985 #ifndef DISABLE_PYCONSOLE
4986 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4990 void SMESHGUI::viewManagers( QStringList& list ) const
4992 list.append( SVTK_Viewer::Type() );
4995 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4997 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4998 SMESH::UpdateSelectionProp( this );
5000 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
5001 for(int i = 0; i < aViews.count() ; i++){
5002 SUIT_ViewWindow *sf = aViews[i];
5005 EmitSignalActivatedViewManager();
5009 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
5011 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
5012 myClippingPlaneInfoMap.erase( theViewManager );
5015 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
5017 theActor->AddObserver( SMESH::DeleteActorEvent,
5018 myEventCallbackCommand.GetPointer(),
5022 void SMESHGUI::ProcessEvents( vtkObject* theObject,
5023 unsigned long theEvent,
5024 void* theClientData,
5027 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
5028 if( theObject && (int) theEvent == SMESH::DeleteActorEvent ) {
5029 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
5030 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
5031 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
5032 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
5033 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
5034 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
5035 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
5036 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
5037 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
5038 SMESH::TActorList::iterator anIter3 = anActorList.begin();
5039 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
5040 if( anActor == *anIter3 ) {
5041 anActorList.erase( anIter3 );
5052 void SMESHGUI::createPreferences()
5054 // General tab ------------------------------------------------------------------------
5055 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
5057 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
5058 setPreferenceProperty( autoUpdate, "columns", 2 );
5059 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
5060 setPreferenceProperty( lim, "min", 0 );
5061 setPreferenceProperty( lim, "max", 100000000 );
5062 setPreferenceProperty( lim, "step", 1000 );
5063 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5064 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
5066 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
5067 setPreferenceProperty( dispgroup, "columns", 2 );
5068 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
5070 modes.append( tr("MEN_WIRE") );
5071 modes.append( tr("MEN_SHADE") );
5072 modes.append( tr("MEN_NODES") );
5073 modes.append( tr("MEN_SHRINK") );
5074 QList<QVariant> indices;
5075 indices.append( 0 );
5076 indices.append( 1 );
5077 indices.append( 2 );
5078 indices.append( 3 );
5079 setPreferenceProperty( dispmode, "strings", modes );
5080 setPreferenceProperty( dispmode, "indexes", indices );
5082 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
5083 setPreferenceProperty( arcgroup, "columns", 2 );
5084 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
5085 QStringList quadraticModes;
5086 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
5087 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
5089 indices.append( 0 );
5090 indices.append( 1 );
5091 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
5092 setPreferenceProperty( quadraticmode, "indexes", indices );
5094 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
5095 "SMESH", "max_angle" );
5096 setPreferenceProperty( maxAngle, "min", 1 );
5097 setPreferenceProperty( maxAngle, "max", 90 );
5099 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
5100 setPreferenceProperty( qaGroup, "columns", 2 );
5101 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
5102 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
5103 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
5104 setPreferenceProperty( prec, "min", 0 );
5105 setPreferenceProperty( prec, "max", 100 );
5106 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
5107 setPreferenceProperty( doubleNodesTol, "precision", 10 );
5108 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
5109 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
5110 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
5113 int cinc = addPreference(tr("PREF_CONTROLS_INCREMENT"), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_increment");
5114 setPreferenceProperty( cinc, "min", 0 );
5115 setPreferenceProperty( cinc, "max", 5 );
5118 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
5119 setPreferenceProperty( exportgroup, "columns", 2 );
5120 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
5121 addPreference( tr( "PREF_SHOW_WARN" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "show_warning" );
5122 int zTol = addPreference( tr( "PREF_ZTOLERANCE" ), exportgroup, LightApp_Preferences::DblSpin, "SMESH", "med_ztolerance" );
5123 setPreferenceProperty( zTol, "precision", 10 );
5124 setPreferenceProperty( zTol, "min", 0.0000000001 );
5125 setPreferenceProperty( zTol, "max", 1000000.0 );
5126 setPreferenceProperty( zTol, "step", 1. );
5127 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
5129 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
5130 setPreferenceProperty( computeGroup, "columns", 2 );
5131 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
5133 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5134 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5135 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5137 indices.append( 0 );
5138 indices.append( 1 );
5139 indices.append( 2 );
5140 setPreferenceProperty( notifyMode, "strings", modes );
5141 setPreferenceProperty( notifyMode, "indexes", indices );
5143 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5144 setPreferenceProperty( infoGroup, "columns", 2 );
5145 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5147 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5148 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5150 indices.append( 0 );
5151 indices.append( 1 );
5152 setPreferenceProperty( elemInfo, "strings", modes );
5153 setPreferenceProperty( elemInfo, "indexes", indices );
5154 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5155 setPreferenceProperty( nodesLim, "min", 0 );
5156 setPreferenceProperty( nodesLim, "max", 10000000 );
5157 setPreferenceProperty( nodesLim, "step", 10000 );
5158 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5159 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5160 setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5161 setPreferenceProperty( ctrlLim, "min", 0 );
5162 setPreferenceProperty( ctrlLim, "max", 10000000 );
5163 setPreferenceProperty( ctrlLim, "step", 1000 );
5164 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5165 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5166 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5167 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5168 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5170 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5171 setPreferenceProperty( segGroup, "columns", 2 );
5172 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5173 "SMESH", "segmentation" );
5174 setPreferenceProperty( segLen, "min", 1 );
5175 setPreferenceProperty( segLen, "max", 10000000 );
5176 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5177 "SMESH", "nb_segments_per_edge" );
5178 setPreferenceProperty( nbSeg, "min", 1 );
5179 setPreferenceProperty( nbSeg, "max", 10000000 );
5181 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5182 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5183 "SMESH", "forget_mesh_on_hyp_modif" );
5186 // Quantities with individual precision settings
5187 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5188 setPreferenceProperty( precGroup, "columns", 2 );
5190 const int nbQuantities = 6;
5191 int precs[nbQuantities], ii = 0;
5192 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5193 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5194 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5195 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5196 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5197 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5198 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5199 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5200 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5201 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5202 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5203 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5205 // Set property for precision value for spinboxes
5206 for ( ii = 0; ii < nbQuantities; ii++ ){
5207 setPreferenceProperty( precs[ii], "min", -14 );
5208 setPreferenceProperty( precs[ii], "max", 14 );
5209 setPreferenceProperty( precs[ii], "precision", 2 );
5212 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5213 setPreferenceProperty( previewGroup, "columns", 2 );
5214 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5215 setPreferenceProperty( chunkSize, "min", 1 );
5216 setPreferenceProperty( chunkSize, "max", 1000 );
5217 setPreferenceProperty( chunkSize, "step", 50 );
5219 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5220 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5222 // Mesh tab ------------------------------------------------------------------------
5223 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5224 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5225 setPreferenceProperty( nodeGroup, "columns", 3 );
5227 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5229 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5231 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5232 QList<QVariant> aMarkerTypeIndicesList;
5233 QList<QVariant> aMarkerTypeIconsList;
5234 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5235 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5236 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5237 aMarkerTypeIndicesList << i;
5238 aMarkerTypeIconsList << pixmap;
5240 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5241 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
5243 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5245 QList<QVariant> aMarkerScaleIndicesList;
5246 QStringList aMarkerScaleValuesList;
5247 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5248 aMarkerScaleIndicesList << i;
5249 //aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5250 aMarkerScaleValuesList << QString::number( i );
5252 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5253 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5255 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5256 //setPreferenceProperty( elemGroup, "columns", 2 );
5258 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5259 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5260 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5261 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5262 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5263 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5264 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5265 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5266 addPreference( tr( "PREF_PREVIEW_COLOR" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5269 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5270 setPreferenceProperty( grpGroup, "columns", 2 );
5272 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5273 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5275 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5276 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5277 /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5278 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5279 double ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5280 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5281 double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5282 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5283 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
5284 LightApp_Preferences::IntSpin, "SMESH", "element_width");
5285 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5286 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5287 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5288 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5290 setPreferenceProperty( size0d, "min", 1 );
5291 setPreferenceProperty( size0d, "max", 10 );
5293 // setPreferenceProperty( ballSize, "min", 1 );
5294 // setPreferenceProperty( ballSize, "max", 10 );
5296 setPreferenceProperty( ballDiameter, "min", 1e-7 );
5297 setPreferenceProperty( ballDiameter, "max", 1e9 );
5298 setPreferenceProperty( ballDiameter, "step", 0.1 );
5300 setPreferenceProperty( ballScale, "min", 1e-2 );
5301 setPreferenceProperty( ballScale, "max", 1e7 );
5302 setPreferenceProperty( ballScale, "step", 0.5 );
5304 setPreferenceProperty( elemW, "min", 1 );
5305 setPreferenceProperty( elemW, "max", 5 );
5307 setPreferenceProperty( outW, "min", 1 );
5308 setPreferenceProperty( outW, "max", 5 );
5310 setPreferenceProperty( shrink, "min", 0 );
5311 setPreferenceProperty( shrink, "max", 100 );
5313 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5314 setPreferenceProperty( numGroup, "columns", 2 );
5316 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5317 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5319 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5320 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5322 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5323 setPreferenceProperty( orientGroup, "columns", 1 );
5325 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5326 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5328 setPreferenceProperty( orientScale, "min", 0.05 );
5329 setPreferenceProperty( orientScale, "max", 0.5 );
5330 setPreferenceProperty( orientScale, "step", 0.05 );
5332 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5334 // Selection tab ------------------------------------------------------------------------
5335 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5337 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5338 setPreferenceProperty( selGroup, "columns", 2 );
5340 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5341 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5343 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5344 setPreferenceProperty( preGroup, "columns", 2 );
5346 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5348 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5349 setPreferenceProperty( precSelGroup, "columns", 2 );
5351 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5352 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5353 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5355 int sinc = addPreference(tr("PREF_SELECTION_INCREMENT"), selTab, LightApp_Preferences::IntSpin, "SMESH", "selection_increment");
5356 setPreferenceProperty( sinc, "min", 0 );
5357 setPreferenceProperty( sinc, "max", 5 );
5359 // Scalar Bar tab ------------------------------------------------------------------------
5360 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5361 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5362 setPreferenceProperty( fontGr, "columns", 2 );
5364 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5365 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5367 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5368 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5370 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5371 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5373 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5374 setPreferenceProperty( numcol, "min", 2 );
5375 setPreferenceProperty( numcol, "max", 256 );
5377 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5378 setPreferenceProperty( numlab, "min", 2 );
5379 setPreferenceProperty( numlab, "max", 65 );
5381 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5382 setPreferenceProperty( orientGr, "columns", 2 );
5383 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5384 QStringList orients;
5385 orients.append( tr( "SMESH_VERTICAL" ) );
5386 orients.append( tr( "SMESH_HORIZONTAL" ) );
5387 indices.clear(); indices.append( 0 ); indices.append( 1 );
5388 setPreferenceProperty( orient, "strings", orients );
5389 setPreferenceProperty( orient, "indexes", indices );
5391 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5392 setPreferenceProperty( posVSizeGr, "columns", 2 );
5393 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5394 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5395 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5396 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5397 setPreferenceProperty( xv, "step", 0.1 );
5398 setPreferenceProperty( xv, "min", 0.0 );
5399 setPreferenceProperty( xv, "max", 1.0 );
5400 setPreferenceProperty( yv, "step", 0.1 );
5401 setPreferenceProperty( yv, "min", 0.0 );
5402 setPreferenceProperty( yv, "max", 1.0 );
5403 setPreferenceProperty( wv, "step", 0.1 );
5404 setPreferenceProperty( wv, "min", 0.0 );
5405 setPreferenceProperty( wv, "max", 1.0 );
5406 setPreferenceProperty( hv, "min", 0.0 );
5407 setPreferenceProperty( hv, "max", 1.0 );
5408 setPreferenceProperty( hv, "step", 0.1 );
5410 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5411 setPreferenceProperty( posHSizeGr, "columns", 2 );
5412 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5413 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5414 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5415 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5416 setPreferenceProperty( xv, "min", 0.0 );
5417 setPreferenceProperty( xv, "max", 1.0 );
5418 setPreferenceProperty( xv, "step", 0.1 );
5419 setPreferenceProperty( xh, "min", 0.0 );
5420 setPreferenceProperty( xh, "max", 1.0 );
5421 setPreferenceProperty( xh, "step", 0.1 );
5422 setPreferenceProperty( yh, "min", 0.0 );
5423 setPreferenceProperty( yh, "max", 1.0 );
5424 setPreferenceProperty( yh, "step", 0.1 );
5425 setPreferenceProperty( wh, "min", 0.0 );
5426 setPreferenceProperty( wh, "max", 1.0 );
5427 setPreferenceProperty( wh, "step", 0.1 );
5428 setPreferenceProperty( hh, "min", 0.0 );
5429 setPreferenceProperty( hh, "max", 1.0 );
5430 setPreferenceProperty( hh, "step", 0.1 );
5432 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5433 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5434 setPreferenceProperty( distributionGr, "columns", 3 );
5436 types.append( tr( "SMESH_MONOCOLOR" ) );
5437 types.append( tr( "SMESH_MULTICOLOR" ) );
5438 indices.clear(); indices.append( 0 ); indices.append( 1 );
5439 setPreferenceProperty( coloringType, "strings", types );
5440 setPreferenceProperty( coloringType, "indexes", indices );
5441 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5445 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5447 if ( sect=="SMESH" ) {
5448 float sbX1 = 0.01, sbY1 = 0.01, sbW = 0.08, sbH = 0.08;
5449 float aTol = 1.00000009999999;
5450 std::string aWarning;
5451 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5453 if ( name== "selection_object_color" ||
5454 name=="selection_element_color" ||
5455 name== "highlight_color" ||
5456 name=="selection_precision_node" ||
5457 name=="selection_precision_element" ||
5458 name=="selection_precision_object" ||
5459 name=="selection_increment")
5461 SMESH::UpdateSelectionProp( this );
5463 else if (name == "scalar_bar_vertical_x" || name == "scalar_bar_vertical_width")
5465 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5466 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5467 if ( sbX1+sbW > aTol ) {
5468 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5471 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5472 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5475 else if (name == "scalar_bar_vertical_y" || name == "scalar_bar_vertical_height" )
5477 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5478 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5479 if ( sbY1 + sbH > aTol ) {
5480 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5481 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5482 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5485 else if (name == "scalar_bar_horizontal_x" || name == "scalar_bar_horizontal_width")
5487 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5488 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5489 if ( sbX1 + sbW > aTol ) {
5490 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5493 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5494 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5497 else if (name == "scalar_bar_horizontal_y" || name == "scalar_bar_horizontal_height")
5499 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5500 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5501 if ( sbY1 + sbH > aTol ) {
5502 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5505 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5506 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5509 else if ( name == "segmentation" )
5511 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5512 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5514 else if ( name == "nb_segments_per_edge" )
5516 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5517 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5519 else if ( name == "historical_python_dump" || name == "forget_mesh_on_hyp_modif" || name == "default_grp_color" )
5521 QString val = aResourceMgr->stringValue( "SMESH", name );
5522 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5524 else if ( name == "numbering_node_color" || name == "numbering_node_font" )
5526 SMESH::UpdateFontProp( this );
5528 else if ( name == "numbering_elem_color" || name == "numbering_elem_font" )
5530 SMESH::UpdateFontProp( this );
5533 if ( aWarning.size() != 0 ) {
5534 aWarning += "The default values are applied instead.";
5535 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5536 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5537 QObject::tr(aWarning.c_str()));
5542 //================================================================================
5544 * \brief Update something in accordance with update flags
5545 * \param theFlags - update flags
5547 * Update viewer or/and object browser etc. in accordance with update flags ( see
5548 * LightApp_UpdateFlags enumeration ).
5550 //================================================================================
5551 void SMESHGUI::update( const int flags )
5553 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5554 SMESH::UpdateView();
5556 SalomeApp_Module::update( flags );
5559 //================================================================================
5561 * \brief Set default selection mode
5563 * SLOT called when operation committed. Sets default selection mode
5565 //================================================================================
5566 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5568 SVTK_ViewWindow* vtkWnd =
5569 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5571 vtkWnd->SetSelectionMode( ActorSelection );
5574 //================================================================================
5576 * \brief Set default selection mode
5578 * SLOT called when operation aborted. Sets default selection mode
5580 //================================================================================
5581 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5583 SVTK_ViewWindow* vtkWnd =
5584 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5586 vtkWnd->SetSelectionMode( ActorSelection );
5589 //================================================================================
5591 * \brief Creates operation with given identifier
5592 * \param id - identifier of operation to be started
5593 * \return Pointer on created operation or NULL if operation is not created
5595 * Virtual method redefined from the base class creates operation with given id.
5596 * It is called called automatically from startOperation method of base class.
5598 //================================================================================
5599 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5601 LightApp_Operation* op = 0;
5602 // to do : create operation here
5605 case SMESHOp::OpSplitBiQuadratic:
5606 op = new SMESHGUI_SplitBiQuadOp();
5608 case SMESHOp::OpConvertMeshToQuadratic:
5609 op = new SMESHGUI_ConvToQuadOp();
5611 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5612 op = new SMESHGUI_Make2DFrom3DOp();
5614 case SMESHOp::OpReorientFaces:
5615 op = new SMESHGUI_ReorientFacesOp();
5617 case SMESHOp::OpCreateMesh:
5618 op = new SMESHGUI_MeshOp( true, true );
5620 case SMESHOp::OpCreateSubMesh:
5621 op = new SMESHGUI_MeshOp( true, false );
5623 case SMESHOp::OpEditMeshOrSubMesh:
5624 case SMESHOp::OpEditMesh:
5625 case SMESHOp::OpEditSubMesh:
5626 op = new SMESHGUI_MeshOp( false );
5628 case SMESHOp::OpCompute:
5629 case SMESHOp::OpComputeSubMesh:
5630 op = new SMESHGUI_ComputeOp();
5632 case SMESHOp::OpPreCompute:
5633 op = new SMESHGUI_PrecomputeOp();
5635 case SMESHOp::OpEvaluate:
5636 op = new SMESHGUI_EvaluateOp();
5638 case SMESHOp::OpMeshOrder:
5639 op = new SMESHGUI_MeshOrderOp();
5641 case SMESHOp::OpCreateGeometryGroup:
5642 op = new SMESHGUI_GroupOnShapeOp();
5644 case SMESHOp::OpFindElementByPoint:
5645 op = new SMESHGUI_FindElemByPointOp();
5647 case SMESHOp::OpMoveNode: // Make mesh pass through point
5648 op = new SMESHGUI_MakeNodeAtPointOp();
5650 case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
5651 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5658 op = SalomeApp_Module::createOperation( id );
5662 //================================================================================
5664 * \brief Stops current operations and starts a given one
5665 * \param id - The id of the operation to start
5667 //================================================================================
5669 void SMESHGUI::switchToOperation(int id)
5671 activeStudy()->abortAllOperations();
5672 startOperation( id );
5675 LightApp_Displayer* SMESHGUI::displayer()
5678 myDisplayer = new SMESHGUI_Displayer( getApp() );
5682 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5685 int aTolerance = 64;
5686 int anIterations = 0;
5692 if( anIterations % aPeriod == 0 )
5695 if( aTolerance < 1 )
5699 aHue = (int)( 360.0 * rand() / RAND_MAX );
5702 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5703 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5704 for( ; it != itEnd; ++it )
5706 SALOMEDS::Color anAutoColor = *it;
5707 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5710 aQColor.getHsv( &h, &s, &v );
5711 if( abs( h - aHue ) < aTolerance )
5723 aColor.setHsv( aHue, 255, 255 );
5725 SALOMEDS::Color aSColor;
5726 aSColor.R = aColor.redF();
5727 aSColor.G = aColor.greenF();
5728 aSColor.B = aColor.blueF();
5733 const char* gSeparator = "_"; // character used to separate parameter names
5734 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5735 const char* gPathSep = "|"; // character used to separate paths
5738 * \brief Store visual parameters
5740 * This method is called just before the study document is saved.
5741 * Store visual parameters in AttributeParameter attribute(s)
5743 void SMESHGUI::storeVisualParameters (int savePoint)
5746 Kernel_Utils::Localizer loc;
5748 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5749 if (!appStudy || !appStudy->studyDS())
5751 _PTR(Study) studyDS = appStudy->studyDS();
5753 // componentName is used for encoding of entries when storing them in IParameters
5754 std::string componentName = myComponentSMESH->ComponentDataType();
5755 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5756 //if (!aSComponent) return;
5759 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5760 componentName.c_str(),
5762 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5764 // store custom markers
5765 if( !myMarkerMap.empty() )
5767 VTK::MarkerMap::const_iterator anIter = myMarkerMap.begin();
5768 for( ; anIter != myMarkerMap.end(); anIter++ )
5770 int anId = anIter->first;
5771 VTK::MarkerData aMarkerData = anIter->second;
5772 std::string aMarkerFileName = aMarkerData.first;
5773 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5774 if( aMarkerTexture.size() < 3 )
5775 continue; // should contain at least width, height and the first value
5777 QString aPropertyName( "texture" );
5778 aPropertyName += gSeparator;
5779 aPropertyName += QString::number( anId );
5781 QString aPropertyValue = aMarkerFileName.c_str();
5782 aPropertyValue += gPathSep;
5784 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5785 ushort aWidth = *aTextureIter++;
5786 ushort aHeight = *aTextureIter++;
5787 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5788 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5789 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5790 aPropertyValue += QString::number( *aTextureIter );
5792 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5796 // viewers counters are used for storing view_numbers in IParameters
5799 // main cycle to store parameters of displayed objects
5800 QList<SUIT_ViewManager*> lst;
5801 QList<SUIT_ViewManager*>::Iterator it;
5802 getApp()->viewManagers(lst);
5803 for (it = lst.begin(); it != lst.end(); it++)
5805 SUIT_ViewManager* vman = *it;
5806 QString vType = vman->getType();
5808 // saving VTK actors properties
5809 if (vType == SVTK_Viewer::Type())
5811 // store the clipping planes attached to the view manager
5812 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5813 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5814 if( anIter != myClippingPlaneInfoMap.end() )
5815 aClippingPlaneInfoList = anIter->second;
5817 if( !aClippingPlaneInfoList.empty() ) {
5818 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5819 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5821 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5822 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5824 QString aPropertyName( "ClippingPlane" );
5825 aPropertyName += gSeparator;
5826 aPropertyName += QString::number( vtkViewers );
5827 aPropertyName += gSeparator;
5828 aPropertyName += QString::number( anId );
5830 QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
5831 aPropertyValue += gDigitsSep;
5832 aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
5833 aPropertyValue += gDigitsSep;
5834 if ( aPlane->PlaneMode == SMESH::Absolute ) {
5835 aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
5836 aPropertyValue += gDigitsSep;
5837 aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
5838 aPropertyValue += gDigitsSep;
5839 aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
5840 aPropertyValue += gDigitsSep;
5841 aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
5842 aPropertyValue += gDigitsSep;
5843 aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
5844 aPropertyValue += gDigitsSep;
5845 aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
5846 aPropertyValue += gDigitsSep;
5847 aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
5849 else if ( aPlane->PlaneMode == SMESH::Relative ) {
5850 aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
5851 aPropertyValue += gDigitsSep;
5852 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5853 aPropertyValue += gDigitsSep;
5854 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5855 aPropertyValue += gDigitsSep;
5856 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5859 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5863 QVector<SUIT_ViewWindow*> views = vman->getViews();
5864 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5866 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5868 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5869 vtkActorCollection* allActors = aCopy.GetActors();
5870 allActors->InitTraversal();
5871 while (vtkActor* actor = allActors->GetNextActor())
5873 if (actor->GetVisibility()) // store only visible actors
5875 SMESH_Actor* aSmeshActor = 0;
5876 if (actor->IsA("SMESH_Actor"))
5877 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5878 if (aSmeshActor && aSmeshActor->hasIO())
5880 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5883 // entry is "encoded" = it does NOT contain component address,
5884 // since it is a subject to change on next component loading
5885 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5887 std::string param, vtkParam = vType.toLatin1().data();
5888 vtkParam += gSeparator;
5889 vtkParam += QString::number(vtkViewers).toLatin1().data();
5890 vtkParam += gSeparator;
5893 param = vtkParam + "Visibility";
5894 ip->setParameter(entry, param, "On");
5897 param = vtkParam + "Representation";
5898 ip->setParameter(entry, param, QString::number
5899 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5902 param = vtkParam + "IsShrunk";
5903 ip->setParameter(entry, param, QString::number
5904 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5906 // Displayed entities
5907 unsigned int aMode = aSmeshActor->GetEntityMode();
5908 bool isE = aMode & SMESH_Actor::eEdges;
5909 bool isF = aMode & SMESH_Actor::eFaces;
5910 bool isV = aMode & SMESH_Actor::eVolumes;
5911 bool is0d = aMode & SMESH_Actor::e0DElements;
5912 bool isB = aMode & SMESH_Actor::eBallElem;
5914 QString modeStr ("e");
5915 modeStr += gDigitsSep; modeStr += QString::number(isE);
5916 modeStr += gDigitsSep; modeStr += "f";
5917 modeStr += gDigitsSep; modeStr += QString::number(isF);
5918 modeStr += gDigitsSep; modeStr += "v";
5919 modeStr += gDigitsSep; modeStr += QString::number(isV);
5920 modeStr += gDigitsSep; modeStr += "0d";
5921 modeStr += gDigitsSep; modeStr += QString::number(is0d);
5922 modeStr += gDigitsSep; modeStr += "b";
5923 modeStr += gDigitsSep; modeStr += QString::number(isB);
5925 param = vtkParam + "Entities";
5926 ip->setParameter(entry, param, modeStr.toLatin1().data());
5932 aSmeshActor->GetSufaceColor(r, g, b, delta);
5933 QStringList colorStr;
5934 colorStr << "surface";
5935 colorStr << QString::number(r);
5936 colorStr << QString::number(g);
5937 colorStr << QString::number(b);
5939 colorStr << "backsurface";
5940 colorStr << QString::number(delta);
5942 aSmeshActor->GetVolumeColor(r, g, b, delta);
5943 colorStr << "volume";
5944 colorStr << QString::number(r);
5945 colorStr << QString::number(g);
5946 colorStr << QString::number(b);
5947 colorStr << QString::number(delta);
5949 aSmeshActor->GetEdgeColor(r, g, b);
5951 colorStr << QString::number(r);
5952 colorStr << QString::number(g);
5953 colorStr << QString::number(b);
5955 aSmeshActor->GetNodeColor(r, g, b);
5957 colorStr << QString::number(r);
5958 colorStr << QString::number(g);
5959 colorStr << QString::number(b);
5961 aSmeshActor->GetOutlineColor(r, g, b);
5962 colorStr << "outline";
5963 colorStr << QString::number(r);
5964 colorStr << QString::number(g);
5965 colorStr << QString::number(b);
5967 aSmeshActor->Get0DColor(r, g, b);
5968 colorStr << "elem0d";
5969 colorStr << QString::number(r);
5970 colorStr << QString::number(g);
5971 colorStr << QString::number(b);
5973 aSmeshActor->GetBallColor(r, g, b);
5975 colorStr << QString::number(r);
5976 colorStr << QString::number(g);
5977 colorStr << QString::number(b);
5979 aSmeshActor->GetFacesOrientationColor(r, g, b);
5980 colorStr << "orientation";
5981 colorStr << QString::number(r);
5982 colorStr << QString::number(g);
5983 colorStr << QString::number(b);
5985 param = vtkParam + "Colors";
5986 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
5989 QStringList sizeStr;
5991 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
5992 sizeStr << "outline";
5993 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
5994 sizeStr << "elem0d";
5995 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
5997 //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
5998 sizeStr << QString::number((double)aSmeshActor->GetBallSize());
5999 sizeStr << QString::number((double)aSmeshActor->GetBallScale());
6000 sizeStr << "shrink";
6001 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
6002 sizeStr << "orientation";
6003 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
6004 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
6006 param = vtkParam + "Sizes";
6007 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
6012 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
6013 if( aMarkerType == VTK::MT_USER ) {
6014 markerStr += "custom";
6015 markerStr += gDigitsSep;
6016 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
6020 markerStr += gDigitsSep;
6021 markerStr += QString::number( (int)aMarkerType );
6022 markerStr += gDigitsSep;
6023 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
6026 param = vtkParam + "PointMarker";
6027 ip->setParameter(entry, param, markerStr.toLatin1().data());
6030 param = vtkParam + "Opacity";
6031 ip->setParameter(entry, param,
6032 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
6035 param = vtkParam + "ClippingPlane";
6037 if( !aClippingPlaneInfoList.empty() ) {
6038 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
6039 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
6041 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
6042 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
6043 SMESH::TActorList::iterator anIter2 = anActorList.begin();
6044 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
6045 if( aSmeshActor == *anIter2 ) {
6046 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
6047 QString::number( anId ).toLatin1().constData() );
6054 ip->setParameter( entry, param, "Off" );
6055 } // if (io->hasEntry())
6056 } // SMESH_Actor && hasIO
6058 } // while.. actors traversal
6062 } // if (SVTK view model)
6063 } // for (viewManagers)
6066 // data structures for clipping planes processing
6070 bool isOpenGLClipping;
6071 vtkIdType RelativeOrientation;
6074 int AbsoluteOrientation;
6075 double X, Y, Z, Dx, Dy, Dz;
6077 typedef std::list<TPlaneData> TPlaneDataList;
6078 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
6080 typedef std::list<vtkActor*> TActorList;
6083 TActorList ActorList;
6084 SUIT_ViewManager* ViewManager;
6086 typedef std::list<TPlaneInfo> TPlaneInfoList;
6087 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
6090 * \brief Restore visual parameters
6092 * This method is called after the study document is opened.
6093 * Restore visual parameters from AttributeParameter attribute(s)
6095 void SMESHGUI::restoreVisualParameters (int savePoint)
6098 Kernel_Utils::Localizer loc;
6100 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6101 if (!appStudy || !appStudy->studyDS())
6103 _PTR(Study) studyDS = appStudy->studyDS();
6105 // componentName is used for encoding of entries when storing them in IParameters
6106 std::string componentName = myComponentSMESH->ComponentDataType();
6107 //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
6108 //if (!aSComponent) return;
6111 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6112 componentName.c_str(),
6114 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6116 // restore custom markers and map of clipping planes
6117 TPlaneDataMap aPlaneDataMap;
6119 std::vector<std::string> properties = ip->getProperties();
6120 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
6122 std::string property = *propIt;
6123 QString aPropertyName( property.c_str() );
6124 QString aPropertyValue( ip->getProperty( property ).c_str() );
6126 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
6127 if( aPropertyNameList.isEmpty() )
6130 QString aPropertyType = aPropertyNameList[0];
6131 if( aPropertyType == "texture" )
6133 if( aPropertyNameList.size() != 2 )
6137 int anId = aPropertyNameList[1].toInt( &ok );
6138 if( !ok || anId < 1 )
6141 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
6142 if( aPropertyValueList.size() != 2 )
6145 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
6146 QString aMarkerTextureString = aPropertyValueList[1];
6147 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
6148 if( aMarkerTextureStringList.size() != 3 )
6152 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6157 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6161 VTK::MarkerTexture aMarkerTexture;
6162 aMarkerTexture.push_back( aWidth );
6163 aMarkerTexture.push_back( aHeight );
6165 QString aMarkerTextureData = aMarkerTextureStringList[2];
6166 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6168 QChar aChar = aMarkerTextureData.at( i );
6169 if( aChar.isDigit() )
6170 aMarkerTexture.push_back( aChar.digitValue() );
6173 myMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6175 else if( aPropertyType == "ClippingPlane" )
6177 if( aPropertyNameList.size() != 3 )
6181 int aViewId = aPropertyNameList[1].toInt( &ok );
6182 if( !ok || aViewId < 0 )
6186 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6187 if( !ok || aClippingPlaneId < 0 )
6190 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6191 if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6194 TPlaneData aPlaneData;
6195 aPlaneData.AbsoluteOrientation = false;
6196 aPlaneData.RelativeOrientation = 0;
6197 aPlaneData.Distance = aPlaneData.Angle[0] = aPlaneData.Angle[1] = 0;
6198 aPlaneData.X = aPlaneData.Y = aPlaneData.Z = 0;
6199 aPlaneData.Dx = aPlaneData.Dy = aPlaneData.Dz = 0;
6201 aPlaneData.Id = aClippingPlaneId;
6204 aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6209 aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6213 if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6216 aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6221 aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6226 aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6231 aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6236 aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6241 aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6246 aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6250 else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6252 aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6257 aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6262 aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6267 aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6272 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6273 aPlaneDataList.push_back( aPlaneData );
6277 TPlaneInfoMap aPlaneInfoMap;
6279 std::vector<std::string> entries = ip->getEntries();
6281 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6283 // entry is a normal entry - it should be "decoded" (setting base address of component)
6284 QString entry (ip->decodeEntry(*entIt).c_str());
6286 // Check that the entry corresponds to a real object in the Study
6287 // as the object may be deleted or modified after the visual state is saved.
6288 _PTR(SObject) so = studyDS->FindObjectID(entry.toUtf8().data());
6289 if (!so) continue; //Skip the not existent entry
6291 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6292 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6294 std::vector<std::string>::iterator namesIt = paramNames.begin();
6295 std::vector<std::string>::iterator valuesIt = paramValues.begin();
6297 // actors are stored in a map after displaying of them for
6298 // quicker access in the future: map < viewID to actor >
6299 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6301 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6303 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6304 // '_' is used as separator and should not be used in viewer type or parameter names.
6305 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6306 if (lst.size() != 3)
6309 QString viewerTypStr = lst[0];
6310 QString viewIndexStr = lst[1];
6311 QString paramNameStr = lst[2];
6314 int viewIndex = viewIndexStr.toUInt(&ok);
6315 if (!ok) // bad conversion of view index to integer
6319 if (viewerTypStr == SVTK_Viewer::Type())
6321 SMESH_Actor* aSmeshActor = 0;
6322 if (vtkActors.IsBound(viewIndex))
6323 aSmeshActor = vtkActors.Find(viewIndex);
6325 QList<SUIT_ViewManager*> lst;
6326 getApp()->viewManagers(viewerTypStr, lst);
6328 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6329 SUIT_ViewManager* vman = NULL;
6330 if (viewIndex >= 0 && viewIndex < lst.count())
6331 vman = lst.at(viewIndex);
6333 if (paramNameStr == "Visibility")
6335 if (!aSmeshActor && displayer() && vman)
6337 SUIT_ViewModel* vmodel = vman->getViewModel();
6338 // SVTK view model can be casted to SALOME_View
6339 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6341 // store displayed actor in a temporary map for quicker
6342 // access later when restoring other parameters
6343 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6344 vtkRenderer* Renderer = vtkView->getRenderer();
6345 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6346 vtkActorCollection* theActors = aCopy.GetActors();
6347 theActors->InitTraversal();
6348 bool isFound = false;
6349 vtkActor *ac = theActors->GetNextActor();
6350 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6351 if (ac->IsA("SMESH_Actor")) {
6352 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6353 if (aGeomAc->hasIO()) {
6354 Handle(SALOME_InteractiveObject) io = aGeomAc->getIO();
6355 if (io->hasEntry() && strcmp(io->getEntry(), entry.toUtf8().data()) == 0) {
6357 vtkActors.Bind(viewIndex, aGeomAc);
6363 } // if (paramNameStr == "Visibility")
6366 // the rest properties "work" with SMESH_Actor
6369 QString val ((*valuesIt).c_str());
6372 if (paramNameStr == "Representation") {
6373 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6376 else if (paramNameStr == "IsShrunk") {
6378 if (!aSmeshActor->IsShrunk())
6379 aSmeshActor->SetShrink();
6382 if (aSmeshActor->IsShrunk())
6383 aSmeshActor->UnShrink();
6386 // Displayed entities
6387 else if (paramNameStr == "Entities") {
6388 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6389 int aEntityMode = SMESH_Actor::eAllEntity;
6390 for ( int i = 0; i < mode.count(); i+=2 ) {
6391 if ( i < mode.count()-1 ) {
6392 QString type = mode[i];
6393 bool val = mode[i+1].toInt();
6394 if ( type == "e" && !val )
6395 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6396 else if ( type == "f" && !val )
6397 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6398 else if ( type == "v" && !val )
6399 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6400 else if ( type == "0d" && !val )
6401 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6402 else if ( type == "b" && !val )
6403 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6406 aSmeshActor->SetEntityMode( aEntityMode );
6409 else if (paramNameStr == "Colors") {
6410 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6417 QColor outlineColor;
6418 QColor orientationColor;
6424 // below lines are required to get default values for delta coefficients
6425 // of backface color for faces and color of reversed volumes
6426 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
6427 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6428 for ( int i = 0; i < colors.count(); i++ ) {
6429 QString type = colors[i];
6430 if ( type == "surface" ) {
6431 // face color is set by 3 values r:g:b, where
6432 // - r,g,b - is rgb color components
6433 if ( i+1 >= colors.count() ) break; // format error
6434 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6435 if ( i+2 >= colors.count() ) break; // format error
6436 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6437 if ( i+3 >= colors.count() ) break; // format error
6438 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6439 faceColor.setRgbF( r, g, b );
6442 else if ( type == "backsurface" ) {
6443 // backface color can be defined in several ways
6444 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6445 // - in latest versions, it is set as delta coefficient
6446 bool rgbOk = false, deltaOk;
6447 if ( i+1 >= colors.count() ) break; // format error
6448 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6449 int delta = colors[i+1].toInt( &deltaOk );
6451 if ( i+1 < colors.count() ) // index is shifted to 1
6452 g = colors[i+1].toDouble( &rgbOk );
6453 if ( rgbOk ) i++; // shift index
6454 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6455 b = colors[i+1].toDouble( &rgbOk );
6457 // - as currently there's no way to set directly backsurface color as it was before,
6458 // we ignore old dump where r,g,b triple was set
6459 // - also we check that delta parameter is set properly
6460 if ( !rgbOk && deltaOk )
6463 else if ( type == "volume" ) {
6464 // volume color is set by 4 values r:g:b:delta, where
6465 // - r,g,b - is a normal volume rgb color components
6466 // - delta - is a reversed volume color delta coefficient
6467 if ( i+1 >= colors.count() ) break; // format error
6468 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6469 if ( i+2 >= colors.count() ) break; // format error
6470 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6471 if ( i+3 >= colors.count() ) break; // format error
6472 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6473 if ( i+4 >= colors.count() ) break; // format error
6474 int delta = colors[i+4].toInt( &bOk );
6475 if ( !bOk ) break; // format error
6476 volumeColor.setRgbF( r, g, b );
6480 else if ( type == "edge" ) {
6481 // edge color is set by 3 values r:g:b, where
6482 // - r,g,b - is rgb color components
6483 if ( i+1 >= colors.count() ) break; // format error
6484 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6485 if ( i+2 >= colors.count() ) break; // format error
6486 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6487 if ( i+3 >= colors.count() ) break; // format error
6488 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6489 edgeColor.setRgbF( r, g, b );
6492 else if ( type == "node" ) {
6493 // node color is set by 3 values r:g:b, where
6494 // - r,g,b - is rgb color components
6495 if ( i+1 >= colors.count() ) break; // format error
6496 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6497 if ( i+2 >= colors.count() ) break; // format error
6498 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6499 if ( i+3 >= colors.count() ) break; // format error
6500 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6501 nodeColor.setRgbF( r, g, b );
6504 else if ( type == "elem0d" ) {
6505 // 0d element color is set by 3 values r:g:b, where
6506 // - r,g,b - is rgb color components
6507 if ( i+1 >= colors.count() ) break; // format error
6508 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6509 if ( i+2 >= colors.count() ) break; // format error
6510 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6511 if ( i+3 >= colors.count() ) break; // format error
6512 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6513 elem0dColor.setRgbF( r, g, b );
6516 else if ( type == "ball" ) {
6517 // ball color is set by 3 values r:g:b, where
6518 // - r,g,b - is rgb color components
6519 if ( i+1 >= colors.count() ) break; // format error
6520 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6521 if ( i+2 >= colors.count() ) break; // format error
6522 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6523 if ( i+3 >= colors.count() ) break; // format error
6524 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6525 ballColor.setRgbF( r, g, b );
6528 else if ( type == "outline" ) {
6529 // outline color is set by 3 values r:g:b, where
6530 // - r,g,b - is rgb color components
6531 if ( i+1 >= colors.count() ) break; // format error
6532 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6533 if ( i+2 >= colors.count() ) break; // format error
6534 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6535 if ( i+3 >= colors.count() ) break; // format error
6536 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6537 outlineColor.setRgbF( r, g, b );
6540 else if ( type == "orientation" ) {
6541 // orientation color is set by 3 values r:g:b, where
6542 // - r,g,b - is rgb color components
6543 if ( i+1 >= colors.count() ) break; // format error
6544 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6545 if ( i+2 >= colors.count() ) break; // format error
6546 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6547 if ( i+3 >= colors.count() ) break; // format error
6548 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6549 orientationColor.setRgbF( r, g, b );
6554 if ( nodeColor.isValid() )
6555 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6557 if ( edgeColor.isValid() )
6558 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6560 if ( faceColor.isValid() )
6561 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6563 if ( volumeColor.isValid() )
6564 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6565 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6566 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6568 if ( elem0dColor.isValid() )
6569 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6571 if ( ballColor.isValid() )
6572 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6574 if ( outlineColor.isValid() )
6575 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6576 // orientation color
6577 if ( orientationColor.isValid() )
6578 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6581 else if (paramNameStr == "Sizes") {
6582 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6585 int outlineWidth = -1;
6586 int elem0dSize = -1;
6587 //int ballSize = -1;
6588 double ballDiameter = -1.0;
6589 double ballScale = -1.0;
6590 double shrinkSize = -1;
6591 double orientationSize = -1;
6592 bool orientation3d = false;
6593 for ( int i = 0; i < sizes.count(); i++ ) {
6594 QString type = sizes[i];
6595 if ( type == "line" ) {
6596 // line (wireframe) width is given as single integer value
6597 if ( i+1 >= sizes.count() ) break; // format error
6598 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6602 if ( type == "outline" ) {
6603 // outline width is given as single integer value
6604 if ( i+1 >= sizes.count() ) break; // format error
6605 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6609 else if ( type == "elem0d" ) {
6610 // 0d element size is given as single integer value
6611 if ( i+1 >= sizes.count() ) break; // format error
6612 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6616 else if ( type == "ball" ) {
6617 // balls are specified by two values: size:scale, where
6618 // - size - is a integer value specifying size
6619 // - scale - is a double value specifying scale factor
6620 if ( i+1 >= sizes.count() ) break; // format error
6621 //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6622 double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6623 if ( i+2 >= sizes.count() ) break; // format error
6624 double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6630 else if ( type == "shrink" ) {
6631 // shrink factor is given as single floating point value
6632 if ( i+1 >= sizes.count() ) break; // format error
6633 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6637 else if ( type == "orientation" ) {
6638 // orientation vectors are specified by two values size:3d, where
6639 // - size - is a floating point value specifying scale factor
6640 // - 3d - is a boolean
6641 if ( i+1 >= sizes.count() ) break; // format error
6642 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6643 if ( i+2 >= sizes.count() ) break; // format error
6644 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6645 orientationSize = v1;
6646 orientation3d = (bool)v2;
6650 // line (wireframe) width
6651 if ( lineWidth > 0 )
6652 aSmeshActor->SetLineWidth( lineWidth );
6654 if ( outlineWidth > 0 )
6655 aSmeshActor->SetOutlineWidth( outlineWidth );
6656 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6657 aSmeshActor->SetOutlineWidth( lineWidth );
6659 if ( elem0dSize > 0 )
6660 aSmeshActor->Set0DSize( elem0dSize );
6662 /*if ( ballSize > 0 )
6663 aSmeshActor->SetBallSize( ballSize );*/
6665 if ( ballDiameter > 0 )
6666 aSmeshActor->SetBallSize( ballDiameter );
6668 if ( ballScale > 0.0 )
6669 aSmeshActor->SetBallScale( ballScale );
6671 if ( shrinkSize > 0 )
6672 aSmeshActor->SetShrinkFactor( shrinkSize );
6673 // orientation vectors
6674 if ( orientationSize > 0 ) {
6675 aSmeshActor->SetFacesOrientationScale( orientationSize );
6676 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6680 else if (paramNameStr == "PointMarker") {
6681 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6682 if( data.count() >= 2 ) {
6684 int aParam1 = data[1].toInt( &ok );
6686 if( data[0] == "std" && data.count() == 3 ) {
6687 int aParam2 = data[2].toInt( &ok );
6688 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6690 else if( data[0] == "custom" ) {
6691 VTK::MarkerMap::const_iterator markerIt = myMarkerMap.find( aParam1 );
6692 if( markerIt != myMarkerMap.end() ) {
6693 VTK::MarkerData aMarkerData = markerIt->second;
6694 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6701 else if (paramNameStr == "Opacity") {
6702 aSmeshActor->SetOpacity(val.toFloat());
6705 else if (paramNameStr.startsWith("ClippingPlane")) {
6706 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6707 // old format - val looks like "Off" or "1:0:0:0.5:0:0"
6708 // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
6709 // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
6710 // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
6711 // new format - val looks like "Off" or "0" (plane id)
6712 // (note: in new format "Off" value is used only for consistency,
6713 // so it is processed together with values in old format)
6714 bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
6715 if( anIsOldFormat ) {
6716 if (paramNameStr == "ClippingPlane1" || val == "Off")
6717 aSmeshActor->RemoveAllClippingPlanes();
6719 QList<SUIT_ViewManager*> lst;
6720 getApp()->viewManagers(viewerTypStr, lst);
6721 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6722 if (viewIndex >= 0 && viewIndex < lst.count()) {
6723 SUIT_ViewManager* vman = lst.at(viewIndex);
6724 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6726 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6728 SMESH::TActorList anActorList;
6729 anActorList.push_back( aSmeshActor );
6730 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
6731 aPlane->myViewWindow = vtkView;
6732 SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
6733 aPlane->PlaneMode = aMode;
6734 bool isOpenGLClipping = ( bool )vals[1].toInt();
6735 aPlane->IsOpenGLClipping = isOpenGLClipping;
6736 if ( aMode == SMESH::Absolute ) {
6737 aPlane->myAbsoluteOrientation = vals[2].toInt();
6738 aPlane->X = vals[3].toFloat();
6739 aPlane->Y = vals[4].toFloat();
6740 aPlane->Z = vals[5].toFloat();
6741 aPlane->Dx = vals[6].toFloat();
6742 aPlane->Dy = vals[7].toFloat();
6743 aPlane->Dz = vals[8].toFloat();
6745 else if ( aMode == SMESH::Relative ) {
6746 aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
6747 aPlane->myDistance = vals[3].toFloat();
6748 aPlane->myAngle[0] = vals[4].toFloat();
6749 aPlane->myAngle[1] = vals[5].toFloat();
6753 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6754 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6755 aClippingPlaneInfo.Plane = aPlane;
6756 aClippingPlaneInfo.ActorList = anActorList;
6757 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6765 int aPlaneId = val.toInt( &ok );
6766 if( ok && aPlaneId >= 0 ) {
6767 bool anIsDefinedPlane = false;
6768 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6769 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6770 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6771 TPlaneInfo& aPlaneInfo = *anIter;
6772 if( aPlaneInfo.PlaneId == aPlaneId ) {
6773 aPlaneInfo.ActorList.push_back( aSmeshActor );
6774 anIsDefinedPlane = true;
6778 if( !anIsDefinedPlane ) {
6779 TPlaneInfo aPlaneInfo;
6780 aPlaneInfo.PlaneId = aPlaneId;
6781 aPlaneInfo.ActorList.push_back( aSmeshActor );
6782 aPlaneInfo.ViewManager = vman;
6784 // to make the list sorted by plane id
6785 anIter = aPlaneInfoList.begin();
6786 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6787 const TPlaneInfo& aPlaneInfoRef = *anIter;
6788 if( aPlaneInfoRef.PlaneId > aPlaneId )
6791 aPlaneInfoList.insert( anIter, aPlaneInfo );
6796 } // if (aSmeshActor)
6797 } // other parameters than Visibility
6799 } // for names/parameters iterator
6800 } // for entries iterator
6802 // take into account planes with empty list of actors referred to them
6803 QList<SUIT_ViewManager*> aVMList;
6804 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6806 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6807 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6808 int aViewId = aPlaneDataIter->first;
6809 if( aViewId >= 0 && aViewId < aVMList.count() ) {
6810 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6812 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6814 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6815 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6816 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6817 const TPlaneData& aPlaneData = *anIter2;
6818 int aPlaneId = aPlaneData.Id;
6820 bool anIsFound = false;
6821 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6822 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6823 const TPlaneInfo& aPlaneInfo = *anIter3;
6824 if( aPlaneInfo.PlaneId == aPlaneId ) {
6831 TPlaneInfo aPlaneInfo; // ActorList field is empty
6832 aPlaneInfo.PlaneId = aPlaneId;
6833 aPlaneInfo.ViewManager = aViewManager;
6835 // to make the list sorted by plane id
6836 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6837 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6838 const TPlaneInfo& aPlaneInfoRef = *anIter4;
6839 if( aPlaneInfoRef.PlaneId > aPlaneId )
6842 aPlaneInfoList.insert( anIter4, aPlaneInfo );
6848 // add clipping planes to actors according to the restored parameters
6849 // and update the clipping plane map
6850 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6851 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6852 int aViewId = anIter1->first;
6853 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6855 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6856 if( anIter2 == aPlaneDataMap.end() )
6858 const TPlaneDataList& aPlaneDataList = anIter2->second;
6860 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6861 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6862 const TPlaneInfo& aPlaneInfo = *anIter3;
6863 int aPlaneId = aPlaneInfo.PlaneId;
6864 const TActorList& anActorList = aPlaneInfo.ActorList;
6865 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6869 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6873 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6875 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6876 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6877 const TPlaneData& aPlaneData = *anIter4;
6878 if( aPlaneData.Id == aPlaneId ) {
6879 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
6880 aPlane->myViewWindow = aViewWindow;
6881 aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
6882 aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
6883 if ( aPlane->PlaneMode == SMESH::Absolute ) {
6884 aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
6885 aPlane->X = aPlaneData.X;
6886 aPlane->Y = aPlaneData.Y;
6887 aPlane->Z = aPlaneData.Z;
6888 aPlane->Dx = aPlaneData.Dx;
6889 aPlane->Dy = aPlaneData.Dy;
6890 aPlane->Dz = aPlaneData.Dz;
6892 else if ( aPlane->PlaneMode == SMESH::Relative ) {
6893 aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
6894 aPlane->myDistance = aPlaneData.Distance;
6895 aPlane->myAngle[0] = aPlaneData.Angle[0];
6896 aPlane->myAngle[1] = aPlaneData.Angle[1];
6899 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6900 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6901 aClippingPlaneInfo.Plane = aPlane;
6902 aClippingPlaneInfo.ActorList = anActorList;
6903 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6914 // update all VTK views
6915 QList<SUIT_ViewManager*> lst;
6916 getApp()->viewManagers(lst);
6917 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6918 SUIT_ViewModel* vmodel = (*it)->getViewModel();
6919 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6920 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6921 // set OpenGL clipping planes
6922 VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
6923 vtkActorCollection* anAllActors = aCopy.GetActors();
6924 anAllActors->InitTraversal();
6925 while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
6926 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
6927 anActor->SetOpenGLClippingPlane();
6929 vtkView->getRenderer()->ResetCameraClippingRange();
6936 \brief Adds preferences for dfont of VTK viewer
6938 \param pIf group identifier
6939 \param param parameter
6940 \return identifier of preferences
6942 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
6944 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6946 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6949 fam.append( tr( "SMESH_FONT_ARIAL" ) );
6950 fam.append( tr( "SMESH_FONT_COURIER" ) );
6951 fam.append( tr( "SMESH_FONT_TIMES" ) );
6953 setPreferenceProperty( tfont, "fonts", fam );
6955 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6956 if ( needSize ) f = f | QtxFontEdit::Size;
6957 setPreferenceProperty( tfont, "features", f );
6963 \brief Actions after hypothesis edition
6964 Updates object browser after hypothesis edition
6966 void SMESHGUI::onHypothesisEdit( int result )
6969 SMESHGUI::Modified();
6970 updateObjBrowser( true );
6974 \brief Actions after choosing menu of control modes
6975 Updates control mode actions according to current selection
6977 void SMESHGUI::onUpdateControlActions()
6979 SALOME_ListIO selected;
6980 if ( LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr() )
6981 aSel->selectedObjects( selected );
6983 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
6984 if ( selected.Extent() ) {
6985 if ( selected.First()->hasEntry() ) {
6986 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( selected.First()->getEntry() )) {
6987 aControl = anActor->GetControlMode();
6988 SALOME_ListIteratorOfListIO it(selected);
6989 for ( it.Next(); it.More(); it.Next() ) {
6990 Handle(SALOME_InteractiveObject) anIO = it.Value();
6991 if ( anIO->hasEntry() ) {
6992 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
6993 if ( aControl != anActor->GetControlMode() ) {
6994 aControl = SMESH_Actor::eNone;
7004 int anAction = ActionToControl( aControl, true );
7006 action( anAction )->setChecked( true );
7008 QMenu* send = (QMenu*)sender();
7009 QList<QAction*> actions = send->actions();
7010 for ( int i = 0; i < actions.size(); i++ )
7011 actions[i]->setChecked( false );
7017 \brief Signal handler closing(SUIT_ViewWindow*) of a view
7018 \param pview view being closed
7020 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
7021 #ifndef DISABLE_PLOT2DVIEWER
7022 //Crear all Plot2d Viewers if need.
7023 SMESH::ClearPlot2Viewers(pview);
7025 EmitSignalCloseView();
7028 void SMESHGUI::message( const QString& msg )
7031 QStringList data = msg.split("/");
7032 if ( data.count() > 0 ) {
7033 if ( data.first() == "mesh_loading" ) {
7035 QString entry = data.count() > 1 ? data[1] : QString();
7036 if ( entry.isEmpty() )
7039 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
7041 _PTR(SObject) obj = study->FindObjectID( entry.toUtf8().constData() );
7044 name = SMESH::fromUtf8(obj->GetName());
7045 if ( name.isEmpty() )
7048 if ( data.last() == "stop" )
7049 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
7051 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
7052 QApplication::processEvents();
7058 \brief Connects or disconnects signals about activating and cloning view on the module slots
7059 \param pview view which is connected/disconnected
7061 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
7065 SUIT_ViewManager* viewMgr = pview->getViewManager();
7067 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7068 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7070 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7071 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7076 \brief Return \c true if object can be renamed
7078 bool SMESHGUI::renameAllowed( const QString& entry) const {
7079 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7083 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7087 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
7092 if(appStudy->isComponent(entry) || obj->isReference())
7095 // check type to prevent renaming of inappropriate objects
7096 int aType = SMESHGUI_Selection::type(qPrintable(entry));
7097 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7098 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7099 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7100 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7101 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
7108 Rename object by entry.
7109 \param entry entry of the object
7110 \param name new name of the object
7111 \brief Return \c true if rename operation finished successfully, \c false otherwise.
7113 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
7115 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7119 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7124 _PTR(Study) aStudy = appStudy->studyDS();
7129 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
7131 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
7136 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
7137 _PTR(GenericAttribute) anAttr;
7138 _PTR(AttributeName) aName;
7140 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
7142 // check type to prevent renaming of inappropriate objects
7143 int aType = SMESHGUI_Selection::type( qPrintable(entry));
7144 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7145 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7146 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7147 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7148 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
7149 if ( !name.isEmpty() ) {
7150 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qUtf8Printable(name) );
7152 // update name of group object and its actor
7153 Handle(SALOME_InteractiveObject) IObject =
7154 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
7156 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
7157 if( !aGroupObject->_is_nil() ) {
7158 aGroupObject->SetName( qUtf8Printable(name) );
7159 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
7160 anActor->setName( qUtf8Printable(name) );
7170 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
7172 static QList<QColor> colors;
7174 if ( colors.isEmpty() ) {
7176 for (int s = 0; s < 2 ; s++)
7178 for (int v = 100; v >= 40; v = v - 20)
7180 for (int h = 0; h < 359 ; h = h + 60)
7182 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
7187 static int currentColor = randomize( colors.size() );
7189 SALOMEDS::Color color;
7190 color.R = (double)colors[currentColor].red() / 255.0;
7191 color.G = (double)colors[currentColor].green() / 255.0;
7192 color.B = (double)colors[currentColor].blue() / 255.0;
7194 currentColor = (currentColor+1) % colors.count();