1 // Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
3 // Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
6 // This library is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU Lesser General Public
8 // License as published by the Free Software Foundation; either
9 // version 2.1 of the License, or (at your option) any later version.
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 // Lesser General Public License for more details.
16 // You should have received a copy of the GNU Lesser General Public
17 // License along with this library; if not, write to the Free Software
18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
22 // File : SMESHGUI.cxx
23 // Author : Nicolas REJNERI, Open CASCADE S.A.S.
25 #include <Standard_math.hxx> // E.A. must be included before Python.h to fix compilation on windows
27 #undef HAVE_FINITE // VSR: avoid compilation warning on Linux : "HAVE_FINITE" redefined
33 #include "SMESHGUI_Add0DElemsOnAllNodesDlg.h"
34 #include "SMESHGUI_AddMeshElementDlg.h"
35 #include "SMESHGUI_AddQuadraticElementDlg.h"
36 #include "SMESHGUI_BuildCompoundDlg.h"
37 #include "SMESHGUI_ClippingDlg.h"
38 #include "SMESHGUI_ComputeDlg.h"
39 #include "SMESHGUI_ConvToQuadOp.h"
40 #include "SMESHGUI_CopyMeshDlg.h"
41 #include "SMESHGUI_CreatePolyhedralVolumeDlg.h"
42 #include "SMESHGUI_DeleteGroupDlg.h"
43 #include "SMESHGUI_Displayer.h"
44 #include "SMESHGUI_DuplicateNodesDlg.h"
45 #include "SMESHGUI_ExtrusionAlongPathDlg.h"
46 #include "SMESHGUI_ExtrusionDlg.h"
47 #include "SMESHGUI_FieldSelectorWdg.h"
48 #include "SMESHGUI_FileInfoDlg.h"
49 #include "SMESHGUI_FileValidator.h"
50 #include "SMESHGUI_FilterDlg.h"
51 #include "SMESHGUI_FilterLibraryDlg.h"
52 #include "SMESHGUI_FindElemByPointDlg.h"
53 #include "SMESHGUI_GroupDlg.h"
54 #include "SMESHGUI_GroupOnShapeDlg.h"
55 #include "SMESHGUI_GroupOpDlg.h"
56 #include "SMESHGUI_Hypotheses.h"
57 #include "SMESHGUI_Make2DFrom3DOp.h"
58 #include "SMESHGUI_MakeNodeAtPointDlg.h"
59 #include "SMESHGUI_Measurements.h"
60 #include "SMESHGUI_MergeDlg.h"
61 #include "SMESHGUI_MeshInfo.h"
62 #include "SMESHGUI_MeshOp.h"
63 #include "SMESHGUI_MeshOrderOp.h"
64 #include "SMESHGUI_MeshPatternDlg.h"
65 #include "SMESHGUI_MultiEditDlg.h"
66 #include "SMESHGUI_NodesDlg.h"
67 #include "SMESHGUI_Operations.h"
68 #include "SMESHGUI_Preferences_ScalarBarDlg.h"
69 #include "SMESHGUI_PropertiesDlg.h"
70 #include "SMESHGUI_RemoveElementsDlg.h"
71 #include "SMESHGUI_RemoveNodesDlg.h"
72 #include "SMESHGUI_RenumberingDlg.h"
73 #include "SMESHGUI_ReorientFacesDlg.h"
74 #include "SMESHGUI_RevolutionDlg.h"
75 #include "SMESHGUI_RotationDlg.h"
76 #include "SMESHGUI_ScaleDlg.h"
77 #include "SMESHGUI_Selection.h"
78 #include "SMESHGUI_SewingDlg.h"
79 #include "SMESHGUI_SingleEditDlg.h"
80 #include "SMESHGUI_SmoothingDlg.h"
81 #include "SMESHGUI_SymmetryDlg.h"
82 #include "SMESHGUI_TranslationDlg.h"
83 #include "SMESHGUI_TransparencyDlg.h"
84 #include "SMESHGUI_DisplayEntitiesDlg.h"
85 #include "SMESHGUI_SplitBiQuad.h"
87 #include "SMESHGUI_FilterUtils.h"
88 #include "SMESHGUI_GEOMGenUtils.h"
89 #include "SMESHGUI_GroupUtils.h"
90 #include "SMESHGUI_HypothesesUtils.h"
91 #include "SMESHGUI_MeshUtils.h"
92 #include "SMESHGUI_PatternUtils.h"
93 #include "SMESHGUI_Utils.h"
94 #include "SMESHGUI_VTKUtils.h"
96 #include "SMESH_version.h"
98 #include "SMESH_ControlsDef.hxx"
99 #include "SMESH_Actor.h"
100 #include "SMESH_ActorUtils.h"
101 #include "SMESH_Client.hxx"
102 #include "SMESH_ScalarBarActor.h"
103 #include "SMESH_TypeFilter.hxx"
105 // SALOME GUI includes
106 #include <SalomeApp_Application.h>
107 #include <SalomeApp_CheckFileDlg.h>
108 #include <SalomeApp_DataObject.h>
109 #include <SalomeApp_Study.h>
110 #include <SalomeApp_Tools.h>
112 #include <LightApp_DataOwner.h>
113 #include <LightApp_NameDlg.h>
114 #include <LightApp_Preferences.h>
115 #include <LightApp_SelectionMgr.h>
116 #include <LightApp_UpdateFlags.h>
118 #include <SVTK_ViewManager.h>
119 #include <SVTK_ViewModel.h>
120 #include <SVTK_ViewWindow.h>
122 #include <VTKViewer_Algorithm.h>
124 #include <SUIT_Desktop.h>
125 #include <SUIT_FileDlg.h>
126 #include <SUIT_MessageBox.h>
127 #include <SUIT_OverrideCursor.h>
128 #include <SUIT_ResourceMgr.h>
129 #include <SUIT_Session.h>
131 #include <QtxPopupMgr.h>
132 #include <QtxFontEdit.h>
134 #include <SALOME_ListIO.hxx>
136 #ifndef DISABLE_PLOT2DVIEWER
137 #include <SPlot2d_ViewModel.h>
138 #include <SPlot2d_Histogram.h>
142 #include <SALOMEconfig.h>
143 #include CORBA_CLIENT_HEADER(SALOMEDS_Attributes)
144 #include CORBA_CLIENT_HEADER(SMESH_MeshEditor)
145 #include CORBA_CLIENT_HEADER(SMESH_Measurements)
146 #include CORBA_CLIENT_HEADER(SMESH_Mesh)
149 // #define INCLUDE_MENUITEM_DEF // VSR commented ????????
150 #include <QApplication>
152 #include <QTextStream>
157 #include <QDialogButtonBox>
160 #include <boost/shared_ptr.hpp>
163 #include <vtkCallbackCommand.h>
164 #include <vtkCamera.h>
165 #include <vtkLookupTable.h>
166 #include <vtkPlane.h>
167 #include <vtkRenderer.h>
169 // SALOME KERNEL includes
170 #include <SALOMEDSClient_ClientFactory.hxx>
171 #include <SALOMEDSClient_IParameters.hxx>
172 #include <SALOMEDSClient_SComponent.hxx>
173 #include <SALOMEDSClient_StudyBuilder.hxx>
174 #include <SALOMEDS_Study.hxx>
175 #include <SALOMEDS_SObject.hxx>
176 #include "utilities.h"
179 #include <Standard_ErrorHandler.hxx>
180 #include <NCollection_DataMap.hxx>
181 #include <NCollection_DoubleMap.hxx>
183 #include <Basics_Utils.hxx>
185 // Below macro, when uncommented, switches on simplified (more performant) algorithm
186 // of auto-color picking up
187 #define SIMPLE_AUTOCOLOR
192 //=============================================================
193 void ImportMeshesFromFile(SMESH::SMESH_Gen_ptr theComponentMesh,
196 void ExportMeshToFile(int theCommandID);
198 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap);
200 void SetDisplayEntity(int theCommandID);
202 int ActionToControl( int theID, bool theReversed = false );
204 void Control( int theCommandID );
207 //================================================================================
209 * \brief Reads meshes from file
211 //================================================================================
213 void ImportMeshesFromFile( SMESH::SMESH_Gen_ptr theComponentMesh,
217 std::string myExtension;
219 if ( theCommandID == SMESHOp::OpImportMED ||
220 theCommandID == SMESHOp::OpPopupImportMED ) {
221 filter.append( QObject::tr( "MED_FILES_FILTER" ) + " (*.*med)" );
222 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
224 else if ( theCommandID == SMESHOp::OpImportUNV ||
225 theCommandID == SMESHOp::OpPopupImportUNV ) {
226 filter.append( QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)" );
228 else if ( theCommandID == SMESHOp::OpImportDAT ||
229 theCommandID == SMESHOp::OpPopupImportDAT ) {
230 filter.append( QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)" );
232 else if ( theCommandID == SMESHOp::OpImportSTL ||
233 theCommandID == SMESHOp::OpPopupImportSTL ) {
234 filter.append( QObject::tr( "STL_FILES_FILTER" ) + " (*.stl)" );
236 else if ( theCommandID == SMESHOp::OpImportCGNS ||
237 theCommandID == SMESHOp::OpPopupImportCGNS ) {
238 filter.append( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
240 else if ( theCommandID == SMESHOp::OpImportSAUV ||
241 theCommandID == SMESHOp::OpPopupImportSAUV ) {
242 filter.append( QObject::tr( "SAUV files (*.sauv*)" ) );
243 filter.append( QObject::tr( "All files (*)" ) );
245 else if ( theCommandID == SMESHOp::OpImportGMF ||
246 theCommandID == SMESHOp::OpPopupImportGMF ) {
247 filter.append( QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" );
248 filter.append( QObject::tr( "GMF_BINARY_FILES_FILTER") + " (*.meshb)" );
251 QString anInitialPath = "";
252 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
253 anInitialPath = QDir::currentPath();
255 QStringList filenames;
256 bool toCreateGroups = true;
258 // if ( theCommandID == SMESHOp::OpImportGMF ) { // GMF
259 // SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg
260 // ( SMESHGUI::desktop(), true, QObject::tr("SMESH_REQUIRED_GROUPS"), true, true );
261 // fd->setWindowTitle( QObject::tr( "SMESH_IMPORT_MESH" ) );
262 // fd->setNameFilters( filter );
263 // fd->SetChecked( true );
265 // filenames << fd->selectedFile();
266 // toCreateGroups = fd->IsChecked();
272 filenames = SUIT_FileDlg::getOpenFileNames( SMESHGUI::desktop(),
275 QObject::tr( "SMESH_IMPORT_MESH" ) );
277 if ( filenames.count() > 0 )
279 SUIT_OverrideCursor wc;
280 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
283 QStringList anEntryList;
284 bool isEmpty = false;
285 for ( QStringList::ConstIterator it = filenames.begin(); it != filenames.end(); ++it )
287 QString filename = *it;
288 SMESH::mesh_array_var aMeshes = new SMESH::mesh_array;
290 switch ( theCommandID ) {
291 case SMESHOp::OpImportDAT:
292 case SMESHOp::OpPopupImportDAT:
294 // DAT format (currently unsupported)
295 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
296 arg( QObject::tr( "SMESH_ERR_NOT_SUPPORTED_FORMAT" ) ) );
299 case SMESHOp::OpImportUNV:
300 case SMESHOp::OpPopupImportUNV:
303 aMeshes->length( 1 );
304 aMeshes[0] = theComponentMesh->CreateMeshesFromUNV( filename.toUtf8().constData() );
305 if ( aMeshes[0]->_is_nil() )
306 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
307 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
310 case SMESHOp::OpImportMED:
311 case SMESHOp::OpPopupImportMED:
314 SMESH::DriverMED_ReadStatus res;
315 aMeshes = theComponentMesh->CreateMeshesFromMED( filename.toUtf8().constData(), res );
316 if ( res != SMESH::DRS_OK ) {
317 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
318 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
322 case SMESHOp::OpImportSTL:
323 case SMESHOp::OpPopupImportSTL:
326 aMeshes->length( 1 );
327 aMeshes[0] = theComponentMesh->CreateMeshesFromSTL( filename.toUtf8().constData() );
328 if ( aMeshes[0]->_is_nil() ) {
329 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
330 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
334 case SMESHOp::OpImportCGNS:
335 case SMESHOp::OpPopupImportCGNS:
338 SMESH::DriverMED_ReadStatus res;
339 aMeshes = theComponentMesh->CreateMeshesFromCGNS( filename.toUtf8().constData(), res );
340 if ( res != SMESH::DRS_OK ) {
341 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
342 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
346 case SMESHOp::OpImportSAUV:
347 case SMESHOp::OpPopupImportSAUV:
350 SMESH::DriverMED_ReadStatus res;
351 aMeshes = theComponentMesh->CreateMeshesFromSAUV( filename.toUtf8().constData(), res );
352 if ( res != SMESH::DRS_OK ) {
353 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
354 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
358 case SMESHOp::OpImportGMF:
359 case SMESHOp::OpPopupImportGMF:
362 SMESH::ComputeError_var res;
363 aMeshes->length( 1 );
364 aMeshes[0] = theComponentMesh->CreateMeshesFromGMF( filename.toUtf8().constData(),
367 if ( res->code != SMESH::DRS_OK ) {
368 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
369 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res->code ).toLatin1().data() ) ) );
370 if ( strlen( res->comment.in() ) > 0 ) {
371 errors.back() += ": ";
372 errors.back() += res->comment.in();
379 catch ( const SALOME::SALOME_Exception& S_ex ) {
380 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
381 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
384 for ( int i = 0, iEnd = aMeshes->length(); i < iEnd; i++ )
386 _PTR(SObject) aMeshSO = SMESH::FindSObject( aMeshes[i] );
388 _PTR(StudyBuilder) aBuilder = aStudy->NewBuilder();
389 _PTR(AttributePixMap) aPixmap = aBuilder->FindOrCreateAttribute( aMeshSO, "AttributePixMap" );
390 aPixmap->SetPixMap( "ICON_SMESH_TREE_MESH_IMPORTED" );
391 if ( theCommandID == SMESHOp::OpImportUNV ) // mesh names aren't taken from the file for UNV import
392 SMESH::SetName( aMeshSO, QFileInfo(filename).fileName() );
394 anEntryList.append( aMeshSO->GetID().c_str() );
402 // update Object browser
403 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
405 // browse to the published meshes
406 if( LightApp_Application* anApp =
407 dynamic_cast<LightApp_Application*>( SUIT_Session::session()->activeApplication() ) )
408 anApp->browseObjects( anEntryList );
410 // show Error message box if there were errors
411 if ( errors.count() > 0 ) {
412 SUIT_MessageBox::critical( SMESHGUI::desktop(),
413 QObject::tr( "SMESH_ERROR" ),
414 QObject::tr( "SMESH_IMPORT_ERRORS" ) + "\n" + errors.join( "\n" ) );
417 // show warning message box, if some imported mesh is empty
419 SUIT_MessageBox::warning( SMESHGUI::desktop(),
420 QObject::tr( "SMESH_WRN_WARNING" ),
421 QObject::tr( "SMESH_DRS_SOME_EMPTY" ) );
426 //================================================================================
428 * \brief Export selected meshes or groups into a file
430 //================================================================================
432 void ExportMeshToFile( int theCommandID )
434 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
435 SALOME_ListIO selected;
437 aSel->selectedObjects( selected );
439 const bool isDAT = ( theCommandID == SMESHOp::OpExportDAT ||
440 theCommandID == SMESHOp::OpPopupExportDAT );
441 const bool isMED = ( theCommandID == SMESHOp::OpExportMED ||
442 theCommandID == SMESHOp::OpPopupExportMED );
443 const bool isUNV = ( theCommandID == SMESHOp::OpExportUNV ||
444 theCommandID == SMESHOp::OpPopupExportUNV );
445 const bool isSTL = ( theCommandID == SMESHOp::OpExportSTL ||
446 theCommandID == SMESHOp::OpPopupExportSTL );
447 const bool isCGNS= ( theCommandID == SMESHOp::OpExportCGNS ||
448 theCommandID == SMESHOp::OpPopupExportCGNS );
449 const bool isSAUV= ( theCommandID == SMESHOp::OpExportSAUV ||
450 theCommandID == SMESHOp::OpPopupExportSAUV );
451 const bool isGMF = ( theCommandID == SMESHOp::OpExportGMF ||
452 theCommandID == SMESHOp::OpPopupExportGMF );
454 const bool multiMeshSupported = ( isMED || isCGNS ); // file can hold several meshes
455 if ( selected.Extent() == 0 || ( selected.Extent() > 1 && !multiMeshSupported ))
457 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
458 bool aCheckWarn = true;
460 aCheckWarn = resMgr->booleanValue( "SMESH", "show_warning", false );
461 // get mesh object from selection and check duplication of their names
462 bool hasDuplicatedMeshNames = false;
463 QList< QPair< SMESH::SMESH_IDSource_var, QString > > aMeshList;
464 QList< QPair< SMESH::SMESH_IDSource_var, QString > >::iterator aMeshIter;
465 SALOME_ListIteratorOfListIO It( selected );
466 for( ; It.More(); It.Next() )
468 Handle(SALOME_InteractiveObject) anIObject = It.Value();
469 SMESH::SMESH_IDSource_var aMeshItem =
470 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIObject);
471 if ( aMeshItem->_is_nil() ) {
472 SUIT_MessageBox::warning( SMESHGUI::desktop(),
473 QObject::tr( "SMESH_WRN_WARNING" ),
474 QObject::tr( "SMESH_BAD_MESH_SELECTION" ));
477 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( aMeshItem );
478 if ( aCheckWarn && !aGroup->_is_nil() )
480 QMessageBox msgBox(SUIT_MessageBox::Warning,
481 QObject::tr("SMESH_WRN_WARNING"),
482 QObject::tr("SMESH_EXPORT_ONLY_GPOUP"),
483 QMessageBox::StandardButton::NoButton,
484 SMESHGUI::desktop());
485 QCheckBox dontShowCheckBox(QObject::tr("SMESH_WRN_SHOW_DLG_CHECKBOX"));
486 msgBox.addButton(QMessageBox::Ok);
487 msgBox.addButton(QMessageBox::Cancel);
488 msgBox.setDefaultButton(QMessageBox::Cancel);
489 QGridLayout* lt = qobject_cast<QGridLayout*>(msgBox.layout());
490 QDialogButtonBox* btnbox = msgBox.findChild<QDialogButtonBox*>();
491 lt->addWidget(&dontShowCheckBox, lt->rowCount(), lt->columnCount()-1, lt->rowCount(), lt->columnCount());
492 lt->addWidget(btnbox, lt->rowCount(), 0, lt->rowCount(), lt->columnCount());
493 if(msgBox.exec() == QMessageBox::Ok)
495 if(dontShowCheckBox.checkState() == Qt::Checked)
498 resMgr->setValue( "SMESH", "show_warning", false);
506 QString aMeshName = anIObject->getName();
508 // check for name duplications
509 if ( !hasDuplicatedMeshNames )
510 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
511 if( aMeshName == (*aMeshIter).second ) {
512 hasDuplicatedMeshNames = true;
517 aMeshList.append( QPair< SMESH::SMESH_IDSource_var, QString >( aMeshItem, aMeshName ) );
520 if( hasDuplicatedMeshNames && isMED ) {
521 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
522 QObject::tr("SMESH_WRN_WARNING"),
523 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_MESH_NAMES"),
524 QObject::tr("SMESH_BUT_YES"),
525 QObject::tr("SMESH_BUT_NO"), 0, 1);
530 aMeshIter = aMeshList.begin();
531 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
532 SMESH::SMESH_Mesh_var aMesh = aMeshOrGroup->GetMesh();
533 QString aMeshName = (*aMeshIter).second;
535 if ( isMED || isCGNS || isSAUV ) // formats where group names must be unique
537 // check for equal group names within each mesh
538 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
539 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
540 if ( !aMeshItem->_is_nil() && aMeshItem->HasDuplicatedGroupNamesMED()) {
541 int aRet = SUIT_MessageBox::warning
542 (SMESHGUI::desktop(),
543 QObject::tr("SMESH_WRN_WARNING"),
544 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_GRP").arg((*aMeshIter).second),
545 QObject::tr("SMESH_BUT_YES"),
546 QObject::tr("SMESH_BUT_NO"), 0, 1);
553 // Warn the user about presence of not supported elements
555 std::vector< SMESH::EntityType > notSupportedElemTypes, presentNotSupported;
559 notSupportedElemTypes.push_back( SMESH::Entity_0D );
560 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
565 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
566 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
567 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
568 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
569 notSupportedElemTypes.push_back( SMESH::Entity_Pyramid );
570 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
571 notSupportedElemTypes.push_back( SMESH::Entity_0D );
572 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
577 notSupportedElemTypes.push_back( SMESH::Entity_Edge );
578 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Edge );
579 notSupportedElemTypes.push_back( SMESH::Entity_0D );
580 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
585 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
590 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
591 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Triangle );
592 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Quadrangle );
593 notSupportedElemTypes.push_back( SMESH::Entity_TriQuad_Hexa );
594 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
595 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
596 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
597 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
602 notSupportedElemTypes.push_back( SMESH::Entity_0D );
603 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
604 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
605 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Pyramid );
606 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Penta );
607 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Penta );
608 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
609 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
610 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
611 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
613 if ( ! notSupportedElemTypes.empty() )
615 SMESH::long_array_var nbElems = aMeshOrGroup->GetMeshInfo();
616 for ( size_t iType = 0; iType < notSupportedElemTypes.size(); ++iType )
617 if ( nbElems[ notSupportedElemTypes[ iType ]] > 0 )
618 presentNotSupported.push_back( notSupportedElemTypes[ iType ]);
620 if ( !presentNotSupported.empty() )
623 const char* typeMsg[] = {
624 "SMESH_NODES", "SMESH_ELEMS0D","SMESH_EDGES","SMESH_QUADRATIC_EDGES",
625 "SMESH_TRIANGLES", "SMESH_QUADRATIC_TRIANGLES", "SMESH_BIQUADRATIC_TRIANGLES",
626 "SMESH_QUADRANGLES","SMESH_QUADRATIC_QUADRANGLES", "SMESH_BIQUADRATIC_QUADRANGLES",
627 "SMESH_POLYGONS","SMESH_QUADRATIC_POLYGONS",
628 "SMESH_TETRAHEDRA","SMESH_QUADRATIC_TETRAHEDRONS","SMESH_PYRAMIDS",
629 "SMESH_QUADRATIC_PYRAMIDS","SMESH_HEXAHEDRA","SMESH_QUADRATIC_HEXAHEDRONS",
630 "SMESH_TRIQUADRATIC_HEXAHEDRONS","SMESH_PENTAHEDRA","SMESH_QUADRATIC_PENTAHEDRONS",
631 "SMESH_BIQUADRATIC_PENTAHEDRONS",
632 "SMESH_OCTAHEDRA","SMESH_POLYEDRONS","SMESH_QUADRATIC_POLYEDRONS","SMESH_BALLS"
634 // is typeMsg complete? (compilation failure mains that enum SMDSAbs_EntityType changed)
635 const int nbTypes = sizeof( typeMsg ) / sizeof( const char* );
636 int _assert[( nbTypes == SMESH::Entity_Last ) ? 2 : -1 ]; _assert[0]=_assert[1]=0;
638 QString andStr = " " + QObject::tr("SMESH_AND") + " ", comma(", ");
639 for ( size_t iType = 0; iType < presentNotSupported.size(); ++iType ) {
640 typeNames += QObject::tr( typeMsg[ presentNotSupported[ iType ]]);
641 if ( iType != presentNotSupported.size() - 1 )
642 typeNames += ( iType == presentNotSupported.size() - 2 ) ? andStr : comma;
644 int aRet = SUIT_MessageBox::warning
645 (SMESHGUI::desktop(),
646 QObject::tr("SMESH_WRN_WARNING"),
647 QObject::tr("EXPORT_NOT_SUPPORTED").arg(aMeshName).arg(format).arg(typeNames),
648 QObject::tr("SMESH_BUT_YES"),
649 QObject::tr("SMESH_BUT_NO"), 0, 1);
654 // Get parameters of export operation
657 SMESH::MED_VERSION aFormat = SMESH::MED_LATEST;
658 // Init the parameters with the default values
659 bool aIsASCII_STL = true;
660 bool toCreateGroups = false;
662 toCreateGroups = resMgr->booleanValue( "SMESH", "auto_groups", false );
663 bool toOverwrite = true;
664 bool toFindOutDim = true;
666 QString aFilter, aTitle = QObject::tr("SMESH_EXPORT_MESH");
667 QString anInitialPath = "";
668 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
669 anInitialPath = QDir::currentPath();
671 QList< QPair< GEOM::ListOfFields_var, QString > > aFieldList;
673 // Get a file name to write in and additional otions
674 if ( isUNV || isDAT || isGMF ) // Export w/o options
677 aFilter = QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)";
679 aFilter = QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)";
681 aFilter = QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" +
682 ";;" + QObject::tr( "GMF_BINARY_FILES_FILTER" ) + " (*.meshb)";
683 if ( anInitialPath.isEmpty() ) anInitialPath = SUIT_FileDlg::getLastVisitedPath();
684 aFilename = SUIT_FileDlg::getFileName(SMESHGUI::desktop(),
685 anInitialPath + QString("/") + aMeshName,
686 aFilter, aTitle, false);
688 else if ( isCGNS )// Export to CGNS
690 const char* theByTypeResource = "cgns_group_elems_by_type";
691 toCreateGroups = SMESHGUI::resourceMgr()->booleanValue( "SMESH", theByTypeResource, false );
693 QStringList checkBoxes;
694 checkBoxes << QObject::tr("CGNS_EXPORT_ELEMS_BY_TYPE");
696 SalomeApp_CheckFileDlg* fd =
697 new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true );
698 fd->setWindowTitle( aTitle );
699 fd->setNameFilter( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
700 if ( !anInitialPath.isEmpty() )
701 fd->setDirectory( anInitialPath );
702 fd->selectFile(aMeshName);
703 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
704 fd->setValidator( fv );
705 fd->SetChecked( toCreateGroups, 0 );
708 aFilename = fd->selectedFile();
709 toOverwrite = fv->isOverwrite();
710 toCreateGroups = fd->IsChecked(0);
711 SMESHGUI::resourceMgr()->setValue("SMESH", theByTypeResource, toCreateGroups );
715 else if ( isSTL ) // Export to STL
717 QMap<QString, int> aFilterMap;
718 aFilterMap.insert( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)", 1 );
719 aFilterMap.insert( QObject::tr( "STL_BIN_FILES_FILTER" ) + " (*.stl)", 0 );
722 QMap<QString, int>::const_iterator it = aFilterMap.begin();
723 for ( ; it != aFilterMap.end(); ++it )
724 filters.push_back( it.key() );
726 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
727 fd->setWindowTitle( aTitle );
728 fd->setNameFilters( filters );
729 fd->selectNameFilter( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
730 if ( !anInitialPath.isEmpty() )
731 fd->setDirectory( anInitialPath );
732 fd->selectFile(aMeshName);
736 aFilename = fd->selectedFile();
737 aIsASCII_STL = (aFilterMap[fd->selectedNameFilter()]) == 1 ? true: false;
742 else if ( isMED || isSAUV ) // Export to MED or SAUV
744 QMap<QString, SMESH::MED_VERSION> aFilterMap;
746 QString v22 (aMesh->GetVersionString(SMESH::MED_V2_2, 2));
747 aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v22 ) + " (*.med)", SMESH::MED_V2_2 );
748 int minor = v22.split(".").last().toInt();
749 int vv= int(SMESH::MED_MINOR_0); // add all minor from 0 to current
750 for (int ii=0; ii<minor; ii++)
752 QString vs = aMesh->GetVersionString(SMESH::MED_VERSION(vv), 2);
753 aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( vs ) + " (*.med)", SMESH::MED_VERSION(vv));
758 aFilterMap.insert("All files (*)", SMESH::MED_V2_1 );
759 aFilterMap.insert("SAUV files (*.sauv)", SMESH::MED_V2_2 );
760 aFilterMap.insert("SAUV files (*.sauve)", SMESH::MED_V2_1 );
764 QString aDefaultFilter;
765 QMap<QString, SMESH::MED_VERSION>::const_iterator it = aFilterMap.begin();
766 for ( ; it != aFilterMap.end(); ++it ) {
767 filters.push_back( it.key() );
768 if (it.value() == SMESH::MED_V2_2)
769 aDefaultFilter = it.key();
771 QStringList checkBoxes;
772 checkBoxes << QObject::tr("SMESH_AUTO_GROUPS") << QObject::tr("SMESH_AUTO_DIM");
774 SMESHGUI_FieldSelectorWdg* fieldSelWdg = new SMESHGUI_FieldSelectorWdg();
775 QList< QWidget* > wdgList;
776 if ( fieldSelWdg->GetAllFields( aMeshList, aFieldList ))
777 wdgList.append( fieldSelWdg );
779 SalomeApp_CheckFileDlg* fd =
780 new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true, wdgList );
781 fd->setWindowTitle( aTitle );
782 fd->setNameFilters( filters );
783 fd->selectNameFilter( aDefaultFilter );
784 fd->SetChecked( toCreateGroups, 0 );
785 fd->SetChecked( toFindOutDim, 1 );
786 if ( !anInitialPath.isEmpty() )
787 fd->setDirectory( anInitialPath );
788 fd->selectFile(aMeshName);
791 QListView *lview = fd->findChild<QListView*>("listView");
793 lview->setMinimumHeight(200);
795 QTreeView *tview = fd->findChild<QTreeView*>("treeView");
797 tview->setMinimumHeight(200);
800 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
801 fd->setValidator( fv );
806 aFilename = fd->selectedFile();
808 aFilename = QString::null;
811 aFormat = aFilterMap[fd->selectedNameFilter()];
812 toOverwrite = fv->isOverwrite();
814 if ( !aFilename.isEmpty() ) {
815 // med-2.1 does not support poly elements
816 if ( aFormat==SMESH::MED_V2_1 )
817 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
818 SMESH::SMESH_IDSource_var aMeshItem = (*aMeshIter).first;
819 SMESH::long_array_var nbElems = aMeshItem->GetMeshInfo();
820 if ( nbElems[ SMESH::Entity_Polygon ] + nbElems[ SMESH::Entity_Quad_Polygon ] +
821 nbElems[ SMESH::Entity_Polyhedra ] + nbElems[ SMESH::Entity_Quad_Polyhedra ])
823 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
824 QObject::tr("SMESH_WRN_WARNING"),
825 QObject::tr("SMESH_EXPORT_MED_V2_1").arg((*aMeshIter).second),
826 QObject::tr("SMESH_BUT_YES"),
827 QObject::tr("SMESH_BUT_NO"), 0, 1);
835 // can't append to an existing using other format
836 SMESH::MED_VERSION aVersion = aFormat; //SMESH::MED_V2_1;
837 bool isVersionOk = SMESHGUI::GetSMESHGen()->GetMEDVersion( aFilename.toUtf8().constData(), aVersion );
838 if( !isVersionOk || aVersion != aFormat ) {
839 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
840 QObject::tr("SMESH_WRN_WARNING"),
841 QObject::tr("SMESH_EXPORT_MED_VERSION_COLLISION").arg(aFilename),
842 QObject::tr("SMESH_BUT_YES"),
843 QObject::tr("SMESH_BUT_NO"), 0, 1);
850 QStringList aMeshNamesCollisionList;
851 SMESH::string_array_var aMeshNames = SMESHGUI::GetSMESHGen()->GetMeshNames( aFilename.toUtf8().constData() );
852 for( int i = 0, n = aMeshNames->length(); i < n; i++ ) {
853 QString anExistingMeshName( aMeshNames[ i ] );
854 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
855 QString anExportMeshName = (*aMeshIter).second;
856 if( anExportMeshName == anExistingMeshName ) {
857 aMeshNamesCollisionList.append( anExportMeshName );
862 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);
878 toCreateGroups = fd->IsChecked(0);
879 toFindOutDim = fd->IsChecked(1);
880 fieldSelWdg->GetSelectedFields();
881 if ( !fieldSelWdg->parent() )
892 if ( !aFilename.isEmpty() ) {
893 // Check whether the file already exists and delete it if yes
894 QFile aFile( aFilename );
895 if ( aFile.exists() && toOverwrite )
897 SUIT_OverrideCursor wc;
900 // Renumbering is not needed since SMDS redesign in V6.2.0 (Nov 2010)
901 // bool Renumber = false;
902 // // PAL 14172 : Check of we have to renumber or not from the preferences before export
904 // Renumber= resMgr->booleanValue("renumbering");
906 // SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
907 // aMeshEditor->RenumberNodes();
908 // aMeshEditor->RenumberElements();
909 // if ( SMESHGUI::automaticUpdate() )
910 // SMESH::UpdateView();
914 aMeshIter = aMeshList.begin();
915 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
917 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
918 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
919 const GEOM::ListOfFields& fields = aFieldList[ aMeshIndex ].first.in();
920 const QString& geoAssFields = aFieldList[ aMeshIndex ].second;
921 const bool hasFields = ( fields.length() || !geoAssFields.isEmpty() );
922 if ( !hasFields && aMeshOrGroup->_is_equivalent( aMeshItem ))
923 aMeshItem->ExportToMEDX( aFilename.toUtf8().data(), toCreateGroups,
924 aFormat, toOverwrite && aMeshIndex == 0, toFindOutDim );
926 aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups,
927 aFormat, toOverwrite && aMeshIndex == 0, toFindOutDim,
928 fields, geoAssFields.toLatin1().data() );
933 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ )
935 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
936 if( !aMeshItem->_is_nil() )
937 aMeshItem->ExportSAUV( aFilename.toUtf8().data(), toCreateGroups );
942 if ( aMeshOrGroup->_is_equivalent( aMesh ))
943 aMesh->ExportDAT( aFilename.toUtf8().data() );
945 aMesh->ExportPartToDAT( aMeshOrGroup, aFilename.toUtf8().data() );
949 if ( aMeshOrGroup->_is_equivalent( aMesh ))
950 aMesh->ExportUNV( aFilename.toUtf8().data() );
952 aMesh->ExportPartToUNV( aMeshOrGroup, aFilename.toUtf8().data() );
956 if ( aMeshOrGroup->_is_equivalent( aMesh ))
957 aMesh->ExportSTL( aFilename.toUtf8().data(), aIsASCII_STL );
959 aMesh->ExportPartToSTL( aMeshOrGroup, aFilename.toUtf8().data(), aIsASCII_STL );
963 aMeshIter = aMeshList.begin();
964 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
966 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
967 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
968 aMeshItem->ExportCGNS( aMeshOrGroup,
969 aFilename.toUtf8().data(),
970 toOverwrite && aMeshIndex == 0,
976 toCreateGroups = true;
977 aMesh->ExportGMF( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups );
980 catch (const SALOME::SALOME_Exception& S_ex){
982 SUIT_MessageBox::warning(SMESHGUI::desktop(),
983 QObject::tr("SMESH_WRN_WARNING"),
984 QObject::tr("SMESH_EXPORT_FAILED"));
990 inline void InverseEntityMode(unsigned int& theOutputMode,
991 unsigned int theMode)
993 bool anIsNotPresent = ~theOutputMode & theMode;
995 theOutputMode |= theMode;
997 theOutputMode &= ~theMode;
1000 void SetDisplayEntity(int theCommandID)
1002 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1003 SALOME_ListIO selected;
1005 aSel->selectedObjects( selected );
1007 if ( selected.Extent() >= 1 ) {
1008 SUIT_OverrideCursor wc;
1009 SALOME_ListIteratorOfListIO It( selected );
1010 for( ; It.More(); It.Next()){
1011 Handle(SALOME_InteractiveObject) IObject = It.Value();
1012 if(IObject->hasEntry()){
1013 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1014 unsigned int aMode = anActor->GetEntityMode();
1015 switch(theCommandID){
1016 case SMESHOp::OpDE0DElements: InverseEntityMode(aMode,SMESH_Actor::e0DElements); break;
1017 case SMESHOp::OpDEEdges: InverseEntityMode(aMode,SMESH_Actor::eEdges); break;
1018 case SMESHOp::OpDEFaces: InverseEntityMode(aMode,SMESH_Actor::eFaces); break;
1019 case SMESHOp::OpDEVolumes: InverseEntityMode(aMode,SMESH_Actor::eVolumes); break;
1020 case SMESHOp::OpDEBalls: InverseEntityMode(aMode,SMESH_Actor::eBallElem); break;
1021 case SMESHOp::OpDEAllEntity: aMode = SMESH_Actor::eAllEntity; break;
1024 anActor->SetEntityMode(aMode);
1033 SalomeApp_Application* app =
1034 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1038 LightApp_SelectionMgr* aSel = app->selectionMgr();
1039 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1040 if ( !aSel || !appStudy )
1043 SALOME_ListIO selected;
1044 aSel->selectedObjects( selected );
1045 if ( selected.IsEmpty() )
1048 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1050 _PTR(Study) aStudy = appStudy->studyDS();
1051 _PTR(SObject) aMainSObject = aStudy->FindObjectID( anIObject->getEntry() );
1052 SMESH::SMESH_Mesh_var aMainObject = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1053 if ( aMainObject->_is_nil() )
1056 SUIT_OverrideCursor wc;
1058 aMainObject->SetAutoColor( true ); // mesh groups are re-colored here
1060 QList<SALOMEDS::Color> aReservedColors;
1062 SMESH::ListOfGroups aListOfGroups = *aMainObject->GetGroups();
1063 for ( int i = 0, n = aListOfGroups.length(); i < n; i++ )
1065 SMESH::SMESH_GroupBase_var aGroupObject = aListOfGroups[i];
1067 #ifdef SIMPLE_AUTOCOLOR // simplified algorithm for auto-colors
1068 SALOMEDS::Color aColor = SMESHGUI::getPredefinedUniqueColor();
1069 #else // old algorithm for auto-colors
1070 SALOMEDS::Color aColor = SMESHGUI::getUniqueColor( aReservedColors );
1071 aReservedColors.append( aColor );
1072 #endif // SIMPLE_AUTOCOLOR
1073 aGroupObject->SetColor( aColor );
1075 _PTR(SObject) aGroupSObject = SMESH::FindSObject(aGroupObject);
1076 if ( aGroupSObject ) {
1079 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry(aGroupSObject->GetID().c_str())) {
1080 switch ( aGroupObject->GetType ()) {
1082 anActor->SetNodeColor( aColor.R, aColor.G, aColor.B ); break;
1084 anActor->SetEdgeColor( aColor.R, aColor.G, aColor.B ); break;
1086 anActor->Set0DColor( aColor.R, aColor.G, aColor.B ); break;
1088 anActor->SetBallColor( aColor.R, aColor.G, aColor.B ); break;
1090 SMESH::GetColor("SMESH", "volume_color", c, delta, "255,0,170|-100");
1091 anActor->SetVolumeColor( aColor.R, aColor.G, aColor.B, delta ); break;
1094 SMESH::GetColor("SMESH", "fill_color", c, delta, "0,170,255|-100");
1095 anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B, delta );
1101 SMESH::RepaintCurrentView();
1104 void OverallMeshQuality()
1106 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1107 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1108 SALOME_ListIO selected;
1110 aSel->selectedObjects( selected );
1112 if ( selected.IsEmpty() ) return;
1113 SALOME_ListIteratorOfListIO It( selected );
1114 for ( ; It.More(); It.Next() ) {
1115 SMESHGUI_CtrlInfoDlg* ctrlDlg = new SMESHGUI_CtrlInfoDlg( SMESHGUI::desktop() );
1116 ctrlDlg->showInfo( It.Value() );
1121 QString functorToString( SMESH::Controls::FunctorPtr f )
1123 QString type = QObject::tr( "UNKNOWN_CONTROL" );
1124 if ( dynamic_cast< SMESH::Controls::Volume* >( f.get() ) )
1125 type = QObject::tr( "VOLUME_3D_ELEMENTS" );
1126 else if ( dynamic_cast< SMESH::Controls::MaxElementLength2D* >( f.get() ) )
1127 type = QObject::tr( "MAX_ELEMENT_LENGTH_2D" );
1128 else if ( dynamic_cast< SMESH::Controls::MaxElementLength3D* >( f.get() ) )
1129 type = QObject::tr( "MAX_ELEMENT_LENGTH_3D" );
1130 else if ( dynamic_cast< SMESH::Controls::MinimumAngle* >( f.get() ) )
1131 type = QObject::tr( "MINIMUMANGLE_ELEMENTS" );
1132 else if ( dynamic_cast< SMESH::Controls::AspectRatio* >( f.get() ) )
1133 type = QObject::tr( "ASPECTRATIO_ELEMENTS" );
1134 else if ( dynamic_cast< SMESH::Controls::AspectRatio3D* >( f.get() ) )
1135 type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" );
1136 else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) )
1137 type = QObject::tr( "WARP_ELEMENTS" );
1138 else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) )
1139 type = QObject::tr( "TAPER_ELEMENTS" );
1140 else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) )
1141 type = QObject::tr( "SKEW_ELEMENTS" );
1142 else if ( dynamic_cast< SMESH::Controls::Area* >( f.get() ) )
1143 type = QObject::tr( "AREA_ELEMENTS" );
1144 else if ( dynamic_cast< SMESH::Controls::Length* >( f.get() ) )
1145 type = QObject::tr( "LENGTH_EDGES" );
1146 else if ( dynamic_cast< SMESH::Controls::Length2D* >( f.get() ) )
1147 type = QObject::tr( "LENGTH2D_EDGES" );
1148 else if ( dynamic_cast< SMESH::Controls::Deflection2D* >( f.get() ) )
1149 type = QObject::tr( "DEFLECTION2D_FACES" );
1150 else if ( dynamic_cast< SMESH::Controls::MultiConnection* >( f.get() ) )
1151 type = QObject::tr( "MULTI_BORDERS" );
1152 else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) )
1153 type = QObject::tr( "MULTI2D_BORDERS" );
1154 else if ( dynamic_cast< SMESH::Controls::FreeNodes* >( f.get() ) )
1155 type = QObject::tr( "FREE_NODES" );
1156 else if ( dynamic_cast< SMESH::Controls::FreeEdges* >( f.get() ) )
1157 type = QObject::tr( "FREE_EDGES" );
1158 else if ( dynamic_cast< SMESH::Controls::FreeBorders* >( f.get() ) )
1159 type = QObject::tr( "FREE_BORDERS" );
1160 else if ( dynamic_cast< SMESH::Controls::FreeFaces* >( f.get() ) )
1161 type = QObject::tr( "FREE_FACES" );
1162 else if ( dynamic_cast< SMESH::Controls::BareBorderVolume* >( f.get() ) )
1163 type = QObject::tr( "BARE_BORDER_VOLUME" );
1164 else if ( dynamic_cast< SMESH::Controls::BareBorderFace* >( f.get() ) )
1165 type = QObject::tr( "BARE_BORDER_FACE" );
1166 else if ( dynamic_cast< SMESH::Controls::OverConstrainedVolume* >( f.get() ) )
1167 type = QObject::tr( "OVER_CONSTRAINED_VOLUME" );
1168 else if ( dynamic_cast< SMESH::Controls::OverConstrainedFace* >( f.get() ) )
1169 type = QObject::tr( "OVER_CONSTRAINED_FACE" );
1170 else if ( dynamic_cast< SMESH::Controls::CoincidentNodes* >( f.get() ) )
1171 type = QObject::tr( "EQUAL_NODE" );
1172 else if ( dynamic_cast< SMESH::Controls::CoincidentElements1D* >( f.get() ) )
1173 type = QObject::tr( "EQUAL_EDGE" );
1174 else if ( dynamic_cast< SMESH::Controls::CoincidentElements2D* >( f.get() ) )
1175 type = QObject::tr( "EQUAL_FACE" );
1176 else if ( dynamic_cast< SMESH::Controls::CoincidentElements3D* >( f.get() ) )
1177 type = QObject::tr( "EQUAL_VOLUME" );
1178 else if ( dynamic_cast< SMESH::Controls::NodeConnectivityNumber* >( f.get() ) )
1179 type = QObject::tr( "NODE_CONNECTIVITY_NB" );
1183 void SaveDistribution()
1185 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1186 SALOME_ListIO selected;
1188 aSel->selectedObjects( selected );
1190 if ( selected.Extent() == 1 ) {
1191 Handle(SALOME_InteractiveObject) anIO = selected.First();
1192 if ( anIO->hasEntry() ) {
1193 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1195 anActor->GetScalarBarActor() &&
1196 anActor->GetControlMode() != SMESH_Actor::eNone )
1198 SMESH_ScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor();
1199 SMESH::Controls::FunctorPtr aFunctor = anActor->GetFunctor();
1200 if ( aScalarBarActor && aFunctor ) {
1201 SMESH::Controls::NumericalFunctor* aNumFun =
1202 dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
1204 std::vector<int> elements;
1205 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
1206 if ( mesh->_is_nil() ) {
1207 SMESH::SMESH_IDSource_var idSource =
1208 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
1209 if ( !idSource->_is_nil() )
1211 SMESH::long_array_var ids = idSource->GetIDs();
1212 elements.resize( ids->length() );
1213 for ( unsigned i = 0; i < elements.size(); ++i )
1214 elements[i] = ids[i];
1217 int nbIntervals = aScalarBarActor->GetMaximumNumberOfColors();
1218 vtkLookupTable* lookupTable =
1219 static_cast<vtkLookupTable*>(aScalarBarActor->GetLookupTable());
1220 double * minmax = lookupTable->GetRange();
1221 bool isLogarithmic = lookupTable->GetScale() == VTK_SCALE_LOG10;
1222 std::vector<int> nbEvents;
1223 std::vector<double> funValues;
1224 aNumFun->GetHistogram( nbIntervals, nbEvents, funValues,
1225 elements, minmax, isLogarithmic );
1226 QString anInitialPath = "";
1227 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
1228 anInitialPath = QDir::currentPath();
1229 QString aMeshName = anIO->getName();
1231 filter.append( QObject::tr( "TEXT_FILES_FILTER" ) + " (*.txt)" );
1232 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
1233 QString aFilename = anInitialPath + "/" + aMeshName + "_" +
1234 functorToString( aFunctor ).toLower().simplified().replace( QRegExp( " |-" ), "_" ) + ".txt";
1235 aFilename = SUIT_FileDlg::getFileName( SMESHGUI::desktop(),
1238 QObject::tr( "SMESH_SAVE_DISTRIBUTION" ),
1240 if ( !aFilename.isEmpty() ) {
1241 QFile f( aFilename );
1242 if ( f.open( QFile::WriteOnly | QFile::Truncate ) ) {
1243 QTextStream out( &f );
1244 out << "# Mesh: " << aMeshName << endl;
1245 out << "# Control: " << functorToString( aFunctor ) << endl;
1247 out.setFieldWidth( 10 );
1248 for ( int i = 0; i < (int)qMin( nbEvents.size(), funValues.size()-1 ); i++ )
1249 out << funValues[i] << "\t" << funValues[i+1] << "\t" << nbEvents[i] << endl;
1260 void ShowElement( int theCommandID )
1262 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1263 SALOME_ListIO selected;
1265 aSel->selectedObjects( selected );
1267 if ( selected.Extent() == 1 ) {
1268 Handle(SALOME_InteractiveObject) anIO = selected.First();
1269 if ( anIO->hasEntry() ) {
1270 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1272 anActor->GetScalarBarActor() &&
1273 anActor->GetControlMode() != SMESH_Actor::eNone )
1275 SMESH_ScalarBarActor *aScalarBarActor = anActor->GetScalarBarActor();
1276 if ( theCommandID == SMESHOp::OpShowDistribution ) {
1277 aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility());
1279 else if ( theCommandID == SMESHOp::OpShowScalarBar ) {
1280 aScalarBarActor->SetVisibility( !aScalarBarActor->GetVisibility());
1287 #ifndef DISABLE_PLOT2DVIEWER
1288 void PlotDistribution()
1290 SalomeApp_Application* app =
1291 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1295 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1296 SALOME_ListIO selected;
1298 aSel->selectedObjects( selected );
1300 if ( selected.Extent() == 1 ) {
1301 Handle(SALOME_InteractiveObject) anIO = selected.First();
1302 if ( anIO->hasEntry() ) {
1303 //Find Actor by entry before getting Plot2d viewer,
1304 //because after call getViewManager( Plot2d_Viewer::Type(), true ) active window is Plot2d Viewer
1305 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1307 SUIT_ViewManager* aViewManager =
1308 app->getViewManager( Plot2d_Viewer::Type(), true ); // create if necessary
1312 SPlot2d_Viewer* aView = dynamic_cast<SPlot2d_Viewer*>(aViewManager->getViewModel());
1316 Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
1320 if ( anActor && anActor->GetControlMode() != SMESH_Actor::eNone )
1322 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1323 QString functorName = functorToString( anActor->GetFunctor());
1324 QString aHistogramName("%1 : %2");
1325 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1326 aHistogram->setName(aHistogramName);
1327 aHistogram->setHorTitle(functorName);
1328 aHistogram->setVerTitle(QObject::tr("DISTRIBUTION_NB_ENT"));
1329 aPlot->displayObject(aHistogram, true);
1334 #endif //DISABLE_PLOT2DVIEWER
1336 void DisableAutoColor()
1338 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1339 SALOME_ListIO selected;
1341 aSel->selectedObjects( selected );
1343 if ( selected.Extent() ) {
1344 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1345 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1346 if ( !aMesh->_is_nil() ) {
1347 aMesh->SetAutoColor( false );
1354 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1355 SALOME_ListIO selected;
1357 aSel->selectedObjects( selected );
1358 if ( selected.Extent() )
1360 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1361 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1362 _PTR(SObject) aSObj = aStudy->FindObjectID(anIObject->getEntry());
1364 if ( aStudy->GetUseCaseBuilder()->SortChildren( aSObj, true/*AscendingOrder*/ ) ) {
1365 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1372 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap)
1374 SALOME_ListIO selected;
1375 SalomeApp_Application* app =
1376 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1380 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1381 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1382 if ( !aSel || !appStudy )
1385 if ( theCommandID == SMESHOp::OpClipping ) { // Clipping dialog can be activated without selection
1386 if ( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
1387 aModule->EmitSignalDeactivateDialog();
1388 if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
1389 (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
1394 _PTR(Study) aStudy = appStudy->studyDS();
1396 aSel->selectedObjects( selected );
1398 if ( selected.Extent() >= 1 )
1400 switch ( theCommandID ) {
1401 case SMESHOp::OpTransparency:
1403 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1404 (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
1407 case SMESHOp::OpProperties:
1410 QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
1411 QColor orientationColor, outlineColor, volumeColor;
1412 int deltaF = 0, deltaV = 0;
1415 double ballScale = 1.0;
1417 int outlineWidth = 1;
1418 double shrinkCoef = 0.0;
1419 double orientationScale = 0.0;
1420 bool orientation3d = false;
1421 VTK::MarkerType markerType = VTK::MT_NONE;
1422 VTK::MarkerScale markerScale = VTK::MS_NONE;
1424 bool hasNodes = false;
1425 int presentEntities = 0;
1426 bool firstTime = true;
1428 SALOME_ListIteratorOfListIO It( selected );
1429 for ( ; It.More(); It.Next() ) {
1430 Handle(SALOME_InteractiveObject) IObject = It.Value();
1431 if ( !IObject->hasEntry() ) continue;
1432 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1433 if ( !anActor || !anActor->GetObject() ) continue;
1436 // nodes: color, marker
1437 anActor->GetNodeColor( color[0], color[1], color[2] );
1438 nodeColor.setRgbF( color[0], color[1], color[2] );
1439 markerType = anActor->GetMarkerType();
1440 markerScale = anActor->GetMarkerScale();
1441 markerId = anActor->GetMarkerTexture();
1442 // edges: color, width
1443 anActor->GetEdgeColor( color[0], color[1], color[2] );
1444 edgeColor.setRgbF( color[0], color[1], color[2] );
1445 edgeWidth = qMax( (int)anActor->GetLineWidth(), 1 ); // minimum allowed width is 1
1446 // faces: front color, back color (delta)
1447 anActor->GetSufaceColor( color[0], color[1], color[2], deltaF );
1448 faceColor.setRgbF( color[0], color[1], color[2] );
1449 // faces: front color, back color (delta)
1450 anActor->GetVolumeColor( color[0], color[1], color[2], deltaV );
1451 volumeColor.setRgbF( color[0], color[1], color[2] );
1452 // 0d elements: color, size
1453 anActor->Get0DColor( color[0], color[1], color[2] );
1454 elem0dColor.setRgbF( color[0], color[1], color[2] );
1455 elem0dSize = qMax( (int)anActor->Get0DSize(), 1 ); // minimum allowed size is 1
1456 // balls: color, size
1457 anActor->GetBallColor( color[0], color[1], color[2] );
1458 ballColor.setRgbF( color[0], color[1], color[2] );
1459 //ballSize = qMax( (int)anActor->GetBallSize(), 1 ); // minimum allowed size is 1
1460 ballScale = qMax( (double)anActor->GetBallScale(), 1e-2 ); // minimum allowed scale is 1e-2
1462 anActor->GetOutlineColor( color[0], color[1], color[2] );
1463 outlineColor.setRgbF( color[0], color[1], color[2] );
1464 outlineWidth = qMax( (int)anActor->GetOutlineWidth(), 1 ); // minimum allowed width is 1
1465 // orientation vectors: color, scale, 3d flag
1466 anActor->GetFacesOrientationColor( color[0], color[1], color[2] );
1467 orientationColor.setRgbF( color[0], color[1], color[2] );
1468 orientationScale = anActor->GetFacesOrientationScale();
1469 orientation3d = anActor->GetFacesOrientation3DVectors();
1471 shrinkCoef = anActor->GetShrinkFactor();
1474 firstTime = false; // we only take properties from first object (for performance reasons)
1477 hasNodes = anActor->GetObject()->GetNbEntities( SMDSAbs_Node );
1478 if ( !(presentEntities & SMESH_Actor::eEdges) && anActor->GetObject()->GetNbEntities( SMDSAbs_Edge ) )
1479 presentEntities = presentEntities | SMESH_Actor::eEdges;
1480 if ( !(presentEntities & SMESH_Actor::eFaces) && anActor->GetObject()->GetNbEntities( SMDSAbs_Face ) )
1481 presentEntities = presentEntities | SMESH_Actor::eFaces;
1482 if ( !(presentEntities & SMESH_Actor::eVolumes) && anActor->GetObject()->GetNbEntities( SMDSAbs_Volume ) )
1483 presentEntities = presentEntities | SMESH_Actor::eVolumes;
1484 if ( !(presentEntities & SMESH_Actor::e0DElements) && anActor->GetObject()->GetNbEntities( SMDSAbs_0DElement ) )
1485 presentEntities = presentEntities | SMESH_Actor::e0DElements;
1486 if ( !(presentEntities & SMESH_Actor::eBallElem) && anActor->GetObject()->GetNbEntities( SMDSAbs_Ball ) )
1487 presentEntities = presentEntities | SMESH_Actor::eBallElem;
1489 // as we know that all types of elements are present, we can exit the loop
1490 if ( presentEntities == SMESH_Actor::eAllEntity )
1494 SMESHGUI_PropertiesDlg dlg( theMarkerMap[ aStudy->StudyId() ], SMESHGUI::desktop() );
1495 // nodes: color, marker
1496 dlg.setNodeColor( nodeColor );
1497 if( markerType != VTK::MT_USER )
1498 dlg.setNodeMarker( markerType, markerScale );
1500 dlg.setNodeCustomMarker( markerId );
1501 // edges: color, line width
1502 dlg.setEdgeColor( edgeColor );
1503 dlg.setEdgeWidth( edgeWidth );
1504 // faces: front color, back color
1505 dlg.setFaceColor( faceColor, deltaF );
1506 // volumes: normal color, reversed color
1507 dlg.setVolumeColor( volumeColor, deltaV );
1508 // outlines: color, line width
1509 dlg.setOutlineColor( outlineColor );
1510 dlg.setOutlineWidth( outlineWidth );
1511 // 0d elements: color, size
1512 dlg.setElem0dColor( elem0dColor );
1513 dlg.setElem0dSize( elem0dSize );
1514 // balls: color, size
1515 dlg.setBallColor( ballColor );
1516 //dlg.setBallSize( ballSize );
1517 dlg.setBallScale( ballScale );
1518 // orientation: color, scale, 3d flag
1519 dlg.setOrientationColor( orientationColor );
1520 dlg.setOrientationSize( int( orientationScale * 100. ) );
1521 dlg.setOrientation3d( orientation3d );
1522 // shrink: scale factor
1523 dlg.setShrinkCoef( int( shrinkCoef * 100. ) );
1524 // hide unused controls
1525 dlg.showControls( presentEntities, hasNodes );
1528 nodeColor = dlg.nodeColor();
1529 markerType = dlg.nodeMarkerType();
1530 markerScale = dlg.nodeMarkerScale();
1531 markerId = dlg.nodeMarkerId();
1532 edgeColor = dlg.edgeColor();
1533 edgeWidth = dlg.edgeWidth();
1534 faceColor = dlg.faceColor();
1535 deltaF = dlg.faceColorDelta();
1536 volumeColor = dlg.volumeColor();
1537 deltaV = dlg.volumeColorDelta();
1538 outlineColor = dlg.outlineColor();
1539 outlineWidth = dlg.outlineWidth();
1540 elem0dColor = dlg.elem0dColor();
1541 elem0dSize = dlg.elem0dSize();
1542 ballColor = dlg.ballColor();
1543 // ballSize = dlg.ballSize();
1544 ballScale = dlg.ballScale();
1545 orientationColor = dlg.orientationColor();
1546 orientationScale = dlg.orientationSize() / 100.;
1547 orientation3d = dlg.orientation3d();
1548 shrinkCoef = dlg.shrinkCoef() / 100.;
1550 // store point markers map that might be changed by the user
1551 theMarkerMap[ aStudy->StudyId() ] = dlg.customMarkers();
1553 // set properties from dialog box to the presentations
1554 SALOME_ListIteratorOfListIO It( selected );
1555 for ( ; It.More(); It.Next() ) {
1556 Handle(SALOME_InteractiveObject) IObject = It.Value();
1557 if ( !IObject->hasEntry() ) continue;
1558 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1559 if ( !anActor ) continue;
1561 // nodes: color, marker
1562 anActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
1563 if ( markerType != VTK::MT_USER ) {
1564 anActor->SetMarkerStd( markerType, markerScale );
1567 const VTK::MarkerMap& markerMap = theMarkerMap[ aStudy->StudyId() ];
1568 VTK::MarkerMap::const_iterator iter = markerMap.find( markerId );
1569 if ( iter != markerMap.end() )
1570 anActor->SetMarkerTexture( markerId, iter->second.second );
1572 // volumes: normal color, reversed color (delta)
1573 anActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
1574 // faces: front color, back color (delta)
1575 anActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
1576 // edges: color, width
1577 anActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
1578 anActor->SetLineWidth( edgeWidth );
1580 anActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
1581 anActor->SetOutlineWidth( outlineWidth );
1582 // 0D elements: color, size
1583 anActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
1584 anActor->Set0DSize( elem0dSize );
1585 // balls: color, size
1586 anActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
1587 // anActor->SetBallSize( ballSize );
1588 anActor->SetBallScale( ballScale );
1589 // orientation: color, scale, 3d flag
1590 anActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
1591 anActor->SetFacesOrientationScale( orientationScale );
1592 anActor->SetFacesOrientation3DVectors( orientation3d );
1594 anActor->SetShrinkFactor( shrinkCoef );
1596 // for groups, set also proper color
1597 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1598 if ( !aGroupObject->_is_nil() ) {
1599 SMESH::ElementType anElementType = aGroupObject->GetType();
1601 switch( anElementType ) {
1603 aColor = nodeColor; break;
1605 aColor = edgeColor; break;
1607 aColor = faceColor; break;
1609 aColor = volumeColor; break;
1611 aColor = elem0dColor; break;
1613 aColor = ballColor; break;
1617 if ( aColor.isValid() ) {
1618 SALOMEDS::Color aGroupColor;
1619 aGroupColor.R = aColor.redF();
1620 aGroupColor.G = aColor.greenF();
1621 aGroupColor.B = aColor.blueF();
1622 aGroupObject->SetColor( aGroupColor );
1624 } // if ( !aGroupObject->_is_nil() )
1625 } // for ( ; It.More(); It.Next() )
1626 SMESH::RepaintCurrentView();
1627 } // if ( dlg.exec() )
1629 } // case SMESHOp::OpProperties:
1630 } // switch(theCommandID)
1631 SUIT_OverrideCursor wc;
1632 SALOME_ListIteratorOfListIO It( selected );
1633 for( ; It.More(); It.Next()){
1634 Handle(SALOME_InteractiveObject) IObject = It.Value();
1635 if(IObject->hasEntry()){
1636 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1637 switch(theCommandID){
1638 case SMESHOp::OpDMWireframe:
1639 anActor->SetRepresentation(SMESH_Actor::eEdge);
1641 case SMESHOp::OpDMShading:
1642 anActor->SetRepresentation(SMESH_Actor::eSurface);
1644 case SMESHOp::OpDMShrink:
1645 if(anActor->IsShrunk())
1646 anActor->UnShrink();
1648 anActor->SetShrink();
1650 case SMESHOp::OpDMNodes:
1651 anActor->SetRepresentation(SMESH_Actor::ePoint);
1653 case SMESHOp::OpRepresentationLines:
1654 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1655 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1657 case SMESHOp::OpRepresentationArcs:
1658 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1659 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1665 SMESH::RepaintCurrentView();
1669 int ActionToControl( int theID, bool theReversed )
1671 NCollection_DoubleMap<int,int> ActionControl;
1672 ActionControl.Bind( 0, SMESH_Actor::eNone );
1673 ActionControl.Bind( SMESHOp::OpFreeNode, SMESH_Actor::eFreeNodes );
1674 ActionControl.Bind( SMESHOp::OpEqualNode, SMESH_Actor::eCoincidentNodes );
1675 ActionControl.Bind( SMESHOp::OpNodeConnectivityNb, SMESH_Actor::eNodeConnectivityNb );
1676 ActionControl.Bind( SMESHOp::OpFreeEdge, SMESH_Actor::eFreeEdges );
1677 ActionControl.Bind( SMESHOp::OpFreeBorder, SMESH_Actor::eFreeBorders );
1678 ActionControl.Bind( SMESHOp::OpLength, SMESH_Actor::eLength );
1679 ActionControl.Bind( SMESHOp::OpConnection, SMESH_Actor::eMultiConnection );
1680 ActionControl.Bind( SMESHOp::OpEqualEdge, SMESH_Actor::eCoincidentElems1D );
1681 ActionControl.Bind( SMESHOp::OpFreeFace, SMESH_Actor::eFreeFaces );
1682 ActionControl.Bind( SMESHOp::OpBareBorderFace, SMESH_Actor::eBareBorderFace );
1683 ActionControl.Bind( SMESHOp::OpOverConstrainedFace, SMESH_Actor::eOverConstrainedFace );
1684 ActionControl.Bind( SMESHOp::OpLength2D, SMESH_Actor::eLength2D );
1685 ActionControl.Bind( SMESHOp::OpDeflection2D, SMESH_Actor::eDeflection2D );
1686 ActionControl.Bind( SMESHOp::OpConnection2D, SMESH_Actor::eMultiConnection2D );
1687 ActionControl.Bind( SMESHOp::OpArea, SMESH_Actor::eArea );
1688 ActionControl.Bind( SMESHOp::OpTaper, SMESH_Actor::eTaper );
1689 ActionControl.Bind( SMESHOp::OpAspectRatio, SMESH_Actor::eAspectRatio );
1690 ActionControl.Bind( SMESHOp::OpMinimumAngle, SMESH_Actor::eMinimumAngle );
1691 ActionControl.Bind( SMESHOp::OpWarpingAngle, SMESH_Actor::eWarping );
1692 ActionControl.Bind( SMESHOp::OpSkew, SMESH_Actor::eSkew );
1693 ActionControl.Bind( SMESHOp::OpMaxElementLength2D, SMESH_Actor::eMaxElementLength2D );
1694 ActionControl.Bind( SMESHOp::OpEqualFace, SMESH_Actor::eCoincidentElems2D );
1695 ActionControl.Bind( SMESHOp::OpAspectRatio3D, SMESH_Actor::eAspectRatio3D );
1696 ActionControl.Bind( SMESHOp::OpVolume, SMESH_Actor::eVolume3D );
1697 ActionControl.Bind( SMESHOp::OpMaxElementLength3D, SMESH_Actor::eMaxElementLength3D );
1698 ActionControl.Bind( SMESHOp::OpBareBorderVolume, SMESH_Actor::eBareBorderVolume );
1699 ActionControl.Bind( SMESHOp::OpOverConstrainedVolume, SMESH_Actor::eOverConstrainedVolume );
1700 ActionControl.Bind( SMESHOp::OpEqualVolume, SMESH_Actor::eCoincidentElems3D );
1702 return theReversed ? ActionControl.Find2( theID ) : ActionControl.Find1( theID );
1705 void Control( int theCommandID )
1707 SMESH_Actor::eControl aControl = SMESH_Actor::eControl( ActionToControl( theCommandID ));
1708 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1710 SALOME_ListIO selected;
1711 if ( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
1712 aSel->selectedObjects( selected );
1714 if ( !selected.IsEmpty() ) {
1715 SALOME_ListIteratorOfListIO It(selected);
1716 for ( ; It.More(); It.Next())
1718 Handle(SALOME_InteractiveObject) anIO = It.Value();
1719 if ( !anIO.IsNull() ) {
1720 _PTR(SObject) SO = aStudy->FindObjectID( It.Value()->getEntry() );
1722 CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
1723 SMESH::SMESH_IDSource_var anIDSrc = SMESH::SMESH_IDSource::_narrow( aObject );
1724 if ( !anIDSrc->_is_nil() ) {
1725 SMESH_Actor *anActor = SMESH::FindActorByEntry( anIO->getEntry());
1726 if (( !anActor && selected.Extent() == 1 ) &&
1727 ( anActor = SMESH::CreateActor( aStudy, anIO->getEntry() )))
1729 anActor->SetControlMode( aControl );
1730 SMESH::DisplayActor( SMESH::GetCurrentVtkView(), anActor );
1731 SMESH::UpdateView ( SMESH::eDisplay, anIO->getEntry() );
1735 if ( anActor->GetControlMode() != aControl )
1736 anActor->SetControlMode( aControl );
1737 QString functorName = functorToString( anActor->GetFunctor() );
1738 int anEntitiesCount = anActor->GetNumberControlEntities();
1739 if (anEntitiesCount >= 0)
1740 functorName = functorName + ": " + QString::number(anEntitiesCount);
1741 anActor->GetScalarBarActor()->SetTitle( functorName.toLatin1().constData() );
1742 SMESH::RepaintCurrentView();
1743 #ifndef DISABLE_PLOT2DVIEWER
1744 if ( anActor->GetPlot2Histogram() ) {
1745 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1746 QString aHistogramName("%1 : %2");
1747 aHistogramName = aHistogramName.arg( anIO->getName() ).arg( functorName );
1748 aHistogram->setName( aHistogramName );
1749 aHistogram->setHorTitle( functorName );
1750 SMESH::ProcessIn2DViewers( anActor );
1762 bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1763 SMESH::MeshObjectType theType,
1764 const QString theInTypeName,
1765 QString & theOutTypeName)
1767 SMESH_TypeFilter aTypeFilter( theType );
1769 if ( !theIO.IsNull() )
1771 entry = theIO->getEntry();
1772 LightApp_DataOwner owner( entry );
1773 if ( aTypeFilter.isOk( &owner )) {
1774 theOutTypeName = theInTypeName;
1782 QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1784 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1785 _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1787 _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1788 CORBA::String_var anID = aSComp->GetID().c_str();
1789 if ( !strcmp(anID.in(),theIO->getEntry()) )
1795 CheckOIType ( theIO, SMESH::HYPOTHESIS, "Hypothesis", aTypeName ) ||
1796 CheckOIType ( theIO, SMESH::ALGORITHM, "Algorithm", aTypeName ) ||
1797 CheckOIType ( theIO, SMESH::MESH, "Mesh", aTypeName ) ||
1798 CheckOIType ( theIO, SMESH::SUBMESH, "SubMesh", aTypeName ) ||
1799 CheckOIType ( theIO, SMESH::GROUP, "Group", aTypeName )
1807 // QString CheckHomogeneousSelection()
1809 // LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1810 // SALOME_ListIO selected;
1812 // aSel->selectedObjects( selected );
1814 // QString RefType = CheckTypeObject(selected.First());
1815 // SALOME_ListIteratorOfListIO It(selected);
1816 // for ( ; It.More(); It.Next())
1818 // Handle(SALOME_InteractiveObject) IObject = It.Value();
1819 // QString Type = CheckTypeObject(IObject);
1820 // if ( Type.compare(RefType) != 0 )
1821 // return "Heterogeneous Selection";
1827 uint randomize( uint size )
1829 static bool initialized = false;
1830 if ( !initialized ) {
1831 qsrand( QDateTime::currentDateTime().toTime_t() );
1835 v = uint( (double)( v ) / RAND_MAX * size );
1836 v = qMax( uint(0), qMin ( v, size-1 ) );
1842 void SMESHGUI::OnEditDelete()
1844 // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1845 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1846 SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1848 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1849 _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1850 _PTR(GenericAttribute) anAttr;
1851 _PTR(AttributeIOR) anIOR;
1853 int objectCount = 0;
1855 QString aParentComponent = QString::null;
1856 Handle(SALOME_InteractiveObject) anIO;
1857 for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1859 anIO = anIt.Value();
1860 QString cur = anIO->getComponentDataType();
1861 _PTR(SObject) aSO = aStudy->FindObjectID(anIO->getEntry());
1863 // check if object is reference
1864 _PTR(SObject) aRefSObj;
1865 aNameList.append("\n - ");
1866 if ( aSO->ReferencedObject( aRefSObj ) ) {
1867 QString aRefName = QString::fromStdString ( aRefSObj->GetName() );
1868 aNameList.append( aRefName );
1869 cur = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1872 aNameList.append(anIO->getName());
1876 if( aParentComponent.isNull() )
1877 aParentComponent = cur;
1878 else if( !aParentComponent.isEmpty() && aParentComponent!=cur )
1879 aParentComponent = "";
1882 if ( objectCount == 0 )
1883 return; // No Valid Objects Selected
1885 if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
1886 SUIT_MessageBox::warning( SMESHGUI::desktop(),
1887 QObject::tr("ERR_ERROR"),
1888 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
1891 // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
1892 if (SUIT_MessageBox::warning
1893 (SMESHGUI::desktop(),
1894 QObject::tr("SMESH_WRN_WARNING"),
1895 QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
1896 SUIT_MessageBox::Yes | SUIT_MessageBox::No,
1897 SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
1900 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1902 // Put the whole hierarchy of sub-objects of the selected SO's into a list and
1903 // then treat them all starting from the deepest objects (at list back)
1904 std::list< _PTR(SObject) > listSO;
1905 SALOME_ListIteratorOfListIO It(selected);
1906 for( ; It.More(); It.Next()) // loop on selected IO's
1908 Handle(SALOME_InteractiveObject) IObject = It.Value();
1909 if(IObject->hasEntry()) {
1910 _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
1912 // disable removal of "SMESH" component object
1913 if(aSO->FindAttribute(anAttr, "AttributeIOR")){
1915 if ( engineIOR() == anIOR->Value().c_str() )
1918 //Check the referenced object
1919 _PTR(SObject) aRefSObject;
1920 if ( aSO && aSO->ReferencedObject( aRefSObject ) )
1921 aSO = aRefSObject; // Delete main Object instead of reference
1923 listSO.push_back( aSO );
1924 std::list< _PTR(SObject) >::iterator itSO = --listSO.end();
1925 for ( ; itSO != listSO.end(); ++itSO ) {
1926 _PTR(ChildIterator) it = aStudy->NewChildIterator( *itSO );
1927 for (it->InitEx(false); it->More(); it->Next())
1928 listSO.push_back( it->Value() );
1932 // Check if none of objects to delete is referred from outside
1933 std::list< _PTR(SObject) >::reverse_iterator ritSO;
1934 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1936 _PTR(SObject) SO = *ritSO;
1937 if ( !SO ) continue;
1938 std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( *ritSO );
1939 for (size_t i = 0; i < aReferences.size(); i++) {
1940 _PTR(SComponent) aComponent = aReferences[i]->GetFatherComponent();
1941 std::string type = aComponent->ComponentDataType();
1942 if ( type != "SMESH" )
1944 SUIT_MessageBox::warning( anApp->desktop(),
1945 QObject::tr("WRN_WARNING"),
1946 QObject::tr("DEP_OBJECT") );
1947 return; // outside SMESH, there is an object depending on a SMESH object
1952 // Call mesh->Clear() to prevent loading mesh from file caused by hypotheses removal
1953 for( It.Initialize( selected ); It.More(); It.Next()) // loop on selected IO's
1955 Handle(SALOME_InteractiveObject) IObject = It.Value();
1956 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface< SMESH::SMESH_Mesh >( IObject );
1957 if ( !mesh->_is_nil() )
1961 // Treat SO's in the list starting from the back
1962 aStudyBuilder->NewCommand(); // There is a transaction
1963 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1965 _PTR(SObject) SO = *ritSO;
1966 if ( !SO ) continue;
1967 std::string anEntry = SO->GetID();
1969 /** Erase graphical object and remove all its data **/
1970 if(SO->FindAttribute(anAttr, "AttributeIOR")) {
1971 SMESH::RemoveVisualObjectWithActors( anEntry.c_str(), true);
1973 /** Remove an object from data structures **/
1974 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
1975 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
1976 if ( !aGroup->_is_nil() ) { // DELETE GROUP
1977 SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
1978 aMesh->RemoveGroup( aGroup );
1980 else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
1981 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
1982 aMesh->RemoveSubMesh( aSubMesh );
1984 _PTR(SObject) aMeshSO = SMESH::FindSObject(aMesh);
1986 SMESH::ModifiedMesh(aMeshSO, false, aMesh->NbNodes()==0);
1989 Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
1990 ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
1991 QString objType = CheckTypeObject(IObject);
1992 if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
1993 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
1994 aStudyBuilder->RemoveObjectWithChildren( SO );
1996 else {// default action: remove SObject from the study
1997 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
1998 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
2000 aStudyBuilder->RemoveObjectWithChildren( SO );
2004 } /* listSO back loop */
2006 aStudyBuilder->CommitCommand();
2008 /* Clear any previous selection */
2010 aSel->setSelectedObjects( l1 );
2012 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
2016 SMESHGUI_EXPORT CAM_Module* createModule()
2018 return new SMESHGUI();
2021 SMESHGUI_EXPORT char* getModuleVersion() {
2022 return (char*)SMESH_VERSION_STR;
2026 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
2028 //=============================================================================
2032 //=============================================================================
2033 SMESHGUI::SMESHGUI() :
2034 SalomeApp_Module( "SMESH" )
2036 if ( CORBA::is_nil( myComponentSMESH ) )
2038 CORBA::Boolean anIsEmbeddedMode;
2039 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
2040 //MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
2042 // 0019923: EDF 765 SMESH : default values of hypothesis
2043 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
2044 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
2045 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
2046 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
2047 myComponentSMESH->SetDefaultNbSegments( nbSeg );
2049 const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif", "default_grp_color" };
2050 for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
2051 if ( aResourceMgr->hasValue( "SMESH", options[i] ))
2053 QString val = aResourceMgr->stringValue( "SMESH", options[i] );
2054 myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
2058 myActiveDialogBox = 0;
2059 myFilterLibraryDlg = 0;
2063 myEventCallbackCommand = vtkCallbackCommand::New();
2064 myEventCallbackCommand->Delete();
2065 myEventCallbackCommand->SetClientData( this );
2066 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
2069 /* load resources for all available meshers */
2070 SMESH::InitAvailableHypotheses();
2073 //=============================================================================
2077 //=============================================================================
2078 SMESHGUI::~SMESHGUI()
2082 //=============================================================================
2086 //=============================================================================
2087 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
2089 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2091 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
2096 //=============================================================================
2100 //=============================================================================
2101 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
2103 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2107 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2108 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2109 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2110 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2111 return autoUpdate && !exceeded;
2114 //=============================================================================
2118 //=============================================================================
2119 bool SMESHGUI::automaticUpdate( SMESH::SMESH_IDSource_ptr theMesh,
2120 int* entities, bool* limitExceeded, int* hidden, long* nbElements )
2122 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2126 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2127 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2128 bool incrementalLimit = resMgr->booleanValue( "SMESH", "incremental_limit", false );
2130 SMESH::long_array_var info = theMesh->GetMeshInfo();
2131 long nbOdElems = info[SMDSEntity_0D];
2132 long nbEdges = info[SMDSEntity_Edge] + info[SMDSEntity_Quad_Edge];
2133 long nbFaces = info[SMDSEntity_Triangle] + info[SMDSEntity_Quad_Triangle] + info[SMDSEntity_BiQuad_Triangle] +
2134 info[SMDSEntity_Quadrangle] + info[SMDSEntity_Quad_Quadrangle] + info[SMDSEntity_BiQuad_Quadrangle] +
2135 info[SMDSEntity_Polygon] + info[SMDSEntity_Quad_Polygon];
2136 long nbVolumes = info[SMDSEntity_Tetra] + info[SMDSEntity_Quad_Tetra] +
2137 info[SMDSEntity_Hexa] + info[SMDSEntity_Quad_Hexa] + info[SMDSEntity_TriQuad_Hexa] +
2138 info[SMDSEntity_Pyramid] + info[SMDSEntity_Quad_Pyramid] +
2139 info[SMDSEntity_Penta] + info[SMDSEntity_Quad_Penta] + info[SMDSEntity_BiQuad_Penta] +
2140 info[SMDSEntity_Polyhedra] +
2141 info[SMDSEntity_Hexagonal_Prism];
2142 long nbBalls = info[SMDSEntity_Ball];
2144 long requestedSize = nbOdElems + nbBalls + nbEdges + nbFaces + nbVolumes;
2145 *nbElements = requestedSize;
2147 *entities = SMESH_Actor::eAllEntity;
2150 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2152 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2154 if ( incrementalLimit ) {
2157 if ( nbOdElems > 0 ) {
2158 if ( total + nbOdElems > updateLimit ) {
2159 *entities = *entities & ~SMESH_Actor::e0DElements;
2160 *hidden = *hidden | SMESH_Actor::e0DElements;
2167 if ( nbEdges > 0 ) {
2168 if ( total + nbEdges > updateLimit ) {
2169 *entities = *entities & ~SMESH_Actor::eEdges;
2170 *hidden = *hidden | SMESH_Actor::eEdges;
2177 if ( nbFaces > 0 ) {
2178 if ( total + nbFaces > updateLimit ) {
2179 *entities = *entities & ~SMESH_Actor::eFaces;
2180 *hidden = *hidden | SMESH_Actor::eFaces;
2187 if ( nbVolumes > 0 ) {
2188 if ( total + nbVolumes > updateLimit ) {
2189 *entities = *entities & ~SMESH_Actor::eVolumes;
2190 *hidden = *hidden | SMESH_Actor::eVolumes;
2197 if ( nbBalls > 0 ) {
2198 if ( total + nbBalls > updateLimit ) {
2199 *entities = *entities & ~SMESH_Actor::eBallElem;
2200 *hidden = *hidden | SMESH_Actor::eBallElem;
2208 return autoUpdate && !exceeded;
2211 //=============================================================================
2215 //=============================================================================
2216 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
2218 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
2221 //=============================================================================
2225 //=============================================================================
2226 SMESHGUI* SMESHGUI::GetSMESHGUI()
2228 SMESHGUI* smeshMod = 0;
2229 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
2232 CAM_Module* module = app->module( "Mesh" );
2233 smeshMod = dynamic_cast<SMESHGUI*>( module );
2236 if ( smeshMod && smeshMod->application() && smeshMod->application()->activeStudy() )
2238 SalomeApp_Study* study = dynamic_cast<SalomeApp_Study*>( smeshMod->application()->activeStudy() );
2241 _PTR(Study) aStudy = study->studyDS();
2243 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
2252 Standard_EXPORT SMESHGUI* GetComponentGUI()
2254 return SMESHGUI::GetSMESHGUI();
2258 //=============================================================================
2262 //=============================================================================
2263 void SMESHGUI::SetState(int aState)
2268 //=============================================================================
2272 //=============================================================================
2273 void SMESHGUI::ResetState()
2278 //=============================================================================
2282 //=============================================================================
2283 void SMESHGUI::EmitSignalDeactivateDialog()
2285 emit SignalDeactivateActiveDialog();
2288 //=============================================================================
2292 //=============================================================================
2293 void SMESHGUI::EmitSignalStudyFrameChanged()
2295 emit SignalStudyFrameChanged();
2298 //=============================================================================
2302 //=============================================================================
2303 void SMESHGUI::EmitSignalCloseAllDialogs()
2305 emit SignalCloseAllDialogs();
2308 //=============================================================================
2312 //=============================================================================
2313 void SMESHGUI::EmitSignalVisibilityChanged()
2315 emit SignalVisibilityChanged();
2318 //=============================================================================
2322 //=============================================================================
2323 void SMESHGUI::EmitSignalCloseView()
2325 emit SignalCloseView();
2328 //=============================================================================
2332 //=============================================================================
2333 void SMESHGUI::EmitSignalActivatedViewManager()
2335 emit SignalActivatedViewManager();
2338 //=============================================================================
2342 //=============================================================================
2343 QDialog *SMESHGUI::GetActiveDialogBox()
2345 return myActiveDialogBox;
2348 //=============================================================================
2352 //=============================================================================
2353 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2355 myActiveDialogBox = (QDialog *) aDlg;
2359 //=============================================================================
2363 //=============================================================================
2364 SUIT_Desktop* SMESHGUI::desktop()
2366 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2368 return app->desktop();
2373 //=============================================================================
2377 //=============================================================================
2378 SalomeApp_Study* SMESHGUI::activeStudy()
2380 SUIT_Application* app = SUIT_Session::session()->activeApplication();
2382 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2387 //=============================================================================
2391 //=============================================================================
2392 void SMESHGUI::Modified( bool theIsUpdateActions )
2394 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2395 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2396 appStudy->Modified();
2397 if( theIsUpdateActions )
2398 app->updateActions();
2403 //=============================================================================
2407 //=============================================================================
2408 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2410 /* Here the position is on the bottom right corner - 10 */
2411 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2413 SUIT_Desktop *PP = desktop();
2414 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2415 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2419 //=============================================================================
2423 //=============================================================================
2424 static int isStudyLocked(_PTR(Study) theStudy){
2425 return theStudy->GetProperties()->IsLocked();
2428 static bool checkLock(_PTR(Study) theStudy) {
2429 if (isStudyLocked(theStudy)) {
2430 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2431 QObject::tr("WRN_WARNING"),
2432 QObject::tr("WRN_STUDY_LOCKED") );
2438 //=======================================================================
2439 //function : CheckActiveStudyLocked
2441 //=======================================================================
2443 bool SMESHGUI::isActiveStudyLocked()
2445 _PTR(Study) aStudy = activeStudy()->studyDS();
2446 return checkLock( aStudy );
2449 //=============================================================================
2453 //=============================================================================
2454 bool SMESHGUI::OnGUIEvent( int theCommandID )
2456 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2460 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
2461 SUIT_ResourceMgr* mgr = resourceMgr();
2465 if (CORBA::is_nil(GetSMESHGen()->GetCurrentStudy())) {
2466 GetSMESHGen()->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
2469 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2470 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2472 //QAction* act = action( theCommandID );
2474 switch (theCommandID) {
2475 case SMESHOp::OpDelete:
2476 if(checkLock(aStudy)) break;
2479 case SMESHOp::OpImportDAT:
2480 case SMESHOp::OpImportUNV:
2481 case SMESHOp::OpImportMED:
2482 case SMESHOp::OpImportSTL:
2483 case SMESHOp::OpImportCGNS:
2484 case SMESHOp::OpImportSAUV:
2485 case SMESHOp::OpImportGMF:
2486 case SMESHOp::OpPopupImportDAT:
2487 case SMESHOp::OpPopupImportUNV:
2488 case SMESHOp::OpPopupImportMED:
2489 case SMESHOp::OpPopupImportSTL:
2490 case SMESHOp::OpPopupImportCGNS:
2491 case SMESHOp::OpPopupImportSAUV:
2492 case SMESHOp::OpPopupImportGMF:
2494 if(checkLock(aStudy)) break;
2495 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2499 case SMESHOp::OpFileInformation:
2501 SALOME_ListIO selected;
2502 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2504 aSel->selectedObjects( selected );
2505 if( selected.Extent() )
2507 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2508 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2509 if ( !aMesh->_is_nil() )
2511 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2517 case SMESHOp::OpExportDAT:
2518 case SMESHOp::OpExportMED:
2519 case SMESHOp::OpExportUNV:
2520 case SMESHOp::OpExportSTL:
2521 case SMESHOp::OpExportCGNS:
2522 case SMESHOp::OpExportSAUV:
2523 case SMESHOp::OpExportGMF:
2524 case SMESHOp::OpPopupExportDAT:
2525 case SMESHOp::OpPopupExportMED:
2526 case SMESHOp::OpPopupExportUNV:
2527 case SMESHOp::OpPopupExportSTL:
2528 case SMESHOp::OpPopupExportCGNS:
2529 case SMESHOp::OpPopupExportSAUV:
2530 case SMESHOp::OpPopupExportGMF:
2532 ::ExportMeshToFile(theCommandID);
2536 case SMESHOp::OpReset: // SCALAR BAR
2538 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2539 SALOME_ListIO selected;
2541 aSel->selectedObjects( selected );
2543 SALOME_ListIteratorOfListIO it(selected);
2544 for( ; it.More(); it.Next()) {
2545 Handle(SALOME_InteractiveObject) anIO = it.Value();
2546 if( anIO->hasEntry() ) {
2547 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2548 anActor->SetControlMode( SMESH_Actor::eNone );
2549 #ifndef DISABLE_PLOT2DVIEWER
2550 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2555 SMESH::UpdateView();
2558 case SMESHOp::OpScalarBarProperties:
2560 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2563 case SMESHOp::OpShowScalarBar:
2565 // show/hide scalar bar
2566 ::ShowElement(theCommandID);
2569 case SMESHOp::OpSaveDistribution:
2571 // dump control distribution data to the text file
2572 ::SaveDistribution();
2576 case SMESHOp::OpShowDistribution:
2578 // show/hide distribution
2579 ::ShowElement(theCommandID);
2583 #ifndef DISABLE_PLOT2DVIEWER
2584 case SMESHOp::OpPlotDistribution:
2586 // plot distribution
2587 ::PlotDistribution();
2593 case SMESHOp::OpAutoColor:
2597 case SMESHOp::OpDisableAutoColor:
2598 ::DisableAutoColor();
2601 case SMESHOp::OpClipping:
2602 case SMESHOp::OpTransparency:
2603 case SMESHOp::OpProperties: // Display preferences (colors, shrink size, line width, ...)
2606 case SMESHOp::OpDMWireframe:
2607 case SMESHOp::OpDMShading:
2608 case SMESHOp::OpDMNodes:
2609 case SMESHOp::OpDMShrink:
2610 ::SetDisplayMode(theCommandID, myMarkerMap);
2613 //2D quadratic representation
2614 case SMESHOp::OpRepresentationLines:
2615 case SMESHOp::OpRepresentationArcs:
2616 ::SetDisplayMode(theCommandID, myMarkerMap);
2620 case SMESHOp::OpDE0DElements:
2621 case SMESHOp::OpDEEdges:
2622 case SMESHOp::OpDEFaces:
2623 case SMESHOp::OpDEVolumes:
2624 case SMESHOp::OpDEBalls:
2625 case SMESHOp::OpDEAllEntity:
2626 ::SetDisplayEntity(theCommandID);
2629 // Choose entities to be displayed
2630 case SMESHOp::OpDEChoose:
2632 ( new SMESHGUI_DisplayEntitiesDlg( SMESHGUI::desktop() ) )->exec();
2636 case SMESHOp::OpOrientationOnFaces:
2638 SUIT_OverrideCursor wc;
2639 LightApp_SelectionMgr* mgr = selectionMgr();
2640 SALOME_ListIO selected; mgr->selectedObjects( selected );
2642 SALOME_ListIteratorOfListIO it(selected);
2643 for( ; it.More(); it.Next()) {
2644 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2645 if(anIObject->hasEntry()) {
2646 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2647 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2654 case SMESHOp::OpUpdate:
2656 if(checkLock(aStudy)) break;
2657 SUIT_OverrideCursor wc;
2660 SMESH::UpdateView();
2662 catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2663 SMESH::OnVisuException();
2665 catch (...) { // PAL16774 (Crash after display of many groups)
2666 SMESH::OnVisuException();
2670 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2671 aSel->selectedObjects( l );
2672 aSel->setSelectedObjects( l );
2676 case SMESHOp::OpHide:
2677 case SMESHOp::OpShow:
2678 case SMESHOp::OpShowOnly:
2680 SUIT_OverrideCursor wc;
2681 SMESH::EDisplaing anAction;
2682 switch (theCommandID) {
2683 case SMESHOp::OpHide: anAction = SMESH::eErase; break;
2684 case SMESHOp::OpShow: anAction = SMESH::eDisplay; break;
2685 case SMESHOp::OpShowOnly: anAction = SMESH::eDisplayOnly; break;
2688 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2689 SALOME_ListIO sel_objects, to_process;
2691 aSel->selectedObjects( sel_objects );
2693 if ( theCommandID==SMESHOp::OpShowOnly )
2695 //MESSAGE("anAction = SMESH::eDisplayOnly");
2696 startOperation( myEraseAll );
2699 extractContainers( sel_objects, to_process );
2704 SALOME_ListIteratorOfListIO It( to_process );
2705 for ( ; It.More(); It.Next())
2707 Handle(SALOME_InteractiveObject) IOS = It.Value();
2708 if ( IOS->hasEntry() )
2710 if ( !SMESH::UpdateView( anAction, IOS->getEntry() )) {
2711 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2712 break; // PAL16774 (Crash after display of many groups)
2714 if (anAction == SMESH::eDisplayOnly)
2715 anAction = SMESH::eDisplay;
2720 // PAL13338 + PAL15161 -->
2721 if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !checkLock(aStudy)) {
2722 SMESH::UpdateView();
2723 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2725 // PAL13338 + PAL15161 <--
2727 catch (...) { // PAL16774 (Crash after display of many groups)
2728 SMESH::OnVisuException();
2731 if (anAction == SMESH::eErase) {
2733 aSel->setSelectedObjects( l1 );
2736 aSel->setSelectedObjects( to_process );
2741 case SMESHOp::OpNode:
2743 if(checkLock(aStudy)) break;
2746 EmitSignalDeactivateDialog();
2748 ( new SMESHGUI_NodesDlg( this ) )->show();
2751 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"),tr("SMESH_WRN_VIEWER_VTK"));
2756 case SMESHOp::OpCreateMesh:
2757 case SMESHOp::OpCreateSubMesh:
2758 case SMESHOp::OpEditMeshOrSubMesh:
2759 case SMESHOp::OpEditMesh:
2760 case SMESHOp::OpEditSubMesh:
2761 case SMESHOp::OpCompute:
2762 case SMESHOp::OpComputeSubMesh:
2763 case SMESHOp::OpPreCompute:
2764 case SMESHOp::OpEvaluate:
2765 case SMESHOp::OpMeshOrder:
2766 startOperation( theCommandID );
2768 case SMESHOp::OpCopyMesh:
2770 if (checkLock(aStudy)) break;
2771 EmitSignalDeactivateDialog();
2772 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2775 case SMESHOp::OpBuildCompoundMesh:
2777 if (checkLock(aStudy)) break;
2778 EmitSignalDeactivateDialog();
2779 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2783 case SMESHOp::OpDiagonalInversion:
2784 case SMESHOp::OpUnionOfTwoTriangle:
2788 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2792 if ( checkLock( aStudy ) )
2795 /*Standard_Boolean aRes;
2796 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2797 if ( aMesh->_is_nil() )
2799 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2800 tr( "SMESH_BAD_SELECTION" ) );
2804 EmitSignalDeactivateDialog();
2805 if ( theCommandID == SMESHOp::OpDiagonalInversion )
2806 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2808 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2811 case SMESHOp::OpOrientation:
2812 case SMESHOp::OpUnionOfTriangles:
2813 case SMESHOp::OpCuttingOfQuadrangles:
2814 case SMESHOp::OpSplitVolumes:
2818 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2822 if ( checkLock( aStudy ) )
2825 EmitSignalDeactivateDialog();
2826 SMESHGUI_MultiEditDlg* aDlg = NULL;
2827 if ( theCommandID == SMESHOp::OpOrientation )
2828 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2829 else if ( theCommandID == SMESHOp::OpUnionOfTriangles )
2830 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2831 else if ( theCommandID == SMESHOp::OpSplitVolumes )
2832 aDlg = new SMESHGUI_SplitVolumesDlg(this);
2834 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2839 case SMESHOp::OpSmoothing:
2841 if(checkLock(aStudy)) break;
2843 EmitSignalDeactivateDialog();
2844 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2847 SUIT_MessageBox::warning(desktop(), tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2851 case SMESHOp::OpExtrusion:
2853 if (checkLock(aStudy)) break;
2855 EmitSignalDeactivateDialog();
2856 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2858 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2862 case SMESHOp::OpExtrusionAlongAPath:
2864 if (checkLock(aStudy)) break;
2866 EmitSignalDeactivateDialog();
2867 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2869 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2873 case SMESHOp::OpRevolution:
2875 if(checkLock(aStudy)) break;
2877 EmitSignalDeactivateDialog();
2878 ( new SMESHGUI_RevolutionDlg( this ) )->show();
2881 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2885 case SMESHOp::OpPatternMapping:
2887 if ( checkLock( aStudy ) )
2891 EmitSignalDeactivateDialog();
2892 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2895 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2899 case SMESHOp::OpSplitBiQuadratic:
2900 case SMESHOp::OpConvertMeshToQuadratic:
2901 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
2902 case SMESHOp::OpReorientFaces:
2903 case SMESHOp::OpCreateGeometryGroup:
2905 startOperation( theCommandID );
2908 case SMESHOp::OpCreateGroup:
2912 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2916 if(checkLock(aStudy)) break;
2917 EmitSignalDeactivateDialog();
2918 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2920 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2921 SALOME_ListIO selected;
2923 aSel->selectedObjects( selected );
2925 int nbSel = selected.Extent();
2927 // check if mesh is selected
2928 aMesh = SMESH::GetMeshByIO( selected.First() );
2930 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2935 case SMESHOp::OpConstructGroup:
2939 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2943 if(checkLock(aStudy)) break;
2944 EmitSignalDeactivateDialog();
2946 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2947 SALOME_ListIO selected;
2949 aSel->selectedObjects( selected );
2951 int nbSel = selected.Extent();
2953 // check if submesh is selected
2954 Handle(SALOME_InteractiveObject) IObject = selected.First();
2955 if (IObject->hasEntry()) {
2956 _PTR(SObject) aSObj = aStudy->FindObjectID(IObject->getEntry());
2958 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2959 if (!aSubMesh->_is_nil()) {
2961 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2962 // get submesh elements list by types
2963 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2964 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2965 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2966 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2967 // create group for each type o elements
2968 QString aName = IObject->getName();
2969 QStringList anEntryList;
2970 if (aNodes->length() > 0) {
2971 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2972 aGroup->Add(aNodes.inout());
2973 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2974 anEntryList.append( aSObject->GetID().c_str() );
2976 if (aEdges->length() > 0) {
2977 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2978 aGroup->Add(aEdges.inout());
2979 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2980 anEntryList.append( aSObject->GetID().c_str() );
2982 if (aFaces->length() > 0) {
2983 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2984 aGroup->Add(aFaces.inout());
2985 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2986 anEntryList.append( aSObject->GetID().c_str() );
2988 if (aVolumes->length() > 0) {
2989 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2990 aGroup->Add(aVolumes.inout());
2991 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2992 anEntryList.append( aSObject->GetID().c_str() );
2995 anApp->browseObjects( anEntryList );
2997 catch(const SALOME::SALOME_Exception & S_ex){
2998 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3005 SUIT_MessageBox::warning(desktop(),
3006 tr("SMESH_WRN_WARNING"),
3007 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
3012 case SMESHOp::OpEditGroup:
3016 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3020 if(checkLock(aStudy)) break;
3021 EmitSignalDeactivateDialog();
3023 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3024 SALOME_ListIO selected;
3026 aSel->selectedObjects( selected );
3028 SALOME_ListIteratorOfListIO It (selected);
3029 int nbSelectedGroups = 0;
3030 for ( ; It.More(); It.Next() )
3032 SMESH::SMESH_GroupBase_var aGroup =
3033 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
3034 if (!aGroup->_is_nil()) {
3036 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
3040 if (nbSelectedGroups == 0)
3042 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
3048 case SMESHOp::OpAddElemGroupPopup: // Add elements to group
3050 if(checkLock(aStudy)) break;
3051 if (myState == 800) {
3052 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3053 if (aDlg) aDlg->onAdd();
3058 case SMESHOp::OpRemoveElemGroupPopup: // Remove elements from group
3060 if(checkLock(aStudy)) break;
3061 if (myState == 800) {
3062 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3063 if (aDlg) aDlg->onRemove();
3068 case SMESHOp::OpEditGeomGroupAsGroup:
3072 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3076 if(checkLock(aStudy)) break;
3077 EmitSignalDeactivateDialog();
3079 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3080 SALOME_ListIO selected;
3082 aSel->selectedObjects( selected );
3084 SALOME_ListIteratorOfListIO It (selected);
3085 for ( ; It.More(); It.Next() )
3087 SMESH::SMESH_GroupOnGeom_var aGroup =
3088 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
3089 if (!aGroup->_is_nil()) {
3090 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3095 SMESH::SMESH_GroupOnFilter_var aGroup =
3096 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
3097 if (!aGroup->_is_nil()) {
3098 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3106 case SMESHOp::OpUnionGroups:
3107 case SMESHOp::OpIntersectGroups:
3108 case SMESHOp::OpCutGroups:
3112 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3116 if ( checkLock( aStudy ) )
3119 EmitSignalDeactivateDialog();
3121 SMESHGUI_GroupOpDlg* aDlg = 0;
3122 if ( theCommandID == SMESHOp::OpUnionGroups )
3123 aDlg = new SMESHGUI_UnionGroupsDlg( this );
3124 else if ( theCommandID == SMESHOp::OpIntersectGroups )
3125 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3127 aDlg = new SMESHGUI_CutGroupsDlg( this );
3134 case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
3136 if ( checkLock( aStudy ) )
3139 EmitSignalDeactivateDialog();
3140 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3146 case SMESHOp::OpDeleteGroup: // Delete groups with their contents
3150 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3154 if ( checkLock( aStudy ) )
3157 EmitSignalDeactivateDialog();
3159 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3163 case SMESHOp::OpMeshInformation:
3164 case SMESHOp::OpWhatIs:
3166 int page = theCommandID == SMESHOp::OpMeshInformation ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3167 EmitSignalDeactivateDialog();
3168 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3169 SALOME_ListIO selected;
3171 aSel->selectedObjects( selected );
3173 if ( selected.Extent() > 1 ) { // a dlg for each IO
3174 SALOME_ListIteratorOfListIO It( selected );
3175 for ( ; It.More(); It.Next() ) {
3176 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3177 dlg->showInfo( It.Value() );
3182 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3188 case SMESHOp::OpFindElementByPoint:
3190 startOperation( theCommandID );
3194 case SMESHOp::OpEditHypothesis:
3196 if(checkLock(aStudy)) break;
3198 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3199 SALOME_ListIO selected;
3201 aSel->selectedObjects( selected );
3203 int nbSel = selected.Extent();
3206 Handle(SALOME_InteractiveObject) anIObject = selected.First();
3207 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3209 if ( !aHypothesis->_is_nil() )
3211 SMESHGUI_GenericHypothesisCreator* aCreator =
3212 SMESH::GetHypothesisCreator( SMESH::toQStr( aHypothesis->GetName() ));
3215 // set geometry of mesh and sub-mesh to aCreator
3216 aSel->selectedObjects( selected, "", /*convertReferences=*/false);
3217 if ( selected.Extent() == 1 )
3219 QString subGeomID, meshGeomID;
3220 Handle(SALOME_InteractiveObject) hypIO = selected.First();
3221 if ( SMESH::GetGeomEntries( hypIO, subGeomID, meshGeomID ))
3223 if ( subGeomID.isEmpty() ) subGeomID = meshGeomID;
3224 aCreator->setShapeEntry( subGeomID );
3225 aCreator->setMainShapeEntry( meshGeomID );
3229 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3239 case SMESHOp::OpUnassign: // REMOVE HYPOTHESIS / ALGORITHMS
3241 if(checkLock(aStudy)) break;
3242 SUIT_OverrideCursor wc;
3244 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3245 SALOME_ListIO selected;
3247 aSel->selectedObjects( selected, QString::null, false );
3249 SALOME_ListIteratorOfListIO It(selected);
3250 for (int i = 0; It.More(); It.Next(), i++) {
3251 Handle(SALOME_InteractiveObject) IObject = It.Value();
3252 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3255 aSel->setSelectedObjects( l1 );
3260 case SMESHOp::OpElem0D:
3261 case SMESHOp::OpBall:
3262 case SMESHOp::OpEdge:
3263 case SMESHOp::OpTriangle:
3264 case SMESHOp::OpQuadrangle:
3265 case SMESHOp::OpPolygon:
3266 case SMESHOp::OpTetrahedron:
3267 case SMESHOp::OpHexahedron:
3268 case SMESHOp::OpPentahedron:
3269 case SMESHOp::OpPyramid:
3270 case SMESHOp::OpHexagonalPrism:
3272 if(checkLock(aStudy)) break;
3274 EmitSignalDeactivateDialog();
3275 SMDSAbs_EntityType type = SMDSEntity_Edge;
3276 switch (theCommandID) {
3277 case SMESHOp::OpElem0D: type = SMDSEntity_0D; break;
3278 case SMESHOp::OpBall: type = SMDSEntity_Ball; break;
3279 case SMESHOp::OpTriangle: type = SMDSEntity_Triangle; break;
3280 case SMESHOp::OpQuadrangle: type = SMDSEntity_Quadrangle; break;
3281 case SMESHOp::OpTetrahedron: type = SMDSEntity_Tetra; break;
3282 case SMESHOp::OpPolygon: type = SMDSEntity_Polygon; break;
3283 case SMESHOp::OpHexahedron: type = SMDSEntity_Hexa; break;
3284 case SMESHOp::OpPentahedron: type = SMDSEntity_Penta; break;
3285 case SMESHOp::OpPyramid: type = SMDSEntity_Pyramid; break;
3286 case SMESHOp::OpHexagonalPrism: type = SMDSEntity_Hexagonal_Prism; break;
3289 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3292 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3296 case SMESHOp::OpPolyhedron:
3298 if(checkLock(aStudy)) break;
3300 EmitSignalDeactivateDialog();
3301 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3304 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3308 case SMESHOp::OpQuadraticEdge:
3309 case SMESHOp::OpQuadraticTriangle:
3310 case SMESHOp::OpBiQuadraticTriangle:
3311 case SMESHOp::OpQuadraticQuadrangle:
3312 case SMESHOp::OpBiQuadraticQuadrangle:
3313 case SMESHOp::OpQuadraticPolygon:
3314 case SMESHOp::OpQuadraticTetrahedron:
3315 case SMESHOp::OpQuadraticPyramid:
3316 case SMESHOp::OpQuadraticPentahedron:
3317 case SMESHOp::OpBiQuadraticPentahedron:
3318 case SMESHOp::OpQuadraticHexahedron:
3319 case SMESHOp::OpTriQuadraticHexahedron:
3321 if(checkLock(aStudy)) break;
3323 EmitSignalDeactivateDialog();
3324 SMDSAbs_EntityType type = SMDSEntity_Last;
3326 switch (theCommandID) {
3327 case SMESHOp::OpQuadraticEdge: type = SMDSEntity_Quad_Edge; break;
3328 case SMESHOp::OpQuadraticTriangle: type = SMDSEntity_Quad_Triangle; break;
3329 case SMESHOp::OpBiQuadraticTriangle: type = SMDSEntity_BiQuad_Triangle; break;
3330 case SMESHOp::OpQuadraticQuadrangle: type = SMDSEntity_Quad_Quadrangle; break;
3331 case SMESHOp::OpBiQuadraticQuadrangle: type = SMDSEntity_BiQuad_Quadrangle; break;
3332 case SMESHOp::OpQuadraticPolygon: type = SMDSEntity_Quad_Polygon; break;
3333 case SMESHOp::OpQuadraticTetrahedron: type = SMDSEntity_Quad_Tetra; break;
3334 case SMESHOp::OpQuadraticPyramid: type = SMDSEntity_Quad_Pyramid; break;
3335 case SMESHOp::OpQuadraticPentahedron: type = SMDSEntity_Quad_Penta; break;
3336 case SMESHOp::OpBiQuadraticPentahedron: type = SMDSEntity_BiQuad_Penta; break;
3337 case SMESHOp::OpQuadraticHexahedron: type = SMDSEntity_Quad_Hexa; break;
3338 case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
3341 if ( type != SMDSEntity_Last )
3342 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3345 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3346 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3350 case SMESHOp::OpRemoveNodes:
3352 if(checkLock(aStudy)) break;
3354 EmitSignalDeactivateDialog();
3355 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3358 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3359 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3363 case SMESHOp::OpRemoveElements: // REMOVES ELEMENTS
3365 if(checkLock(aStudy)) break;
3367 EmitSignalDeactivateDialog();
3368 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3372 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3373 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3377 case SMESHOp::OpClearMesh: {
3379 if(checkLock(aStudy)) break;
3381 SALOME_ListIO selected;
3382 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3383 aSel->selectedObjects( selected );
3385 SUIT_OverrideCursor wc;
3386 SALOME_ListIteratorOfListIO It (selected);
3387 for ( ; It.More(); It.Next() )
3389 Handle(SALOME_InteractiveObject) IOS = It.Value();
3390 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3391 if ( aMesh->_is_nil()) continue;
3394 if ( aMesh->NbNodes() == 0 ) // imported mesh is not empty
3395 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3396 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3397 SMESH::ModifiedMesh( aMeshSObj, false, true);
3398 // hide groups and submeshes
3399 _PTR(ChildIterator) anIter =
3400 SMESH::GetActiveStudyDocument()->NewChildIterator( aMeshSObj );
3401 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3403 _PTR(SObject) so = anIter->Value();
3404 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3407 catch (const SALOME::SALOME_Exception& S_ex){
3409 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3413 SMESH::UpdateView();
3417 case SMESHOp::OpRemoveOrphanNodes:
3419 if(checkLock(aStudy)) break;
3420 SALOME_ListIO selected;
3421 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3422 aSel->selectedObjects( selected );
3423 if ( selected.Extent() == 1 ) {
3424 Handle(SALOME_InteractiveObject) anIO = selected.First();
3425 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3426 if ( !aMesh->_is_nil() ) {
3427 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3428 tr( "SMESH_WARNING" ),
3429 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3430 SUIT_MessageBox::Yes |
3431 SUIT_MessageBox::No,
3432 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3435 SUIT_OverrideCursor wc;
3436 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3437 int removed = aMeshEditor->RemoveOrphanNodes();
3438 SUIT_MessageBox::information(SMESHGUI::desktop(),
3439 tr("SMESH_INFORMATION"),
3440 tr("NB_NODES_REMOVED").arg(removed));
3441 if ( removed > 0 ) {
3442 SMESH::UpdateView();
3443 SMESHGUI::Modified();
3446 catch (const SALOME::SALOME_Exception& S_ex) {
3447 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3456 case SMESHOp::OpRenumberingNodes:
3458 if(checkLock(aStudy)) break;
3460 EmitSignalDeactivateDialog();
3461 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3465 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3466 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3470 case SMESHOp::OpRenumberingElements:
3472 if(checkLock(aStudy)) break;
3474 EmitSignalDeactivateDialog();
3475 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3479 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3480 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3484 case SMESHOp::OpTranslation:
3486 if(checkLock(aStudy)) break;
3488 EmitSignalDeactivateDialog();
3489 ( new SMESHGUI_TranslationDlg( this ) )->show();
3492 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3493 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3497 case SMESHOp::OpRotation:
3499 if(checkLock(aStudy)) break;
3501 EmitSignalDeactivateDialog();
3502 ( new SMESHGUI_RotationDlg( this ) )->show();
3505 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3506 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3510 case SMESHOp::OpSymmetry:
3512 if(checkLock(aStudy)) break;
3514 EmitSignalDeactivateDialog();
3515 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3518 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3519 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3523 case SMESHOp::OpScale:
3525 if(checkLock(aStudy)) break;
3527 EmitSignalDeactivateDialog();
3528 ( new SMESHGUI_ScaleDlg( this ) )->show();
3531 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3532 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3537 case SMESHOp::OpSewing:
3539 if(checkLock(aStudy)) break;
3541 EmitSignalDeactivateDialog();
3542 ( new SMESHGUI_SewingDlg( this ) )->show();
3545 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3546 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3550 case SMESHOp::OpMergeNodes:
3552 if(checkLock(aStudy)) break;
3554 EmitSignalDeactivateDialog();
3555 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3558 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3559 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3563 case SMESHOp::OpMergeElements:
3565 if (checkLock(aStudy)) break;
3567 EmitSignalDeactivateDialog();
3568 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3570 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3571 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3576 case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
3577 startOperation( SMESHOp::OpMoveNode );
3580 case SMESHOp::OpDuplicateNodes:
3582 if(checkLock(aStudy)) break;
3584 EmitSignalDeactivateDialog();
3585 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3588 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3589 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3594 case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
3595 startOperation( SMESHOp::OpElem0DOnElemNodes );
3598 case SMESHOp::OpSelectFiltersLibrary: // Library of selection filters
3600 static QList<int> aTypes;
3601 if ( aTypes.isEmpty() )
3603 aTypes.append( SMESH::NODE );
3604 aTypes.append( SMESH::EDGE );
3605 aTypes.append( SMESH::FACE );
3606 aTypes.append( SMESH::VOLUME );
3608 if (!myFilterLibraryDlg)
3609 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3610 else if (myFilterLibraryDlg->isHidden())
3611 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3612 myFilterLibraryDlg->raise();
3616 case SMESHOp::OpFreeNode:
3617 case SMESHOp::OpEqualNode:
3618 case SMESHOp::OpNodeConnectivityNb:
3619 case SMESHOp::OpFreeEdge:
3620 case SMESHOp::OpFreeBorder:
3621 case SMESHOp::OpLength:
3622 case SMESHOp::OpConnection:
3623 case SMESHOp::OpEqualEdge:
3624 case SMESHOp::OpFreeFace:
3625 case SMESHOp::OpBareBorderFace:
3626 case SMESHOp::OpOverConstrainedFace:
3627 case SMESHOp::OpLength2D:
3628 case SMESHOp::OpDeflection2D:
3629 case SMESHOp::OpConnection2D:
3630 case SMESHOp::OpArea:
3631 case SMESHOp::OpTaper:
3632 case SMESHOp::OpAspectRatio:
3633 case SMESHOp::OpMinimumAngle:
3634 case SMESHOp::OpWarpingAngle:
3635 case SMESHOp::OpSkew:
3636 case SMESHOp::OpMaxElementLength2D:
3637 case SMESHOp::OpEqualFace:
3638 case SMESHOp::OpAspectRatio3D:
3639 case SMESHOp::OpVolume:
3640 case SMESHOp::OpMaxElementLength3D:
3641 case SMESHOp::OpBareBorderVolume:
3642 case SMESHOp::OpOverConstrainedVolume:
3643 case SMESHOp::OpEqualVolume:
3646 LightApp_SelectionMgr* mgr = selectionMgr();
3647 SALOME_ListIO selected; mgr->selectedObjects( selected );
3649 if( !selected.IsEmpty() ) {
3650 SUIT_OverrideCursor wc;
3651 ::Control( theCommandID );
3654 SUIT_MessageBox::warning(desktop(),
3655 tr( "SMESH_WRN_WARNING" ),
3656 tr( "SMESH_BAD_SELECTION" ) );
3660 SUIT_MessageBox::warning(desktop(),
3661 tr( "SMESH_WRN_WARNING" ),
3662 tr( "NOT_A_VTK_VIEWER" ) );
3665 case SMESHOp::OpOverallMeshQuality:
3666 OverallMeshQuality();
3668 case SMESHOp::OpNumberingNodes:
3670 SUIT_OverrideCursor wc;
3671 LightApp_SelectionMgr* mgr = selectionMgr();
3672 SALOME_ListIO selected; mgr->selectedObjects( selected );
3674 SALOME_ListIteratorOfListIO it(selected);
3675 for( ; it.More(); it.Next()) {
3676 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3677 if(anIObject->hasEntry()) {
3678 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3679 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3685 case SMESHOp::OpNumberingElements:
3687 SUIT_OverrideCursor wc;
3688 LightApp_SelectionMgr* mgr = selectionMgr();
3689 SALOME_ListIO selected; mgr->selectedObjects( selected );
3691 SALOME_ListIteratorOfListIO it(selected);
3692 for( ; it.More(); it.Next()) {
3693 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3694 if(anIObject->hasEntry())
3695 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3696 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3701 case SMESHOp::OpPropertiesLength:
3702 case SMESHOp::OpPropertiesArea:
3703 case SMESHOp::OpPropertiesVolume:
3704 case SMESHOp::OpMinimumDistance:
3705 case SMESHOp::OpBoundingBox:
3707 int page = SMESHGUI_MeasureDlg::MinDistance;
3708 if ( theCommandID == SMESHOp::OpBoundingBox )
3709 page = SMESHGUI_MeasureDlg::BoundingBox;
3710 else if ( theCommandID == SMESHOp::OpPropertiesLength )
3711 page = SMESHGUI_MeasureDlg::Length;
3712 else if ( theCommandID == SMESHOp::OpPropertiesArea )
3713 page = SMESHGUI_MeasureDlg::Area;
3714 else if ( theCommandID == SMESHOp::OpPropertiesVolume )
3715 page = SMESHGUI_MeasureDlg::Volume;
3717 EmitSignalDeactivateDialog();
3718 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3722 case SMESHOp::OpSortChild:
3728 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3729 //updateObjBrowser();
3733 //=============================================================================
3737 //=============================================================================
3738 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3743 //=============================================================================
3747 //=============================================================================
3748 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3753 //=============================================================================
3757 //=============================================================================
3758 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3763 //=============================================================================
3764 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3765 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3767 //=============================================================================
3768 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3769 SUIT_ViewWindow* wnd )
3771 if(theIO->hasEntry()){
3772 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3773 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3777 //=======================================================================
3778 // function : createSMESHAction
3780 //=======================================================================
3781 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3782 const int key, const bool toggle, const QString& shortcutAction )
3785 QWidget* parent = application()->desktop();
3786 SUIT_ResourceMgr* resMgr = resourceMgr();
3788 if ( !icon_id.isEmpty() )
3789 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3791 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3792 if ( !pix.isNull() )
3793 icon = QIcon( pix );
3795 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3796 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3797 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3799 createAction( id, tooltip, icon, menu, status_bar, key, parent,
3800 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3803 //=======================================================================
3804 // function : createPopupItem
3806 //=======================================================================
3807 void SMESHGUI::createPopupItem( const int id,
3808 const QString& clients,
3809 const QString& types,
3810 const QString& theRule,
3813 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3814 popupMgr()->insert( action( id ), pId, 0 );
3816 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3817 QString dc = "selcount"; // VSR : insetad of QtxPopupSelection::defSelCountParam()
3818 QString rule = "(%1) and (%2) and (%3)";
3819 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3820 if( clients.isEmpty() )
3821 rule = rule.arg( QString( "true" ) );
3823 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3824 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3827 bool cont = myRules.contains( id );
3829 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3831 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3832 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3835 //=======================================================================
3836 // function : initialize
3838 //=======================================================================
3839 void SMESHGUI::initialize( CAM_Application* app )
3841 SalomeApp_Module::initialize( app );
3843 // SUIT_ResourceMgr* mgr = app->resourceMgr();
3845 /* Automatic Update flag */
3846 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3848 // ----- create actions --------------
3850 //createSMESHAction( SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
3851 createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_I) );
3852 createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
3853 createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL" );
3855 createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
3857 createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
3858 createSMESHAction( SMESHOp::OpImportGMF, "IMPORT_GMF" );
3859 createSMESHAction( SMESHOp::OpPopupImportUNV, "IMPORT_UNV");
3860 createSMESHAction( SMESHOp::OpPopupImportMED, "IMPORT_MED");
3861 createSMESHAction( SMESHOp::OpPopupImportSTL, "IMPORT_STL" );
3863 createSMESHAction( SMESHOp::OpPopupImportCGNS, "IMPORT_CGNS" );
3865 createSMESHAction( SMESHOp::OpPopupImportSAUV, "IMPORT_SAUV" );
3866 createSMESHAction( SMESHOp::OpPopupImportGMF, "IMPORT_GMF" );
3868 createSMESHAction( SMESHOp::OpExportDAT, "DAT" );
3869 createSMESHAction( SMESHOp::OpExportMED, "MED" );
3870 createSMESHAction( SMESHOp::OpExportUNV, "UNV" );
3871 createSMESHAction( SMESHOp::OpExportSTL, "STL" );
3873 createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
3875 createSMESHAction( SMESHOp::OpExportSAUV, "SAUV");
3876 createSMESHAction( SMESHOp::OpExportGMF, "GMF" );
3877 createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
3878 createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
3879 createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
3880 createSMESHAction( SMESHOp::OpPopupExportSTL, "STL" );
3882 createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
3884 createSMESHAction( SMESHOp::OpPopupExportSAUV, "SAUV");
3885 createSMESHAction( SMESHOp::OpPopupExportGMF, "GMF" );
3886 createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
3887 createSMESHAction( SMESHOp::OpDelete, "DELETE", "ICON_DELETE", Qt::Key_Delete );
3888 createSMESHAction( SMESHOp::OpSelectFiltersLibrary, "SEL_FILTER_LIB" );
3889 createSMESHAction( SMESHOp::OpCreateMesh, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
3890 createSMESHAction( SMESHOp::OpCreateSubMesh, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
3891 createSMESHAction( SMESHOp::OpEditMeshOrSubMesh, "EDIT_MESHSUBMESH", "ICON_DLG_EDIT_MESH" );
3892 createSMESHAction( SMESHOp::OpEditMesh, "EDIT_MESH", "ICON_DLG_EDIT_MESH" );
3893 createSMESHAction( SMESHOp::OpEditSubMesh, "EDIT_SUBMESH", "ICON_DLG_EDIT_MESH" );
3894 createSMESHAction( SMESHOp::OpBuildCompoundMesh, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
3895 createSMESHAction( SMESHOp::OpCopyMesh, "COPY_MESH", "ICON_COPY_MESH" );
3896 createSMESHAction( SMESHOp::OpCompute, "COMPUTE", "ICON_COMPUTE" );
3897 createSMESHAction( SMESHOp::OpComputeSubMesh, "COMPUTE_SUBMESH", "ICON_COMPUTE" );
3898 createSMESHAction( SMESHOp::OpPreCompute, "PRECOMPUTE", "ICON_PRECOMPUTE" );
3899 createSMESHAction( SMESHOp::OpEvaluate, "EVALUATE", "ICON_EVALUATE" );
3900 createSMESHAction( SMESHOp::OpMeshOrder, "MESH_ORDER", "ICON_MESH_ORDER");
3901 createSMESHAction( SMESHOp::OpCreateGroup, "CREATE_GROUP", "ICON_CREATE_GROUP" );
3902 createSMESHAction( SMESHOp::OpCreateGeometryGroup, "CREATE_GEO_GROUP", "ICON_CREATE_GEO_GROUP" );
3903 createSMESHAction( SMESHOp::OpConstructGroup, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
3904 createSMESHAction( SMESHOp::OpEditGroup, "EDIT_GROUP", "ICON_EDIT_GROUP" );
3905 createSMESHAction( SMESHOp::OpEditGeomGroupAsGroup, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3906 createSMESHAction( SMESHOp::OpUnionGroups, "UN_GROUP", "ICON_UNION" );
3907 createSMESHAction( SMESHOp::OpIntersectGroups, "INT_GROUP", "ICON_INTERSECT" );
3908 createSMESHAction( SMESHOp::OpCutGroups, "CUT_GROUP", "ICON_CUT" );
3909 createSMESHAction( SMESHOp::OpGroupUnderlyingElem, "UNDERLYING_ELEMS", "ICON_UNDERLYING_ELEMS" );
3910 createSMESHAction( SMESHOp::OpAddElemGroupPopup, "ADD_TO_GROUP" );
3911 createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE_FROM_GROUP" );
3912 createSMESHAction( SMESHOp::OpDeleteGroup, "DEL_GROUP", "ICON_DEL_GROUP" );
3913 createSMESHAction( SMESHOp::OpMeshInformation , "ADV_INFO", "ICON_ADV_INFO" );
3914 //createSMESHAction( SMESHOp::OpStdInfo, "STD_INFO", "ICON_STD_INFO" );
3915 //createSMESHAction( SMESHOp::OpWhatIs, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3916 createSMESHAction( SMESHOp::OpFindElementByPoint, "FIND_ELEM", "ICON_FIND_ELEM" );
3918 createSMESHAction( SMESHOp::OpFreeNode, "FREE_NODE", "ICON_FREE_NODE", 0, true );
3919 createSMESHAction( SMESHOp::OpEqualNode, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
3920 createSMESHAction( SMESHOp::OpNodeConnectivityNb, "NODE_CONNECTIVITY_NB", "ICON_NODE_CONN_NB", 0, true );
3921 createSMESHAction( SMESHOp::OpFreeEdge, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
3922 createSMESHAction( SMESHOp::OpFreeBorder, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
3923 createSMESHAction( SMESHOp::OpLength, "LENGTH", "ICON_LENGTH", 0, true );
3924 createSMESHAction( SMESHOp::OpConnection, "CONNECTION", "ICON_CONNECTION", 0, true );
3925 createSMESHAction( SMESHOp::OpEqualEdge, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
3926 createSMESHAction( SMESHOp::OpFreeFace, "FREE_FACES", "ICON_FREE_FACES", 0, true );
3927 createSMESHAction( SMESHOp::OpBareBorderFace, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
3928 createSMESHAction( SMESHOp::OpOverConstrainedFace, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
3929 createSMESHAction( SMESHOp::OpLength2D, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
3930 createSMESHAction( SMESHOp::OpDeflection2D, "DEFLECTION_2D", "ICON_DEFLECTION_2D", 0, true );
3931 createSMESHAction( SMESHOp::OpConnection2D, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
3932 createSMESHAction( SMESHOp::OpArea, "AREA", "ICON_AREA", 0, true );
3933 createSMESHAction( SMESHOp::OpTaper, "TAPER", "ICON_TAPER", 0, true );
3934 createSMESHAction( SMESHOp::OpAspectRatio, "ASPECT", "ICON_ASPECT", 0, true );
3935 createSMESHAction( SMESHOp::OpMinimumAngle, "MIN_ANG", "ICON_ANGLE", 0, true );
3936 createSMESHAction( SMESHOp::OpWarpingAngle, "WARP", "ICON_WARP", 0, true );
3937 createSMESHAction( SMESHOp::OpSkew, "SKEW", "ICON_SKEW", 0, true );
3938 createSMESHAction( SMESHOp::OpMaxElementLength2D, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
3939 createSMESHAction( SMESHOp::OpEqualFace, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
3940 createSMESHAction( SMESHOp::OpAspectRatio3D, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
3941 createSMESHAction( SMESHOp::OpVolume, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
3942 createSMESHAction( SMESHOp::OpMaxElementLength3D, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
3943 createSMESHAction( SMESHOp::OpBareBorderVolume, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
3944 createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
3945 createSMESHAction( SMESHOp::OpEqualVolume, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
3946 createSMESHAction( SMESHOp::OpOverallMeshQuality, "OVERALL_MESH_QUALITY", "ICON_OVL_MESH_QUALITY" );
3948 createSMESHAction( SMESHOp::OpNode, "NODE", "ICON_DLG_NODE" );
3949 createSMESHAction( SMESHOp::OpElem0D, "ELEM0D", "ICON_DLG_ELEM0D" );
3950 createSMESHAction( SMESHOp::OpElem0DOnElemNodes, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
3951 createSMESHAction( SMESHOp::OpBall, "BALL", "ICON_DLG_BALL" );
3952 createSMESHAction( SMESHOp::OpEdge, "EDGE", "ICON_DLG_EDGE" );
3953 createSMESHAction( SMESHOp::OpTriangle, "TRIANGLE", "ICON_DLG_TRIANGLE" );
3954 createSMESHAction( SMESHOp::OpQuadrangle, "QUAD", "ICON_DLG_QUADRANGLE" );
3955 createSMESHAction( SMESHOp::OpPolygon, "POLYGON", "ICON_DLG_POLYGON" );
3956 createSMESHAction( SMESHOp::OpTetrahedron, "TETRA", "ICON_DLG_TETRAS" );
3957 createSMESHAction( SMESHOp::OpHexahedron, "HEXA", "ICON_DLG_HEXAS" );
3958 createSMESHAction( SMESHOp::OpPentahedron, "PENTA", "ICON_DLG_PENTA" );
3959 createSMESHAction( SMESHOp::OpPyramid , "PYRAMID", "ICON_DLG_PYRAMID" );
3960 createSMESHAction( SMESHOp::OpHexagonalPrism, "OCTA", "ICON_DLG_OCTA" );
3961 createSMESHAction( SMESHOp::OpPolyhedron, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
3962 createSMESHAction( SMESHOp::OpQuadraticEdge, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
3963 createSMESHAction( SMESHOp::OpQuadraticTriangle, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
3964 createSMESHAction( SMESHOp::OpBiQuadraticTriangle, "BIQUADRATIC_TRIANGLE", "ICON_DLG_BIQUADRATIC_TRIANGLE" );
3965 createSMESHAction( SMESHOp::OpQuadraticQuadrangle, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
3966 createSMESHAction( SMESHOp::OpBiQuadraticQuadrangle, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
3967 createSMESHAction( SMESHOp::OpQuadraticPolygon, "QUADRATIC_POLYGON", "ICON_DLG_QUADRATIC_POLYGON" );
3968 createSMESHAction( SMESHOp::OpQuadraticTetrahedron, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
3969 createSMESHAction( SMESHOp::OpQuadraticPyramid, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
3970 createSMESHAction( SMESHOp::OpQuadraticPentahedron, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
3971 createSMESHAction( SMESHOp::OpBiQuadraticPentahedron, "BIQUADRATIC_PENTAHEDRON", "ICON_DLG_BIQUADRATIC_PENTAHEDRON" );
3972 createSMESHAction( SMESHOp::OpQuadraticHexahedron, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
3973 createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
3975 createSMESHAction( SMESHOp::OpRemoveNodes, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
3976 createSMESHAction( SMESHOp::OpRemoveElements, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
3977 createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
3978 createSMESHAction( SMESHOp::OpClearMesh, "CLEAR_MESH", "ICON_CLEAR_MESH" );
3980 //createSMESHAction( SMESHOp::OpRenumberingNodes, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
3981 //createSMESHAction( SMESHOp::OpRenumberingElements, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
3983 createSMESHAction( SMESHOp::OpTranslation, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
3984 createSMESHAction( SMESHOp::OpRotation, "ROT", "ICON_DLG_MESH_ROTATION" );
3985 createSMESHAction( SMESHOp::OpSymmetry, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
3986 createSMESHAction( SMESHOp::OpScale, "SCALE", "ICON_DLG_MESH_SCALE" );
3987 createSMESHAction( SMESHOp::OpSewing, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
3988 createSMESHAction( SMESHOp::OpMergeNodes, "MERGE", "ICON_SMESH_MERGE_NODES" );
3989 createSMESHAction( SMESHOp::OpMergeElements, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
3990 createSMESHAction( SMESHOp::OpMoveNode, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
3991 createSMESHAction( SMESHOp::OpDuplicateNodes, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
3992 createSMESHAction( SMESHOp::OpDiagonalInversion, "INV", "ICON_DLG_MESH_DIAGONAL" );
3993 createSMESHAction( SMESHOp::OpUnionOfTwoTriangle, "UNION2", "ICON_UNION2TRI" );
3994 createSMESHAction( SMESHOp::OpOrientation, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
3995 createSMESHAction( SMESHOp::OpReorientFaces, "REORIENT_2D", "ICON_REORIENT_2D" );
3996 createSMESHAction( SMESHOp::OpUnionOfTriangles, "UNION", "ICON_UNIONTRI" );
3997 createSMESHAction( SMESHOp::OpCuttingOfQuadrangles, "CUT", "ICON_CUTQUAD" );
3998 createSMESHAction( SMESHOp::OpSplitVolumes, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
3999 createSMESHAction( SMESHOp::OpSplitBiQuadratic, "SPLIT_BIQUAD", "ICON_SPLIT_BIQUAD" );
4000 createSMESHAction( SMESHOp::OpSmoothing, "SMOOTH", "ICON_DLG_SMOOTHING" );
4001 createSMESHAction( SMESHOp::OpExtrusion, "EXTRUSION", "ICON_EXTRUSION" );
4002 createSMESHAction( SMESHOp::OpExtrusionAlongAPath, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
4003 createSMESHAction( SMESHOp::OpRevolution, "REVOLUTION", "ICON_REVOLUTION" );
4004 createSMESHAction( SMESHOp::OpPatternMapping, "MAP", "ICON_MAP" );
4005 createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
4006 createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D", "ICON_2D_FROM_3D" );
4008 createSMESHAction( SMESHOp::OpReset, "RESET" );
4009 createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
4010 createSMESHAction( SMESHOp::OpShowScalarBar, "SHOW_SCALAR_BAR","",0, true );
4011 createSMESHAction( SMESHOp::OpSaveDistribution, "SAVE_DISTRIBUTION" );
4012 createSMESHAction( SMESHOp::OpShowDistribution, "SHOW_DISTRIBUTION","",0, true );
4013 #ifndef DISABLE_PLOT2DVIEWER
4014 createSMESHAction( SMESHOp::OpPlotDistribution, "PLOT_DISTRIBUTION" );
4016 createSMESHAction( SMESHOp::OpDMWireframe, "WIRE", "ICON_WIRE", 0, true );
4017 createSMESHAction( SMESHOp::OpDMShading, "SHADE", "ICON_SHADE", 0, true );
4018 createSMESHAction( SMESHOp::OpDMNodes, "NODES", "ICON_POINTS", 0, true );
4019 createSMESHAction( SMESHOp::OpDMShrink, "SHRINK", "ICON_SHRINK", 0, true );
4020 createSMESHAction( SMESHOp::OpUpdate, "UPDATE", "ICON_UPDATE" );
4021 createSMESHAction( SMESHOp::OpDE0DElements, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
4022 createSMESHAction( SMESHOp::OpDEEdges, "EDGES", "ICON_DLG_EDGE", 0, true );
4023 createSMESHAction( SMESHOp::OpDEFaces, "FACES", "ICON_DLG_TRIANGLE", 0, true );
4024 createSMESHAction( SMESHOp::OpDEVolumes, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
4025 createSMESHAction( SMESHOp::OpDEBalls, "BALLS", "ICON_DLG_BALL", 0, true );
4026 createSMESHAction( SMESHOp::OpDEChoose, "CHOOSE", "ICON_DLG_CHOOSE", 0, false );
4027 createSMESHAction( SMESHOp::OpDEAllEntity, "ALL", "ICON_DLG_CHOOSE_ALL", 0, false );
4028 createSMESHAction( SMESHOp::OpOrientationOnFaces, "FACE_ORIENTATION", "", 0, true );
4030 createSMESHAction( SMESHOp::OpRepresentationLines, "LINE_REPRESENTATION", "", 0, true );
4031 createSMESHAction( SMESHOp::OpRepresentationArcs, "ARC_REPRESENTATION", "", 0, true );
4033 createSMESHAction( SMESHOp::OpEditHypothesis, "EDIT_HYPO" );
4034 createSMESHAction( SMESHOp::OpUnassign, "UNASSIGN" );
4035 createSMESHAction( SMESHOp::OpNumberingNodes, "NUM_NODES", "", 0, true );
4036 createSMESHAction( SMESHOp::OpNumberingElements, "NUM_ELEMENTS", "", 0, true );
4037 createSMESHAction( SMESHOp::OpProperties, "COLORS" );
4038 createSMESHAction( SMESHOp::OpTransparency, "TRANSP" );
4039 createSMESHAction( SMESHOp::OpClipping, "CLIP" );
4040 createSMESHAction( SMESHOp::OpAutoColor, "AUTO_COLOR" );
4041 createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
4043 createSMESHAction( SMESHOp::OpMinimumDistance, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
4044 createSMESHAction( SMESHOp::OpBoundingBox, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
4045 createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH", "ICON_MEASURE_LENGTH" );
4046 createSMESHAction( SMESHOp::OpPropertiesArea, "MEASURE_AREA", "ICON_MEASURE_AREA" );
4047 createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME", "ICON_MEASURE_VOLUME" );
4049 createSMESHAction( SMESHOp::OpHide, "HIDE", "ICON_HIDE" );
4050 createSMESHAction( SMESHOp::OpShow, "SHOW", "ICON_SHOW" );
4051 createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
4053 createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
4055 QList<int> aCtrlActions;
4056 aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode
4057 << SMESHOp::OpNodeConnectivityNb // node controls
4058 << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
4059 << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge // edge controls
4060 << SMESHOp::OpDeflection2D
4061 << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
4062 << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
4063 << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
4064 << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
4065 << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace // face controls
4066 << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
4067 << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
4068 << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume; // volume controls
4069 QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
4070 aCtrlGroup->setExclusive( true );
4071 for( int i = 0; i < aCtrlActions.size(); i++ )
4072 aCtrlGroup->addAction( action( aCtrlActions[i] ) );
4074 // ----- create menu --------------
4075 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
4076 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
4077 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
4078 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
4079 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
4080 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
4081 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
4082 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
4084 createMenu( separator(), fileId );
4086 QMenu* nodeMenu = new QMenu(); QMenu* edgeMenu = new QMenu();
4087 QMenu* faceMenu = new QMenu(); QMenu* volumeMenu = new QMenu();
4088 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
4089 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
4090 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10, -1, nodeMenu ),
4091 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10, -1, edgeMenu ),
4092 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10, -1, faceMenu ),
4093 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10, -1, volumeMenu ),
4094 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
4095 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
4096 //renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
4097 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
4098 basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
4100 //createMenu( SMESHOp::OpImportDAT, importId, -1 );
4101 createMenu( SMESHOp::OpImportUNV, importId, -1 );
4102 createMenu( SMESHOp::OpImportMED, importId, -1 );
4103 createMenu( SMESHOp::OpImportSTL, importId, -1 );
4105 createMenu( SMESHOp::OpImportCGNS, importId, -1 );
4107 createMenu( SMESHOp::OpImportSAUV, importId, -1 );
4108 createMenu( SMESHOp::OpImportGMF, importId, -1 );
4109 createMenu( SMESHOp::OpExportDAT, exportId, -1 );
4110 createMenu( SMESHOp::OpExportMED, exportId, -1 );
4111 createMenu( SMESHOp::OpExportUNV, exportId, -1 );
4112 createMenu( SMESHOp::OpExportSTL, exportId, -1 );
4114 createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
4116 createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
4117 createMenu( SMESHOp::OpExportGMF, exportId, -1 );
4118 createMenu( separator(), fileId, 10 );
4120 createMenu( SMESHOp::OpDelete, editId, -1 );
4122 createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
4124 createMenu( SMESHOp::OpCreateMesh, meshId, -1 ); // "Mesh" menu
4125 createMenu( SMESHOp::OpCreateSubMesh, meshId, -1 );
4126 createMenu( SMESHOp::OpEditMeshOrSubMesh, meshId, -1 );
4127 createMenu( SMESHOp::OpBuildCompoundMesh, meshId, -1 );
4128 createMenu( SMESHOp::OpCopyMesh, meshId, -1 );
4129 createMenu( separator(), meshId, -1 );
4130 createMenu( SMESHOp::OpCompute, meshId, -1 );
4131 createMenu( SMESHOp::OpPreCompute, meshId, -1 );
4132 createMenu( SMESHOp::OpEvaluate, meshId, -1 );
4133 createMenu( SMESHOp::OpMeshOrder, meshId, -1 );
4134 createMenu( separator(), meshId, -1 );
4135 createMenu( SMESHOp::OpCreateGroup, meshId, -1 );
4136 createMenu( SMESHOp::OpCreateGeometryGroup, meshId, -1 );
4137 createMenu( SMESHOp::OpConstructGroup, meshId, -1 );
4138 createMenu( SMESHOp::OpEditGroup, meshId, -1 );
4139 createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4140 createMenu( separator(), meshId, -1 );
4141 createMenu( SMESHOp::OpUnionGroups, meshId, -1 );
4142 createMenu( SMESHOp::OpIntersectGroups, meshId, -1 );
4143 createMenu( SMESHOp::OpCutGroups, meshId, -1 );
4144 createMenu( separator(), meshId, -1 );
4145 createMenu( SMESHOp::OpGroupUnderlyingElem, meshId, -1 );
4146 createMenu( separator(), meshId, -1 );
4147 createMenu( SMESHOp::OpMeshInformation, meshId, -1 );
4148 //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4149 //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4150 createMenu( SMESHOp::OpFindElementByPoint, meshId, -1 );
4151 createMenu( separator(), meshId, -1 );
4153 createMenu( SMESHOp::OpFreeNode, nodeId, -1 );
4154 createMenu( SMESHOp::OpEqualNode, nodeId, -1 );
4155 //createMenu( SMESHOp::OpNodeConnectivityNb, nodeId, -1 );
4156 createMenu( SMESHOp::OpFreeBorder, edgeId, -1 );
4157 createMenu( SMESHOp::OpLength, edgeId, -1 );
4158 createMenu( SMESHOp::OpConnection, edgeId, -1 );
4159 createMenu( SMESHOp::OpEqualEdge, edgeId, -1 );
4160 createMenu( SMESHOp::OpFreeEdge, faceId, -1 );
4161 createMenu( SMESHOp::OpFreeFace, faceId, -1 );
4162 createMenu( SMESHOp::OpBareBorderFace, faceId, -1 );
4163 createMenu( SMESHOp::OpOverConstrainedFace, faceId, -1 );
4164 createMenu( SMESHOp::OpLength2D, faceId, -1 );
4165 createMenu( SMESHOp::OpConnection2D, faceId, -1 );
4166 createMenu( SMESHOp::OpArea, faceId, -1 );
4167 createMenu( SMESHOp::OpTaper, faceId, -1 );
4168 createMenu( SMESHOp::OpAspectRatio, faceId, -1 );
4169 createMenu( SMESHOp::OpMinimumAngle, faceId, -1 );
4170 createMenu( SMESHOp::OpWarpingAngle, faceId, -1 );
4171 createMenu( SMESHOp::OpSkew, faceId, -1 );
4172 createMenu( SMESHOp::OpMaxElementLength2D, faceId, -1 );
4173 createMenu( SMESHOp::OpEqualFace, faceId, -1 );
4174 createMenu( SMESHOp::OpDeflection2D, faceId, -1 );
4175 createMenu( SMESHOp::OpAspectRatio3D, volumeId, -1 );
4176 createMenu( SMESHOp::OpVolume, volumeId, -1 );
4177 createMenu( SMESHOp::OpMaxElementLength3D, volumeId, -1 );
4178 createMenu( SMESHOp::OpBareBorderVolume, volumeId, -1 );
4179 createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4180 createMenu( SMESHOp::OpEqualVolume, volumeId, -1 );
4181 createMenu( separator(), ctrlId, -1 );
4182 createMenu( SMESHOp::OpReset, ctrlId, -1 );
4183 createMenu( separator(), ctrlId, -1 );
4184 createMenu( SMESHOp::OpOverallMeshQuality, ctrlId, -1 );
4186 createMenu( SMESHOp::OpNode, addId, -1 );
4187 createMenu( SMESHOp::OpElem0D, addId, -1 );
4188 createMenu( SMESHOp::OpElem0DOnElemNodes, addId, -1 );
4189 createMenu( SMESHOp::OpBall, addId, -1 );
4190 createMenu( SMESHOp::OpEdge, addId, -1 );
4191 createMenu( SMESHOp::OpTriangle, addId, -1 );
4192 createMenu( SMESHOp::OpQuadrangle, addId, -1 );
4193 createMenu( SMESHOp::OpPolygon, addId, -1 );
4194 createMenu( SMESHOp::OpTetrahedron, addId, -1 );
4195 createMenu( SMESHOp::OpHexahedron, addId, -1 );
4196 createMenu( SMESHOp::OpPentahedron, addId, -1 );
4197 createMenu( SMESHOp::OpPyramid, addId, -1 );
4198 createMenu( SMESHOp::OpHexagonalPrism, addId, -1 );
4199 createMenu( SMESHOp::OpPolyhedron, addId, -1 );
4200 createMenu( separator(), addId, -1 );
4201 createMenu( SMESHOp::OpQuadraticEdge, addId, -1 );
4202 createMenu( SMESHOp::OpQuadraticTriangle, addId, -1 );
4203 createMenu( SMESHOp::OpBiQuadraticTriangle , addId, -1 );
4204 createMenu( SMESHOp::OpQuadraticQuadrangle, addId, -1 );
4205 createMenu( SMESHOp::OpBiQuadraticQuadrangle, addId, -1 );
4206 createMenu( SMESHOp::OpQuadraticPolygon, addId, -1 );
4207 createMenu( SMESHOp::OpQuadraticTetrahedron, addId, -1 );
4208 createMenu( SMESHOp::OpQuadraticPyramid, addId, -1 );
4209 createMenu( SMESHOp::OpQuadraticPentahedron, addId, -1 );
4210 createMenu( SMESHOp::OpBiQuadraticPentahedron, addId, -1 );
4211 createMenu( SMESHOp::OpQuadraticHexahedron, addId, -1 );
4212 createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4214 createMenu( SMESHOp::OpRemoveNodes, removeId, -1 );
4215 createMenu( SMESHOp::OpRemoveElements, removeId, -1 );
4216 createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4217 createMenu( separator(), removeId, -1 );
4218 createMenu( SMESHOp::OpDeleteGroup, removeId, -1 );
4219 createMenu( separator(), removeId, -1 );
4220 createMenu( SMESHOp::OpClearMesh, removeId, -1 );
4222 //createMenu( SMESHOp::OpRenumberingNodes, renumId, -1 );
4223 //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4225 createMenu( SMESHOp::OpTranslation, transfId, -1 );
4226 createMenu( SMESHOp::OpRotation, transfId, -1 );
4227 createMenu( SMESHOp::OpSymmetry, transfId, -1 );
4228 createMenu( SMESHOp::OpScale, transfId, -1 );
4229 createMenu( SMESHOp::OpSewing, transfId, -1 );
4230 createMenu( SMESHOp::OpMergeNodes, transfId, -1 );
4231 createMenu( SMESHOp::OpMergeElements, transfId, -1 );
4232 createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4234 createMenu( SMESHOp::OpMoveNode, modifyId, -1 );
4235 createMenu( SMESHOp::OpDiagonalInversion, modifyId, -1 );
4236 createMenu( SMESHOp::OpUnionOfTwoTriangle, modifyId, -1 );
4237 createMenu( SMESHOp::OpOrientation, modifyId, -1 );
4238 createMenu( SMESHOp::OpReorientFaces, modifyId, -1 );
4239 createMenu( SMESHOp::OpUnionOfTriangles, modifyId, -1 );
4240 createMenu( SMESHOp::OpCuttingOfQuadrangles, modifyId, -1 );
4241 createMenu( SMESHOp::OpSplitVolumes, modifyId, -1 );
4242 createMenu( SMESHOp::OpSplitBiQuadratic, modifyId, -1 );
4243 createMenu( SMESHOp::OpSmoothing, modifyId, -1 );
4244 createMenu( SMESHOp::OpExtrusion, modifyId, -1 );
4245 createMenu( SMESHOp::OpExtrusionAlongAPath , modifyId, -1 );
4246 createMenu( SMESHOp::OpRevolution, modifyId, -1 );
4247 createMenu( SMESHOp::OpPatternMapping, modifyId, -1 );
4248 createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4249 createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4251 createMenu( SMESHOp::OpMinimumDistance, measureId, -1 );
4252 createMenu( SMESHOp::OpBoundingBox, measureId, -1 );
4253 createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4254 createMenu( SMESHOp::OpPropertiesArea, basicPropId, -1 );
4255 createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4256 createMenu( SMESHOp::OpUpdate, viewId, -1 );
4258 connect( nodeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4259 connect( edgeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4260 connect( faceMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4261 connect( volumeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4263 // ----- create toolbars --------------
4264 int meshTb = createTool( tr( "TB_MESH" ), QString( "SMESHMeshToolbar" ) ),
4265 info = createTool( tr( "TB_INFO" ), QString( "SMESHInformationToolbar" ) ),
4266 groupTb = createTool( tr( "TB_GROUP" ), QString( "SMESHGroupToolbar" ) ),
4267 ctrl0dTb = createTool( tr( "TB_CTRL0D" ), QString( "SMESHNodeControlsToolbar" ) ),
4268 ctrl1dTb = createTool( tr( "TB_CTRL1D" ), QString( "SMESHEdgeControlsToolbar" ) ),
4269 ctrl2dTb = createTool( tr( "TB_CTRL2D" ), QString( "SMESHFaceControlsToolbar" ) ),
4270 ctrl3dTb = createTool( tr( "TB_CTRL3D" ), QString( "SMESHVolumeControlsToolbar" ) ),
4271 addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ),
4272 addNonElemTb = createTool( tr( "TB_ADDNON" ), QString( "SMESHAddElementToolbar" ) ),
4273 remTb = createTool( tr( "TB_REM" ), QString( "SMESHRemoveToolbar" ) ),
4274 //renumbTb = createTool( tr( "TB_RENUMBER" ), QString( "SMESHRenumberingToolbar" ) ),
4275 transformTb = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ),
4276 modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ),
4277 measuremTb = createTool( tr( "TB_MEASUREM" ), QString( "SMESHMeasurementsToolbar" ) ),
4278 dispModeTb = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4280 createTool( SMESHOp::OpCreateMesh, meshTb );
4281 createTool( SMESHOp::OpCreateSubMesh, meshTb );
4282 createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4283 createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4284 createTool( SMESHOp::OpCopyMesh, meshTb );
4285 createTool( separator(), meshTb );
4286 createTool( SMESHOp::OpCompute, meshTb );
4287 createTool( SMESHOp::OpPreCompute, meshTb );
4288 createTool( SMESHOp::OpEvaluate, meshTb );
4289 createTool( SMESHOp::OpMeshOrder, meshTb );
4291 createTool( SMESHOp::OpCreateGroup, groupTb );
4292 createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4293 createTool( SMESHOp::OpConstructGroup, groupTb );
4294 createTool( SMESHOp::OpEditGroup, groupTb );
4296 createTool( SMESHOp::OpMeshInformation, info );
4297 //createTool( SMESHOp::OpStdInfo, meshTb );
4298 //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4299 createTool( SMESHOp::OpFindElementByPoint, info );
4301 createTool( SMESHOp::OpFreeNode, ctrl0dTb );
4302 createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4303 //createTool( SMESHOp::OpNodeConnectivityNb, ctrl0dTb );
4305 createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4306 createTool( SMESHOp::OpLength, ctrl1dTb );
4307 createTool( SMESHOp::OpConnection, ctrl1dTb );
4308 createTool( SMESHOp::OpEqualEdge, ctrl1dTb );
4310 createTool( SMESHOp::OpFreeEdge, ctrl2dTb );
4311 createTool( SMESHOp::OpFreeFace, ctrl2dTb );
4312 createTool( SMESHOp::OpBareBorderFace, ctrl2dTb );
4313 createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4314 createTool( SMESHOp::OpLength2D, ctrl2dTb );
4315 createTool( SMESHOp::OpConnection2D, ctrl2dTb );
4316 createTool( SMESHOp::OpArea, ctrl2dTb );
4317 createTool( SMESHOp::OpTaper, ctrl2dTb );
4318 createTool( SMESHOp::OpAspectRatio, ctrl2dTb );
4319 createTool( SMESHOp::OpMinimumAngle, ctrl2dTb );
4320 createTool( SMESHOp::OpWarpingAngle, ctrl2dTb );
4321 createTool( SMESHOp::OpSkew, ctrl2dTb );
4322 createTool( SMESHOp::OpMaxElementLength2D, ctrl2dTb );
4323 createTool( SMESHOp::OpEqualFace, ctrl2dTb );
4324 createTool( SMESHOp::OpDeflection2D, ctrl2dTb );
4326 createTool( SMESHOp::OpAspectRatio3D, ctrl3dTb );
4327 createTool( SMESHOp::OpVolume, ctrl3dTb );
4328 createTool( SMESHOp::OpMaxElementLength3D, ctrl3dTb );
4329 createTool( SMESHOp::OpBareBorderVolume, ctrl3dTb );
4330 createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
4331 createTool( SMESHOp::OpEqualVolume, ctrl3dTb );
4333 createTool( SMESHOp::OpNode, addElemTb );
4334 createTool( SMESHOp::OpElem0D, addElemTb );
4335 createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4336 createTool( SMESHOp::OpBall, addElemTb );
4337 createTool( SMESHOp::OpEdge, addElemTb );
4338 createTool( SMESHOp::OpTriangle, addElemTb );
4339 createTool( SMESHOp::OpQuadrangle, addElemTb );
4340 createTool( SMESHOp::OpPolygon, addElemTb );
4341 createTool( SMESHOp::OpTetrahedron, addElemTb );
4342 createTool( SMESHOp::OpHexahedron, addElemTb );
4343 createTool( SMESHOp::OpPentahedron, addElemTb );
4344 createTool( SMESHOp::OpPyramid, addElemTb );
4345 createTool( SMESHOp::OpHexagonalPrism, addElemTb );
4346 createTool( SMESHOp::OpPolyhedron, addElemTb );
4348 createTool( SMESHOp::OpQuadraticEdge, addNonElemTb );
4349 createTool( SMESHOp::OpQuadraticTriangle, addNonElemTb );
4350 createTool( SMESHOp::OpBiQuadraticTriangle, addNonElemTb );
4351 createTool( SMESHOp::OpQuadraticQuadrangle, addNonElemTb );
4352 createTool( SMESHOp::OpBiQuadraticQuadrangle, addNonElemTb );
4353 createTool( SMESHOp::OpQuadraticPolygon, addNonElemTb );
4354 createTool( SMESHOp::OpQuadraticTetrahedron, addNonElemTb );
4355 createTool( SMESHOp::OpQuadraticPyramid, addNonElemTb );
4356 createTool( SMESHOp::OpQuadraticPentahedron, addNonElemTb );
4357 createTool( SMESHOp::OpBiQuadraticPentahedron, addNonElemTb );
4358 createTool( SMESHOp::OpQuadraticHexahedron, addNonElemTb );
4359 createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4361 createTool( SMESHOp::OpRemoveNodes, remTb );
4362 createTool( SMESHOp::OpRemoveElements, remTb );
4363 createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4364 createTool( SMESHOp::OpClearMesh, remTb );
4366 //createTool( SMESHOp::OpRenumberingNodes, renumbTb );
4367 //createTool( SMESHOp::OpRenumberingElements, renumbTb );
4369 createTool( SMESHOp::OpTranslation, transformTb );
4370 createTool( SMESHOp::OpRotation, transformTb );
4371 createTool( SMESHOp::OpSymmetry, transformTb );
4372 createTool( SMESHOp::OpScale, transformTb );
4373 createTool( SMESHOp::OpSewing, transformTb );
4374 createTool( SMESHOp::OpMergeNodes, transformTb );
4375 createTool( SMESHOp::OpMergeElements, transformTb );
4376 createTool( SMESHOp::OpDuplicateNodes, transformTb );
4378 createTool( SMESHOp::OpMoveNode, modifyTb );
4379 createTool( SMESHOp::OpDiagonalInversion, modifyTb );
4380 createTool( SMESHOp::OpUnionOfTwoTriangle, modifyTb );
4381 createTool( SMESHOp::OpOrientation, modifyTb );
4382 createTool( SMESHOp::OpReorientFaces, modifyTb );
4383 createTool( SMESHOp::OpUnionOfTriangles, modifyTb );
4384 createTool( SMESHOp::OpCuttingOfQuadrangles, modifyTb );
4385 createTool( SMESHOp::OpSplitVolumes, modifyTb );
4386 createTool( SMESHOp::OpSplitBiQuadratic, modifyTb );
4387 createTool( SMESHOp::OpSmoothing, modifyTb );
4388 createTool( SMESHOp::OpExtrusion, modifyTb );
4389 createTool( SMESHOp::OpExtrusionAlongAPath, modifyTb );
4390 createTool( SMESHOp::OpRevolution, modifyTb );
4391 createTool( SMESHOp::OpPatternMapping, modifyTb );
4392 createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4393 createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4395 createTool( SMESHOp::OpMinimumDistance, measuremTb );
4397 createTool( SMESHOp::OpUpdate, dispModeTb );
4399 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4400 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4404 OB = "'ObjectBrowser'",
4405 View = "'" + SVTK_Viewer::Type() + "'",
4407 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4408 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4409 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4410 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4411 smesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::COMPONENT ) ),
4412 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4413 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4414 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4415 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4416 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4417 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4418 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4420 mesh_part = mesh + " " + subMesh + " " + group,
4421 mesh_group = mesh + " " + group,
4422 mesh_submesh = mesh + " " + subMesh,
4423 hyp_alg = hypo + " " + algo;
4425 // popup for object browser
4427 isInvisible("not( isVisible )"),
4428 isEmpty("numberOfNodes = 0"),
4429 isNotEmpty("numberOfNodes <> 0"),
4431 // has nodes, edges, etc in VISIBLE! actor
4432 hasNodes("(numberOfNodes > 0 ) && hasActor"),
4433 hasElems("(count( elemTypes ) > 0)"),
4434 hasDifferentElems("(count( elemTypes ) > 1)"),
4435 hasDifferentObjElems("(count( objElemTypes ) > 1)"),
4436 hasBalls("({'BallElem'} in elemTypes)"),
4437 hasElems0d("({'Elem0d'} in elemTypes)"),
4438 hasEdges("({'Edge'} in elemTypes)"),
4439 hasFaces("({'Face'} in elemTypes)"),
4440 hasVolumes("({'Volume'} in elemTypes)"),
4441 hasFacesOrVolumes("(({'Face'} in elemTypes) || ({'Volume'} in elemTypes)) ");
4443 createPopupItem( SMESHOp::OpFileInformation, OB, mesh, "&& selcount=1 && isImported" );
4444 createPopupItem( SMESHOp::OpCreateSubMesh, OB, mesh, "&& hasGeomReference");
4445 createPopupItem( SMESHOp::OpEditMesh, OB, mesh, "&& selcount=1" );
4446 createPopupItem( SMESHOp::OpEditSubMesh, OB, subMesh, "&& selcount=1 && hasGeomReference" );
4447 createPopupItem( SMESHOp::OpEditGroup, OB, group );
4448 createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4450 popupMgr()->insert( separator(), -1, 0 );
4451 createPopupItem( SMESHOp::OpCompute, OB, mesh, "&& selcount=1 && isComputable" );
4452 createPopupItem( SMESHOp::OpComputeSubMesh, OB, subMesh, "&& selcount=1 && isComputable" );
4453 createPopupItem( SMESHOp::OpPreCompute, OB, mesh, "&& selcount=1 && isPreComputable" );
4454 createPopupItem( SMESHOp::OpEvaluate, OB, mesh, "&& selcount=1 && isComputable" );
4455 createPopupItem( SMESHOp::OpMeshOrder, OB, mesh, "&& selcount=1 && isComputable && hasGeomReference" );
4456 createPopupItem( SMESHOp::OpUpdate, OB, mesh_part );
4457 createPopupItem( SMESHOp::OpMeshInformation, OB, mesh_part );
4458 createPopupItem( SMESHOp::OpFindElementByPoint,OB, mesh_group, "&& selcount=1" );
4459 createPopupItem( SMESHOp::OpOverallMeshQuality,OB, mesh_part );
4460 popupMgr()->insert( separator(), -1, 0 );
4461 createPopupItem( SMESHOp::OpCreateGroup, OB, mesh, "&& selcount=1" );
4462 createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh, "&& selcount=1 && hasGeomReference" );
4463 createPopupItem( SMESHOp::OpConstructGroup, OB, subMesh );
4464 popupMgr()->insert( separator(), -1, 0 );
4465 createPopupItem( SMESHOp::OpEditHypothesis, OB, hypo, "&& isEditableHyp");
4466 createPopupItem( SMESHOp::OpUnassign, OB, hyp_alg );
4467 popupMgr()->insert( separator(), -1, 0 );
4468 createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh_submesh );
4469 createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh_group, "&& selcount=1 && dim>=2");
4470 popupMgr()->insert( separator(), -1, 0 );
4471 createPopupItem( SMESHOp::OpClearMesh, OB, mesh );
4472 //popupMgr()->insert( separator(), -1, 0 );
4474 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4475 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4476 QString only_one_2D = only_one_non_empty + " && dim>1";
4478 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4479 createPopupItem( SMESHOp::OpPopupExportMED, OB, mesh_group, multiple_non_empty, anId );
4480 createPopupItem( SMESHOp::OpPopupExportUNV, OB, mesh_group, only_one_non_empty, anId );
4481 createPopupItem( SMESHOp::OpPopupExportSTL, OB, mesh_group, only_one_2D, anId );
4483 createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4485 createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, only_one_non_empty, anId );
4486 createPopupItem( SMESHOp::OpPopupExportGMF, OB, mesh_group, only_one_non_empty, anId );
4487 createPopupItem( SMESHOp::OpPopupExportDAT, OB, mesh_group, only_one_non_empty, anId );
4488 createPopupItem( SMESHOp::OpDelete, OB, mesh_part + " " + hyp_alg );
4489 createPopupItem( SMESHOp::OpDeleteGroup, OB, group );
4491 anId = popupMgr()->insert( tr( "MEN_IMPORT" ), -1, -1 ); // IMPORT submenu
4492 createPopupItem( SMESHOp::OpPopupImportMED, OB, smesh, "", anId );
4493 createPopupItem( SMESHOp::OpPopupImportUNV, OB, smesh, "", anId );
4494 createPopupItem( SMESHOp::OpPopupImportSTL, OB, smesh, "", anId );
4496 createPopupItem( SMESHOp::OpPopupImportCGNS, OB, smesh, "", anId );
4498 createPopupItem( SMESHOp::OpPopupImportSAUV, OB, smesh, "", anId );
4499 createPopupItem( SMESHOp::OpPopupImportGMF, OB, smesh, "", anId );
4500 createPopupItem( SMESHOp::OpPopupImportDAT, OB, smesh, "", anId );
4501 popupMgr()->insert( separator(), -1, 0 );
4504 createPopupItem( SMESHOp::OpEditGroup, View, group );
4505 createPopupItem( SMESHOp::OpAddElemGroupPopup, View, elems, "&& guiState = 800" );
4506 createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems, "&& guiState = 800" );
4508 popupMgr()->insert( separator(), -1, 0 );
4509 createPopupItem( SMESHOp::OpUpdate, View, mesh_part );
4510 createPopupItem( SMESHOp::OpMeshInformation, View, mesh_part );
4511 createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4512 createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh );
4513 popupMgr()->insert( separator(), -1, 0 );
4515 createPopupItem( SMESHOp::OpAutoColor, OB + " " + View, mesh, "&& (not isAutoColor)" );
4516 createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4517 popupMgr()->insert( separator(), -1, 0 );
4519 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4520 QString aType = QString( "%1type in {%2}" ).arg( lc );
4521 aType = aType.arg( mesh_part );
4522 QString aMeshInVTK = aClient + "&&" + aType;
4524 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4525 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4526 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4528 //-------------------------------------------------
4530 //-------------------------------------------------
4531 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4533 popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4534 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4535 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4537 popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4538 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4539 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4541 popupMgr()->insert( separator(), -1, -1 );
4543 //-------------------------------------------------
4545 //-------------------------------------------------
4546 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4548 popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4549 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4550 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4552 popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4553 popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4554 popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4556 popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4557 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4558 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4560 popupMgr()->insert( separator(), anId, -1 );
4562 popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4563 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4564 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4566 //-------------------------------------------------
4568 //-------------------------------------------------
4569 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4571 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4573 popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4574 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4575 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4577 popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4578 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4579 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4581 popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4582 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4583 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4585 popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4586 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4587 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4589 popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4590 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4591 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4593 popupMgr()->insert( separator(), anId, -1 );
4595 popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4596 popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&& $type in {" + mesh + "} &&" + hasDifferentObjElems, QtxPopupMgr::VisibleRule );
4598 popupMgr()->insert( separator(), anId, -1 );
4600 popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4601 popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4604 //-------------------------------------------------
4605 // Representation of the 2D Quadratic elements
4606 //-------------------------------------------------
4607 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4608 popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4609 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "&& isVisible && isQuadratic",QtxPopupMgr::VisibleRule );
4610 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4612 popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4613 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "&& isVisible && isQuadratic", QtxPopupMgr::VisibleRule );
4614 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4616 //-------------------------------------------------
4617 // Orientation of faces
4618 //-------------------------------------------------
4619 popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4620 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4621 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4623 //-------------------------------------------------
4625 //-------------------------------------------------
4626 popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4627 popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4629 //-------------------------------------------------
4631 //-------------------------------------------------
4632 popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4633 popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4635 //-------------------------------------------------
4637 //-------------------------------------------------
4639 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4640 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4641 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4642 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4644 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4646 popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4647 popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4649 popupMgr()->insert( separator(), anId, -1 );
4651 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4653 popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4654 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4655 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4657 popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4658 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4659 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4661 // popupMgr()->insert( action( SMESHOp::OpNodeConnectivityNb ), aSubId, -1 );
4662 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4663 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), "controlMode = 'eNodeConnectivityNb'", QtxPopupMgr::ToggleRule );
4665 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4667 popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4668 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVTK + "&&" + hasEdges + "&&" + hasFacesOrVolumes, QtxPopupMgr::VisibleRule );
4669 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4671 popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4672 popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4673 popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4675 popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4676 popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4677 popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4678 popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4679 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4680 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4682 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4684 popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4685 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4686 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4688 popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4689 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4690 QtxPopupMgr::VisibleRule );
4691 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4693 popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4694 popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4695 popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4697 popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4698 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4699 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4701 popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
4702 popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4703 popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4705 popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
4706 popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4707 popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4709 popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
4710 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4711 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4713 popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
4714 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4715 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4717 popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
4718 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4719 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4721 popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
4722 popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4723 popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4725 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
4726 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4727 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4729 popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
4730 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4731 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4733 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
4734 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4735 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4737 popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
4738 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4739 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4741 popupMgr()->insert ( action( SMESHOp::OpDeflection2D ), aSubId, -1 );
4742 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), aMeshInVtkHasFaces + " && hasGeomReference", QtxPopupMgr::VisibleRule );
4743 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), "controlMode = 'eDeflection2D'", QtxPopupMgr::ToggleRule );
4745 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4747 popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D ), aSubId, -1 );
4748 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4749 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4751 popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
4752 popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4753 popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4755 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
4756 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4757 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4759 popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
4760 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4761 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4763 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
4764 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4765 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4767 popupMgr()->insert ( action( SMESHOp::OpEqualVolume ), aSubId, -1 );
4768 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4769 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4771 popupMgr()->insert( separator(), anId, -1 );
4773 popupMgr()->insert( action( SMESHOp::OpShowScalarBar ), anId, -1 );
4774 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4775 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone' && isScalarBarVisible", QtxPopupMgr::ToggleRule );
4776 popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
4777 popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4779 popupMgr()->insert( separator(), anId, -1 );
4781 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4783 popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
4784 popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4786 popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
4787 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4788 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isScalarBarVisible && isDistributionVisible", QtxPopupMgr::ToggleRule);
4790 #ifndef DISABLE_PLOT2DVIEWER
4791 popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
4792 popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4795 //-------------------------------------------------
4797 //-------------------------------------------------
4798 popupMgr()->insert( separator(), -1, -1 );
4799 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4800 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4801 popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
4802 popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4804 popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
4805 popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4807 popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
4808 popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4810 popupMgr()->insert( separator(), -1, -1 );
4812 //-------------------------------------------------
4814 //-------------------------------------------------
4815 popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
4816 popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4818 popupMgr()->insert( separator(), -1, -1 );
4820 popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
4821 popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
4822 popupMgr()->insert( separator(), -1, -1 );
4824 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4825 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4827 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4828 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4831 //================================================================================
4833 * \brief Return true if SMESH or GEOM objects are selected.
4834 * Is called form LightApp_Module::activateModule() which clear selection if
4835 * not isSelectionCompatible()
4837 //================================================================================
4839 bool SMESHGUI::isSelectionCompatible()
4841 bool isCompatible = true;
4842 SALOME_ListIO selected;
4843 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4844 Sel->selectedObjects( selected );
4846 SALOME_ListIteratorOfListIO It( selected );
4847 for ( ; isCompatible && It.More(); It.Next())
4849 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4850 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4852 return isCompatible;
4856 bool SMESHGUI::reusableOperation( const int id )
4858 // compute, evaluate and precompute are not reusable operations
4859 return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate ) ? false : SalomeApp_Module::reusableOperation( id );
4862 bool SMESHGUI::activateModule( SUIT_Study* study )
4864 bool res = SalomeApp_Module::activateModule( study );
4866 setMenuShown( true );
4867 setToolShown( true );
4869 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4870 PyGILState_STATE gstate = PyGILState_Ensure();
4871 PyObject* pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4872 if ( !pluginsmanager ) {
4876 PyObject* result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toUtf8().data(),tr("SMESH_PLUGINS_OTHER").toUtf8().data());
4881 PyGILState_Release(gstate);
4882 // end of SMESH plugins loading
4884 // Reset actions accelerator keys
4885 action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
4887 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4888 GetSMESHGen()->SetCurrentStudy(SALOMEDS::Study::_nil());
4889 if ( SalomeApp_Study* s = dynamic_cast<SalomeApp_Study*>( study )) {
4890 if ( _PTR(Study) aStudy = s->studyDS() )
4891 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
4894 // get all view currently opened in the study and connect their signals to
4895 // the corresponding slots of the class.
4896 SUIT_Desktop* aDesk = study->application()->desktop();
4898 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4899 SUIT_ViewWindow* wnd;
4900 foreach ( wnd, wndList )
4904 Py_XDECREF(pluginsmanager);
4908 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4910 setMenuShown( false );
4911 setToolShown( false );
4913 EmitSignalCloseAllDialogs();
4915 // Unset actions accelerator keys
4916 action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
4918 return SalomeApp_Module::deactivateModule( study );
4921 void SMESHGUI::studyClosed( SUIT_Study* s )
4925 SMESH::RemoveVisuData( s->id() );
4926 SalomeApp_Module::studyClosed( s );
4929 void SMESHGUI::OnGUIEvent()
4931 const QObject* obj = sender();
4932 if ( !obj || !obj->inherits( "QAction" ) )
4934 int id = actionId((QAction*)obj);
4939 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4941 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
4942 if ( CORBA::is_nil( myComponentSMESH ) )
4944 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4946 aGUI.myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4947 return aGUI.myComponentSMESH;
4950 myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4951 return myComponentSMESH;
4954 QString SMESHGUI::engineIOR() const
4956 CORBA::ORB_var anORB = getApp()->orb();
4957 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4958 return QString( anIOR.in() );
4961 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4963 SalomeApp_Module::contextMenuPopup( client, menu, title );
4965 selectionMgr()->selectedObjects( lst );
4966 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4967 Handle(SALOME_InteractiveObject) io = lst.First();
4968 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4969 _PTR(Study) study = appStudy->studyDS();
4970 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4972 QString aName = QString( SMESH::fromUtf8(obj->GetName()) );
4973 while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4974 aName.remove( (aName.length() - 1), 1 );
4980 LightApp_Selection* SMESHGUI::createSelection() const
4982 return new SMESHGUI_Selection();
4985 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4987 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4988 aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
4989 #ifndef DISABLE_PYCONSOLE
4990 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4994 void SMESHGUI::viewManagers( QStringList& list ) const
4996 list.append( SVTK_Viewer::Type() );
4999 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
5001 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
5002 SMESH::UpdateSelectionProp( this );
5004 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
5005 for(int i = 0; i < aViews.count() ; i++){
5006 SUIT_ViewWindow *sf = aViews[i];
5009 EmitSignalActivatedViewManager();
5013 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
5015 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
5016 myClippingPlaneInfoMap.erase( theViewManager );
5019 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
5021 theActor->AddObserver( SMESH::DeleteActorEvent,
5022 myEventCallbackCommand.GetPointer(),
5026 void SMESHGUI::ProcessEvents( vtkObject* theObject,
5027 unsigned long theEvent,
5028 void* theClientData,
5031 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
5032 if( theObject && (int) theEvent == SMESH::DeleteActorEvent ) {
5033 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
5034 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
5035 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
5036 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
5037 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
5038 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
5039 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
5040 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
5041 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
5042 SMESH::TActorList::iterator anIter3 = anActorList.begin();
5043 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
5044 if( anActor == *anIter3 ) {
5045 anActorList.erase( anIter3 );
5056 void SMESHGUI::createPreferences()
5058 // General tab ------------------------------------------------------------------------
5059 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
5061 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
5062 setPreferenceProperty( autoUpdate, "columns", 2 );
5063 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
5064 setPreferenceProperty( lim, "min", 0 );
5065 setPreferenceProperty( lim, "max", 100000000 );
5066 setPreferenceProperty( lim, "step", 1000 );
5067 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5068 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
5070 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
5071 setPreferenceProperty( dispgroup, "columns", 2 );
5072 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
5074 modes.append( tr("MEN_WIRE") );
5075 modes.append( tr("MEN_SHADE") );
5076 modes.append( tr("MEN_NODES") );
5077 modes.append( tr("MEN_SHRINK") );
5078 QList<QVariant> indices;
5079 indices.append( 0 );
5080 indices.append( 1 );
5081 indices.append( 2 );
5082 indices.append( 3 );
5083 setPreferenceProperty( dispmode, "strings", modes );
5084 setPreferenceProperty( dispmode, "indexes", indices );
5086 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
5087 setPreferenceProperty( arcgroup, "columns", 2 );
5088 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
5089 QStringList quadraticModes;
5090 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
5091 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
5093 indices.append( 0 );
5094 indices.append( 1 );
5095 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
5096 setPreferenceProperty( quadraticmode, "indexes", indices );
5098 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
5099 "SMESH", "max_angle" );
5100 setPreferenceProperty( maxAngle, "min", 1 );
5101 setPreferenceProperty( maxAngle, "max", 90 );
5103 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
5104 setPreferenceProperty( qaGroup, "columns", 2 );
5105 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
5106 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
5107 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
5108 setPreferenceProperty( prec, "min", 0 );
5109 setPreferenceProperty( prec, "max", 100 );
5110 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
5111 setPreferenceProperty( doubleNodesTol, "precision", 10 );
5112 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
5113 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
5114 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
5117 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
5118 setPreferenceProperty( exportgroup, "columns", 2 );
5119 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
5120 addPreference( tr( "PREF_SHOW_WARN" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "show_warning" );
5121 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
5123 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
5124 setPreferenceProperty( computeGroup, "columns", 2 );
5125 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
5127 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5128 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5129 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5131 indices.append( 0 );
5132 indices.append( 1 );
5133 indices.append( 2 );
5134 setPreferenceProperty( notifyMode, "strings", modes );
5135 setPreferenceProperty( notifyMode, "indexes", indices );
5137 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5138 setPreferenceProperty( infoGroup, "columns", 2 );
5139 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5141 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5142 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5144 indices.append( 0 );
5145 indices.append( 1 );
5146 setPreferenceProperty( elemInfo, "strings", modes );
5147 setPreferenceProperty( elemInfo, "indexes", indices );
5148 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5149 setPreferenceProperty( nodesLim, "min", 0 );
5150 setPreferenceProperty( nodesLim, "max", 10000000 );
5151 setPreferenceProperty( nodesLim, "step", 10000 );
5152 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5153 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5154 setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5155 setPreferenceProperty( ctrlLim, "min", 0 );
5156 setPreferenceProperty( ctrlLim, "max", 10000000 );
5157 setPreferenceProperty( ctrlLim, "step", 1000 );
5158 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5159 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5160 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5161 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5162 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5164 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5165 setPreferenceProperty( segGroup, "columns", 2 );
5166 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5167 "SMESH", "segmentation" );
5168 setPreferenceProperty( segLen, "min", 1 );
5169 setPreferenceProperty( segLen, "max", 10000000 );
5170 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5171 "SMESH", "nb_segments_per_edge" );
5172 setPreferenceProperty( nbSeg, "min", 1 );
5173 setPreferenceProperty( nbSeg, "max", 10000000 );
5175 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5176 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5177 "SMESH", "forget_mesh_on_hyp_modif" );
5180 // Quantities with individual precision settings
5181 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5182 setPreferenceProperty( precGroup, "columns", 2 );
5184 const int nbQuantities = 6;
5185 int precs[nbQuantities], ii = 0;
5186 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5187 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5188 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5189 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5190 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5191 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5192 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5193 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5194 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5195 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5196 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5197 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5199 // Set property for precision value for spinboxes
5200 for ( ii = 0; ii < nbQuantities; ii++ ){
5201 setPreferenceProperty( precs[ii], "min", -14 );
5202 setPreferenceProperty( precs[ii], "max", 14 );
5203 setPreferenceProperty( precs[ii], "precision", 2 );
5206 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5207 setPreferenceProperty( previewGroup, "columns", 2 );
5208 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5209 setPreferenceProperty( chunkSize, "min", 1 );
5210 setPreferenceProperty( chunkSize, "max", 1000 );
5211 setPreferenceProperty( chunkSize, "step", 50 );
5213 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5214 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5216 // Mesh tab ------------------------------------------------------------------------
5217 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5218 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5219 setPreferenceProperty( nodeGroup, "columns", 3 );
5221 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5223 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5225 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5226 QList<QVariant> aMarkerTypeIndicesList;
5227 QList<QVariant> aMarkerTypeIconsList;
5228 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5229 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5230 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5231 aMarkerTypeIndicesList << i;
5232 aMarkerTypeIconsList << pixmap;
5234 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5235 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
5237 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5239 QList<QVariant> aMarkerScaleIndicesList;
5240 QStringList aMarkerScaleValuesList;
5241 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5242 aMarkerScaleIndicesList << i;
5243 //aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5244 aMarkerScaleValuesList << QString::number( i );
5246 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5247 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5249 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5250 //setPreferenceProperty( elemGroup, "columns", 2 );
5252 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5253 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5254 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5255 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5256 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5257 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5258 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5259 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5260 addPreference( tr( "PREF_PREVIEW_COLOR" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5263 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5264 setPreferenceProperty( grpGroup, "columns", 2 );
5266 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5267 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5269 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5270 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5271 /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5272 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5273 double ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5274 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5275 double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5276 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5277 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
5278 LightApp_Preferences::IntSpin, "SMESH", "element_width");
5279 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5280 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5281 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5282 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5284 setPreferenceProperty( size0d, "min", 1 );
5285 setPreferenceProperty( size0d, "max", 10 );
5287 // setPreferenceProperty( ballSize, "min", 1 );
5288 // setPreferenceProperty( ballSize, "max", 10 );
5290 setPreferenceProperty( ballDiameter, "min", 1e-7 );
5291 setPreferenceProperty( ballDiameter, "max", 1e9 );
5292 setPreferenceProperty( ballDiameter, "step", 0.1 );
5294 setPreferenceProperty( ballScale, "min", 1e-2 );
5295 setPreferenceProperty( ballScale, "max", 1e7 );
5296 setPreferenceProperty( ballScale, "step", 0.5 );
5298 setPreferenceProperty( elemW, "min", 1 );
5299 setPreferenceProperty( elemW, "max", 5 );
5301 setPreferenceProperty( outW, "min", 1 );
5302 setPreferenceProperty( outW, "max", 5 );
5304 setPreferenceProperty( shrink, "min", 0 );
5305 setPreferenceProperty( shrink, "max", 100 );
5307 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5308 setPreferenceProperty( numGroup, "columns", 2 );
5310 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5311 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5313 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5314 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5316 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5317 setPreferenceProperty( orientGroup, "columns", 1 );
5319 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5320 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5322 setPreferenceProperty( orientScale, "min", 0.05 );
5323 setPreferenceProperty( orientScale, "max", 0.5 );
5324 setPreferenceProperty( orientScale, "step", 0.05 );
5326 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5328 // Selection tab ------------------------------------------------------------------------
5329 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5331 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5332 setPreferenceProperty( selGroup, "columns", 2 );
5334 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5335 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5337 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5338 setPreferenceProperty( preGroup, "columns", 2 );
5340 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5342 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5343 setPreferenceProperty( precSelGroup, "columns", 2 );
5345 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5346 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5347 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5349 // Scalar Bar tab ------------------------------------------------------------------------
5350 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5351 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5352 setPreferenceProperty( fontGr, "columns", 2 );
5354 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5355 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5357 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5358 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5360 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5361 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5363 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5364 setPreferenceProperty( numcol, "min", 2 );
5365 setPreferenceProperty( numcol, "max", 256 );
5367 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5368 setPreferenceProperty( numlab, "min", 2 );
5369 setPreferenceProperty( numlab, "max", 65 );
5371 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5372 setPreferenceProperty( orientGr, "columns", 2 );
5373 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5374 QStringList orients;
5375 orients.append( tr( "SMESH_VERTICAL" ) );
5376 orients.append( tr( "SMESH_HORIZONTAL" ) );
5377 indices.clear(); indices.append( 0 ); indices.append( 1 );
5378 setPreferenceProperty( orient, "strings", orients );
5379 setPreferenceProperty( orient, "indexes", indices );
5381 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5382 setPreferenceProperty( posVSizeGr, "columns", 2 );
5383 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5384 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5385 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5386 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5387 setPreferenceProperty( xv, "step", 0.1 );
5388 setPreferenceProperty( xv, "min", 0.0 );
5389 setPreferenceProperty( xv, "max", 1.0 );
5390 setPreferenceProperty( yv, "step", 0.1 );
5391 setPreferenceProperty( yv, "min", 0.0 );
5392 setPreferenceProperty( yv, "max", 1.0 );
5393 setPreferenceProperty( wv, "step", 0.1 );
5394 setPreferenceProperty( wv, "min", 0.0 );
5395 setPreferenceProperty( wv, "max", 1.0 );
5396 setPreferenceProperty( hv, "min", 0.0 );
5397 setPreferenceProperty( hv, "max", 1.0 );
5398 setPreferenceProperty( hv, "step", 0.1 );
5400 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5401 setPreferenceProperty( posHSizeGr, "columns", 2 );
5402 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5403 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5404 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5405 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5406 setPreferenceProperty( xv, "min", 0.0 );
5407 setPreferenceProperty( xv, "max", 1.0 );
5408 setPreferenceProperty( xv, "step", 0.1 );
5409 setPreferenceProperty( xh, "min", 0.0 );
5410 setPreferenceProperty( xh, "max", 1.0 );
5411 setPreferenceProperty( xh, "step", 0.1 );
5412 setPreferenceProperty( yh, "min", 0.0 );
5413 setPreferenceProperty( yh, "max", 1.0 );
5414 setPreferenceProperty( yh, "step", 0.1 );
5415 setPreferenceProperty( wh, "min", 0.0 );
5416 setPreferenceProperty( wh, "max", 1.0 );
5417 setPreferenceProperty( wh, "step", 0.1 );
5418 setPreferenceProperty( hh, "min", 0.0 );
5419 setPreferenceProperty( hh, "max", 1.0 );
5420 setPreferenceProperty( hh, "step", 0.1 );
5422 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5423 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5424 setPreferenceProperty( distributionGr, "columns", 3 );
5426 types.append( tr( "SMESH_MONOCOLOR" ) );
5427 types.append( tr( "SMESH_MULTICOLOR" ) );
5428 indices.clear(); indices.append( 0 ); indices.append( 1 );
5429 setPreferenceProperty( coloringType, "strings", types );
5430 setPreferenceProperty( coloringType, "indexes", indices );
5431 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5435 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5437 if ( sect=="SMESH" ) {
5438 float sbX1 = 0.01, sbY1 = 0.01, sbW = 0.08, sbH = 0.08;
5439 float aTol = 1.00000009999999;
5440 std::string aWarning;
5441 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5443 if ( name== "selection_object_color" ||
5444 name=="selection_element_color" ||
5445 name== "highlight_color" ||
5446 name=="selection_precision_node" ||
5447 name=="selection_precision_element" ||
5448 name=="selection_precision_object" )
5450 SMESH::UpdateSelectionProp( this );
5452 else if (name == "scalar_bar_vertical_x" || name == "scalar_bar_vertical_width")
5454 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5455 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5456 if ( sbX1+sbW > aTol ) {
5457 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5460 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5461 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5464 else if (name == "scalar_bar_vertical_y" || name == "scalar_bar_vertical_height" )
5466 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5467 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5468 if ( sbY1 + sbH > aTol ) {
5469 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5470 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5471 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5474 else if (name == "scalar_bar_horizontal_x" || name == "scalar_bar_horizontal_width")
5476 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5477 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5478 if ( sbX1 + sbW > aTol ) {
5479 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5482 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5483 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5486 else if (name == "scalar_bar_horizontal_y" || name == "scalar_bar_horizontal_height")
5488 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5489 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5490 if ( sbY1 + sbH > aTol ) {
5491 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5494 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5495 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5498 else if ( name == "segmentation" )
5500 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5501 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5503 else if ( name == "nb_segments_per_edge" )
5505 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5506 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5508 else if ( name == "historical_python_dump" || name == "forget_mesh_on_hyp_modif" || name == "default_grp_color" )
5510 QString val = aResourceMgr->stringValue( "SMESH", name );
5511 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5513 else if ( name == "numbering_node_color" || name == "numbering_node_font" )
5515 SMESH::UpdateFontProp( this );
5517 else if ( name == "numbering_elem_color" || name == "numbering_elem_font" )
5519 SMESH::UpdateFontProp( this );
5522 if ( aWarning.size() != 0 ) {
5523 aWarning += "The default values are applied instead.";
5524 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5525 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5526 QObject::tr(aWarning.c_str()));
5531 //================================================================================
5533 * \brief Update something in accordance with update flags
5534 * \param theFlags - update flags
5536 * Update viewer or/and object browser etc. in accordance with update flags ( see
5537 * LightApp_UpdateFlags enumeration ).
5539 //================================================================================
5540 void SMESHGUI::update( const int flags )
5542 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5543 SMESH::UpdateView();
5545 SalomeApp_Module::update( flags );
5548 //================================================================================
5550 * \brief Set default selection mode
5552 * SLOT called when operation committed. Sets default selection mode
5554 //================================================================================
5555 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5557 SVTK_ViewWindow* vtkWnd =
5558 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5560 vtkWnd->SetSelectionMode( ActorSelection );
5563 //================================================================================
5565 * \brief Set default selection mode
5567 * SLOT called when operation aborted. Sets default selection mode
5569 //================================================================================
5570 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5572 SVTK_ViewWindow* vtkWnd =
5573 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5575 vtkWnd->SetSelectionMode( ActorSelection );
5578 //================================================================================
5580 * \brief Creates operation with given identifier
5581 * \param id - identifier of operation to be started
5582 * \return Pointer on created operation or NULL if operation is not created
5584 * Virtual method redefined from the base class creates operation with given id.
5585 * It is called called automatically from startOperation method of base class.
5587 //================================================================================
5588 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5590 LightApp_Operation* op = 0;
5591 // to do : create operation here
5594 case SMESHOp::OpSplitBiQuadratic:
5595 op = new SMESHGUI_SplitBiQuadOp();
5597 case SMESHOp::OpConvertMeshToQuadratic:
5598 op = new SMESHGUI_ConvToQuadOp();
5600 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5601 op = new SMESHGUI_Make2DFrom3DOp();
5603 case SMESHOp::OpReorientFaces:
5604 op = new SMESHGUI_ReorientFacesOp();
5606 case SMESHOp::OpCreateMesh:
5607 op = new SMESHGUI_MeshOp( true, true );
5609 case SMESHOp::OpCreateSubMesh:
5610 op = new SMESHGUI_MeshOp( true, false );
5612 case SMESHOp::OpEditMeshOrSubMesh:
5613 case SMESHOp::OpEditMesh:
5614 case SMESHOp::OpEditSubMesh:
5615 op = new SMESHGUI_MeshOp( false );
5617 case SMESHOp::OpCompute:
5618 case SMESHOp::OpComputeSubMesh:
5619 op = new SMESHGUI_ComputeOp();
5621 case SMESHOp::OpPreCompute:
5622 op = new SMESHGUI_PrecomputeOp();
5624 case SMESHOp::OpEvaluate:
5625 op = new SMESHGUI_EvaluateOp();
5627 case SMESHOp::OpMeshOrder:
5628 op = new SMESHGUI_MeshOrderOp();
5630 case SMESHOp::OpCreateGeometryGroup:
5631 op = new SMESHGUI_GroupOnShapeOp();
5633 case SMESHOp::OpFindElementByPoint:
5634 op = new SMESHGUI_FindElemByPointOp();
5636 case SMESHOp::OpMoveNode: // Make mesh pass through point
5637 op = new SMESHGUI_MakeNodeAtPointOp();
5639 case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
5640 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5647 op = SalomeApp_Module::createOperation( id );
5651 //================================================================================
5653 * \brief Stops current operations and starts a given one
5654 * \param id - The id of the operation to start
5656 //================================================================================
5658 void SMESHGUI::switchToOperation(int id)
5660 if ( _PTR(Study) aStudy = SMESH::GetActiveStudyDocument() )
5661 activeStudy()->abortAllOperations();
5662 startOperation( id );
5665 LightApp_Displayer* SMESHGUI::displayer()
5668 myDisplayer = new SMESHGUI_Displayer( getApp() );
5672 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5675 int aTolerance = 64;
5676 int anIterations = 0;
5682 if( anIterations % aPeriod == 0 )
5685 if( aTolerance < 1 )
5689 aHue = (int)( 360.0 * rand() / RAND_MAX );
5692 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5693 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5694 for( ; it != itEnd; ++it )
5696 SALOMEDS::Color anAutoColor = *it;
5697 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5700 aQColor.getHsv( &h, &s, &v );
5701 if( abs( h - aHue ) < aTolerance )
5713 aColor.setHsv( aHue, 255, 255 );
5715 SALOMEDS::Color aSColor;
5716 aSColor.R = aColor.redF();
5717 aSColor.G = aColor.greenF();
5718 aSColor.B = aColor.blueF();
5723 const char* gSeparator = "_"; // character used to separate parameter names
5724 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5725 const char* gPathSep = "|"; // character used to separate paths
5728 * \brief Store visual parameters
5730 * This method is called just before the study document is saved.
5731 * Store visual parameters in AttributeParameter attribue(s)
5733 void SMESHGUI::storeVisualParameters (int savePoint)
5736 Kernel_Utils::Localizer loc;
5738 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5739 if (!appStudy || !appStudy->studyDS())
5741 _PTR(Study) studyDS = appStudy->studyDS();
5743 // componentName is used for encoding of entries when storing them in IParameters
5744 std::string componentName = myComponentSMESH->ComponentDataType();
5745 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5746 //if (!aSComponent) return;
5749 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5750 componentName.c_str(),
5752 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5754 // store map of custom markers
5755 const VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5756 if( !aMarkerMap.empty() )
5758 VTK::MarkerMap::const_iterator anIter = aMarkerMap.begin();
5759 for( ; anIter != aMarkerMap.end(); anIter++ )
5761 int anId = anIter->first;
5762 VTK::MarkerData aMarkerData = anIter->second;
5763 std::string aMarkerFileName = aMarkerData.first;
5764 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5765 if( aMarkerTexture.size() < 3 )
5766 continue; // should contain at least width, height and the first value
5768 QString aPropertyName( "texture" );
5769 aPropertyName += gSeparator;
5770 aPropertyName += QString::number( anId );
5772 QString aPropertyValue = aMarkerFileName.c_str();
5773 aPropertyValue += gPathSep;
5775 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5776 ushort aWidth = *aTextureIter++;
5777 ushort aHeight = *aTextureIter++;
5778 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5779 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5780 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5781 aPropertyValue += QString::number( *aTextureIter );
5783 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5787 // viewers counters are used for storing view_numbers in IParameters
5790 // main cycle to store parameters of displayed objects
5791 QList<SUIT_ViewManager*> lst;
5792 QList<SUIT_ViewManager*>::Iterator it;
5793 getApp()->viewManagers(lst);
5794 for (it = lst.begin(); it != lst.end(); it++)
5796 SUIT_ViewManager* vman = *it;
5797 QString vType = vman->getType();
5799 // saving VTK actors properties
5800 if (vType == SVTK_Viewer::Type())
5802 // store the clipping planes attached to the view manager
5803 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5804 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5805 if( anIter != myClippingPlaneInfoMap.end() )
5806 aClippingPlaneInfoList = anIter->second;
5808 if( !aClippingPlaneInfoList.empty() ) {
5809 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5810 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5812 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5813 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5815 QString aPropertyName( "ClippingPlane" );
5816 aPropertyName += gSeparator;
5817 aPropertyName += QString::number( vtkViewers );
5818 aPropertyName += gSeparator;
5819 aPropertyName += QString::number( anId );
5821 QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
5822 aPropertyValue += gDigitsSep;
5823 aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
5824 aPropertyValue += gDigitsSep;
5825 if ( aPlane->PlaneMode == SMESH::Absolute ) {
5826 aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
5827 aPropertyValue += gDigitsSep;
5828 aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
5829 aPropertyValue += gDigitsSep;
5830 aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
5831 aPropertyValue += gDigitsSep;
5832 aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
5833 aPropertyValue += gDigitsSep;
5834 aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
5835 aPropertyValue += gDigitsSep;
5836 aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
5837 aPropertyValue += gDigitsSep;
5838 aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
5840 else if ( aPlane->PlaneMode == SMESH::Relative ) {
5841 aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
5842 aPropertyValue += gDigitsSep;
5843 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5844 aPropertyValue += gDigitsSep;
5845 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5846 aPropertyValue += gDigitsSep;
5847 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5850 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5854 QVector<SUIT_ViewWindow*> views = vman->getViews();
5855 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5857 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5859 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5860 vtkActorCollection* allActors = aCopy.GetActors();
5861 allActors->InitTraversal();
5862 while (vtkActor* actor = allActors->GetNextActor())
5864 if (actor->GetVisibility()) // store only visible actors
5866 SMESH_Actor* aSmeshActor = 0;
5867 if (actor->IsA("SMESH_Actor"))
5868 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5869 if (aSmeshActor && aSmeshActor->hasIO())
5871 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5874 // entry is "encoded" = it does NOT contain component address,
5875 // since it is a subject to change on next component loading
5876 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5878 std::string param, vtkParam = vType.toLatin1().data();
5879 vtkParam += gSeparator;
5880 vtkParam += QString::number(vtkViewers).toLatin1().data();
5881 vtkParam += gSeparator;
5884 param = vtkParam + "Visibility";
5885 ip->setParameter(entry, param, "On");
5888 param = vtkParam + "Representation";
5889 ip->setParameter(entry, param, QString::number
5890 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5893 param = vtkParam + "IsShrunk";
5894 ip->setParameter(entry, param, QString::number
5895 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5897 // Displayed entities
5898 unsigned int aMode = aSmeshActor->GetEntityMode();
5899 bool isE = aMode & SMESH_Actor::eEdges;
5900 bool isF = aMode & SMESH_Actor::eFaces;
5901 bool isV = aMode & SMESH_Actor::eVolumes;
5902 bool is0d = aMode & SMESH_Actor::e0DElements;
5903 bool isB = aMode & SMESH_Actor::eBallElem;
5905 QString modeStr ("e");
5906 modeStr += gDigitsSep; modeStr += QString::number(isE);
5907 modeStr += gDigitsSep; modeStr += "f";
5908 modeStr += gDigitsSep; modeStr += QString::number(isF);
5909 modeStr += gDigitsSep; modeStr += "v";
5910 modeStr += gDigitsSep; modeStr += QString::number(isV);
5911 modeStr += gDigitsSep; modeStr += "0d";
5912 modeStr += gDigitsSep; modeStr += QString::number(is0d);
5913 modeStr += gDigitsSep; modeStr += "b";
5914 modeStr += gDigitsSep; modeStr += QString::number(isB);
5916 param = vtkParam + "Entities";
5917 ip->setParameter(entry, param, modeStr.toLatin1().data());
5923 aSmeshActor->GetSufaceColor(r, g, b, delta);
5924 QStringList colorStr;
5925 colorStr << "surface";
5926 colorStr << QString::number(r);
5927 colorStr << QString::number(g);
5928 colorStr << QString::number(b);
5930 colorStr << "backsurface";
5931 colorStr << QString::number(delta);
5933 aSmeshActor->GetVolumeColor(r, g, b, delta);
5934 colorStr << "volume";
5935 colorStr << QString::number(r);
5936 colorStr << QString::number(g);
5937 colorStr << QString::number(b);
5938 colorStr << QString::number(delta);
5940 aSmeshActor->GetEdgeColor(r, g, b);
5942 colorStr << QString::number(r);
5943 colorStr << QString::number(g);
5944 colorStr << QString::number(b);
5946 aSmeshActor->GetNodeColor(r, g, b);
5948 colorStr << QString::number(r);
5949 colorStr << QString::number(g);
5950 colorStr << QString::number(b);
5952 aSmeshActor->GetOutlineColor(r, g, b);
5953 colorStr << "outline";
5954 colorStr << QString::number(r);
5955 colorStr << QString::number(g);
5956 colorStr << QString::number(b);
5958 aSmeshActor->Get0DColor(r, g, b);
5959 colorStr << "elem0d";
5960 colorStr << QString::number(r);
5961 colorStr << QString::number(g);
5962 colorStr << QString::number(b);
5964 aSmeshActor->GetBallColor(r, g, b);
5966 colorStr << QString::number(r);
5967 colorStr << QString::number(g);
5968 colorStr << QString::number(b);
5970 aSmeshActor->GetFacesOrientationColor(r, g, b);
5971 colorStr << "orientation";
5972 colorStr << QString::number(r);
5973 colorStr << QString::number(g);
5974 colorStr << QString::number(b);
5976 param = vtkParam + "Colors";
5977 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
5980 QStringList sizeStr;
5982 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
5983 sizeStr << "outline";
5984 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
5985 sizeStr << "elem0d";
5986 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
5988 //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
5989 sizeStr << QString::number((double)aSmeshActor->GetBallSize());
5990 sizeStr << QString::number((double)aSmeshActor->GetBallScale());
5991 sizeStr << "shrink";
5992 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
5993 sizeStr << "orientation";
5994 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
5995 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
5997 param = vtkParam + "Sizes";
5998 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
6003 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
6004 if( aMarkerType == VTK::MT_USER ) {
6005 markerStr += "custom";
6006 markerStr += gDigitsSep;
6007 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
6011 markerStr += gDigitsSep;
6012 markerStr += QString::number( (int)aMarkerType );
6013 markerStr += gDigitsSep;
6014 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
6017 param = vtkParam + "PointMarker";
6018 ip->setParameter(entry, param, markerStr.toLatin1().data());
6021 param = vtkParam + "Opacity";
6022 ip->setParameter(entry, param,
6023 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
6026 param = vtkParam + "ClippingPlane";
6028 if( !aClippingPlaneInfoList.empty() ) {
6029 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
6030 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
6032 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
6033 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
6034 SMESH::TActorList::iterator anIter2 = anActorList.begin();
6035 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
6036 if( aSmeshActor == *anIter2 ) {
6037 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
6038 QString::number( anId ).toLatin1().constData() );
6045 ip->setParameter( entry, param, "Off" );
6046 } // if (io->hasEntry())
6047 } // SMESH_Actor && hasIO
6049 } // while.. actors traversal
6053 } // if (SVTK view model)
6054 } // for (viewManagers)
6057 // data structures for clipping planes processing
6061 bool isOpenGLClipping;
6062 vtkIdType RelativeOrientation;
6065 int AbsoluteOrientation;
6066 double X, Y, Z, Dx, Dy, Dz;
6068 typedef std::list<TPlaneData> TPlaneDataList;
6069 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
6071 typedef std::list<vtkActor*> TActorList;
6074 TActorList ActorList;
6075 SUIT_ViewManager* ViewManager;
6077 typedef std::list<TPlaneInfo> TPlaneInfoList;
6078 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
6081 * \brief Restore visual parameters
6083 * This method is called after the study document is opened.
6084 * Restore visual parameters from AttributeParameter attribue(s)
6086 void SMESHGUI::restoreVisualParameters (int savePoint)
6089 Kernel_Utils::Localizer loc;
6091 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6092 if (!appStudy || !appStudy->studyDS())
6094 _PTR(Study) studyDS = appStudy->studyDS();
6096 // componentName is used for encoding of entries when storing them in IParameters
6097 std::string componentName = myComponentSMESH->ComponentDataType();
6098 //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
6099 //if (!aSComponent) return;
6102 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6103 componentName.c_str(),
6105 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6107 // restore map of custom markers and map of clipping planes
6108 VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
6109 TPlaneDataMap aPlaneDataMap;
6111 std::vector<std::string> properties = ip->getProperties();
6112 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
6114 std::string property = *propIt;
6115 QString aPropertyName( property.c_str() );
6116 QString aPropertyValue( ip->getProperty( property ).c_str() );
6118 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
6119 if( aPropertyNameList.isEmpty() )
6122 QString aPropertyType = aPropertyNameList[0];
6123 if( aPropertyType == "texture" )
6125 if( aPropertyNameList.size() != 2 )
6129 int anId = aPropertyNameList[1].toInt( &ok );
6130 if( !ok || anId < 1 )
6133 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
6134 if( aPropertyValueList.size() != 2 )
6137 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
6138 QString aMarkerTextureString = aPropertyValueList[1];
6139 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
6140 if( aMarkerTextureStringList.size() != 3 )
6144 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6149 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6153 VTK::MarkerTexture aMarkerTexture;
6154 aMarkerTexture.push_back( aWidth );
6155 aMarkerTexture.push_back( aHeight );
6157 QString aMarkerTextureData = aMarkerTextureStringList[2];
6158 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6160 QChar aChar = aMarkerTextureData.at( i );
6161 if( aChar.isDigit() )
6162 aMarkerTexture.push_back( aChar.digitValue() );
6165 aMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6167 else if( aPropertyType == "ClippingPlane" )
6169 if( aPropertyNameList.size() != 3 )
6173 int aViewId = aPropertyNameList[1].toInt( &ok );
6174 if( !ok || aViewId < 0 )
6178 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6179 if( !ok || aClippingPlaneId < 0 )
6182 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6183 if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6186 TPlaneData aPlaneData;
6187 aPlaneData.AbsoluteOrientation = false;
6188 aPlaneData.RelativeOrientation = 0;
6189 aPlaneData.Distance = aPlaneData.Angle[0] = aPlaneData.Angle[1] = 0;
6190 aPlaneData.X = aPlaneData.Y = aPlaneData.Z = 0;
6191 aPlaneData.Dx = aPlaneData.Dy = aPlaneData.Dz = 0;
6193 aPlaneData.Id = aClippingPlaneId;
6196 aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6201 aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6205 if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6208 aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6213 aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6218 aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6223 aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6228 aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6233 aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6238 aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6242 else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6244 aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6249 aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6254 aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6259 aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6264 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6265 aPlaneDataList.push_back( aPlaneData );
6269 TPlaneInfoMap aPlaneInfoMap;
6271 std::vector<std::string> entries = ip->getEntries();
6273 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6275 // entry is a normal entry - it should be "decoded" (setting base address of component)
6276 QString entry (ip->decodeEntry(*entIt).c_str());
6278 // Check that the entry corresponds to a real object in the Study
6279 // as the object may be deleted or modified after the visual state is saved.
6280 _PTR(SObject) so = studyDS->FindObjectID(entry.toLatin1().data());
6281 if (!so) continue; //Skip the not existent entry
6283 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6284 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6286 std::vector<std::string>::iterator namesIt = paramNames.begin();
6287 std::vector<std::string>::iterator valuesIt = paramValues.begin();
6289 // actors are stored in a map after displaying of them for
6290 // quicker access in the future: map < viewID to actor >
6291 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6293 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6295 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6296 // '_' is used as separator and should not be used in viewer type or parameter names.
6297 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6298 if (lst.size() != 3)
6301 QString viewerTypStr = lst[0];
6302 QString viewIndexStr = lst[1];
6303 QString paramNameStr = lst[2];
6306 int viewIndex = viewIndexStr.toUInt(&ok);
6307 if (!ok) // bad conversion of view index to integer
6311 if (viewerTypStr == SVTK_Viewer::Type())
6313 SMESH_Actor* aSmeshActor = 0;
6314 if (vtkActors.IsBound(viewIndex))
6315 aSmeshActor = vtkActors.Find(viewIndex);
6317 QList<SUIT_ViewManager*> lst;
6318 getApp()->viewManagers(viewerTypStr, lst);
6320 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6321 SUIT_ViewManager* vman = NULL;
6322 if (viewIndex >= 0 && viewIndex < lst.count())
6323 vman = lst.at(viewIndex);
6325 if (paramNameStr == "Visibility")
6327 if (!aSmeshActor && displayer() && vman)
6329 SUIT_ViewModel* vmodel = vman->getViewModel();
6330 // SVTK view model can be casted to SALOME_View
6331 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6333 // store displayed actor in a temporary map for quicker
6334 // access later when restoring other parameters
6335 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6336 vtkRenderer* Renderer = vtkView->getRenderer();
6337 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6338 vtkActorCollection* theActors = aCopy.GetActors();
6339 theActors->InitTraversal();
6340 bool isFound = false;
6341 vtkActor *ac = theActors->GetNextActor();
6342 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6343 if (ac->IsA("SMESH_Actor")) {
6344 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6345 if (aGeomAc->hasIO()) {
6346 Handle(SALOME_InteractiveObject) io = aGeomAc->getIO();
6347 if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) {
6349 vtkActors.Bind(viewIndex, aGeomAc);
6355 } // if (paramNameStr == "Visibility")
6358 // the rest properties "work" with SMESH_Actor
6361 QString val ((*valuesIt).c_str());
6364 if (paramNameStr == "Representation") {
6365 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6368 else if (paramNameStr == "IsShrunk") {
6370 if (!aSmeshActor->IsShrunk())
6371 aSmeshActor->SetShrink();
6374 if (aSmeshActor->IsShrunk())
6375 aSmeshActor->UnShrink();
6378 // Displayed entities
6379 else if (paramNameStr == "Entities") {
6380 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6381 int aEntityMode = SMESH_Actor::eAllEntity;
6382 for ( int i = 0; i < mode.count(); i+=2 ) {
6383 if ( i < mode.count()-1 ) {
6384 QString type = mode[i];
6385 bool val = mode[i+1].toInt();
6386 if ( type == "e" && !val )
6387 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6388 else if ( type == "f" && !val )
6389 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6390 else if ( type == "v" && !val )
6391 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6392 else if ( type == "0d" && !val )
6393 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6394 else if ( type == "b" && !val )
6395 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6398 aSmeshActor->SetEntityMode( aEntityMode );
6401 else if (paramNameStr == "Colors") {
6402 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6409 QColor outlineColor;
6410 QColor orientationColor;
6416 // below lines are required to get default values for delta coefficients
6417 // of backface color for faces and color of reversed volumes
6418 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
6419 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6420 for ( int i = 0; i < colors.count(); i++ ) {
6421 QString type = colors[i];
6422 if ( type == "surface" ) {
6423 // face color is set by 3 values r:g:b, where
6424 // - r,g,b - is rgb color components
6425 if ( i+1 >= colors.count() ) break; // format error
6426 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6427 if ( i+2 >= colors.count() ) break; // format error
6428 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6429 if ( i+3 >= colors.count() ) break; // format error
6430 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6431 faceColor.setRgbF( r, g, b );
6434 else if ( type == "backsurface" ) {
6435 // backface color can be defined in several ways
6436 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6437 // - in latest versions, it is set as delta coefficient
6438 bool rgbOk = false, deltaOk;
6439 if ( i+1 >= colors.count() ) break; // format error
6440 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6441 int delta = colors[i+1].toInt( &deltaOk );
6443 if ( i+1 < colors.count() ) // index is shifted to 1
6444 g = colors[i+1].toDouble( &rgbOk );
6445 if ( rgbOk ) i++; // shift index
6446 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6447 b = colors[i+1].toDouble( &rgbOk );
6449 // - as currently there's no way to set directly backsurface color as it was before,
6450 // we ignore old dump where r,g,b triple was set
6451 // - also we check that delta parameter is set properly
6452 if ( !rgbOk && deltaOk )
6455 else if ( type == "volume" ) {
6456 // volume color is set by 4 values r:g:b:delta, where
6457 // - r,g,b - is a normal volume rgb color components
6458 // - delta - is a reversed volume color delta coefficient
6459 if ( i+1 >= colors.count() ) break; // format error
6460 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6461 if ( i+2 >= colors.count() ) break; // format error
6462 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6463 if ( i+3 >= colors.count() ) break; // format error
6464 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6465 if ( i+4 >= colors.count() ) break; // format error
6466 int delta = colors[i+4].toInt( &bOk );
6467 if ( !bOk ) break; // format error
6468 volumeColor.setRgbF( r, g, b );
6472 else if ( type == "edge" ) {
6473 // edge color is set by 3 values r:g:b, where
6474 // - r,g,b - is rgb color components
6475 if ( i+1 >= colors.count() ) break; // format error
6476 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6477 if ( i+2 >= colors.count() ) break; // format error
6478 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6479 if ( i+3 >= colors.count() ) break; // format error
6480 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6481 edgeColor.setRgbF( r, g, b );
6484 else if ( type == "node" ) {
6485 // node color is set by 3 values r:g:b, where
6486 // - r,g,b - is rgb color components
6487 if ( i+1 >= colors.count() ) break; // format error
6488 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6489 if ( i+2 >= colors.count() ) break; // format error
6490 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6491 if ( i+3 >= colors.count() ) break; // format error
6492 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6493 nodeColor.setRgbF( r, g, b );
6496 else if ( type == "elem0d" ) {
6497 // 0d element color is set by 3 values r:g:b, where
6498 // - r,g,b - is rgb color components
6499 if ( i+1 >= colors.count() ) break; // format error
6500 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6501 if ( i+2 >= colors.count() ) break; // format error
6502 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6503 if ( i+3 >= colors.count() ) break; // format error
6504 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6505 elem0dColor.setRgbF( r, g, b );
6508 else if ( type == "ball" ) {
6509 // ball color is set by 3 values r:g:b, where
6510 // - r,g,b - is rgb color components
6511 if ( i+1 >= colors.count() ) break; // format error
6512 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6513 if ( i+2 >= colors.count() ) break; // format error
6514 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6515 if ( i+3 >= colors.count() ) break; // format error
6516 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6517 ballColor.setRgbF( r, g, b );
6520 else if ( type == "outline" ) {
6521 // outline color is set by 3 values r:g:b, where
6522 // - r,g,b - is rgb color components
6523 if ( i+1 >= colors.count() ) break; // format error
6524 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6525 if ( i+2 >= colors.count() ) break; // format error
6526 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6527 if ( i+3 >= colors.count() ) break; // format error
6528 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6529 outlineColor.setRgbF( r, g, b );
6532 else if ( type == "orientation" ) {
6533 // orientation color is set by 3 values r:g:b, where
6534 // - r,g,b - is rgb color components
6535 if ( i+1 >= colors.count() ) break; // format error
6536 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6537 if ( i+2 >= colors.count() ) break; // format error
6538 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6539 if ( i+3 >= colors.count() ) break; // format error
6540 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6541 orientationColor.setRgbF( r, g, b );
6546 if ( nodeColor.isValid() )
6547 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6549 if ( edgeColor.isValid() )
6550 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6552 if ( faceColor.isValid() )
6553 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6555 if ( volumeColor.isValid() )
6556 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6557 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6558 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6560 if ( elem0dColor.isValid() )
6561 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6563 if ( ballColor.isValid() )
6564 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6566 if ( outlineColor.isValid() )
6567 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6568 // orientation color
6569 if ( orientationColor.isValid() )
6570 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6573 else if (paramNameStr == "Sizes") {
6574 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6577 int outlineWidth = -1;
6578 int elem0dSize = -1;
6579 //int ballSize = -1;
6580 double ballDiameter = -1.0;
6581 double ballScale = -1.0;
6582 double shrinkSize = -1;
6583 double orientationSize = -1;
6584 bool orientation3d = false;
6585 for ( int i = 0; i < sizes.count(); i++ ) {
6586 QString type = sizes[i];
6587 if ( type == "line" ) {
6588 // line (wireframe) width is given as single integer value
6589 if ( i+1 >= sizes.count() ) break; // format error
6590 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6594 if ( type == "outline" ) {
6595 // outline width is given as single integer value
6596 if ( i+1 >= sizes.count() ) break; // format error
6597 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6601 else if ( type == "elem0d" ) {
6602 // 0d element size is given as single integer value
6603 if ( i+1 >= sizes.count() ) break; // format error
6604 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6608 else if ( type == "ball" ) {
6609 // balls are specified by two values: size:scale, where
6610 // - size - is a integer value specifying size
6611 // - scale - is a double value specifying scale factor
6612 if ( i+1 >= sizes.count() ) break; // format error
6613 //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6614 double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6615 if ( i+2 >= sizes.count() ) break; // format error
6616 double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6622 else if ( type == "shrink" ) {
6623 // shrink factor is given as single floating point value
6624 if ( i+1 >= sizes.count() ) break; // format error
6625 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6629 else if ( type == "orientation" ) {
6630 // orientation vectors are specified by two values size:3d, where
6631 // - size - is a floating point value specifying scale factor
6632 // - 3d - is a boolean
6633 if ( i+1 >= sizes.count() ) break; // format error
6634 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6635 if ( i+2 >= sizes.count() ) break; // format error
6636 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6637 orientationSize = v1;
6638 orientation3d = (bool)v2;
6642 // line (wireframe) width
6643 if ( lineWidth > 0 )
6644 aSmeshActor->SetLineWidth( lineWidth );
6646 if ( outlineWidth > 0 )
6647 aSmeshActor->SetOutlineWidth( outlineWidth );
6648 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6649 aSmeshActor->SetOutlineWidth( lineWidth );
6651 if ( elem0dSize > 0 )
6652 aSmeshActor->Set0DSize( elem0dSize );
6654 /*if ( ballSize > 0 )
6655 aSmeshActor->SetBallSize( ballSize );*/
6657 if ( ballDiameter > 0 )
6658 aSmeshActor->SetBallSize( ballDiameter );
6660 if ( ballScale > 0.0 )
6661 aSmeshActor->SetBallScale( ballScale );
6663 if ( shrinkSize > 0 )
6664 aSmeshActor->SetShrinkFactor( shrinkSize );
6665 // orientation vectors
6666 if ( orientationSize > 0 ) {
6667 aSmeshActor->SetFacesOrientationScale( orientationSize );
6668 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6672 else if (paramNameStr == "PointMarker") {
6673 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6674 if( data.count() >= 2 ) {
6676 int aParam1 = data[1].toInt( &ok );
6678 if( data[0] == "std" && data.count() == 3 ) {
6679 int aParam2 = data[2].toInt( &ok );
6680 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6682 else if( data[0] == "custom" ) {
6683 VTK::MarkerMap::const_iterator markerIt = aMarkerMap.find( aParam1 );
6684 if( markerIt != aMarkerMap.end() ) {
6685 VTK::MarkerData aMarkerData = markerIt->second;
6686 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6693 else if (paramNameStr == "Opacity") {
6694 aSmeshActor->SetOpacity(val.toFloat());
6697 else if (paramNameStr.startsWith("ClippingPlane")) {
6698 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6699 // old format - val looks like "Off" or "1:0:0:0.5:0:0"
6700 // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
6701 // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
6702 // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
6703 // new format - val looks like "Off" or "0" (plane id)
6704 // (note: in new format "Off" value is used only for consistency,
6705 // so it is processed together with values in old format)
6706 bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
6707 if( anIsOldFormat ) {
6708 if (paramNameStr == "ClippingPlane1" || val == "Off")
6709 aSmeshActor->RemoveAllClippingPlanes();
6711 QList<SUIT_ViewManager*> lst;
6712 getApp()->viewManagers(viewerTypStr, lst);
6713 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6714 if (viewIndex >= 0 && viewIndex < lst.count()) {
6715 SUIT_ViewManager* vman = lst.at(viewIndex);
6716 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6718 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6720 SMESH::TActorList anActorList;
6721 anActorList.push_back( aSmeshActor );
6722 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
6723 aPlane->myViewWindow = vtkView;
6724 SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
6725 aPlane->PlaneMode = aMode;
6726 bool isOpenGLClipping = ( bool )vals[1].toInt();
6727 aPlane->IsOpenGLClipping = isOpenGLClipping;
6728 if ( aMode == SMESH::Absolute ) {
6729 aPlane->myAbsoluteOrientation = vals[2].toInt();
6730 aPlane->X = vals[3].toFloat();
6731 aPlane->Y = vals[4].toFloat();
6732 aPlane->Z = vals[5].toFloat();
6733 aPlane->Dx = vals[6].toFloat();
6734 aPlane->Dy = vals[7].toFloat();
6735 aPlane->Dz = vals[8].toFloat();
6737 else if ( aMode == SMESH::Relative ) {
6738 aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
6739 aPlane->myDistance = vals[3].toFloat();
6740 aPlane->myAngle[0] = vals[4].toFloat();
6741 aPlane->myAngle[1] = vals[5].toFloat();
6745 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6746 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6747 aClippingPlaneInfo.Plane = aPlane;
6748 aClippingPlaneInfo.ActorList = anActorList;
6749 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6757 int aPlaneId = val.toInt( &ok );
6758 if( ok && aPlaneId >= 0 ) {
6759 bool anIsDefinedPlane = false;
6760 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6761 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6762 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6763 TPlaneInfo& aPlaneInfo = *anIter;
6764 if( aPlaneInfo.PlaneId == aPlaneId ) {
6765 aPlaneInfo.ActorList.push_back( aSmeshActor );
6766 anIsDefinedPlane = true;
6770 if( !anIsDefinedPlane ) {
6771 TPlaneInfo aPlaneInfo;
6772 aPlaneInfo.PlaneId = aPlaneId;
6773 aPlaneInfo.ActorList.push_back( aSmeshActor );
6774 aPlaneInfo.ViewManager = vman;
6776 // to make the list sorted by plane id
6777 anIter = aPlaneInfoList.begin();
6778 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6779 const TPlaneInfo& aPlaneInfoRef = *anIter;
6780 if( aPlaneInfoRef.PlaneId > aPlaneId )
6783 aPlaneInfoList.insert( anIter, aPlaneInfo );
6788 } // if (aSmeshActor)
6789 } // other parameters than Visibility
6791 } // for names/parameters iterator
6792 } // for entries iterator
6794 // take into account planes with empty list of actors referred to them
6795 QList<SUIT_ViewManager*> aVMList;
6796 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6798 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6799 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6800 int aViewId = aPlaneDataIter->first;
6801 if( aViewId >= 0 && aViewId < aVMList.count() ) {
6802 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6804 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6806 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6807 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6808 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6809 const TPlaneData& aPlaneData = *anIter2;
6810 int aPlaneId = aPlaneData.Id;
6812 bool anIsFound = false;
6813 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6814 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6815 const TPlaneInfo& aPlaneInfo = *anIter3;
6816 if( aPlaneInfo.PlaneId == aPlaneId ) {
6823 TPlaneInfo aPlaneInfo; // ActorList field is empty
6824 aPlaneInfo.PlaneId = aPlaneId;
6825 aPlaneInfo.ViewManager = aViewManager;
6827 // to make the list sorted by plane id
6828 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6829 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6830 const TPlaneInfo& aPlaneInfoRef = *anIter4;
6831 if( aPlaneInfoRef.PlaneId > aPlaneId )
6834 aPlaneInfoList.insert( anIter4, aPlaneInfo );
6840 // add clipping planes to actors according to the restored parameters
6841 // and update the clipping plane map
6842 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6843 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6844 int aViewId = anIter1->first;
6845 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6847 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6848 if( anIter2 == aPlaneDataMap.end() )
6850 const TPlaneDataList& aPlaneDataList = anIter2->second;
6852 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6853 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6854 const TPlaneInfo& aPlaneInfo = *anIter3;
6855 int aPlaneId = aPlaneInfo.PlaneId;
6856 const TActorList& anActorList = aPlaneInfo.ActorList;
6857 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6861 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6865 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6867 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6868 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6869 const TPlaneData& aPlaneData = *anIter4;
6870 if( aPlaneData.Id == aPlaneId ) {
6871 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
6872 aPlane->myViewWindow = aViewWindow;
6873 aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
6874 aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
6875 if ( aPlane->PlaneMode == SMESH::Absolute ) {
6876 aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
6877 aPlane->X = aPlaneData.X;
6878 aPlane->Y = aPlaneData.Y;
6879 aPlane->Z = aPlaneData.Z;
6880 aPlane->Dx = aPlaneData.Dx;
6881 aPlane->Dy = aPlaneData.Dy;
6882 aPlane->Dz = aPlaneData.Dz;
6884 else if ( aPlane->PlaneMode == SMESH::Relative ) {
6885 aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
6886 aPlane->myDistance = aPlaneData.Distance;
6887 aPlane->myAngle[0] = aPlaneData.Angle[0];
6888 aPlane->myAngle[1] = aPlaneData.Angle[1];
6891 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6892 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6893 aClippingPlaneInfo.Plane = aPlane;
6894 aClippingPlaneInfo.ActorList = anActorList;
6895 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6906 // update all VTK views
6907 QList<SUIT_ViewManager*> lst;
6908 getApp()->viewManagers(lst);
6909 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6910 SUIT_ViewModel* vmodel = (*it)->getViewModel();
6911 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6912 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6913 // set OpenGL clipping planes
6914 VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
6915 vtkActorCollection* anAllActors = aCopy.GetActors();
6916 anAllActors->InitTraversal();
6917 while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
6918 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
6919 anActor->SetOpenGLClippingPlane();
6921 vtkView->getRenderer()->ResetCameraClippingRange();
6928 \brief Adds preferences for dfont of VTK viewer
6930 \param pIf group identifier
6931 \param param parameter
6932 \return identifier of preferences
6934 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
6936 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6938 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6941 fam.append( tr( "SMESH_FONT_ARIAL" ) );
6942 fam.append( tr( "SMESH_FONT_COURIER" ) );
6943 fam.append( tr( "SMESH_FONT_TIMES" ) );
6945 setPreferenceProperty( tfont, "fonts", fam );
6947 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6948 if ( needSize ) f = f | QtxFontEdit::Size;
6949 setPreferenceProperty( tfont, "features", f );
6955 \brief Actions after hypothesis edition
6956 Updates object browser after hypothesis edition
6958 void SMESHGUI::onHypothesisEdit( int result )
6961 SMESHGUI::Modified();
6962 updateObjBrowser( true );
6966 \brief Actions after choosing menu of control modes
6967 Updates control mode actions according to current selection
6969 void SMESHGUI::onUpdateControlActions()
6971 SALOME_ListIO selected;
6972 if ( LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr() )
6973 aSel->selectedObjects( selected );
6975 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
6976 if ( selected.Extent() ) {
6977 if ( selected.First()->hasEntry() ) {
6978 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( selected.First()->getEntry() )) {
6979 aControl = anActor->GetControlMode();
6980 SALOME_ListIteratorOfListIO it(selected);
6981 for ( it.Next(); it.More(); it.Next() ) {
6982 Handle(SALOME_InteractiveObject) anIO = it.Value();
6983 if ( anIO->hasEntry() ) {
6984 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
6985 if ( aControl != anActor->GetControlMode() ) {
6986 aControl = SMESH_Actor::eNone;
6996 int anAction = ActionToControl( aControl, true );
6998 action( anAction )->setChecked( true );
7000 QMenu* send = (QMenu*)sender();
7001 QList<QAction*> actions = send->actions();
7002 for ( int i = 0; i < actions.size(); i++ )
7003 actions[i]->setChecked( false );
7009 \brief Signal handler closing(SUIT_ViewWindow*) of a view
7010 \param pview view being closed
7012 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
7013 #ifndef DISABLE_PLOT2DVIEWER
7014 //Crear all Plot2d Viewers if need.
7015 SMESH::ClearPlot2Viewers(pview);
7017 EmitSignalCloseView();
7020 void SMESHGUI::message( const QString& msg )
7023 QStringList data = msg.split("/");
7024 if ( data.count() > 0 ) {
7025 if ( data.first() == "mesh_loading" ) {
7027 QString entry = data.count() > 1 ? data[1] : QString();
7028 if ( entry.isEmpty() )
7031 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
7033 _PTR(SObject) obj = study->FindObjectID( entry.toLatin1().constData() );
7036 name = SMESH::fromUtf8(obj->GetName());
7037 if ( name.isEmpty() )
7040 if ( data.last() == "stop" )
7041 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
7043 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
7044 QApplication::processEvents();
7050 \brief Connects or disconnects signals about activating and cloning view on the module slots
7051 \param pview view which is connected/disconnected
7053 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
7057 SUIT_ViewManager* viewMgr = pview->getViewManager();
7059 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7060 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7062 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7063 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7068 \brief Return \c true if object can be renamed
7070 bool SMESHGUI::renameAllowed( const QString& entry) const {
7071 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7075 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7079 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
7084 if(appStudy->isComponent(entry) || obj->isReference())
7087 // check type to prevent renaming of inappropriate objects
7088 int aType = SMESHGUI_Selection::type(qPrintable(entry), SMESH::GetActiveStudyDocument());
7089 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7090 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7091 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7092 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7093 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
7100 Rename object by entry.
7101 \param entry entry of the object
7102 \param name new name of the object
7103 \brief Return \c true if rename operation finished successfully, \c false otherwise.
7105 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
7107 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7111 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7116 _PTR(Study) aStudy = appStudy->studyDS();
7121 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
7123 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
7128 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
7129 _PTR(GenericAttribute) anAttr;
7130 _PTR(AttributeName) aName;
7132 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
7134 // check type to prevent renaming of inappropriate objects
7135 int aType = SMESHGUI_Selection::type( qPrintable(entry), SMESH::GetActiveStudyDocument() );
7136 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7137 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7138 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7139 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7140 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
7141 if ( !name.isEmpty() ) {
7142 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
7144 // update name of group object and its actor
7145 Handle(SALOME_InteractiveObject) IObject =
7146 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
7148 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
7149 if( !aGroupObject->_is_nil() ) {
7150 aGroupObject->SetName( qPrintable(name) );
7151 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
7152 anActor->setName( qPrintable(name) );
7162 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
7164 static QList<QColor> colors;
7166 if ( colors.isEmpty() ) {
7168 for (int s = 0; s < 2 ; s++)
7170 for (int v = 100; v >= 40; v = v - 20)
7172 for (int h = 0; h < 359 ; h = h + 60)
7174 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
7179 static int currentColor = randomize( colors.size() );
7181 SALOMEDS::Color color;
7182 color.R = (double)colors[currentColor].red() / 255.0;
7183 color.G = (double)colors[currentColor].green() / 255.0;
7184 color.B = (double)colors[currentColor].blue() / 255.0;
7186 currentColor = (currentColor+1) % colors.count();