1 // Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
3 // Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
6 // This library is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU Lesser General Public
8 // License as published by the Free Software Foundation; either
9 // version 2.1 of the License, or (at your option) any later version.
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 // Lesser General Public License for more details.
16 // You should have received a copy of the GNU Lesser General Public
17 // License along with this library; if not, write to the Free Software
18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
22 // File : SMESHGUI.cxx
23 // Author : Nicolas REJNERI, Open CASCADE S.A.S.
25 #include <Standard_math.hxx> // E.A. must be included before Python.h to fix compilation on windows
27 #undef HAVE_FINITE // VSR: avoid compilation warning on Linux : "HAVE_FINITE" redefined
33 #include "SMESHGUI_Add0DElemsOnAllNodesDlg.h"
34 #include "SMESHGUI_AddMeshElementDlg.h"
35 #include "SMESHGUI_AddQuadraticElementDlg.h"
36 #include "SMESHGUI_BuildCompoundDlg.h"
37 #include "SMESHGUI_ClippingDlg.h"
38 #include "SMESHGUI_ComputeDlg.h"
39 #include "SMESHGUI_ConvToQuadOp.h"
40 #include "SMESHGUI_CopyMeshDlg.h"
41 #include "SMESHGUI_CreatePolyhedralVolumeDlg.h"
42 #include "SMESHGUI_DeleteGroupDlg.h"
43 #include "SMESHGUI_Displayer.h"
44 #include "SMESHGUI_DuplicateNodesDlg.h"
45 #include "SMESHGUI_ExtrusionAlongPathDlg.h"
46 #include "SMESHGUI_ExtrusionDlg.h"
47 #include "SMESHGUI_FieldSelectorWdg.h"
48 #include "SMESHGUI_FileInfoDlg.h"
49 #include "SMESHGUI_FileValidator.h"
50 #include "SMESHGUI_FilterDlg.h"
51 #include "SMESHGUI_FilterLibraryDlg.h"
52 #include "SMESHGUI_FindElemByPointDlg.h"
53 #include "SMESHGUI_GroupDlg.h"
54 #include "SMESHGUI_GroupOnShapeDlg.h"
55 #include "SMESHGUI_GroupOpDlg.h"
56 #include "SMESHGUI_Hypotheses.h"
57 #include "SMESHGUI_Make2DFrom3DOp.h"
58 #include "SMESHGUI_MakeNodeAtPointDlg.h"
59 #include "SMESHGUI_Measurements.h"
60 #include "SMESHGUI_MergeDlg.h"
61 #include "SMESHGUI_MeshInfo.h"
62 #include "SMESHGUI_MeshOp.h"
63 #include "SMESHGUI_MeshOrderOp.h"
64 #include "SMESHGUI_MeshPatternDlg.h"
65 #include "SMESHGUI_MultiEditDlg.h"
66 #include "SMESHGUI_NodesDlg.h"
67 #include "SMESHGUI_Operations.h"
68 #include "SMESHGUI_Preferences_ScalarBarDlg.h"
69 #include "SMESHGUI_PropertiesDlg.h"
70 #include "SMESHGUI_RemoveElementsDlg.h"
71 #include "SMESHGUI_RemoveNodesDlg.h"
72 #include "SMESHGUI_RenumberingDlg.h"
73 #include "SMESHGUI_ReorientFacesDlg.h"
74 #include "SMESHGUI_RevolutionDlg.h"
75 #include "SMESHGUI_RotationDlg.h"
76 #include "SMESHGUI_ScaleDlg.h"
77 #include "SMESHGUI_Selection.h"
78 #include "SMESHGUI_SewingDlg.h"
79 #include "SMESHGUI_SingleEditDlg.h"
80 #include "SMESHGUI_SmoothingDlg.h"
81 #include "SMESHGUI_SymmetryDlg.h"
82 #include "SMESHGUI_TranslationDlg.h"
83 #include "SMESHGUI_TransparencyDlg.h"
84 #include "SMESHGUI_DisplayEntitiesDlg.h"
85 #include "SMESHGUI_SplitBiQuad.h"
87 #include "SMESHGUI_FilterUtils.h"
88 #include "SMESHGUI_GEOMGenUtils.h"
89 #include "SMESHGUI_GroupUtils.h"
90 #include "SMESHGUI_HypothesesUtils.h"
91 #include "SMESHGUI_MeshUtils.h"
92 #include "SMESHGUI_PatternUtils.h"
93 #include "SMESHGUI_Utils.h"
94 #include "SMESHGUI_VTKUtils.h"
96 #include "SMESH_version.h"
98 #include "SMESH_ControlsDef.hxx"
99 #include "SMESH_Actor.h"
100 #include "SMESH_ActorUtils.h"
101 #include "SMESH_Client.hxx"
102 #include "SMESH_ScalarBarActor.h"
103 #include "SMESH_TypeFilter.hxx"
105 // SALOME GUI includes
106 #include <SalomeApp_Application.h>
107 #include <SalomeApp_CheckFileDlg.h>
108 #include <SalomeApp_DataObject.h>
109 #include <SalomeApp_Study.h>
110 #include <SalomeApp_Tools.h>
112 #include <LightApp_DataOwner.h>
113 #include <LightApp_NameDlg.h>
114 #include <LightApp_Preferences.h>
115 #include <LightApp_SelectionMgr.h>
116 #include <LightApp_UpdateFlags.h>
118 #include <SVTK_ViewManager.h>
119 #include <SVTK_ViewModel.h>
120 #include <SVTK_ViewWindow.h>
122 #include <VTKViewer_Algorithm.h>
124 #include <SUIT_Desktop.h>
125 #include <SUIT_FileDlg.h>
126 #include <SUIT_MessageBox.h>
127 #include <SUIT_OverrideCursor.h>
128 #include <SUIT_ResourceMgr.h>
129 #include <SUIT_Session.h>
131 #include <QtxPopupMgr.h>
132 #include <QtxFontEdit.h>
134 #include <SALOME_ListIO.hxx>
136 #ifndef DISABLE_PLOT2DVIEWER
137 #include <SPlot2d_ViewModel.h>
138 #include <SPlot2d_Histogram.h>
142 #include <SALOMEconfig.h>
143 #include CORBA_CLIENT_HEADER(SALOMEDS_Attributes)
144 #include CORBA_CLIENT_HEADER(SMESH_MeshEditor)
145 #include CORBA_CLIENT_HEADER(SMESH_Measurements)
148 // #define INCLUDE_MENUITEM_DEF // VSR commented ????????
149 #include <QApplication>
151 #include <QTextStream>
156 #include <QDialogButtonBox>
159 #include <boost/shared_ptr.hpp>
162 #include <vtkCallbackCommand.h>
163 #include <vtkCamera.h>
164 #include <vtkLookupTable.h>
165 #include <vtkPlane.h>
166 #include <vtkRenderer.h>
168 // SALOME KERNEL includes
169 #include <SALOMEDSClient_ClientFactory.hxx>
170 #include <SALOMEDSClient_IParameters.hxx>
171 #include <SALOMEDSClient_SComponent.hxx>
172 #include <SALOMEDSClient_StudyBuilder.hxx>
173 #include <SALOMEDS_Study.hxx>
174 #include <SALOMEDS_SObject.hxx>
175 #include "utilities.h"
178 #include <Standard_ErrorHandler.hxx>
179 #include <NCollection_DataMap.hxx>
180 #include <NCollection_DoubleMap.hxx>
182 #include <Basics_Utils.hxx>
184 // Below macro, when uncommented, switches on simplified (more performant) algorithm
185 // of auto-color picking up
186 #define SIMPLE_AUTOCOLOR
191 //=============================================================
192 void ImportMeshesFromFile(SMESH::SMESH_Gen_ptr theComponentMesh,
195 void ExportMeshToFile(int theCommandID);
197 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap);
199 void SetDisplayEntity(int theCommandID);
201 int ActionToControl( int theID, bool theReversed = false );
203 void Control( int theCommandID );
206 //================================================================================
208 * \brief Reads meshes from file
210 //================================================================================
212 void ImportMeshesFromFile( SMESH::SMESH_Gen_ptr theComponentMesh,
216 std::string myExtension;
218 if ( theCommandID == SMESHOp::OpImportMED ||
219 theCommandID == SMESHOp::OpPopupImportMED ) {
220 filter.append( QObject::tr( "MED_FILES_FILTER" ) + " (*.*med)" );
221 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
223 else if ( theCommandID == SMESHOp::OpImportUNV ||
224 theCommandID == SMESHOp::OpPopupImportUNV ) {
225 filter.append( QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)" );
227 else if ( theCommandID == SMESHOp::OpImportDAT ||
228 theCommandID == SMESHOp::OpPopupImportDAT ) {
229 filter.append( QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)" );
231 else if ( theCommandID == SMESHOp::OpImportSTL ||
232 theCommandID == SMESHOp::OpPopupImportSTL ) {
233 filter.append( QObject::tr( "STL_FILES_FILTER" ) + " (*.stl)" );
235 else if ( theCommandID == SMESHOp::OpImportCGNS ||
236 theCommandID == SMESHOp::OpPopupImportCGNS ) {
237 filter.append( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
239 else if ( theCommandID == SMESHOp::OpImportSAUV ||
240 theCommandID == SMESHOp::OpPopupImportSAUV ) {
241 filter.append( QObject::tr( "SAUV files (*.sauv*)" ) );
242 filter.append( QObject::tr( "All files (*)" ) );
244 else if ( theCommandID == SMESHOp::OpImportGMF ||
245 theCommandID == SMESHOp::OpPopupImportGMF ) {
246 filter.append( QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" );
247 filter.append( QObject::tr( "GMF_BINARY_FILES_FILTER") + " (*.meshb)" );
250 QString anInitialPath = "";
251 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
252 anInitialPath = QDir::currentPath();
254 QStringList filenames;
255 bool toCreateGroups = true;
257 // if ( theCommandID == SMESHOp::OpImportGMF ) { // GMF
258 // SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg
259 // ( SMESHGUI::desktop(), true, QObject::tr("SMESH_REQUIRED_GROUPS"), true, true );
260 // fd->setWindowTitle( QObject::tr( "SMESH_IMPORT_MESH" ) );
261 // fd->setNameFilters( filter );
262 // fd->SetChecked( true );
264 // filenames << fd->selectedFile();
265 // toCreateGroups = fd->IsChecked();
271 filenames = SUIT_FileDlg::getOpenFileNames( SMESHGUI::desktop(),
274 QObject::tr( "SMESH_IMPORT_MESH" ) );
276 if ( filenames.count() > 0 )
278 SUIT_OverrideCursor wc;
279 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
282 QStringList anEntryList;
283 bool isEmpty = false;
284 for ( QStringList::ConstIterator it = filenames.begin(); it != filenames.end(); ++it )
286 QString filename = *it;
287 SMESH::mesh_array_var aMeshes = new SMESH::mesh_array;
289 switch ( theCommandID ) {
290 case SMESHOp::OpImportDAT:
291 case SMESHOp::OpPopupImportDAT:
293 // DAT format (currently unsupported)
294 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
295 arg( QObject::tr( "SMESH_ERR_NOT_SUPPORTED_FORMAT" ) ) );
298 case SMESHOp::OpImportUNV:
299 case SMESHOp::OpPopupImportUNV:
302 aMeshes->length( 1 );
303 aMeshes[0] = theComponentMesh->CreateMeshesFromUNV( filename.toUtf8().constData() );
304 if ( aMeshes[0]->_is_nil() )
305 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
306 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
309 case SMESHOp::OpImportMED:
310 case SMESHOp::OpPopupImportMED:
313 SMESH::DriverMED_ReadStatus res;
314 aMeshes = theComponentMesh->CreateMeshesFromMED( filename.toUtf8().constData(), res );
315 if ( res != SMESH::DRS_OK ) {
316 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
317 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
321 case SMESHOp::OpImportSTL:
322 case SMESHOp::OpPopupImportSTL:
325 aMeshes->length( 1 );
326 aMeshes[0] = theComponentMesh->CreateMeshesFromSTL( filename.toUtf8().constData() );
327 if ( aMeshes[0]->_is_nil() ) {
328 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
329 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
333 case SMESHOp::OpImportCGNS:
334 case SMESHOp::OpPopupImportCGNS:
337 SMESH::DriverMED_ReadStatus res;
338 aMeshes = theComponentMesh->CreateMeshesFromCGNS( filename.toUtf8().constData(), res );
339 if ( res != SMESH::DRS_OK ) {
340 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
341 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
345 case SMESHOp::OpImportSAUV:
346 case SMESHOp::OpPopupImportSAUV:
349 SMESH::DriverMED_ReadStatus res;
350 aMeshes = theComponentMesh->CreateMeshesFromSAUV( filename.toUtf8().constData(), res );
351 if ( res != SMESH::DRS_OK ) {
352 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
353 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
357 case SMESHOp::OpImportGMF:
358 case SMESHOp::OpPopupImportGMF:
361 SMESH::ComputeError_var res;
362 aMeshes->length( 1 );
363 aMeshes[0] = theComponentMesh->CreateMeshesFromGMF( filename.toUtf8().constData(),
366 if ( res->code != SMESH::DRS_OK ) {
367 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
368 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res->code ).toLatin1().data() ) ) );
369 if ( strlen( res->comment.in() ) > 0 ) {
370 errors.back() += ": ";
371 errors.back() += res->comment.in();
378 catch ( const SALOME::SALOME_Exception& S_ex ) {
379 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
380 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
383 for ( int i = 0, iEnd = aMeshes->length(); i < iEnd; i++ )
385 _PTR(SObject) aMeshSO = SMESH::FindSObject( aMeshes[i] );
387 _PTR(StudyBuilder) aBuilder = aStudy->NewBuilder();
388 _PTR(AttributePixMap) aPixmap = aBuilder->FindOrCreateAttribute( aMeshSO, "AttributePixMap" );
389 aPixmap->SetPixMap( "ICON_SMESH_TREE_MESH_IMPORTED" );
390 if ( theCommandID == SMESHOp::OpImportUNV ) // mesh names aren't taken from the file for UNV import
391 SMESH::SetName( aMeshSO, QFileInfo(filename).fileName() );
393 anEntryList.append( aMeshSO->GetID().c_str() );
401 // update Object browser
402 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
404 // browse to the published meshes
405 if( LightApp_Application* anApp =
406 dynamic_cast<LightApp_Application*>( SUIT_Session::session()->activeApplication() ) )
407 anApp->browseObjects( anEntryList );
409 // show Error message box if there were errors
410 if ( errors.count() > 0 ) {
411 SUIT_MessageBox::critical( SMESHGUI::desktop(),
412 QObject::tr( "SMESH_ERROR" ),
413 QObject::tr( "SMESH_IMPORT_ERRORS" ) + "\n" + errors.join( "\n" ) );
416 // show warning message box, if some imported mesh is empty
418 SUIT_MessageBox::warning( SMESHGUI::desktop(),
419 QObject::tr( "SMESH_WRN_WARNING" ),
420 QObject::tr( "SMESH_DRS_SOME_EMPTY" ) );
425 //================================================================================
427 * \brief Export selected meshes or groups into a file
429 //================================================================================
431 void ExportMeshToFile( int theCommandID )
433 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
434 SALOME_ListIO selected;
436 aSel->selectedObjects( selected );
438 const bool isDAT = ( theCommandID == SMESHOp::OpExportDAT ||
439 theCommandID == SMESHOp::OpPopupExportDAT );
440 const bool isMED = ( theCommandID == SMESHOp::OpExportMED ||
441 theCommandID == SMESHOp::OpPopupExportMED );
442 const bool isUNV = ( theCommandID == SMESHOp::OpExportUNV ||
443 theCommandID == SMESHOp::OpPopupExportUNV );
444 const bool isSTL = ( theCommandID == SMESHOp::OpExportSTL ||
445 theCommandID == SMESHOp::OpPopupExportSTL );
446 const bool isCGNS= ( theCommandID == SMESHOp::OpExportCGNS ||
447 theCommandID == SMESHOp::OpPopupExportCGNS );
448 const bool isSAUV= ( theCommandID == SMESHOp::OpExportSAUV ||
449 theCommandID == SMESHOp::OpPopupExportSAUV );
450 const bool isGMF = ( theCommandID == SMESHOp::OpExportGMF ||
451 theCommandID == SMESHOp::OpPopupExportGMF );
453 const bool multiMeshSupported = ( isMED || isCGNS ); // file can hold several meshes
454 if ( selected.Extent() == 0 || ( selected.Extent() > 1 && !multiMeshSupported ))
456 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
457 bool aCheckWarn = true;
459 aCheckWarn = resMgr->booleanValue( "SMESH", "show_warning", false );
460 // get mesh object from selection and check duplication of their names
461 bool hasDuplicatedMeshNames = false;
462 QList< QPair< SMESH::SMESH_IDSource_var, QString > > aMeshList;
463 QList< QPair< SMESH::SMESH_IDSource_var, QString > >::iterator aMeshIter;
464 SALOME_ListIteratorOfListIO It( selected );
465 for( ; It.More(); It.Next() )
467 Handle(SALOME_InteractiveObject) anIObject = It.Value();
468 SMESH::SMESH_IDSource_var aMeshItem =
469 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIObject);
470 if ( aMeshItem->_is_nil() ) {
471 SUIT_MessageBox::warning( SMESHGUI::desktop(),
472 QObject::tr( "SMESH_WRN_WARNING" ),
473 QObject::tr( "SMESH_BAD_MESH_SELECTION" ));
476 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( aMeshItem );
477 if ( aCheckWarn && !aGroup->_is_nil() )
479 QMessageBox msgBox(SUIT_MessageBox::Warning,
480 QObject::tr("SMESH_WRN_WARNING"),
481 QObject::tr("SMESH_EXPORT_ONLY_GPOUP"),
482 QMessageBox::StandardButton::NoButton,
483 SMESHGUI::desktop());
484 QCheckBox dontShowCheckBox(QObject::tr("SMESH_WRN_SHOW_DLG_CHECKBOX"));
485 msgBox.addButton(QMessageBox::Ok);
486 msgBox.addButton(QMessageBox::Cancel);
487 msgBox.setDefaultButton(QMessageBox::Cancel);
488 QGridLayout* lt = qobject_cast<QGridLayout*>(msgBox.layout());
489 QDialogButtonBox* btnbox = msgBox.findChild<QDialogButtonBox*>();
490 lt->addWidget(&dontShowCheckBox, lt->rowCount(), lt->columnCount()-1, lt->rowCount(), lt->columnCount());
491 lt->addWidget(btnbox, lt->rowCount(), 0, lt->rowCount(), lt->columnCount());
492 if(msgBox.exec() == QMessageBox::Ok)
494 if(dontShowCheckBox.checkState() == Qt::Checked)
497 resMgr->setValue( "SMESH", "show_warning", false);
505 QString aMeshName = anIObject->getName();
507 // check for name duplications
508 if ( !hasDuplicatedMeshNames )
509 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
510 if( aMeshName == (*aMeshIter).second ) {
511 hasDuplicatedMeshNames = true;
516 aMeshList.append( QPair< SMESH::SMESH_IDSource_var, QString >( aMeshItem, aMeshName ) );
519 if( hasDuplicatedMeshNames && isMED ) {
520 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
521 QObject::tr("SMESH_WRN_WARNING"),
522 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_MESH_NAMES"),
523 QObject::tr("SMESH_BUT_YES"),
524 QObject::tr("SMESH_BUT_NO"), 0, 1);
529 aMeshIter = aMeshList.begin();
530 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
531 SMESH::SMESH_Mesh_var aMesh = aMeshOrGroup->GetMesh();
532 QString aMeshName = (*aMeshIter).second;
534 if ( isMED || isCGNS || isSAUV ) // formats where group names must be unique
536 // check for equal group names within each mesh
537 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
538 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
539 if ( !aMeshItem->_is_nil() && aMeshItem->HasDuplicatedGroupNamesMED()) {
540 int aRet = SUIT_MessageBox::warning
541 (SMESHGUI::desktop(),
542 QObject::tr("SMESH_WRN_WARNING"),
543 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_GRP").arg((*aMeshIter).second),
544 QObject::tr("SMESH_BUT_YES"),
545 QObject::tr("SMESH_BUT_NO"), 0, 1);
552 // Warn the user about presence of not supported elements
554 std::vector< SMESH::EntityType > notSupportedElemTypes, presentNotSupported;
558 notSupportedElemTypes.push_back( SMESH::Entity_0D );
559 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
564 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
565 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
566 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
567 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
568 notSupportedElemTypes.push_back( SMESH::Entity_Pyramid );
569 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
570 notSupportedElemTypes.push_back( SMESH::Entity_0D );
571 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
576 notSupportedElemTypes.push_back( SMESH::Entity_Edge );
577 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Edge );
578 notSupportedElemTypes.push_back( SMESH::Entity_0D );
579 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
584 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
589 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
590 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Triangle );
591 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Quadrangle );
592 notSupportedElemTypes.push_back( SMESH::Entity_TriQuad_Hexa );
593 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
594 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
595 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
596 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
601 notSupportedElemTypes.push_back( SMESH::Entity_0D );
602 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
603 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
604 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Pyramid );
605 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Penta );
606 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Penta );
607 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
608 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
609 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
610 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
612 if ( ! notSupportedElemTypes.empty() )
614 SMESH::long_array_var nbElems = aMeshOrGroup->GetMeshInfo();
615 for ( size_t iType = 0; iType < notSupportedElemTypes.size(); ++iType )
616 if ( nbElems[ notSupportedElemTypes[ iType ]] > 0 )
617 presentNotSupported.push_back( notSupportedElemTypes[ iType ]);
619 if ( !presentNotSupported.empty() )
622 const char* typeMsg[] = {
623 "SMESH_NODES", "SMESH_ELEMS0D","SMESH_EDGES","SMESH_QUADRATIC_EDGES",
624 "SMESH_TRIANGLES", "SMESH_QUADRATIC_TRIANGLES", "SMESH_BIQUADRATIC_TRIANGLES",
625 "SMESH_QUADRANGLES","SMESH_QUADRATIC_QUADRANGLES", "SMESH_BIQUADRATIC_QUADRANGLES",
626 "SMESH_POLYGONS","SMESH_QUADRATIC_POLYGONS",
627 "SMESH_TETRAHEDRA","SMESH_QUADRATIC_TETRAHEDRONS","SMESH_PYRAMIDS",
628 "SMESH_QUADRATIC_PYRAMIDS","SMESH_HEXAHEDRA","SMESH_QUADRATIC_HEXAHEDRONS",
629 "SMESH_TRIQUADRATIC_HEXAHEDRONS","SMESH_PENTAHEDRA","SMESH_QUADRATIC_PENTAHEDRONS",
630 "SMESH_BIQUADRATIC_PENTAHEDRONS",
631 "SMESH_OCTAHEDRA","SMESH_POLYEDRONS","SMESH_QUADRATIC_POLYEDRONS","SMESH_BALLS"
633 // is typeMsg complete? (compilation failure mains that enum SMDSAbs_EntityType changed)
634 const int nbTypes = sizeof( typeMsg ) / sizeof( const char* );
635 int _assert[( nbTypes == SMESH::Entity_Last ) ? 2 : -1 ]; _assert[0]=_assert[1]=0;
637 QString andStr = " " + QObject::tr("SMESH_AND") + " ", comma(", ");
638 for ( size_t iType = 0; iType < presentNotSupported.size(); ++iType ) {
639 typeNames += QObject::tr( typeMsg[ presentNotSupported[ iType ]]);
640 if ( iType != presentNotSupported.size() - 1 )
641 typeNames += ( iType == presentNotSupported.size() - 2 ) ? andStr : comma;
643 int aRet = SUIT_MessageBox::warning
644 (SMESHGUI::desktop(),
645 QObject::tr("SMESH_WRN_WARNING"),
646 QObject::tr("EXPORT_NOT_SUPPORTED").arg(aMeshName).arg(format).arg(typeNames),
647 QObject::tr("SMESH_BUT_YES"),
648 QObject::tr("SMESH_BUT_NO"), 0, 1);
653 // Get parameters of export operation
656 SMESH::MED_VERSION aFormat = SMESH::MED_V2_2;
657 // Init the parameters with the default values
658 bool aIsASCII_STL = true;
659 bool toCreateGroups = false;
661 toCreateGroups = resMgr->booleanValue( "SMESH", "auto_groups", false );
662 bool toOverwrite = true;
663 bool toFindOutDim = true;
665 QString aFilter, aTitle = QObject::tr("SMESH_EXPORT_MESH");
666 QString anInitialPath = "";
667 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
668 anInitialPath = QDir::currentPath();
670 QList< QPair< GEOM::ListOfFields_var, QString > > aFieldList;
672 // Get a file name to write in and additional otions
673 if ( isUNV || isDAT || isGMF ) // Export w/o options
676 aFilter = QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)";
678 aFilter = QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)";
680 aFilter = QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" +
681 ";;" + QObject::tr( "GMF_BINARY_FILES_FILTER" ) + " (*.meshb)";
682 if ( anInitialPath.isEmpty() ) anInitialPath = SUIT_FileDlg::getLastVisitedPath();
683 aFilename = SUIT_FileDlg::getFileName(SMESHGUI::desktop(),
684 anInitialPath + QString("/") + aMeshName,
685 aFilter, aTitle, false);
687 else if ( isCGNS )// Export to CGNS
689 const char* theByTypeResource = "cgns_group_elems_by_type";
690 toCreateGroups = SMESHGUI::resourceMgr()->booleanValue( "SMESH", theByTypeResource, false );
692 QStringList checkBoxes;
693 checkBoxes << QObject::tr("CGNS_EXPORT_ELEMS_BY_TYPE");
695 SalomeApp_CheckFileDlg* fd =
696 new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true );
697 fd->setWindowTitle( aTitle );
698 fd->setNameFilter( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
699 if ( !anInitialPath.isEmpty() )
700 fd->setDirectory( anInitialPath );
701 fd->selectFile(aMeshName);
702 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
703 fd->setValidator( fv );
704 fd->SetChecked( toCreateGroups, 0 );
707 aFilename = fd->selectedFile();
708 toOverwrite = fv->isOverwrite();
709 toCreateGroups = fd->IsChecked(0);
710 SMESHGUI::resourceMgr()->setValue("SMESH", theByTypeResource, toCreateGroups );
714 else if ( isSTL ) // Export to STL
716 QMap<QString, int> aFilterMap;
717 aFilterMap.insert( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)", 1 );
718 aFilterMap.insert( QObject::tr( "STL_BIN_FILES_FILTER" ) + " (*.stl)", 0 );
721 QMap<QString, int>::const_iterator it = aFilterMap.begin();
722 for ( ; it != aFilterMap.end(); ++it )
723 filters.push_back( it.key() );
725 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
726 fd->setWindowTitle( aTitle );
727 fd->setNameFilters( filters );
728 fd->selectNameFilter( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
729 if ( !anInitialPath.isEmpty() )
730 fd->setDirectory( anInitialPath );
731 fd->selectFile(aMeshName);
735 aFilename = fd->selectedFile();
736 aIsASCII_STL = (aFilterMap[fd->selectedNameFilter()]) == 1 ? true: false;
741 else if ( isMED || isSAUV ) // Export to MED or SAUV
743 QMap<QString, SMESH::MED_VERSION> aFilterMap;
744 //QString v21 (aMesh->GetVersionString(SMESH::MED_V2_1, 2));
746 QString v22 (aMesh->GetVersionString(SMESH::MED_V2_2, 2));
747 //aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v21 ) + " (*.med)", SMESH::MED_V2_1 );
748 aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v22 ) + " (*.med)", SMESH::MED_V2_2 );
751 aFilterMap.insert("All files (*)", SMESH::MED_V2_1 );
752 aFilterMap.insert("SAUV files (*.sauv)", SMESH::MED_V2_2 );
753 aFilterMap.insert("SAUV files (*.sauve)", SMESH::MED_V2_1 );
757 QString aDefaultFilter;
758 QMap<QString, SMESH::MED_VERSION>::const_iterator it = aFilterMap.begin();
759 for ( ; it != aFilterMap.end(); ++it ) {
760 filters.push_back( it.key() );
761 if (it.value() == SMESH::MED_V2_2)
762 aDefaultFilter = it.key();
764 QStringList checkBoxes;
765 checkBoxes << QObject::tr("SMESH_AUTO_GROUPS") << QObject::tr("SMESH_AUTO_DIM");
767 SMESHGUI_FieldSelectorWdg* fieldSelWdg = new SMESHGUI_FieldSelectorWdg();
768 QList< QWidget* > wdgList;
769 if ( fieldSelWdg->GetAllFields( aMeshList, aFieldList ))
770 wdgList.append( fieldSelWdg );
772 SalomeApp_CheckFileDlg* fd =
773 new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true, wdgList );
774 fd->setWindowTitle( aTitle );
775 fd->setNameFilters( filters );
776 fd->selectNameFilter( aDefaultFilter );
777 fd->SetChecked( toCreateGroups, 0 );
778 fd->SetChecked( toFindOutDim, 1 );
779 if ( !anInitialPath.isEmpty() )
780 fd->setDirectory( anInitialPath );
781 fd->selectFile(aMeshName);
784 QListView *lview = fd->findChild<QListView*>("listView");
786 lview->setMinimumHeight(200);
788 QTreeView *tview = fd->findChild<QTreeView*>("treeView");
790 tview->setMinimumHeight(200);
793 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
794 fd->setValidator( fv );
799 aFilename = fd->selectedFile();
801 aFilename = QString::null;
804 aFormat = aFilterMap[fd->selectedNameFilter()];
805 toOverwrite = fv->isOverwrite();
807 if ( !aFilename.isEmpty() ) {
808 // med-2.1 does not support poly elements
809 if ( aFormat==SMESH::MED_V2_1 )
810 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
811 SMESH::SMESH_IDSource_var aMeshItem = (*aMeshIter).first;
812 SMESH::long_array_var nbElems = aMeshItem->GetMeshInfo();
813 if ( nbElems[ SMESH::Entity_Polygon ] + nbElems[ SMESH::Entity_Quad_Polygon ] +
814 nbElems[ SMESH::Entity_Polyhedra ] + nbElems[ SMESH::Entity_Quad_Polyhedra ])
816 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
817 QObject::tr("SMESH_WRN_WARNING"),
818 QObject::tr("SMESH_EXPORT_MED_V2_1").arg((*aMeshIter).second),
819 QObject::tr("SMESH_BUT_YES"),
820 QObject::tr("SMESH_BUT_NO"), 0, 1);
828 // can't append to an existing using other format
829 SMESH::MED_VERSION aVersion = SMESH::MED_V2_1;
830 bool isVersionOk = SMESHGUI::GetSMESHGen()->GetMEDVersion( aFilename.toUtf8().constData(), aVersion );
831 if( !isVersionOk || aVersion != aFormat ) {
832 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
833 QObject::tr("SMESH_WRN_WARNING"),
834 QObject::tr("SMESH_EXPORT_MED_VERSION_COLLISION").arg(aFilename),
835 QObject::tr("SMESH_BUT_YES"),
836 QObject::tr("SMESH_BUT_NO"), 0, 1);
843 QStringList aMeshNamesCollisionList;
844 SMESH::string_array_var aMeshNames = SMESHGUI::GetSMESHGen()->GetMeshNames( aFilename.toUtf8().constData() );
845 for( int i = 0, n = aMeshNames->length(); i < n; i++ ) {
846 QString anExistingMeshName( aMeshNames[ i ] );
847 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
848 QString anExportMeshName = (*aMeshIter).second;
849 if( anExportMeshName == anExistingMeshName ) {
850 aMeshNamesCollisionList.append( anExportMeshName );
855 if( !aMeshNamesCollisionList.isEmpty() ) {
856 QString aMeshNamesCollisionString = aMeshNamesCollisionList.join( ", " );
857 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
858 QObject::tr("SMESH_WRN_WARNING"),
859 QObject::tr("SMESH_EXPORT_MED_MESH_NAMES_COLLISION").arg(aMeshNamesCollisionString),
860 QObject::tr("SMESH_BUT_YES"),
861 QObject::tr("SMESH_BUT_NO"),
862 QObject::tr("SMESH_BUT_CANCEL"), 0, 2);
871 toCreateGroups = fd->IsChecked(0);
872 toFindOutDim = fd->IsChecked(1);
873 fieldSelWdg->GetSelectedFields();
874 if ( !fieldSelWdg->parent() )
885 if ( !aFilename.isEmpty() ) {
886 // Check whether the file already exists and delete it if yes
887 QFile aFile( aFilename );
888 if ( aFile.exists() && toOverwrite )
890 SUIT_OverrideCursor wc;
893 // Renumbering is not needed since SMDS redesign in V6.2.0 (Nov 2010)
894 // bool Renumber = false;
895 // // PAL 14172 : Check of we have to renumber or not from the preferences before export
897 // Renumber= resMgr->booleanValue("renumbering");
899 // SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
900 // aMeshEditor->RenumberNodes();
901 // aMeshEditor->RenumberElements();
902 // if ( SMESHGUI::automaticUpdate() )
903 // SMESH::UpdateView();
907 aMeshIter = aMeshList.begin();
908 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
910 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
911 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
912 const GEOM::ListOfFields& fields = aFieldList[ aMeshIndex ].first.in();
913 const QString& geoAssFields = aFieldList[ aMeshIndex ].second;
914 const bool hasFields = ( fields.length() || !geoAssFields.isEmpty() );
915 if ( !hasFields && aMeshOrGroup->_is_equivalent( aMeshItem ))
916 aMeshItem->ExportToMEDX( aFilename.toUtf8().data(), toCreateGroups,
917 aFormat, toOverwrite && aMeshIndex == 0, toFindOutDim );
919 aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups,
920 aFormat, toOverwrite && aMeshIndex == 0, toFindOutDim,
921 fields, geoAssFields.toLatin1().data() );
926 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ )
928 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
929 if( !aMeshItem->_is_nil() )
930 aMeshItem->ExportSAUV( aFilename.toUtf8().data(), toCreateGroups );
935 if ( aMeshOrGroup->_is_equivalent( aMesh ))
936 aMesh->ExportDAT( aFilename.toUtf8().data() );
938 aMesh->ExportPartToDAT( aMeshOrGroup, aFilename.toUtf8().data() );
942 if ( aMeshOrGroup->_is_equivalent( aMesh ))
943 aMesh->ExportUNV( aFilename.toUtf8().data() );
945 aMesh->ExportPartToUNV( aMeshOrGroup, aFilename.toUtf8().data() );
949 if ( aMeshOrGroup->_is_equivalent( aMesh ))
950 aMesh->ExportSTL( aFilename.toUtf8().data(), aIsASCII_STL );
952 aMesh->ExportPartToSTL( aMeshOrGroup, aFilename.toUtf8().data(), aIsASCII_STL );
956 aMeshIter = aMeshList.begin();
957 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
959 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
960 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
961 aMeshItem->ExportCGNS( aMeshOrGroup,
962 aFilename.toUtf8().data(),
963 toOverwrite && aMeshIndex == 0,
969 toCreateGroups = true;
970 aMesh->ExportGMF( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups );
973 catch (const SALOME::SALOME_Exception& S_ex){
975 SUIT_MessageBox::warning(SMESHGUI::desktop(),
976 QObject::tr("SMESH_WRN_WARNING"),
977 QObject::tr("SMESH_EXPORT_FAILED"));
983 inline void InverseEntityMode(unsigned int& theOutputMode,
984 unsigned int theMode)
986 bool anIsNotPresent = ~theOutputMode & theMode;
988 theOutputMode |= theMode;
990 theOutputMode &= ~theMode;
993 void SetDisplayEntity(int theCommandID)
995 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
996 SALOME_ListIO selected;
998 aSel->selectedObjects( selected );
1000 if ( selected.Extent() >= 1 ) {
1001 SUIT_OverrideCursor wc;
1002 SALOME_ListIteratorOfListIO It( selected );
1003 for( ; It.More(); It.Next()){
1004 Handle(SALOME_InteractiveObject) IObject = It.Value();
1005 if(IObject->hasEntry()){
1006 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1007 unsigned int aMode = anActor->GetEntityMode();
1008 switch(theCommandID){
1009 case SMESHOp::OpDE0DElements: InverseEntityMode(aMode,SMESH_Actor::e0DElements); break;
1010 case SMESHOp::OpDEEdges: InverseEntityMode(aMode,SMESH_Actor::eEdges); break;
1011 case SMESHOp::OpDEFaces: InverseEntityMode(aMode,SMESH_Actor::eFaces); break;
1012 case SMESHOp::OpDEVolumes: InverseEntityMode(aMode,SMESH_Actor::eVolumes); break;
1013 case SMESHOp::OpDEBalls: InverseEntityMode(aMode,SMESH_Actor::eBallElem); break;
1014 case SMESHOp::OpDEAllEntity: aMode = SMESH_Actor::eAllEntity; break;
1017 anActor->SetEntityMode(aMode);
1026 SalomeApp_Application* app =
1027 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1031 LightApp_SelectionMgr* aSel = app->selectionMgr();
1032 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1033 if ( !aSel || !appStudy )
1036 SALOME_ListIO selected;
1037 aSel->selectedObjects( selected );
1038 if ( selected.IsEmpty() )
1041 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1043 _PTR(Study) aStudy = appStudy->studyDS();
1044 _PTR(SObject) aMainSObject = aStudy->FindObjectID( anIObject->getEntry() );
1045 SMESH::SMESH_Mesh_var aMainObject = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1046 if ( aMainObject->_is_nil() )
1049 SUIT_OverrideCursor wc;
1051 aMainObject->SetAutoColor( true ); // mesh groups are re-colored here
1053 QList<SALOMEDS::Color> aReservedColors;
1055 SMESH::ListOfGroups aListOfGroups = *aMainObject->GetGroups();
1056 for ( int i = 0, n = aListOfGroups.length(); i < n; i++ )
1058 SMESH::SMESH_GroupBase_var aGroupObject = aListOfGroups[i];
1060 #ifdef SIMPLE_AUTOCOLOR // simplified algorithm for auto-colors
1061 SALOMEDS::Color aColor = SMESHGUI::getPredefinedUniqueColor();
1062 #else // old algorithm for auto-colors
1063 SALOMEDS::Color aColor = SMESHGUI::getUniqueColor( aReservedColors );
1064 aReservedColors.append( aColor );
1065 #endif // SIMPLE_AUTOCOLOR
1066 aGroupObject->SetColor( aColor );
1068 _PTR(SObject) aGroupSObject = SMESH::FindSObject(aGroupObject);
1069 if ( aGroupSObject ) {
1072 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry(aGroupSObject->GetID().c_str())) {
1073 switch ( aGroupObject->GetType ()) {
1075 anActor->SetNodeColor( aColor.R, aColor.G, aColor.B ); break;
1077 anActor->SetEdgeColor( aColor.R, aColor.G, aColor.B ); break;
1079 anActor->Set0DColor( aColor.R, aColor.G, aColor.B ); break;
1081 anActor->SetBallColor( aColor.R, aColor.G, aColor.B ); break;
1083 SMESH::GetColor("SMESH", "volume_color", c, delta, "255,0,170|-100");
1084 anActor->SetVolumeColor( aColor.R, aColor.G, aColor.B, delta ); break;
1087 SMESH::GetColor("SMESH", "fill_color", c, delta, "0,170,255|-100");
1088 anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B, delta );
1094 SMESH::RepaintCurrentView();
1097 void OverallMeshQuality()
1099 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1100 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1101 SALOME_ListIO selected;
1103 aSel->selectedObjects( selected );
1105 if ( selected.IsEmpty() ) return;
1106 SALOME_ListIteratorOfListIO It( selected );
1107 for ( ; It.More(); It.Next() ) {
1108 SMESHGUI_CtrlInfoDlg* ctrlDlg = new SMESHGUI_CtrlInfoDlg( SMESHGUI::desktop() );
1109 ctrlDlg->showInfo( It.Value() );
1114 QString functorToString( SMESH::Controls::FunctorPtr f )
1116 QString type = QObject::tr( "UNKNOWN_CONTROL" );
1117 if ( dynamic_cast< SMESH::Controls::Volume* >( f.get() ) )
1118 type = QObject::tr( "VOLUME_3D_ELEMENTS" );
1119 else if ( dynamic_cast< SMESH::Controls::MaxElementLength2D* >( f.get() ) )
1120 type = QObject::tr( "MAX_ELEMENT_LENGTH_2D" );
1121 else if ( dynamic_cast< SMESH::Controls::MaxElementLength3D* >( f.get() ) )
1122 type = QObject::tr( "MAX_ELEMENT_LENGTH_3D" );
1123 else if ( dynamic_cast< SMESH::Controls::MinimumAngle* >( f.get() ) )
1124 type = QObject::tr( "MINIMUMANGLE_ELEMENTS" );
1125 else if ( dynamic_cast< SMESH::Controls::AspectRatio* >( f.get() ) )
1126 type = QObject::tr( "ASPECTRATIO_ELEMENTS" );
1127 else if ( dynamic_cast< SMESH::Controls::AspectRatio3D* >( f.get() ) )
1128 type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" );
1129 else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) )
1130 type = QObject::tr( "WARP_ELEMENTS" );
1131 else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) )
1132 type = QObject::tr( "TAPER_ELEMENTS" );
1133 else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) )
1134 type = QObject::tr( "SKEW_ELEMENTS" );
1135 else if ( dynamic_cast< SMESH::Controls::Area* >( f.get() ) )
1136 type = QObject::tr( "AREA_ELEMENTS" );
1137 else if ( dynamic_cast< SMESH::Controls::Length* >( f.get() ) )
1138 type = QObject::tr( "LENGTH_EDGES" );
1139 else if ( dynamic_cast< SMESH::Controls::Length2D* >( f.get() ) )
1140 type = QObject::tr( "LENGTH2D_EDGES" );
1141 else if ( dynamic_cast< SMESH::Controls::Deflection2D* >( f.get() ) )
1142 type = QObject::tr( "DEFLECTION2D_FACES" );
1143 else if ( dynamic_cast< SMESH::Controls::MultiConnection* >( f.get() ) )
1144 type = QObject::tr( "MULTI_BORDERS" );
1145 else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) )
1146 type = QObject::tr( "MULTI2D_BORDERS" );
1147 else if ( dynamic_cast< SMESH::Controls::FreeNodes* >( f.get() ) )
1148 type = QObject::tr( "FREE_NODES" );
1149 else if ( dynamic_cast< SMESH::Controls::FreeEdges* >( f.get() ) )
1150 type = QObject::tr( "FREE_EDGES" );
1151 else if ( dynamic_cast< SMESH::Controls::FreeBorders* >( f.get() ) )
1152 type = QObject::tr( "FREE_BORDERS" );
1153 else if ( dynamic_cast< SMESH::Controls::FreeFaces* >( f.get() ) )
1154 type = QObject::tr( "FREE_FACES" );
1155 else if ( dynamic_cast< SMESH::Controls::BareBorderVolume* >( f.get() ) )
1156 type = QObject::tr( "BARE_BORDER_VOLUME" );
1157 else if ( dynamic_cast< SMESH::Controls::BareBorderFace* >( f.get() ) )
1158 type = QObject::tr( "BARE_BORDER_FACE" );
1159 else if ( dynamic_cast< SMESH::Controls::OverConstrainedVolume* >( f.get() ) )
1160 type = QObject::tr( "OVER_CONSTRAINED_VOLUME" );
1161 else if ( dynamic_cast< SMESH::Controls::OverConstrainedFace* >( f.get() ) )
1162 type = QObject::tr( "OVER_CONSTRAINED_FACE" );
1163 else if ( dynamic_cast< SMESH::Controls::CoincidentNodes* >( f.get() ) )
1164 type = QObject::tr( "EQUAL_NODE" );
1165 else if ( dynamic_cast< SMESH::Controls::CoincidentElements1D* >( f.get() ) )
1166 type = QObject::tr( "EQUAL_EDGE" );
1167 else if ( dynamic_cast< SMESH::Controls::CoincidentElements2D* >( f.get() ) )
1168 type = QObject::tr( "EQUAL_FACE" );
1169 else if ( dynamic_cast< SMESH::Controls::CoincidentElements3D* >( f.get() ) )
1170 type = QObject::tr( "EQUAL_VOLUME" );
1171 else if ( dynamic_cast< SMESH::Controls::NodeConnectivityNumber* >( f.get() ) )
1172 type = QObject::tr( "NODE_CONNECTIVITY_NB" );
1176 void SaveDistribution()
1178 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1179 SALOME_ListIO selected;
1181 aSel->selectedObjects( selected );
1183 if ( selected.Extent() == 1 ) {
1184 Handle(SALOME_InteractiveObject) anIO = selected.First();
1185 if ( anIO->hasEntry() ) {
1186 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1188 anActor->GetScalarBarActor() &&
1189 anActor->GetControlMode() != SMESH_Actor::eNone )
1191 SMESH_ScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor();
1192 SMESH::Controls::FunctorPtr aFunctor = anActor->GetFunctor();
1193 if ( aScalarBarActor && aFunctor ) {
1194 SMESH::Controls::NumericalFunctor* aNumFun =
1195 dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
1197 std::vector<int> elements;
1198 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
1199 if ( mesh->_is_nil() ) {
1200 SMESH::SMESH_IDSource_var idSource =
1201 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
1202 if ( !idSource->_is_nil() )
1204 SMESH::long_array_var ids = idSource->GetIDs();
1205 elements.resize( ids->length() );
1206 for ( unsigned i = 0; i < elements.size(); ++i )
1207 elements[i] = ids[i];
1210 int nbIntervals = aScalarBarActor->GetMaximumNumberOfColors();
1211 vtkLookupTable* lookupTable =
1212 static_cast<vtkLookupTable*>(aScalarBarActor->GetLookupTable());
1213 double * minmax = lookupTable->GetRange();
1214 bool isLogarithmic = lookupTable->GetScale() == VTK_SCALE_LOG10;
1215 std::vector<int> nbEvents;
1216 std::vector<double> funValues;
1217 aNumFun->GetHistogram( nbIntervals, nbEvents, funValues,
1218 elements, minmax, isLogarithmic );
1219 QString anInitialPath = "";
1220 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
1221 anInitialPath = QDir::currentPath();
1222 QString aMeshName = anIO->getName();
1224 filter.append( QObject::tr( "TEXT_FILES_FILTER" ) + " (*.txt)" );
1225 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
1226 QString aFilename = anInitialPath + "/" + aMeshName + "_" +
1227 functorToString( aFunctor ).toLower().simplified().replace( QRegExp( " |-" ), "_" ) + ".txt";
1228 aFilename = SUIT_FileDlg::getFileName( SMESHGUI::desktop(),
1231 QObject::tr( "SMESH_SAVE_DISTRIBUTION" ),
1233 if ( !aFilename.isEmpty() ) {
1234 QFile f( aFilename );
1235 if ( f.open( QFile::WriteOnly | QFile::Truncate ) ) {
1236 QTextStream out( &f );
1237 out << "# Mesh: " << aMeshName << endl;
1238 out << "# Control: " << functorToString( aFunctor ) << endl;
1240 out.setFieldWidth( 10 );
1241 for ( int i = 0; i < (int)qMin( nbEvents.size(), funValues.size()-1 ); i++ )
1242 out << funValues[i] << "\t" << funValues[i+1] << "\t" << nbEvents[i] << endl;
1253 void ShowElement( int theCommandID )
1255 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1256 SALOME_ListIO selected;
1258 aSel->selectedObjects( selected );
1260 if ( selected.Extent() == 1 ) {
1261 Handle(SALOME_InteractiveObject) anIO = selected.First();
1262 if ( anIO->hasEntry() ) {
1263 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1265 anActor->GetScalarBarActor() &&
1266 anActor->GetControlMode() != SMESH_Actor::eNone )
1268 SMESH_ScalarBarActor *aScalarBarActor = anActor->GetScalarBarActor();
1269 if ( theCommandID == SMESHOp::OpShowDistribution ) {
1270 aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility());
1272 else if ( theCommandID == SMESHOp::OpShowScalarBar ) {
1273 aScalarBarActor->SetVisibility( !aScalarBarActor->GetVisibility());
1280 #ifndef DISABLE_PLOT2DVIEWER
1281 void PlotDistribution()
1283 SalomeApp_Application* app =
1284 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1288 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1289 SALOME_ListIO selected;
1291 aSel->selectedObjects( selected );
1293 if ( selected.Extent() == 1 ) {
1294 Handle(SALOME_InteractiveObject) anIO = selected.First();
1295 if ( anIO->hasEntry() ) {
1296 //Find Actor by entry before getting Plot2d viewer,
1297 //because after call getViewManager( Plot2d_Viewer::Type(), true ) active window is Plot2d Viewer
1298 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1300 SUIT_ViewManager* aViewManager =
1301 app->getViewManager( Plot2d_Viewer::Type(), true ); // create if necessary
1305 SPlot2d_Viewer* aView = dynamic_cast<SPlot2d_Viewer*>(aViewManager->getViewModel());
1309 Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
1313 if ( anActor && anActor->GetControlMode() != SMESH_Actor::eNone )
1315 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1316 QString functorName = functorToString( anActor->GetFunctor());
1317 QString aHistogramName("%1 : %2");
1318 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1319 aHistogram->setName(aHistogramName);
1320 aHistogram->setHorTitle(functorName);
1321 aHistogram->setVerTitle(QObject::tr("DISTRIBUTION_NB_ENT"));
1322 aPlot->displayObject(aHistogram, true);
1327 #endif //DISABLE_PLOT2DVIEWER
1329 void DisableAutoColor()
1331 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1332 SALOME_ListIO selected;
1334 aSel->selectedObjects( selected );
1336 if ( selected.Extent() ) {
1337 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1338 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1339 if ( !aMesh->_is_nil() ) {
1340 aMesh->SetAutoColor( false );
1347 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1348 SALOME_ListIO selected;
1350 aSel->selectedObjects( selected );
1351 if ( selected.Extent() )
1353 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1354 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1355 _PTR(SObject) aSObj = aStudy->FindObjectID(anIObject->getEntry());
1357 if ( aStudy->GetUseCaseBuilder()->SortChildren( aSObj, true/*AscendingOrder*/ ) ) {
1358 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1365 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap)
1367 SALOME_ListIO selected;
1368 SalomeApp_Application* app =
1369 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1373 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1374 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1375 if ( !aSel || !appStudy )
1378 if ( theCommandID == SMESHOp::OpClipping ) { // Clipping dialog can be activated without selection
1379 if ( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
1380 aModule->EmitSignalDeactivateDialog();
1381 if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
1382 (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
1387 _PTR(Study) aStudy = appStudy->studyDS();
1389 aSel->selectedObjects( selected );
1391 if ( selected.Extent() >= 1 )
1393 switch ( theCommandID ) {
1394 case SMESHOp::OpTransparency:
1396 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1397 (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
1400 case SMESHOp::OpProperties:
1403 QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
1404 QColor orientationColor, outlineColor, volumeColor;
1405 int deltaF = 0, deltaV = 0;
1408 double ballScale = 1.0;
1410 int outlineWidth = 1;
1411 double shrinkCoef = 0.0;
1412 double orientationScale = 0.0;
1413 bool orientation3d = false;
1414 VTK::MarkerType markerType = VTK::MT_NONE;
1415 VTK::MarkerScale markerScale = VTK::MS_NONE;
1417 bool hasNodes = false;
1418 int presentEntities = 0;
1419 bool firstTime = true;
1421 SALOME_ListIteratorOfListIO It( selected );
1422 for ( ; It.More(); It.Next() ) {
1423 Handle(SALOME_InteractiveObject) IObject = It.Value();
1424 if ( !IObject->hasEntry() ) continue;
1425 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1426 if ( !anActor || !anActor->GetObject() ) continue;
1429 // nodes: color, marker
1430 anActor->GetNodeColor( color[0], color[1], color[2] );
1431 nodeColor.setRgbF( color[0], color[1], color[2] );
1432 markerType = anActor->GetMarkerType();
1433 markerScale = anActor->GetMarkerScale();
1434 markerId = anActor->GetMarkerTexture();
1435 // edges: color, width
1436 anActor->GetEdgeColor( color[0], color[1], color[2] );
1437 edgeColor.setRgbF( color[0], color[1], color[2] );
1438 edgeWidth = qMax( (int)anActor->GetLineWidth(), 1 ); // minimum allowed width is 1
1439 // faces: front color, back color (delta)
1440 anActor->GetSufaceColor( color[0], color[1], color[2], deltaF );
1441 faceColor.setRgbF( color[0], color[1], color[2] );
1442 // faces: front color, back color (delta)
1443 anActor->GetVolumeColor( color[0], color[1], color[2], deltaV );
1444 volumeColor.setRgbF( color[0], color[1], color[2] );
1445 // 0d elements: color, size
1446 anActor->Get0DColor( color[0], color[1], color[2] );
1447 elem0dColor.setRgbF( color[0], color[1], color[2] );
1448 elem0dSize = qMax( (int)anActor->Get0DSize(), 1 ); // minimum allowed size is 1
1449 // balls: color, size
1450 anActor->GetBallColor( color[0], color[1], color[2] );
1451 ballColor.setRgbF( color[0], color[1], color[2] );
1452 //ballSize = qMax( (int)anActor->GetBallSize(), 1 ); // minimum allowed size is 1
1453 ballScale = qMax( (double)anActor->GetBallScale(), 1e-2 ); // minimum allowed scale is 1e-2
1455 anActor->GetOutlineColor( color[0], color[1], color[2] );
1456 outlineColor.setRgbF( color[0], color[1], color[2] );
1457 outlineWidth = qMax( (int)anActor->GetOutlineWidth(), 1 ); // minimum allowed width is 1
1458 // orientation vectors: color, scale, 3d flag
1459 anActor->GetFacesOrientationColor( color[0], color[1], color[2] );
1460 orientationColor.setRgbF( color[0], color[1], color[2] );
1461 orientationScale = anActor->GetFacesOrientationScale();
1462 orientation3d = anActor->GetFacesOrientation3DVectors();
1464 shrinkCoef = anActor->GetShrinkFactor();
1467 firstTime = false; // we only take properties from first object (for performance reasons)
1470 hasNodes = anActor->GetObject()->GetNbEntities( SMDSAbs_Node );
1471 if ( !(presentEntities & SMESH_Actor::eEdges) && anActor->GetObject()->GetNbEntities( SMDSAbs_Edge ) )
1472 presentEntities = presentEntities | SMESH_Actor::eEdges;
1473 if ( !(presentEntities & SMESH_Actor::eFaces) && anActor->GetObject()->GetNbEntities( SMDSAbs_Face ) )
1474 presentEntities = presentEntities | SMESH_Actor::eFaces;
1475 if ( !(presentEntities & SMESH_Actor::eVolumes) && anActor->GetObject()->GetNbEntities( SMDSAbs_Volume ) )
1476 presentEntities = presentEntities | SMESH_Actor::eVolumes;
1477 if ( !(presentEntities & SMESH_Actor::e0DElements) && anActor->GetObject()->GetNbEntities( SMDSAbs_0DElement ) )
1478 presentEntities = presentEntities | SMESH_Actor::e0DElements;
1479 if ( !(presentEntities & SMESH_Actor::eBallElem) && anActor->GetObject()->GetNbEntities( SMDSAbs_Ball ) )
1480 presentEntities = presentEntities | SMESH_Actor::eBallElem;
1482 // as we know that all types of elements are present, we can exit the loop
1483 if ( presentEntities == SMESH_Actor::eAllEntity )
1487 SMESHGUI_PropertiesDlg dlg( theMarkerMap[ aStudy->StudyId() ], SMESHGUI::desktop() );
1488 // nodes: color, marker
1489 dlg.setNodeColor( nodeColor );
1490 if( markerType != VTK::MT_USER )
1491 dlg.setNodeMarker( markerType, markerScale );
1493 dlg.setNodeCustomMarker( markerId );
1494 // edges: color, line width
1495 dlg.setEdgeColor( edgeColor );
1496 dlg.setEdgeWidth( edgeWidth );
1497 // faces: front color, back color
1498 dlg.setFaceColor( faceColor, deltaF );
1499 // volumes: normal color, reversed color
1500 dlg.setVolumeColor( volumeColor, deltaV );
1501 // outlines: color, line width
1502 dlg.setOutlineColor( outlineColor );
1503 dlg.setOutlineWidth( outlineWidth );
1504 // 0d elements: color, size
1505 dlg.setElem0dColor( elem0dColor );
1506 dlg.setElem0dSize( elem0dSize );
1507 // balls: color, size
1508 dlg.setBallColor( ballColor );
1509 //dlg.setBallSize( ballSize );
1510 dlg.setBallScale( ballScale );
1511 // orientation: color, scale, 3d flag
1512 dlg.setOrientationColor( orientationColor );
1513 dlg.setOrientationSize( int( orientationScale * 100. ) );
1514 dlg.setOrientation3d( orientation3d );
1515 // shrink: scale factor
1516 dlg.setShrinkCoef( int( shrinkCoef * 100. ) );
1517 // hide unused controls
1518 dlg.showControls( presentEntities, hasNodes );
1521 nodeColor = dlg.nodeColor();
1522 markerType = dlg.nodeMarkerType();
1523 markerScale = dlg.nodeMarkerScale();
1524 markerId = dlg.nodeMarkerId();
1525 edgeColor = dlg.edgeColor();
1526 edgeWidth = dlg.edgeWidth();
1527 faceColor = dlg.faceColor();
1528 deltaF = dlg.faceColorDelta();
1529 volumeColor = dlg.volumeColor();
1530 deltaV = dlg.volumeColorDelta();
1531 outlineColor = dlg.outlineColor();
1532 outlineWidth = dlg.outlineWidth();
1533 elem0dColor = dlg.elem0dColor();
1534 elem0dSize = dlg.elem0dSize();
1535 ballColor = dlg.ballColor();
1536 // ballSize = dlg.ballSize();
1537 ballScale = dlg.ballScale();
1538 orientationColor = dlg.orientationColor();
1539 orientationScale = dlg.orientationSize() / 100.;
1540 orientation3d = dlg.orientation3d();
1541 shrinkCoef = dlg.shrinkCoef() / 100.;
1543 // store point markers map that might be changed by the user
1544 theMarkerMap[ aStudy->StudyId() ] = dlg.customMarkers();
1546 // set properties from dialog box to the presentations
1547 SALOME_ListIteratorOfListIO It( selected );
1548 for ( ; It.More(); It.Next() ) {
1549 Handle(SALOME_InteractiveObject) IObject = It.Value();
1550 if ( !IObject->hasEntry() ) continue;
1551 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1552 if ( !anActor ) continue;
1554 // nodes: color, marker
1555 anActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
1556 if ( markerType != VTK::MT_USER ) {
1557 anActor->SetMarkerStd( markerType, markerScale );
1560 const VTK::MarkerMap& markerMap = theMarkerMap[ aStudy->StudyId() ];
1561 VTK::MarkerMap::const_iterator iter = markerMap.find( markerId );
1562 if ( iter != markerMap.end() )
1563 anActor->SetMarkerTexture( markerId, iter->second.second );
1565 // volumes: normal color, reversed color (delta)
1566 anActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
1567 // faces: front color, back color (delta)
1568 anActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
1569 // edges: color, width
1570 anActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
1571 anActor->SetLineWidth( edgeWidth );
1573 anActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
1574 anActor->SetOutlineWidth( outlineWidth );
1575 // 0D elements: color, size
1576 anActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
1577 anActor->Set0DSize( elem0dSize );
1578 // balls: color, size
1579 anActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
1580 // anActor->SetBallSize( ballSize );
1581 anActor->SetBallScale( ballScale );
1582 // orientation: color, scale, 3d flag
1583 anActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
1584 anActor->SetFacesOrientationScale( orientationScale );
1585 anActor->SetFacesOrientation3DVectors( orientation3d );
1587 anActor->SetShrinkFactor( shrinkCoef );
1589 // for groups, set also proper color
1590 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1591 if ( !aGroupObject->_is_nil() ) {
1592 SMESH::ElementType anElementType = aGroupObject->GetType();
1594 switch( anElementType ) {
1596 aColor = nodeColor; break;
1598 aColor = edgeColor; break;
1600 aColor = faceColor; break;
1602 aColor = volumeColor; break;
1604 aColor = elem0dColor; break;
1606 aColor = ballColor; break;
1610 if ( aColor.isValid() ) {
1611 SALOMEDS::Color aGroupColor;
1612 aGroupColor.R = aColor.redF();
1613 aGroupColor.G = aColor.greenF();
1614 aGroupColor.B = aColor.blueF();
1615 aGroupObject->SetColor( aGroupColor );
1617 } // if ( !aGroupObject->_is_nil() )
1618 } // for ( ; It.More(); It.Next() )
1619 SMESH::RepaintCurrentView();
1620 } // if ( dlg.exec() )
1622 } // case SMESHOp::OpProperties:
1623 } // switch(theCommandID)
1624 SUIT_OverrideCursor wc;
1625 SALOME_ListIteratorOfListIO It( selected );
1626 for( ; It.More(); It.Next()){
1627 Handle(SALOME_InteractiveObject) IObject = It.Value();
1628 if(IObject->hasEntry()){
1629 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1630 switch(theCommandID){
1631 case SMESHOp::OpDMWireframe:
1632 anActor->SetRepresentation(SMESH_Actor::eEdge);
1634 case SMESHOp::OpDMShading:
1635 anActor->SetRepresentation(SMESH_Actor::eSurface);
1637 case SMESHOp::OpDMShrink:
1638 if(anActor->IsShrunk())
1639 anActor->UnShrink();
1641 anActor->SetShrink();
1643 case SMESHOp::OpDMNodes:
1644 anActor->SetRepresentation(SMESH_Actor::ePoint);
1646 case SMESHOp::OpRepresentationLines:
1647 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1648 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1650 case SMESHOp::OpRepresentationArcs:
1651 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1652 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1658 SMESH::RepaintCurrentView();
1662 int ActionToControl( int theID, bool theReversed )
1664 NCollection_DoubleMap<int,int> ActionControl;
1665 ActionControl.Bind( 0, SMESH_Actor::eNone );
1666 ActionControl.Bind( SMESHOp::OpFreeNode, SMESH_Actor::eFreeNodes );
1667 ActionControl.Bind( SMESHOp::OpEqualNode, SMESH_Actor::eCoincidentNodes );
1668 ActionControl.Bind( SMESHOp::OpNodeConnectivityNb, SMESH_Actor::eNodeConnectivityNb );
1669 ActionControl.Bind( SMESHOp::OpFreeEdge, SMESH_Actor::eFreeEdges );
1670 ActionControl.Bind( SMESHOp::OpFreeBorder, SMESH_Actor::eFreeBorders );
1671 ActionControl.Bind( SMESHOp::OpLength, SMESH_Actor::eLength );
1672 ActionControl.Bind( SMESHOp::OpConnection, SMESH_Actor::eMultiConnection );
1673 ActionControl.Bind( SMESHOp::OpEqualEdge, SMESH_Actor::eCoincidentElems1D );
1674 ActionControl.Bind( SMESHOp::OpFreeFace, SMESH_Actor::eFreeFaces );
1675 ActionControl.Bind( SMESHOp::OpBareBorderFace, SMESH_Actor::eBareBorderFace );
1676 ActionControl.Bind( SMESHOp::OpOverConstrainedFace, SMESH_Actor::eOverConstrainedFace );
1677 ActionControl.Bind( SMESHOp::OpLength2D, SMESH_Actor::eLength2D );
1678 ActionControl.Bind( SMESHOp::OpDeflection2D, SMESH_Actor::eDeflection2D );
1679 ActionControl.Bind( SMESHOp::OpConnection2D, SMESH_Actor::eMultiConnection2D );
1680 ActionControl.Bind( SMESHOp::OpArea, SMESH_Actor::eArea );
1681 ActionControl.Bind( SMESHOp::OpTaper, SMESH_Actor::eTaper );
1682 ActionControl.Bind( SMESHOp::OpAspectRatio, SMESH_Actor::eAspectRatio );
1683 ActionControl.Bind( SMESHOp::OpMinimumAngle, SMESH_Actor::eMinimumAngle );
1684 ActionControl.Bind( SMESHOp::OpWarpingAngle, SMESH_Actor::eWarping );
1685 ActionControl.Bind( SMESHOp::OpSkew, SMESH_Actor::eSkew );
1686 ActionControl.Bind( SMESHOp::OpMaxElementLength2D, SMESH_Actor::eMaxElementLength2D );
1687 ActionControl.Bind( SMESHOp::OpEqualFace, SMESH_Actor::eCoincidentElems2D );
1688 ActionControl.Bind( SMESHOp::OpAspectRatio3D, SMESH_Actor::eAspectRatio3D );
1689 ActionControl.Bind( SMESHOp::OpVolume, SMESH_Actor::eVolume3D );
1690 ActionControl.Bind( SMESHOp::OpMaxElementLength3D, SMESH_Actor::eMaxElementLength3D );
1691 ActionControl.Bind( SMESHOp::OpBareBorderVolume, SMESH_Actor::eBareBorderVolume );
1692 ActionControl.Bind( SMESHOp::OpOverConstrainedVolume, SMESH_Actor::eOverConstrainedVolume );
1693 ActionControl.Bind( SMESHOp::OpEqualVolume, SMESH_Actor::eCoincidentElems3D );
1695 return theReversed ? ActionControl.Find2( theID ) : ActionControl.Find1( theID );
1698 void Control( int theCommandID )
1700 SMESH_Actor::eControl aControl = SMESH_Actor::eControl( ActionToControl( theCommandID ));
1701 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1703 SALOME_ListIO selected;
1704 if ( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
1705 aSel->selectedObjects( selected );
1707 if ( !selected.IsEmpty() ) {
1708 SALOME_ListIteratorOfListIO It(selected);
1709 for ( ; It.More(); It.Next())
1711 Handle(SALOME_InteractiveObject) anIO = It.Value();
1712 if ( !anIO.IsNull() ) {
1713 _PTR(SObject) SO = aStudy->FindObjectID( It.Value()->getEntry() );
1715 CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
1716 SMESH::SMESH_IDSource_var anIDSrc = SMESH::SMESH_IDSource::_narrow( aObject );
1717 if ( !anIDSrc->_is_nil() ) {
1718 SMESH_Actor *anActor = SMESH::FindActorByEntry( anIO->getEntry());
1719 if (( !anActor && selected.Extent() == 1 ) &&
1720 ( anActor = SMESH::CreateActor( aStudy, anIO->getEntry() )))
1722 anActor->SetControlMode( aControl );
1723 SMESH::DisplayActor( SMESH::GetCurrentVtkView(), anActor );
1724 SMESH::UpdateView ( SMESH::eDisplay, anIO->getEntry() );
1728 if ( anActor->GetControlMode() != aControl )
1729 anActor->SetControlMode( aControl );
1730 QString functorName = functorToString( anActor->GetFunctor() );
1731 int anEntitiesCount = anActor->GetNumberControlEntities();
1732 if (anEntitiesCount >= 0)
1733 functorName = functorName + ": " + QString::number(anEntitiesCount);
1734 anActor->GetScalarBarActor()->SetTitle( functorName.toLatin1().constData() );
1735 SMESH::RepaintCurrentView();
1736 #ifndef DISABLE_PLOT2DVIEWER
1737 if ( anActor->GetPlot2Histogram() ) {
1738 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1739 QString aHistogramName("%1 : %2");
1740 aHistogramName = aHistogramName.arg( anIO->getName() ).arg( functorName );
1741 aHistogram->setName( aHistogramName );
1742 aHistogram->setHorTitle( functorName );
1743 SMESH::ProcessIn2DViewers( anActor );
1755 bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1756 SMESH::MeshObjectType theType,
1757 const QString theInTypeName,
1758 QString & theOutTypeName)
1760 SMESH_TypeFilter aTypeFilter( theType );
1762 if ( !theIO.IsNull() )
1764 entry = theIO->getEntry();
1765 LightApp_DataOwner owner( entry );
1766 if ( aTypeFilter.isOk( &owner )) {
1767 theOutTypeName = theInTypeName;
1775 QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1777 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1778 _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1780 _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1781 CORBA::String_var anID = aSComp->GetID().c_str();
1782 if ( !strcmp(anID.in(),theIO->getEntry()) )
1788 CheckOIType ( theIO, SMESH::HYPOTHESIS, "Hypothesis", aTypeName ) ||
1789 CheckOIType ( theIO, SMESH::ALGORITHM, "Algorithm", aTypeName ) ||
1790 CheckOIType ( theIO, SMESH::MESH, "Mesh", aTypeName ) ||
1791 CheckOIType ( theIO, SMESH::SUBMESH, "SubMesh", aTypeName ) ||
1792 CheckOIType ( theIO, SMESH::GROUP, "Group", aTypeName )
1800 // QString CheckHomogeneousSelection()
1802 // LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1803 // SALOME_ListIO selected;
1805 // aSel->selectedObjects( selected );
1807 // QString RefType = CheckTypeObject(selected.First());
1808 // SALOME_ListIteratorOfListIO It(selected);
1809 // for ( ; It.More(); It.Next())
1811 // Handle(SALOME_InteractiveObject) IObject = It.Value();
1812 // QString Type = CheckTypeObject(IObject);
1813 // if ( Type.compare(RefType) != 0 )
1814 // return "Heterogeneous Selection";
1820 uint randomize( uint size )
1822 static bool initialized = false;
1823 if ( !initialized ) {
1824 qsrand( QDateTime::currentDateTime().toTime_t() );
1828 v = uint( (double)( v ) / RAND_MAX * size );
1829 v = qMax( uint(0), qMin ( v, size-1 ) );
1835 void SMESHGUI::OnEditDelete()
1837 // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1838 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1839 SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1841 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1842 _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1843 _PTR(GenericAttribute) anAttr;
1844 _PTR(AttributeIOR) anIOR;
1846 int objectCount = 0;
1848 QString aParentComponent = QString::null;
1849 Handle(SALOME_InteractiveObject) anIO;
1850 for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1852 anIO = anIt.Value();
1853 QString cur = anIO->getComponentDataType();
1854 _PTR(SObject) aSO = aStudy->FindObjectID(anIO->getEntry());
1856 // check if object is reference
1857 _PTR(SObject) aRefSObj;
1858 aNameList.append("\n - ");
1859 if ( aSO->ReferencedObject( aRefSObj ) ) {
1860 QString aRefName = QString::fromStdString ( aRefSObj->GetName() );
1861 aNameList.append( aRefName );
1862 cur = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1865 aNameList.append(anIO->getName());
1869 if( aParentComponent.isNull() )
1870 aParentComponent = cur;
1871 else if( !aParentComponent.isEmpty() && aParentComponent!=cur )
1872 aParentComponent = "";
1875 if ( objectCount == 0 )
1876 return; // No Valid Objects Selected
1878 if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
1879 SUIT_MessageBox::warning( SMESHGUI::desktop(),
1880 QObject::tr("ERR_ERROR"),
1881 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
1884 // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
1885 if (SUIT_MessageBox::warning
1886 (SMESHGUI::desktop(),
1887 QObject::tr("SMESH_WRN_WARNING"),
1888 QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
1889 SUIT_MessageBox::Yes | SUIT_MessageBox::No,
1890 SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
1893 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1895 // Put the whole hierarchy of sub-objects of the selected SO's into a list and
1896 // then treat them all starting from the deepest objects (at list back)
1897 std::list< _PTR(SObject) > listSO;
1898 SALOME_ListIteratorOfListIO It(selected);
1899 for( ; It.More(); It.Next()) // loop on selected IO's
1901 Handle(SALOME_InteractiveObject) IObject = It.Value();
1902 if(IObject->hasEntry()) {
1903 _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
1905 // disable removal of "SMESH" component object
1906 if(aSO->FindAttribute(anAttr, "AttributeIOR")){
1908 if ( engineIOR() == anIOR->Value().c_str() )
1911 //Check the referenced object
1912 _PTR(SObject) aRefSObject;
1913 if ( aSO && aSO->ReferencedObject( aRefSObject ) )
1914 aSO = aRefSObject; // Delete main Object instead of reference
1916 listSO.push_back( aSO );
1917 std::list< _PTR(SObject) >::iterator itSO = --listSO.end();
1918 for ( ; itSO != listSO.end(); ++itSO ) {
1919 _PTR(ChildIterator) it = aStudy->NewChildIterator( *itSO );
1920 for (it->InitEx(false); it->More(); it->Next())
1921 listSO.push_back( it->Value() );
1925 // Check if none of objects to delete is referred from outside
1926 std::list< _PTR(SObject) >::reverse_iterator ritSO;
1927 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1929 _PTR(SObject) SO = *ritSO;
1930 if ( !SO ) continue;
1931 std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( *ritSO );
1932 for (size_t i = 0; i < aReferences.size(); i++) {
1933 _PTR(SComponent) aComponent = aReferences[i]->GetFatherComponent();
1934 std::string type = aComponent->ComponentDataType();
1935 if ( type != "SMESH" )
1937 SUIT_MessageBox::warning( anApp->desktop(),
1938 QObject::tr("WRN_WARNING"),
1939 QObject::tr("DEP_OBJECT") );
1940 return; // outside SMESH, there is an object depending on a SMESH object
1945 // Call mesh->Clear() to prevent loading mesh from file caused by hypotheses removal
1946 for( It.Initialize( selected ); It.More(); It.Next()) // loop on selected IO's
1948 Handle(SALOME_InteractiveObject) IObject = It.Value();
1949 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface< SMESH::SMESH_Mesh >( IObject );
1950 if ( !mesh->_is_nil() )
1954 // Treat SO's in the list starting from the back
1955 aStudyBuilder->NewCommand(); // There is a transaction
1956 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1958 _PTR(SObject) SO = *ritSO;
1959 if ( !SO ) continue;
1960 std::string anEntry = SO->GetID();
1962 /** Erase graphical object and remove all its data **/
1963 if(SO->FindAttribute(anAttr, "AttributeIOR")) {
1964 SMESH::RemoveVisualObjectWithActors( anEntry.c_str(), true);
1966 /** Remove an object from data structures **/
1967 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
1968 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
1969 if ( !aGroup->_is_nil() ) { // DELETE GROUP
1970 SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
1971 aMesh->RemoveGroup( aGroup );
1973 else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
1974 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
1975 aMesh->RemoveSubMesh( aSubMesh );
1977 _PTR(SObject) aMeshSO = SMESH::FindSObject(aMesh);
1979 SMESH::ModifiedMesh(aMeshSO, false, aMesh->NbNodes()==0);
1982 Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
1983 ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
1984 QString objType = CheckTypeObject(IObject);
1985 if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
1986 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
1987 aStudyBuilder->RemoveObjectWithChildren( SO );
1989 else {// default action: remove SObject from the study
1990 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
1991 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
1993 aStudyBuilder->RemoveObjectWithChildren( SO );
1997 } /* listSO back loop */
1999 aStudyBuilder->CommitCommand();
2001 /* Clear any previous selection */
2003 aSel->setSelectedObjects( l1 );
2005 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
2009 SMESHGUI_EXPORT CAM_Module* createModule()
2011 return new SMESHGUI();
2014 SMESHGUI_EXPORT char* getModuleVersion() {
2015 return (char*)SMESH_VERSION_STR;
2019 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
2021 //=============================================================================
2025 //=============================================================================
2026 SMESHGUI::SMESHGUI() :
2027 SalomeApp_Module( "SMESH" )
2029 if ( CORBA::is_nil( myComponentSMESH ) )
2031 CORBA::Boolean anIsEmbeddedMode;
2032 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
2033 //MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
2035 // 0019923: EDF 765 SMESH : default values of hypothesis
2036 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
2037 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
2038 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
2039 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
2040 myComponentSMESH->SetDefaultNbSegments( nbSeg );
2042 const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif", "default_grp_color" };
2043 for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
2044 if ( aResourceMgr->hasValue( "SMESH", options[i] ))
2046 QString val = aResourceMgr->stringValue( "SMESH", options[i] );
2047 myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
2051 myActiveDialogBox = 0;
2052 myFilterLibraryDlg = 0;
2056 myEventCallbackCommand = vtkCallbackCommand::New();
2057 myEventCallbackCommand->Delete();
2058 myEventCallbackCommand->SetClientData( this );
2059 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
2062 /* load resources for all available meshers */
2063 SMESH::InitAvailableHypotheses();
2066 //=============================================================================
2070 //=============================================================================
2071 SMESHGUI::~SMESHGUI()
2075 //=============================================================================
2079 //=============================================================================
2080 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
2082 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2084 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
2089 //=============================================================================
2093 //=============================================================================
2094 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
2096 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2100 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2101 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2102 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2103 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2104 return autoUpdate && !exceeded;
2107 //=============================================================================
2111 //=============================================================================
2112 bool SMESHGUI::automaticUpdate( SMESH::SMESH_IDSource_ptr theMesh,
2113 int* entities, bool* limitExceeded, int* hidden, long* nbElements )
2115 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2119 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2120 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2121 bool incrementalLimit = resMgr->booleanValue( "SMESH", "incremental_limit", false );
2123 SMESH::long_array_var info = theMesh->GetMeshInfo();
2124 long nbOdElems = info[SMDSEntity_0D];
2125 long nbEdges = info[SMDSEntity_Edge] + info[SMDSEntity_Quad_Edge];
2126 long nbFaces = info[SMDSEntity_Triangle] + info[SMDSEntity_Quad_Triangle] + info[SMDSEntity_BiQuad_Triangle] +
2127 info[SMDSEntity_Quadrangle] + info[SMDSEntity_Quad_Quadrangle] + info[SMDSEntity_BiQuad_Quadrangle] +
2128 info[SMDSEntity_Polygon] + info[SMDSEntity_Quad_Polygon];
2129 long nbVolumes = info[SMDSEntity_Tetra] + info[SMDSEntity_Quad_Tetra] +
2130 info[SMDSEntity_Hexa] + info[SMDSEntity_Quad_Hexa] + info[SMDSEntity_TriQuad_Hexa] +
2131 info[SMDSEntity_Pyramid] + info[SMDSEntity_Quad_Pyramid] +
2132 info[SMDSEntity_Penta] + info[SMDSEntity_Quad_Penta] + info[SMDSEntity_BiQuad_Penta] +
2133 info[SMDSEntity_Polyhedra] +
2134 info[SMDSEntity_Hexagonal_Prism];
2135 long nbBalls = info[SMDSEntity_Ball];
2137 long requestedSize = nbOdElems + nbBalls + nbEdges + nbFaces + nbVolumes;
2138 *nbElements = requestedSize;
2140 *entities = SMESH_Actor::eAllEntity;
2143 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2145 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2147 if ( incrementalLimit ) {
2150 if ( nbOdElems > 0 ) {
2151 if ( total + nbOdElems > updateLimit ) {
2152 *entities = *entities & ~SMESH_Actor::e0DElements;
2153 *hidden = *hidden | SMESH_Actor::e0DElements;
2160 if ( nbEdges > 0 ) {
2161 if ( total + nbEdges > updateLimit ) {
2162 *entities = *entities & ~SMESH_Actor::eEdges;
2163 *hidden = *hidden | SMESH_Actor::eEdges;
2170 if ( nbFaces > 0 ) {
2171 if ( total + nbFaces > updateLimit ) {
2172 *entities = *entities & ~SMESH_Actor::eFaces;
2173 *hidden = *hidden | SMESH_Actor::eFaces;
2180 if ( nbVolumes > 0 ) {
2181 if ( total + nbVolumes > updateLimit ) {
2182 *entities = *entities & ~SMESH_Actor::eVolumes;
2183 *hidden = *hidden | SMESH_Actor::eVolumes;
2190 if ( nbBalls > 0 ) {
2191 if ( total + nbBalls > updateLimit ) {
2192 *entities = *entities & ~SMESH_Actor::eBallElem;
2193 *hidden = *hidden | SMESH_Actor::eBallElem;
2201 return autoUpdate && !exceeded;
2204 //=============================================================================
2208 //=============================================================================
2209 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
2211 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
2214 //=============================================================================
2218 //=============================================================================
2219 SMESHGUI* SMESHGUI::GetSMESHGUI()
2221 SMESHGUI* smeshMod = 0;
2222 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
2225 CAM_Module* module = app->module( "Mesh" );
2226 smeshMod = dynamic_cast<SMESHGUI*>( module );
2229 if ( smeshMod && smeshMod->application() && smeshMod->application()->activeStudy() )
2231 SalomeApp_Study* study = dynamic_cast<SalomeApp_Study*>( smeshMod->application()->activeStudy() );
2234 _PTR(Study) aStudy = study->studyDS();
2236 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
2245 Standard_EXPORT SMESHGUI* GetComponentGUI()
2247 return SMESHGUI::GetSMESHGUI();
2251 //=============================================================================
2255 //=============================================================================
2256 void SMESHGUI::SetState(int aState)
2261 //=============================================================================
2265 //=============================================================================
2266 void SMESHGUI::ResetState()
2271 //=============================================================================
2275 //=============================================================================
2276 void SMESHGUI::EmitSignalDeactivateDialog()
2278 emit SignalDeactivateActiveDialog();
2281 //=============================================================================
2285 //=============================================================================
2286 void SMESHGUI::EmitSignalStudyFrameChanged()
2288 emit SignalStudyFrameChanged();
2291 //=============================================================================
2295 //=============================================================================
2296 void SMESHGUI::EmitSignalCloseAllDialogs()
2298 emit SignalCloseAllDialogs();
2301 //=============================================================================
2305 //=============================================================================
2306 void SMESHGUI::EmitSignalVisibilityChanged()
2308 emit SignalVisibilityChanged();
2311 //=============================================================================
2315 //=============================================================================
2316 void SMESHGUI::EmitSignalCloseView()
2318 emit SignalCloseView();
2321 //=============================================================================
2325 //=============================================================================
2326 void SMESHGUI::EmitSignalActivatedViewManager()
2328 emit SignalActivatedViewManager();
2331 //=============================================================================
2335 //=============================================================================
2336 QDialog *SMESHGUI::GetActiveDialogBox()
2338 return myActiveDialogBox;
2341 //=============================================================================
2345 //=============================================================================
2346 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2348 myActiveDialogBox = (QDialog *) aDlg;
2352 //=============================================================================
2356 //=============================================================================
2357 SUIT_Desktop* SMESHGUI::desktop()
2359 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2361 return app->desktop();
2366 //=============================================================================
2370 //=============================================================================
2371 SalomeApp_Study* SMESHGUI::activeStudy()
2373 SUIT_Application* app = SUIT_Session::session()->activeApplication();
2375 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2380 //=============================================================================
2384 //=============================================================================
2385 void SMESHGUI::Modified( bool theIsUpdateActions )
2387 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2388 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2389 appStudy->Modified();
2390 if( theIsUpdateActions )
2391 app->updateActions();
2396 //=============================================================================
2400 //=============================================================================
2401 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2403 /* Here the position is on the bottom right corner - 10 */
2404 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2406 SUIT_Desktop *PP = desktop();
2407 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2408 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2412 //=============================================================================
2416 //=============================================================================
2417 static int isStudyLocked(_PTR(Study) theStudy){
2418 return theStudy->GetProperties()->IsLocked();
2421 static bool checkLock(_PTR(Study) theStudy) {
2422 if (isStudyLocked(theStudy)) {
2423 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2424 QObject::tr("WRN_WARNING"),
2425 QObject::tr("WRN_STUDY_LOCKED") );
2431 //=======================================================================
2432 //function : CheckActiveStudyLocked
2434 //=======================================================================
2436 bool SMESHGUI::isActiveStudyLocked()
2438 _PTR(Study) aStudy = activeStudy()->studyDS();
2439 return checkLock( aStudy );
2442 //=============================================================================
2446 //=============================================================================
2447 bool SMESHGUI::OnGUIEvent( int theCommandID )
2449 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2453 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
2454 SUIT_ResourceMgr* mgr = resourceMgr();
2458 if (CORBA::is_nil(GetSMESHGen()->GetCurrentStudy())) {
2459 GetSMESHGen()->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
2462 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2463 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2465 //QAction* act = action( theCommandID );
2467 switch (theCommandID) {
2468 case SMESHOp::OpDelete:
2469 if(checkLock(aStudy)) break;
2472 case SMESHOp::OpImportDAT:
2473 case SMESHOp::OpImportUNV:
2474 case SMESHOp::OpImportMED:
2475 case SMESHOp::OpImportSTL:
2476 case SMESHOp::OpImportCGNS:
2477 case SMESHOp::OpImportSAUV:
2478 case SMESHOp::OpImportGMF:
2479 case SMESHOp::OpPopupImportDAT:
2480 case SMESHOp::OpPopupImportUNV:
2481 case SMESHOp::OpPopupImportMED:
2482 case SMESHOp::OpPopupImportSTL:
2483 case SMESHOp::OpPopupImportCGNS:
2484 case SMESHOp::OpPopupImportSAUV:
2485 case SMESHOp::OpPopupImportGMF:
2487 if(checkLock(aStudy)) break;
2488 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2492 case SMESHOp::OpFileInformation:
2494 SALOME_ListIO selected;
2495 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2497 aSel->selectedObjects( selected );
2498 if( selected.Extent() )
2500 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2501 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2502 if ( !aMesh->_is_nil() )
2504 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2510 case SMESHOp::OpExportDAT:
2511 case SMESHOp::OpExportMED:
2512 case SMESHOp::OpExportUNV:
2513 case SMESHOp::OpExportSTL:
2514 case SMESHOp::OpExportCGNS:
2515 case SMESHOp::OpExportSAUV:
2516 case SMESHOp::OpExportGMF:
2517 case SMESHOp::OpPopupExportDAT:
2518 case SMESHOp::OpPopupExportMED:
2519 case SMESHOp::OpPopupExportUNV:
2520 case SMESHOp::OpPopupExportSTL:
2521 case SMESHOp::OpPopupExportCGNS:
2522 case SMESHOp::OpPopupExportSAUV:
2523 case SMESHOp::OpPopupExportGMF:
2525 ::ExportMeshToFile(theCommandID);
2529 case SMESHOp::OpReset: // SCALAR BAR
2531 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2532 SALOME_ListIO selected;
2534 aSel->selectedObjects( selected );
2536 SALOME_ListIteratorOfListIO it(selected);
2537 for( ; it.More(); it.Next()) {
2538 Handle(SALOME_InteractiveObject) anIO = it.Value();
2539 if( anIO->hasEntry() ) {
2540 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2541 anActor->SetControlMode( SMESH_Actor::eNone );
2542 #ifndef DISABLE_PLOT2DVIEWER
2543 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2548 SMESH::UpdateView();
2551 case SMESHOp::OpScalarBarProperties:
2553 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2556 case SMESHOp::OpShowScalarBar:
2558 // show/hide scalar bar
2559 ::ShowElement(theCommandID);
2562 case SMESHOp::OpSaveDistribution:
2564 // dump control distribution data to the text file
2565 ::SaveDistribution();
2569 case SMESHOp::OpShowDistribution:
2571 // show/hide distribution
2572 ::ShowElement(theCommandID);
2576 #ifndef DISABLE_PLOT2DVIEWER
2577 case SMESHOp::OpPlotDistribution:
2579 // plot distribution
2580 ::PlotDistribution();
2586 case SMESHOp::OpAutoColor:
2590 case SMESHOp::OpDisableAutoColor:
2591 ::DisableAutoColor();
2594 case SMESHOp::OpClipping:
2595 case SMESHOp::OpTransparency:
2596 case SMESHOp::OpProperties: // Display preferences (colors, shrink size, line width, ...)
2599 case SMESHOp::OpDMWireframe:
2600 case SMESHOp::OpDMShading:
2601 case SMESHOp::OpDMNodes:
2602 case SMESHOp::OpDMShrink:
2603 ::SetDisplayMode(theCommandID, myMarkerMap);
2606 //2D quadratic representation
2607 case SMESHOp::OpRepresentationLines:
2608 case SMESHOp::OpRepresentationArcs:
2609 ::SetDisplayMode(theCommandID, myMarkerMap);
2613 case SMESHOp::OpDE0DElements:
2614 case SMESHOp::OpDEEdges:
2615 case SMESHOp::OpDEFaces:
2616 case SMESHOp::OpDEVolumes:
2617 case SMESHOp::OpDEBalls:
2618 case SMESHOp::OpDEAllEntity:
2619 ::SetDisplayEntity(theCommandID);
2622 // Choose entities to be displayed
2623 case SMESHOp::OpDEChoose:
2625 ( new SMESHGUI_DisplayEntitiesDlg( SMESHGUI::desktop() ) )->exec();
2629 case SMESHOp::OpOrientationOnFaces:
2631 SUIT_OverrideCursor wc;
2632 LightApp_SelectionMgr* mgr = selectionMgr();
2633 SALOME_ListIO selected; mgr->selectedObjects( selected );
2635 SALOME_ListIteratorOfListIO it(selected);
2636 for( ; it.More(); it.Next()) {
2637 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2638 if(anIObject->hasEntry()) {
2639 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2640 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2647 case SMESHOp::OpUpdate:
2649 if(checkLock(aStudy)) break;
2650 SUIT_OverrideCursor wc;
2652 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2655 SMESH::UpdateView();
2657 catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2658 SMESH::OnVisuException();
2660 catch (...) { // PAL16774 (Crash after display of many groups)
2661 SMESH::OnVisuException();
2665 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2666 aSel->selectedObjects( l );
2667 aSel->setSelectedObjects( l );
2671 case SMESHOp::OpHide:
2672 case SMESHOp::OpShow:
2673 case SMESHOp::OpShowOnly:
2675 SUIT_OverrideCursor wc;
2676 SMESH::EDisplaing anAction;
2677 switch (theCommandID) {
2678 case SMESHOp::OpHide: anAction = SMESH::eErase; break;
2679 case SMESHOp::OpShow: anAction = SMESH::eDisplay; break;
2680 case SMESHOp::OpShowOnly: anAction = SMESH::eDisplayOnly; break;
2683 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2684 SALOME_ListIO sel_objects, to_process;
2686 aSel->selectedObjects( sel_objects );
2688 if ( theCommandID==SMESHOp::OpShowOnly )
2690 //MESSAGE("anAction = SMESH::eDisplayOnly");
2691 startOperation( myEraseAll );
2694 extractContainers( sel_objects, to_process );
2699 SALOME_ListIteratorOfListIO It( to_process );
2700 for ( ; It.More(); It.Next())
2702 Handle(SALOME_InteractiveObject) IOS = It.Value();
2703 if ( IOS->hasEntry() )
2705 if ( !SMESH::UpdateView( anAction, IOS->getEntry() )) {
2706 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2707 break; // PAL16774 (Crash after display of many groups)
2709 if (anAction == SMESH::eDisplayOnly)
2710 anAction = SMESH::eDisplay;
2715 // PAL13338 + PAL15161 -->
2716 if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !checkLock(aStudy)) {
2717 SMESH::UpdateView();
2718 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2720 // PAL13338 + PAL15161 <--
2722 catch (...) { // PAL16774 (Crash after display of many groups)
2723 SMESH::OnVisuException();
2726 if (anAction == SMESH::eErase) {
2728 aSel->setSelectedObjects( l1 );
2731 aSel->setSelectedObjects( to_process );
2736 case SMESHOp::OpNode:
2738 if(checkLock(aStudy)) break;
2741 EmitSignalDeactivateDialog();
2743 ( new SMESHGUI_NodesDlg( this ) )->show();
2746 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"),tr("SMESH_WRN_VIEWER_VTK"));
2751 case SMESHOp::OpCreateMesh:
2752 case SMESHOp::OpCreateSubMesh:
2753 case SMESHOp::OpEditMeshOrSubMesh:
2754 case SMESHOp::OpEditMesh:
2755 case SMESHOp::OpEditSubMesh:
2756 case SMESHOp::OpCompute:
2757 case SMESHOp::OpComputeSubMesh:
2758 case SMESHOp::OpPreCompute:
2759 case SMESHOp::OpEvaluate:
2760 case SMESHOp::OpMeshOrder:
2761 startOperation( theCommandID );
2763 case SMESHOp::OpCopyMesh:
2765 if (checkLock(aStudy)) break;
2766 EmitSignalDeactivateDialog();
2767 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2770 case SMESHOp::OpBuildCompoundMesh:
2772 if (checkLock(aStudy)) break;
2773 EmitSignalDeactivateDialog();
2774 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2778 case SMESHOp::OpDiagonalInversion:
2779 case SMESHOp::OpUnionOfTwoTriangle:
2783 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2787 if ( checkLock( aStudy ) )
2790 /*Standard_Boolean aRes;
2791 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2792 if ( aMesh->_is_nil() )
2794 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2795 tr( "SMESH_BAD_SELECTION" ) );
2799 EmitSignalDeactivateDialog();
2800 if ( theCommandID == SMESHOp::OpDiagonalInversion )
2801 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2803 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2806 case SMESHOp::OpOrientation:
2807 case SMESHOp::OpUnionOfTriangles:
2808 case SMESHOp::OpCuttingOfQuadrangles:
2809 case SMESHOp::OpSplitVolumes:
2813 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2817 if ( checkLock( aStudy ) )
2820 EmitSignalDeactivateDialog();
2821 SMESHGUI_MultiEditDlg* aDlg = NULL;
2822 if ( theCommandID == SMESHOp::OpOrientation )
2823 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2824 else if ( theCommandID == SMESHOp::OpUnionOfTriangles )
2825 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2826 else if ( theCommandID == SMESHOp::OpSplitVolumes )
2827 aDlg = new SMESHGUI_SplitVolumesDlg(this);
2829 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2834 case SMESHOp::OpSmoothing:
2836 if(checkLock(aStudy)) break;
2838 EmitSignalDeactivateDialog();
2839 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2842 SUIT_MessageBox::warning(desktop(), tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2846 case SMESHOp::OpExtrusion:
2848 if (checkLock(aStudy)) break;
2850 EmitSignalDeactivateDialog();
2851 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2853 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2857 case SMESHOp::OpExtrusionAlongAPath:
2859 if (checkLock(aStudy)) break;
2861 EmitSignalDeactivateDialog();
2862 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2864 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2868 case SMESHOp::OpRevolution:
2870 if(checkLock(aStudy)) break;
2872 EmitSignalDeactivateDialog();
2873 ( new SMESHGUI_RevolutionDlg( this ) )->show();
2876 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2880 case SMESHOp::OpPatternMapping:
2882 if ( checkLock( aStudy ) )
2886 EmitSignalDeactivateDialog();
2887 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2890 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2894 case SMESHOp::OpSplitBiQuadratic:
2895 case SMESHOp::OpConvertMeshToQuadratic:
2896 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
2897 case SMESHOp::OpReorientFaces:
2898 case SMESHOp::OpCreateGeometryGroup:
2900 startOperation( theCommandID );
2903 case SMESHOp::OpCreateGroup:
2907 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2911 if(checkLock(aStudy)) break;
2912 EmitSignalDeactivateDialog();
2913 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2915 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2916 SALOME_ListIO selected;
2918 aSel->selectedObjects( selected );
2920 int nbSel = selected.Extent();
2922 // check if mesh is selected
2923 aMesh = SMESH::GetMeshByIO( selected.First() );
2925 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2930 case SMESHOp::OpConstructGroup:
2934 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2938 if(checkLock(aStudy)) break;
2939 EmitSignalDeactivateDialog();
2941 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2942 SALOME_ListIO selected;
2944 aSel->selectedObjects( selected );
2946 int nbSel = selected.Extent();
2948 // check if submesh is selected
2949 Handle(SALOME_InteractiveObject) IObject = selected.First();
2950 if (IObject->hasEntry()) {
2951 _PTR(SObject) aSObj = aStudy->FindObjectID(IObject->getEntry());
2953 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2954 if (!aSubMesh->_is_nil()) {
2956 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2957 // get submesh elements list by types
2958 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2959 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2960 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2961 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2962 // create group for each type o elements
2963 QString aName = IObject->getName();
2964 QStringList anEntryList;
2965 if (aNodes->length() > 0) {
2966 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2967 aGroup->Add(aNodes.inout());
2968 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2969 anEntryList.append( aSObject->GetID().c_str() );
2971 if (aEdges->length() > 0) {
2972 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2973 aGroup->Add(aEdges.inout());
2974 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2975 anEntryList.append( aSObject->GetID().c_str() );
2977 if (aFaces->length() > 0) {
2978 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2979 aGroup->Add(aFaces.inout());
2980 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2981 anEntryList.append( aSObject->GetID().c_str() );
2983 if (aVolumes->length() > 0) {
2984 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2985 aGroup->Add(aVolumes.inout());
2986 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2987 anEntryList.append( aSObject->GetID().c_str() );
2990 anApp->browseObjects( anEntryList );
2992 catch(const SALOME::SALOME_Exception & S_ex){
2993 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3000 SUIT_MessageBox::warning(desktop(),
3001 tr("SMESH_WRN_WARNING"),
3002 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
3007 case SMESHOp::OpEditGroup:
3011 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3015 if(checkLock(aStudy)) break;
3016 EmitSignalDeactivateDialog();
3018 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3019 SALOME_ListIO selected;
3021 aSel->selectedObjects( selected );
3023 SALOME_ListIteratorOfListIO It (selected);
3024 int nbSelectedGroups = 0;
3025 for ( ; It.More(); It.Next() )
3027 SMESH::SMESH_GroupBase_var aGroup =
3028 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
3029 if (!aGroup->_is_nil()) {
3031 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
3035 if (nbSelectedGroups == 0)
3037 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
3043 case SMESHOp::OpAddElemGroupPopup: // Add elements to group
3045 if(checkLock(aStudy)) break;
3046 if (myState == 800) {
3047 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3048 if (aDlg) aDlg->onAdd();
3053 case SMESHOp::OpRemoveElemGroupPopup: // Remove elements from group
3055 if(checkLock(aStudy)) break;
3056 if (myState == 800) {
3057 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3058 if (aDlg) aDlg->onRemove();
3063 case SMESHOp::OpEditGeomGroupAsGroup:
3067 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3071 if(checkLock(aStudy)) break;
3072 EmitSignalDeactivateDialog();
3074 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3075 SALOME_ListIO selected;
3077 aSel->selectedObjects( selected );
3079 SALOME_ListIteratorOfListIO It (selected);
3080 for ( ; It.More(); It.Next() )
3082 SMESH::SMESH_GroupOnGeom_var aGroup =
3083 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
3084 if (!aGroup->_is_nil()) {
3085 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3090 SMESH::SMESH_GroupOnFilter_var aGroup =
3091 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
3092 if (!aGroup->_is_nil()) {
3093 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3101 case SMESHOp::OpUnionGroups:
3102 case SMESHOp::OpIntersectGroups:
3103 case SMESHOp::OpCutGroups:
3107 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3111 if ( checkLock( aStudy ) )
3114 EmitSignalDeactivateDialog();
3116 SMESHGUI_GroupOpDlg* aDlg = 0;
3117 if ( theCommandID == SMESHOp::OpUnionGroups )
3118 aDlg = new SMESHGUI_UnionGroupsDlg( this );
3119 else if ( theCommandID == SMESHOp::OpIntersectGroups )
3120 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3122 aDlg = new SMESHGUI_CutGroupsDlg( this );
3129 case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
3131 if ( checkLock( aStudy ) )
3134 EmitSignalDeactivateDialog();
3135 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3141 case SMESHOp::OpDeleteGroup: // Delete groups with their contents
3145 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3149 if ( checkLock( aStudy ) )
3152 EmitSignalDeactivateDialog();
3154 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3158 case SMESHOp::OpMeshInformation:
3159 case SMESHOp::OpWhatIs:
3161 int page = theCommandID == SMESHOp::OpMeshInformation ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3162 EmitSignalDeactivateDialog();
3163 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3164 SALOME_ListIO selected;
3166 aSel->selectedObjects( selected );
3168 if ( selected.Extent() > 1 ) { // a dlg for each IO
3169 SALOME_ListIteratorOfListIO It( selected );
3170 for ( ; It.More(); It.Next() ) {
3171 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3172 dlg->showInfo( It.Value() );
3177 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3183 case SMESHOp::OpFindElementByPoint:
3185 startOperation( theCommandID );
3189 case SMESHOp::OpEditHypothesis:
3191 if(checkLock(aStudy)) break;
3193 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3194 SALOME_ListIO selected;
3196 aSel->selectedObjects( selected );
3198 int nbSel = selected.Extent();
3201 Handle(SALOME_InteractiveObject) anIObject = selected.First();
3202 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3204 if ( !aHypothesis->_is_nil() )
3206 SMESHGUI_GenericHypothesisCreator* aCreator =
3207 SMESH::GetHypothesisCreator( SMESH::toQStr( aHypothesis->GetName() ));
3210 // set geometry of mesh and sub-mesh to aCreator
3211 aSel->selectedObjects( selected, "", /*convertReferences=*/false);
3212 if ( selected.Extent() == 1 )
3214 QString subGeomID, meshGeomID;
3215 Handle(SALOME_InteractiveObject) hypIO = selected.First();
3216 if ( SMESH::GetGeomEntries( hypIO, subGeomID, meshGeomID ))
3218 if ( subGeomID.isEmpty() ) subGeomID = meshGeomID;
3219 aCreator->setShapeEntry( subGeomID );
3220 aCreator->setMainShapeEntry( meshGeomID );
3224 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3234 case SMESHOp::OpUnassign: // REMOVE HYPOTHESIS / ALGORITHMS
3236 if(checkLock(aStudy)) break;
3237 SUIT_OverrideCursor wc;
3239 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3240 SALOME_ListIO selected;
3242 aSel->selectedObjects( selected, QString::null, false );
3244 SALOME_ListIteratorOfListIO It(selected);
3245 for (int i = 0; It.More(); It.Next(), i++) {
3246 Handle(SALOME_InteractiveObject) IObject = It.Value();
3247 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3250 aSel->setSelectedObjects( l1 );
3255 case SMESHOp::OpElem0D:
3256 case SMESHOp::OpBall:
3257 case SMESHOp::OpEdge:
3258 case SMESHOp::OpTriangle:
3259 case SMESHOp::OpQuadrangle:
3260 case SMESHOp::OpPolygon:
3261 case SMESHOp::OpTetrahedron:
3262 case SMESHOp::OpHexahedron:
3263 case SMESHOp::OpPentahedron:
3264 case SMESHOp::OpPyramid:
3265 case SMESHOp::OpHexagonalPrism:
3267 if(checkLock(aStudy)) break;
3269 EmitSignalDeactivateDialog();
3270 SMDSAbs_EntityType type = SMDSEntity_Edge;
3271 switch (theCommandID) {
3272 case SMESHOp::OpElem0D: type = SMDSEntity_0D; break;
3273 case SMESHOp::OpBall: type = SMDSEntity_Ball; break;
3274 case SMESHOp::OpTriangle: type = SMDSEntity_Triangle; break;
3275 case SMESHOp::OpQuadrangle: type = SMDSEntity_Quadrangle; break;
3276 case SMESHOp::OpTetrahedron: type = SMDSEntity_Tetra; break;
3277 case SMESHOp::OpPolygon: type = SMDSEntity_Polygon; break;
3278 case SMESHOp::OpHexahedron: type = SMDSEntity_Hexa; break;
3279 case SMESHOp::OpPentahedron: type = SMDSEntity_Penta; break;
3280 case SMESHOp::OpPyramid: type = SMDSEntity_Pyramid; break;
3281 case SMESHOp::OpHexagonalPrism: type = SMDSEntity_Hexagonal_Prism; break;
3284 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3287 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3291 case SMESHOp::OpPolyhedron:
3293 if(checkLock(aStudy)) break;
3295 EmitSignalDeactivateDialog();
3296 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3299 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3303 case SMESHOp::OpQuadraticEdge:
3304 case SMESHOp::OpQuadraticTriangle:
3305 case SMESHOp::OpBiQuadraticTriangle:
3306 case SMESHOp::OpQuadraticQuadrangle:
3307 case SMESHOp::OpBiQuadraticQuadrangle:
3308 case SMESHOp::OpQuadraticPolygon:
3309 case SMESHOp::OpQuadraticTetrahedron:
3310 case SMESHOp::OpQuadraticPyramid:
3311 case SMESHOp::OpQuadraticPentahedron:
3312 case SMESHOp::OpBiQuadraticPentahedron:
3313 case SMESHOp::OpQuadraticHexahedron:
3314 case SMESHOp::OpTriQuadraticHexahedron:
3316 if(checkLock(aStudy)) break;
3318 EmitSignalDeactivateDialog();
3319 SMDSAbs_EntityType type = SMDSEntity_Last;
3321 switch (theCommandID) {
3322 case SMESHOp::OpQuadraticEdge: type = SMDSEntity_Quad_Edge; break;
3323 case SMESHOp::OpQuadraticTriangle: type = SMDSEntity_Quad_Triangle; break;
3324 case SMESHOp::OpBiQuadraticTriangle: type = SMDSEntity_BiQuad_Triangle; break;
3325 case SMESHOp::OpQuadraticQuadrangle: type = SMDSEntity_Quad_Quadrangle; break;
3326 case SMESHOp::OpBiQuadraticQuadrangle: type = SMDSEntity_BiQuad_Quadrangle; break;
3327 case SMESHOp::OpQuadraticPolygon: type = SMDSEntity_Quad_Polygon; break;
3328 case SMESHOp::OpQuadraticTetrahedron: type = SMDSEntity_Quad_Tetra; break;
3329 case SMESHOp::OpQuadraticPyramid: type = SMDSEntity_Quad_Pyramid; break;
3330 case SMESHOp::OpQuadraticPentahedron: type = SMDSEntity_Quad_Penta; break;
3331 case SMESHOp::OpBiQuadraticPentahedron: type = SMDSEntity_BiQuad_Penta; break;
3332 case SMESHOp::OpQuadraticHexahedron: type = SMDSEntity_Quad_Hexa; break;
3333 case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
3336 if ( type != SMDSEntity_Last )
3337 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3340 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3341 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3345 case SMESHOp::OpRemoveNodes:
3347 if(checkLock(aStudy)) break;
3349 EmitSignalDeactivateDialog();
3350 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3353 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3354 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3358 case SMESHOp::OpRemoveElements: // REMOVES ELEMENTS
3360 if(checkLock(aStudy)) break;
3362 EmitSignalDeactivateDialog();
3363 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3367 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3368 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3372 case SMESHOp::OpClearMesh: {
3374 if(checkLock(aStudy)) break;
3376 SALOME_ListIO selected;
3377 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3378 aSel->selectedObjects( selected );
3380 SUIT_OverrideCursor wc;
3381 SALOME_ListIteratorOfListIO It (selected);
3382 for ( ; It.More(); It.Next() )
3384 Handle(SALOME_InteractiveObject) IOS = It.Value();
3385 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3386 if ( aMesh->_is_nil()) continue;
3389 if ( aMesh->NbNodes() == 0 ) // imported mesh is not empty
3390 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3391 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3392 SMESH::ModifiedMesh( aMeshSObj, false, true);
3393 // hide groups and submeshes
3394 _PTR(ChildIterator) anIter =
3395 SMESH::GetActiveStudyDocument()->NewChildIterator( aMeshSObj );
3396 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3398 _PTR(SObject) so = anIter->Value();
3399 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3402 catch (const SALOME::SALOME_Exception& S_ex){
3404 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3408 SMESH::UpdateView();
3412 case SMESHOp::OpRemoveOrphanNodes:
3414 if(checkLock(aStudy)) break;
3415 SALOME_ListIO selected;
3416 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3417 aSel->selectedObjects( selected );
3418 if ( selected.Extent() == 1 ) {
3419 Handle(SALOME_InteractiveObject) anIO = selected.First();
3420 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3421 if ( !aMesh->_is_nil() ) {
3422 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3423 tr( "SMESH_WARNING" ),
3424 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3425 SUIT_MessageBox::Yes |
3426 SUIT_MessageBox::No,
3427 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3430 SUIT_OverrideCursor wc;
3431 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3432 int removed = aMeshEditor->RemoveOrphanNodes();
3433 SUIT_MessageBox::information(SMESHGUI::desktop(),
3434 tr("SMESH_INFORMATION"),
3435 tr("NB_NODES_REMOVED").arg(removed));
3436 if ( removed > 0 ) {
3437 SMESH::UpdateView();
3438 SMESHGUI::Modified();
3441 catch (const SALOME::SALOME_Exception& S_ex) {
3442 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3451 case SMESHOp::OpRenumberingNodes:
3453 if(checkLock(aStudy)) break;
3455 EmitSignalDeactivateDialog();
3456 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3460 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3461 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3465 case SMESHOp::OpRenumberingElements:
3467 if(checkLock(aStudy)) break;
3469 EmitSignalDeactivateDialog();
3470 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3474 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3475 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3479 case SMESHOp::OpTranslation:
3481 if(checkLock(aStudy)) break;
3483 EmitSignalDeactivateDialog();
3484 ( new SMESHGUI_TranslationDlg( this ) )->show();
3487 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3488 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3492 case SMESHOp::OpRotation:
3494 if(checkLock(aStudy)) break;
3496 EmitSignalDeactivateDialog();
3497 ( new SMESHGUI_RotationDlg( this ) )->show();
3500 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3501 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3505 case SMESHOp::OpSymmetry:
3507 if(checkLock(aStudy)) break;
3509 EmitSignalDeactivateDialog();
3510 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3513 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3514 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3518 case SMESHOp::OpScale:
3520 if(checkLock(aStudy)) break;
3522 EmitSignalDeactivateDialog();
3523 ( new SMESHGUI_ScaleDlg( this ) )->show();
3526 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3527 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3532 case SMESHOp::OpSewing:
3534 if(checkLock(aStudy)) break;
3536 EmitSignalDeactivateDialog();
3537 ( new SMESHGUI_SewingDlg( this ) )->show();
3540 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3541 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3545 case SMESHOp::OpMergeNodes:
3547 if(checkLock(aStudy)) break;
3549 EmitSignalDeactivateDialog();
3550 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3553 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3554 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3558 case SMESHOp::OpMergeElements:
3560 if (checkLock(aStudy)) break;
3562 EmitSignalDeactivateDialog();
3563 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3565 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3566 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3571 case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
3572 startOperation( SMESHOp::OpMoveNode );
3575 case SMESHOp::OpDuplicateNodes:
3577 if(checkLock(aStudy)) break;
3579 EmitSignalDeactivateDialog();
3580 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3583 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3584 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3589 case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
3590 startOperation( SMESHOp::OpElem0DOnElemNodes );
3593 case SMESHOp::OpSelectFiltersLibrary: // Library of selection filters
3595 static QList<int> aTypes;
3596 if ( aTypes.isEmpty() )
3598 aTypes.append( SMESH::NODE );
3599 aTypes.append( SMESH::EDGE );
3600 aTypes.append( SMESH::FACE );
3601 aTypes.append( SMESH::VOLUME );
3603 if (!myFilterLibraryDlg)
3604 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3605 else if (myFilterLibraryDlg->isHidden())
3606 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3607 myFilterLibraryDlg->raise();
3611 case SMESHOp::OpFreeNode:
3612 case SMESHOp::OpEqualNode:
3613 case SMESHOp::OpNodeConnectivityNb:
3614 case SMESHOp::OpFreeEdge:
3615 case SMESHOp::OpFreeBorder:
3616 case SMESHOp::OpLength:
3617 case SMESHOp::OpConnection:
3618 case SMESHOp::OpEqualEdge:
3619 case SMESHOp::OpFreeFace:
3620 case SMESHOp::OpBareBorderFace:
3621 case SMESHOp::OpOverConstrainedFace:
3622 case SMESHOp::OpLength2D:
3623 case SMESHOp::OpDeflection2D:
3624 case SMESHOp::OpConnection2D:
3625 case SMESHOp::OpArea:
3626 case SMESHOp::OpTaper:
3627 case SMESHOp::OpAspectRatio:
3628 case SMESHOp::OpMinimumAngle:
3629 case SMESHOp::OpWarpingAngle:
3630 case SMESHOp::OpSkew:
3631 case SMESHOp::OpMaxElementLength2D:
3632 case SMESHOp::OpEqualFace:
3633 case SMESHOp::OpAspectRatio3D:
3634 case SMESHOp::OpVolume:
3635 case SMESHOp::OpMaxElementLength3D:
3636 case SMESHOp::OpBareBorderVolume:
3637 case SMESHOp::OpOverConstrainedVolume:
3638 case SMESHOp::OpEqualVolume:
3641 LightApp_SelectionMgr* mgr = selectionMgr();
3642 SALOME_ListIO selected; mgr->selectedObjects( selected );
3644 if( !selected.IsEmpty() ) {
3645 SUIT_OverrideCursor wc;
3646 ::Control( theCommandID );
3649 SUIT_MessageBox::warning(desktop(),
3650 tr( "SMESH_WRN_WARNING" ),
3651 tr( "SMESH_BAD_SELECTION" ) );
3655 SUIT_MessageBox::warning(desktop(),
3656 tr( "SMESH_WRN_WARNING" ),
3657 tr( "NOT_A_VTK_VIEWER" ) );
3660 case SMESHOp::OpOverallMeshQuality:
3661 OverallMeshQuality();
3663 case SMESHOp::OpNumberingNodes:
3665 SUIT_OverrideCursor wc;
3666 LightApp_SelectionMgr* mgr = selectionMgr();
3667 SALOME_ListIO selected; mgr->selectedObjects( selected );
3669 SALOME_ListIteratorOfListIO it(selected);
3670 for( ; it.More(); it.Next()) {
3671 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3672 if(anIObject->hasEntry()) {
3673 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3674 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3680 case SMESHOp::OpNumberingElements:
3682 SUIT_OverrideCursor wc;
3683 LightApp_SelectionMgr* mgr = selectionMgr();
3684 SALOME_ListIO selected; mgr->selectedObjects( selected );
3686 SALOME_ListIteratorOfListIO it(selected);
3687 for( ; it.More(); it.Next()) {
3688 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3689 if(anIObject->hasEntry())
3690 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3691 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3696 case SMESHOp::OpPropertiesLength:
3697 case SMESHOp::OpPropertiesArea:
3698 case SMESHOp::OpPropertiesVolume:
3699 case SMESHOp::OpMinimumDistance:
3700 case SMESHOp::OpBoundingBox:
3702 int page = SMESHGUI_MeasureDlg::MinDistance;
3703 if ( theCommandID == SMESHOp::OpBoundingBox )
3704 page = SMESHGUI_MeasureDlg::BoundingBox;
3705 else if ( theCommandID == SMESHOp::OpPropertiesLength )
3706 page = SMESHGUI_MeasureDlg::Length;
3707 else if ( theCommandID == SMESHOp::OpPropertiesArea )
3708 page = SMESHGUI_MeasureDlg::Area;
3709 else if ( theCommandID == SMESHOp::OpPropertiesVolume )
3710 page = SMESHGUI_MeasureDlg::Volume;
3712 EmitSignalDeactivateDialog();
3713 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3717 case SMESHOp::OpSortChild:
3723 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3724 //updateObjBrowser();
3728 //=============================================================================
3732 //=============================================================================
3733 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3738 //=============================================================================
3742 //=============================================================================
3743 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3748 //=============================================================================
3752 //=============================================================================
3753 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3758 //=============================================================================
3759 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3760 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3762 //=============================================================================
3763 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3764 SUIT_ViewWindow* wnd )
3766 if(theIO->hasEntry()){
3767 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3768 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3772 //=======================================================================
3773 // function : createSMESHAction
3775 //=======================================================================
3776 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3777 const int key, const bool toggle, const QString& shortcutAction )
3780 QWidget* parent = application()->desktop();
3781 SUIT_ResourceMgr* resMgr = resourceMgr();
3783 if ( !icon_id.isEmpty() )
3784 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3786 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3787 if ( !pix.isNull() )
3788 icon = QIcon( pix );
3790 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3791 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3792 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3794 createAction( id, tooltip, icon, menu, status_bar, key, parent,
3795 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3798 //=======================================================================
3799 // function : createPopupItem
3801 //=======================================================================
3802 void SMESHGUI::createPopupItem( const int id,
3803 const QString& clients,
3804 const QString& types,
3805 const QString& theRule,
3808 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3809 popupMgr()->insert( action( id ), pId, 0 );
3811 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3812 QString dc = "selcount"; // VSR : insetad of QtxPopupSelection::defSelCountParam()
3813 QString rule = "(%1) and (%2) and (%3)";
3814 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3815 if( clients.isEmpty() )
3816 rule = rule.arg( QString( "true" ) );
3818 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3819 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3822 bool cont = myRules.contains( id );
3824 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3826 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3827 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3830 //=======================================================================
3831 // function : initialize
3833 //=======================================================================
3834 void SMESHGUI::initialize( CAM_Application* app )
3836 SalomeApp_Module::initialize( app );
3838 // SUIT_ResourceMgr* mgr = app->resourceMgr();
3840 /* Automatic Update flag */
3841 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3843 // ----- create actions --------------
3845 //createSMESHAction( SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
3846 createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_I) );
3847 createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
3848 createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL" );
3850 createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
3852 createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
3853 createSMESHAction( SMESHOp::OpImportGMF, "IMPORT_GMF" );
3854 createSMESHAction( SMESHOp::OpPopupImportUNV, "IMPORT_UNV");
3855 createSMESHAction( SMESHOp::OpPopupImportMED, "IMPORT_MED");
3856 createSMESHAction( SMESHOp::OpPopupImportSTL, "IMPORT_STL" );
3858 createSMESHAction( SMESHOp::OpPopupImportCGNS, "IMPORT_CGNS" );
3860 createSMESHAction( SMESHOp::OpPopupImportSAUV, "IMPORT_SAUV" );
3861 createSMESHAction( SMESHOp::OpPopupImportGMF, "IMPORT_GMF" );
3863 createSMESHAction( SMESHOp::OpExportDAT, "DAT" );
3864 createSMESHAction( SMESHOp::OpExportMED, "MED" );
3865 createSMESHAction( SMESHOp::OpExportUNV, "UNV" );
3866 createSMESHAction( SMESHOp::OpExportSTL, "STL" );
3868 createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
3870 createSMESHAction( SMESHOp::OpExportSAUV, "SAUV");
3871 createSMESHAction( SMESHOp::OpExportGMF, "GMF" );
3872 createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
3873 createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
3874 createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
3875 createSMESHAction( SMESHOp::OpPopupExportSTL, "STL" );
3877 createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
3879 createSMESHAction( SMESHOp::OpPopupExportSAUV, "SAUV");
3880 createSMESHAction( SMESHOp::OpPopupExportGMF, "GMF" );
3881 createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
3882 createSMESHAction( SMESHOp::OpDelete, "DELETE", "ICON_DELETE", Qt::Key_Delete );
3883 createSMESHAction( SMESHOp::OpSelectFiltersLibrary, "SEL_FILTER_LIB" );
3884 createSMESHAction( SMESHOp::OpCreateMesh, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
3885 createSMESHAction( SMESHOp::OpCreateSubMesh, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
3886 createSMESHAction( SMESHOp::OpEditMeshOrSubMesh, "EDIT_MESHSUBMESH", "ICON_DLG_EDIT_MESH" );
3887 createSMESHAction( SMESHOp::OpEditMesh, "EDIT_MESH", "ICON_DLG_EDIT_MESH" );
3888 createSMESHAction( SMESHOp::OpEditSubMesh, "EDIT_SUBMESH", "ICON_DLG_EDIT_MESH" );
3889 createSMESHAction( SMESHOp::OpBuildCompoundMesh, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
3890 createSMESHAction( SMESHOp::OpCopyMesh, "COPY_MESH", "ICON_COPY_MESH" );
3891 createSMESHAction( SMESHOp::OpCompute, "COMPUTE", "ICON_COMPUTE" );
3892 createSMESHAction( SMESHOp::OpComputeSubMesh, "COMPUTE_SUBMESH", "ICON_COMPUTE" );
3893 createSMESHAction( SMESHOp::OpPreCompute, "PRECOMPUTE", "ICON_PRECOMPUTE" );
3894 createSMESHAction( SMESHOp::OpEvaluate, "EVALUATE", "ICON_EVALUATE" );
3895 createSMESHAction( SMESHOp::OpMeshOrder, "MESH_ORDER", "ICON_MESH_ORDER");
3896 createSMESHAction( SMESHOp::OpCreateGroup, "CREATE_GROUP", "ICON_CREATE_GROUP" );
3897 createSMESHAction( SMESHOp::OpCreateGeometryGroup, "CREATE_GEO_GROUP", "ICON_CREATE_GEO_GROUP" );
3898 createSMESHAction( SMESHOp::OpConstructGroup, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
3899 createSMESHAction( SMESHOp::OpEditGroup, "EDIT_GROUP", "ICON_EDIT_GROUP" );
3900 createSMESHAction( SMESHOp::OpEditGeomGroupAsGroup, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3901 createSMESHAction( SMESHOp::OpUnionGroups, "UN_GROUP", "ICON_UNION" );
3902 createSMESHAction( SMESHOp::OpIntersectGroups, "INT_GROUP", "ICON_INTERSECT" );
3903 createSMESHAction( SMESHOp::OpCutGroups, "CUT_GROUP", "ICON_CUT" );
3904 createSMESHAction( SMESHOp::OpGroupUnderlyingElem, "UNDERLYING_ELEMS", "ICON_UNDERLYING_ELEMS" );
3905 createSMESHAction( SMESHOp::OpAddElemGroupPopup, "ADD_TO_GROUP" );
3906 createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE_FROM_GROUP" );
3907 createSMESHAction( SMESHOp::OpDeleteGroup, "DEL_GROUP", "ICON_DEL_GROUP" );
3908 createSMESHAction( SMESHOp::OpMeshInformation , "ADV_INFO", "ICON_ADV_INFO" );
3909 //createSMESHAction( SMESHOp::OpStdInfo, "STD_INFO", "ICON_STD_INFO" );
3910 //createSMESHAction( SMESHOp::OpWhatIs, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3911 createSMESHAction( SMESHOp::OpFindElementByPoint, "FIND_ELEM", "ICON_FIND_ELEM" );
3913 createSMESHAction( SMESHOp::OpFreeNode, "FREE_NODE", "ICON_FREE_NODE", 0, true );
3914 createSMESHAction( SMESHOp::OpEqualNode, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
3915 createSMESHAction( SMESHOp::OpNodeConnectivityNb, "NODE_CONNECTIVITY_NB", "ICON_NODE_CONN_NB", 0, true );
3916 createSMESHAction( SMESHOp::OpFreeEdge, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
3917 createSMESHAction( SMESHOp::OpFreeBorder, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
3918 createSMESHAction( SMESHOp::OpLength, "LENGTH", "ICON_LENGTH", 0, true );
3919 createSMESHAction( SMESHOp::OpConnection, "CONNECTION", "ICON_CONNECTION", 0, true );
3920 createSMESHAction( SMESHOp::OpEqualEdge, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
3921 createSMESHAction( SMESHOp::OpFreeFace, "FREE_FACES", "ICON_FREE_FACES", 0, true );
3922 createSMESHAction( SMESHOp::OpBareBorderFace, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
3923 createSMESHAction( SMESHOp::OpOverConstrainedFace, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
3924 createSMESHAction( SMESHOp::OpLength2D, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
3925 createSMESHAction( SMESHOp::OpDeflection2D, "DEFLECTION_2D", "ICON_DEFLECTION_2D", 0, true );
3926 createSMESHAction( SMESHOp::OpConnection2D, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
3927 createSMESHAction( SMESHOp::OpArea, "AREA", "ICON_AREA", 0, true );
3928 createSMESHAction( SMESHOp::OpTaper, "TAPER", "ICON_TAPER", 0, true );
3929 createSMESHAction( SMESHOp::OpAspectRatio, "ASPECT", "ICON_ASPECT", 0, true );
3930 createSMESHAction( SMESHOp::OpMinimumAngle, "MIN_ANG", "ICON_ANGLE", 0, true );
3931 createSMESHAction( SMESHOp::OpWarpingAngle, "WARP", "ICON_WARP", 0, true );
3932 createSMESHAction( SMESHOp::OpSkew, "SKEW", "ICON_SKEW", 0, true );
3933 createSMESHAction( SMESHOp::OpMaxElementLength2D, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
3934 createSMESHAction( SMESHOp::OpEqualFace, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
3935 createSMESHAction( SMESHOp::OpAspectRatio3D, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
3936 createSMESHAction( SMESHOp::OpVolume, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
3937 createSMESHAction( SMESHOp::OpMaxElementLength3D, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
3938 createSMESHAction( SMESHOp::OpBareBorderVolume, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
3939 createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
3940 createSMESHAction( SMESHOp::OpEqualVolume, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
3941 createSMESHAction( SMESHOp::OpOverallMeshQuality, "OVERALL_MESH_QUALITY", "ICON_OVL_MESH_QUALITY" );
3943 createSMESHAction( SMESHOp::OpNode, "NODE", "ICON_DLG_NODE" );
3944 createSMESHAction( SMESHOp::OpElem0D, "ELEM0D", "ICON_DLG_ELEM0D" );
3945 createSMESHAction( SMESHOp::OpElem0DOnElemNodes, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
3946 createSMESHAction( SMESHOp::OpBall, "BALL", "ICON_DLG_BALL" );
3947 createSMESHAction( SMESHOp::OpEdge, "EDGE", "ICON_DLG_EDGE" );
3948 createSMESHAction( SMESHOp::OpTriangle, "TRIANGLE", "ICON_DLG_TRIANGLE" );
3949 createSMESHAction( SMESHOp::OpQuadrangle, "QUAD", "ICON_DLG_QUADRANGLE" );
3950 createSMESHAction( SMESHOp::OpPolygon, "POLYGON", "ICON_DLG_POLYGON" );
3951 createSMESHAction( SMESHOp::OpTetrahedron, "TETRA", "ICON_DLG_TETRAS" );
3952 createSMESHAction( SMESHOp::OpHexahedron, "HEXA", "ICON_DLG_HEXAS" );
3953 createSMESHAction( SMESHOp::OpPentahedron, "PENTA", "ICON_DLG_PENTA" );
3954 createSMESHAction( SMESHOp::OpPyramid , "PYRAMID", "ICON_DLG_PYRAMID" );
3955 createSMESHAction( SMESHOp::OpHexagonalPrism, "OCTA", "ICON_DLG_OCTA" );
3956 createSMESHAction( SMESHOp::OpPolyhedron, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
3957 createSMESHAction( SMESHOp::OpQuadraticEdge, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
3958 createSMESHAction( SMESHOp::OpQuadraticTriangle, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
3959 createSMESHAction( SMESHOp::OpBiQuadraticTriangle, "BIQUADRATIC_TRIANGLE", "ICON_DLG_BIQUADRATIC_TRIANGLE" );
3960 createSMESHAction( SMESHOp::OpQuadraticQuadrangle, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
3961 createSMESHAction( SMESHOp::OpBiQuadraticQuadrangle, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
3962 createSMESHAction( SMESHOp::OpQuadraticPolygon, "QUADRATIC_POLYGON", "ICON_DLG_QUADRATIC_POLYGON" );
3963 createSMESHAction( SMESHOp::OpQuadraticTetrahedron, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
3964 createSMESHAction( SMESHOp::OpQuadraticPyramid, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
3965 createSMESHAction( SMESHOp::OpQuadraticPentahedron, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
3966 createSMESHAction( SMESHOp::OpBiQuadraticPentahedron, "BIQUADRATIC_PENTAHEDRON", "ICON_DLG_BIQUADRATIC_PENTAHEDRON" );
3967 createSMESHAction( SMESHOp::OpQuadraticHexahedron, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
3968 createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
3970 createSMESHAction( SMESHOp::OpRemoveNodes, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
3971 createSMESHAction( SMESHOp::OpRemoveElements, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
3972 createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
3973 createSMESHAction( SMESHOp::OpClearMesh, "CLEAR_MESH", "ICON_CLEAR_MESH" );
3975 //createSMESHAction( SMESHOp::OpRenumberingNodes, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
3976 //createSMESHAction( SMESHOp::OpRenumberingElements, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
3978 createSMESHAction( SMESHOp::OpTranslation, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
3979 createSMESHAction( SMESHOp::OpRotation, "ROT", "ICON_DLG_MESH_ROTATION" );
3980 createSMESHAction( SMESHOp::OpSymmetry, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
3981 createSMESHAction( SMESHOp::OpScale, "SCALE", "ICON_DLG_MESH_SCALE" );
3982 createSMESHAction( SMESHOp::OpSewing, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
3983 createSMESHAction( SMESHOp::OpMergeNodes, "MERGE", "ICON_SMESH_MERGE_NODES" );
3984 createSMESHAction( SMESHOp::OpMergeElements, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
3985 createSMESHAction( SMESHOp::OpMoveNode, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
3986 createSMESHAction( SMESHOp::OpDuplicateNodes, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
3987 createSMESHAction( SMESHOp::OpDiagonalInversion, "INV", "ICON_DLG_MESH_DIAGONAL" );
3988 createSMESHAction( SMESHOp::OpUnionOfTwoTriangle, "UNION2", "ICON_UNION2TRI" );
3989 createSMESHAction( SMESHOp::OpOrientation, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
3990 createSMESHAction( SMESHOp::OpReorientFaces, "REORIENT_2D", "ICON_REORIENT_2D" );
3991 createSMESHAction( SMESHOp::OpUnionOfTriangles, "UNION", "ICON_UNIONTRI" );
3992 createSMESHAction( SMESHOp::OpCuttingOfQuadrangles, "CUT", "ICON_CUTQUAD" );
3993 createSMESHAction( SMESHOp::OpSplitVolumes, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
3994 createSMESHAction( SMESHOp::OpSplitBiQuadratic, "SPLIT_BIQUAD", "ICON_SPLIT_BIQUAD" );
3995 createSMESHAction( SMESHOp::OpSmoothing, "SMOOTH", "ICON_DLG_SMOOTHING" );
3996 createSMESHAction( SMESHOp::OpExtrusion, "EXTRUSION", "ICON_EXTRUSION" );
3997 createSMESHAction( SMESHOp::OpExtrusionAlongAPath, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
3998 createSMESHAction( SMESHOp::OpRevolution, "REVOLUTION", "ICON_REVOLUTION" );
3999 createSMESHAction( SMESHOp::OpPatternMapping, "MAP", "ICON_MAP" );
4000 createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
4001 createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D", "ICON_2D_FROM_3D" );
4003 createSMESHAction( SMESHOp::OpReset, "RESET" );
4004 createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
4005 createSMESHAction( SMESHOp::OpShowScalarBar, "SHOW_SCALAR_BAR","",0, true );
4006 createSMESHAction( SMESHOp::OpSaveDistribution, "SAVE_DISTRIBUTION" );
4007 createSMESHAction( SMESHOp::OpShowDistribution, "SHOW_DISTRIBUTION","",0, true );
4008 #ifndef DISABLE_PLOT2DVIEWER
4009 createSMESHAction( SMESHOp::OpPlotDistribution, "PLOT_DISTRIBUTION" );
4011 createSMESHAction( SMESHOp::OpDMWireframe, "WIRE", "ICON_WIRE", 0, true );
4012 createSMESHAction( SMESHOp::OpDMShading, "SHADE", "ICON_SHADE", 0, true );
4013 createSMESHAction( SMESHOp::OpDMNodes, "NODES", "ICON_POINTS", 0, true );
4014 createSMESHAction( SMESHOp::OpDMShrink, "SHRINK", "ICON_SHRINK", 0, true );
4015 createSMESHAction( SMESHOp::OpUpdate, "UPDATE", "ICON_UPDATE" );
4016 createSMESHAction( SMESHOp::OpDE0DElements, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
4017 createSMESHAction( SMESHOp::OpDEEdges, "EDGES", "ICON_DLG_EDGE", 0, true );
4018 createSMESHAction( SMESHOp::OpDEFaces, "FACES", "ICON_DLG_TRIANGLE", 0, true );
4019 createSMESHAction( SMESHOp::OpDEVolumes, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
4020 createSMESHAction( SMESHOp::OpDEBalls, "BALLS", "ICON_DLG_BALL", 0, true );
4021 createSMESHAction( SMESHOp::OpDEChoose, "CHOOSE", "ICON_DLG_CHOOSE", 0, false );
4022 createSMESHAction( SMESHOp::OpDEAllEntity, "ALL", "ICON_DLG_CHOOSE_ALL", 0, false );
4023 createSMESHAction( SMESHOp::OpOrientationOnFaces, "FACE_ORIENTATION", "", 0, true );
4025 createSMESHAction( SMESHOp::OpRepresentationLines, "LINE_REPRESENTATION", "", 0, true );
4026 createSMESHAction( SMESHOp::OpRepresentationArcs, "ARC_REPRESENTATION", "", 0, true );
4028 createSMESHAction( SMESHOp::OpEditHypothesis, "EDIT_HYPO" );
4029 createSMESHAction( SMESHOp::OpUnassign, "UNASSIGN" );
4030 createSMESHAction( SMESHOp::OpNumberingNodes, "NUM_NODES", "", 0, true );
4031 createSMESHAction( SMESHOp::OpNumberingElements, "NUM_ELEMENTS", "", 0, true );
4032 createSMESHAction( SMESHOp::OpProperties, "COLORS" );
4033 createSMESHAction( SMESHOp::OpTransparency, "TRANSP" );
4034 createSMESHAction( SMESHOp::OpClipping, "CLIP" );
4035 createSMESHAction( SMESHOp::OpAutoColor, "AUTO_COLOR" );
4036 createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
4038 createSMESHAction( SMESHOp::OpMinimumDistance, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
4039 createSMESHAction( SMESHOp::OpBoundingBox, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
4040 createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH", "ICON_MEASURE_LENGTH" );
4041 createSMESHAction( SMESHOp::OpPropertiesArea, "MEASURE_AREA", "ICON_MEASURE_AREA" );
4042 createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME", "ICON_MEASURE_VOLUME" );
4044 createSMESHAction( SMESHOp::OpHide, "HIDE", "ICON_HIDE" );
4045 createSMESHAction( SMESHOp::OpShow, "SHOW", "ICON_SHOW" );
4046 createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
4048 createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
4050 QList<int> aCtrlActions;
4051 aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode
4052 << SMESHOp::OpNodeConnectivityNb // node controls
4053 << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
4054 << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge // edge controls
4055 << SMESHOp::OpDeflection2D
4056 << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
4057 << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
4058 << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
4059 << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
4060 << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace // face controls
4061 << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
4062 << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
4063 << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume; // volume controls
4064 QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
4065 aCtrlGroup->setExclusive( true );
4066 for( int i = 0; i < aCtrlActions.size(); i++ )
4067 aCtrlGroup->addAction( action( aCtrlActions[i] ) );
4069 // ----- create menu --------------
4070 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
4071 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
4072 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
4073 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
4074 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
4075 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
4076 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
4077 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
4079 createMenu( separator(), fileId );
4081 QMenu* nodeMenu = new QMenu(); QMenu* edgeMenu = new QMenu();
4082 QMenu* faceMenu = new QMenu(); QMenu* volumeMenu = new QMenu();
4083 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
4084 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
4085 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10, -1, nodeMenu ),
4086 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10, -1, edgeMenu ),
4087 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10, -1, faceMenu ),
4088 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10, -1, volumeMenu ),
4089 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
4090 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
4091 //renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
4092 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
4093 basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
4095 //createMenu( SMESHOp::OpImportDAT, importId, -1 );
4096 createMenu( SMESHOp::OpImportUNV, importId, -1 );
4097 createMenu( SMESHOp::OpImportMED, importId, -1 );
4098 createMenu( SMESHOp::OpImportSTL, importId, -1 );
4100 createMenu( SMESHOp::OpImportCGNS, importId, -1 );
4102 createMenu( SMESHOp::OpImportSAUV, importId, -1 );
4103 createMenu( SMESHOp::OpImportGMF, importId, -1 );
4104 createMenu( SMESHOp::OpExportDAT, exportId, -1 );
4105 createMenu( SMESHOp::OpExportMED, exportId, -1 );
4106 createMenu( SMESHOp::OpExportUNV, exportId, -1 );
4107 createMenu( SMESHOp::OpExportSTL, exportId, -1 );
4109 createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
4111 createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
4112 createMenu( SMESHOp::OpExportGMF, exportId, -1 );
4113 createMenu( separator(), fileId, 10 );
4115 createMenu( SMESHOp::OpDelete, editId, -1 );
4117 createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
4119 createMenu( SMESHOp::OpCreateMesh, meshId, -1 ); // "Mesh" menu
4120 createMenu( SMESHOp::OpCreateSubMesh, meshId, -1 );
4121 createMenu( SMESHOp::OpEditMeshOrSubMesh, meshId, -1 );
4122 createMenu( SMESHOp::OpBuildCompoundMesh, meshId, -1 );
4123 createMenu( SMESHOp::OpCopyMesh, meshId, -1 );
4124 createMenu( separator(), meshId, -1 );
4125 createMenu( SMESHOp::OpCompute, meshId, -1 );
4126 createMenu( SMESHOp::OpPreCompute, meshId, -1 );
4127 createMenu( SMESHOp::OpEvaluate, meshId, -1 );
4128 createMenu( SMESHOp::OpMeshOrder, meshId, -1 );
4129 createMenu( separator(), meshId, -1 );
4130 createMenu( SMESHOp::OpCreateGroup, meshId, -1 );
4131 createMenu( SMESHOp::OpCreateGeometryGroup, meshId, -1 );
4132 createMenu( SMESHOp::OpConstructGroup, meshId, -1 );
4133 createMenu( SMESHOp::OpEditGroup, meshId, -1 );
4134 createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4135 createMenu( separator(), meshId, -1 );
4136 createMenu( SMESHOp::OpUnionGroups, meshId, -1 );
4137 createMenu( SMESHOp::OpIntersectGroups, meshId, -1 );
4138 createMenu( SMESHOp::OpCutGroups, meshId, -1 );
4139 createMenu( separator(), meshId, -1 );
4140 createMenu( SMESHOp::OpGroupUnderlyingElem, meshId, -1 );
4141 createMenu( separator(), meshId, -1 );
4142 createMenu( SMESHOp::OpMeshInformation, meshId, -1 );
4143 //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4144 //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4145 createMenu( SMESHOp::OpFindElementByPoint, meshId, -1 );
4146 createMenu( separator(), meshId, -1 );
4148 createMenu( SMESHOp::OpFreeNode, nodeId, -1 );
4149 createMenu( SMESHOp::OpEqualNode, nodeId, -1 );
4150 //createMenu( SMESHOp::OpNodeConnectivityNb, nodeId, -1 );
4151 createMenu( SMESHOp::OpFreeBorder, edgeId, -1 );
4152 createMenu( SMESHOp::OpLength, edgeId, -1 );
4153 createMenu( SMESHOp::OpConnection, edgeId, -1 );
4154 createMenu( SMESHOp::OpEqualEdge, edgeId, -1 );
4155 createMenu( SMESHOp::OpFreeEdge, faceId, -1 );
4156 createMenu( SMESHOp::OpFreeFace, faceId, -1 );
4157 createMenu( SMESHOp::OpBareBorderFace, faceId, -1 );
4158 createMenu( SMESHOp::OpOverConstrainedFace, faceId, -1 );
4159 createMenu( SMESHOp::OpLength2D, faceId, -1 );
4160 createMenu( SMESHOp::OpConnection2D, faceId, -1 );
4161 createMenu( SMESHOp::OpArea, faceId, -1 );
4162 createMenu( SMESHOp::OpTaper, faceId, -1 );
4163 createMenu( SMESHOp::OpAspectRatio, faceId, -1 );
4164 createMenu( SMESHOp::OpMinimumAngle, faceId, -1 );
4165 createMenu( SMESHOp::OpWarpingAngle, faceId, -1 );
4166 createMenu( SMESHOp::OpSkew, faceId, -1 );
4167 createMenu( SMESHOp::OpMaxElementLength2D, faceId, -1 );
4168 createMenu( SMESHOp::OpEqualFace, faceId, -1 );
4169 createMenu( SMESHOp::OpDeflection2D, faceId, -1 );
4170 createMenu( SMESHOp::OpAspectRatio3D, volumeId, -1 );
4171 createMenu( SMESHOp::OpVolume, volumeId, -1 );
4172 createMenu( SMESHOp::OpMaxElementLength3D, volumeId, -1 );
4173 createMenu( SMESHOp::OpBareBorderVolume, volumeId, -1 );
4174 createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4175 createMenu( SMESHOp::OpEqualVolume, volumeId, -1 );
4176 createMenu( separator(), ctrlId, -1 );
4177 createMenu( SMESHOp::OpReset, ctrlId, -1 );
4178 createMenu( separator(), ctrlId, -1 );
4179 createMenu( SMESHOp::OpOverallMeshQuality, ctrlId, -1 );
4181 createMenu( SMESHOp::OpNode, addId, -1 );
4182 createMenu( SMESHOp::OpElem0D, addId, -1 );
4183 createMenu( SMESHOp::OpElem0DOnElemNodes, addId, -1 );
4184 createMenu( SMESHOp::OpBall, addId, -1 );
4185 createMenu( SMESHOp::OpEdge, addId, -1 );
4186 createMenu( SMESHOp::OpTriangle, addId, -1 );
4187 createMenu( SMESHOp::OpQuadrangle, addId, -1 );
4188 createMenu( SMESHOp::OpPolygon, addId, -1 );
4189 createMenu( SMESHOp::OpTetrahedron, addId, -1 );
4190 createMenu( SMESHOp::OpHexahedron, addId, -1 );
4191 createMenu( SMESHOp::OpPentahedron, addId, -1 );
4192 createMenu( SMESHOp::OpPyramid, addId, -1 );
4193 createMenu( SMESHOp::OpHexagonalPrism, addId, -1 );
4194 createMenu( SMESHOp::OpPolyhedron, addId, -1 );
4195 createMenu( separator(), addId, -1 );
4196 createMenu( SMESHOp::OpQuadraticEdge, addId, -1 );
4197 createMenu( SMESHOp::OpQuadraticTriangle, addId, -1 );
4198 createMenu( SMESHOp::OpBiQuadraticTriangle , addId, -1 );
4199 createMenu( SMESHOp::OpQuadraticQuadrangle, addId, -1 );
4200 createMenu( SMESHOp::OpBiQuadraticQuadrangle, addId, -1 );
4201 createMenu( SMESHOp::OpQuadraticPolygon, addId, -1 );
4202 createMenu( SMESHOp::OpQuadraticTetrahedron, addId, -1 );
4203 createMenu( SMESHOp::OpQuadraticPyramid, addId, -1 );
4204 createMenu( SMESHOp::OpQuadraticPentahedron, addId, -1 );
4205 createMenu( SMESHOp::OpBiQuadraticPentahedron, addId, -1 );
4206 createMenu( SMESHOp::OpQuadraticHexahedron, addId, -1 );
4207 createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4209 createMenu( SMESHOp::OpRemoveNodes, removeId, -1 );
4210 createMenu( SMESHOp::OpRemoveElements, removeId, -1 );
4211 createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4212 createMenu( separator(), removeId, -1 );
4213 createMenu( SMESHOp::OpDeleteGroup, removeId, -1 );
4214 createMenu( separator(), removeId, -1 );
4215 createMenu( SMESHOp::OpClearMesh, removeId, -1 );
4217 //createMenu( SMESHOp::OpRenumberingNodes, renumId, -1 );
4218 //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4220 createMenu( SMESHOp::OpTranslation, transfId, -1 );
4221 createMenu( SMESHOp::OpRotation, transfId, -1 );
4222 createMenu( SMESHOp::OpSymmetry, transfId, -1 );
4223 createMenu( SMESHOp::OpScale, transfId, -1 );
4224 createMenu( SMESHOp::OpSewing, transfId, -1 );
4225 createMenu( SMESHOp::OpMergeNodes, transfId, -1 );
4226 createMenu( SMESHOp::OpMergeElements, transfId, -1 );
4227 createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4229 createMenu( SMESHOp::OpMoveNode, modifyId, -1 );
4230 createMenu( SMESHOp::OpDiagonalInversion, modifyId, -1 );
4231 createMenu( SMESHOp::OpUnionOfTwoTriangle, modifyId, -1 );
4232 createMenu( SMESHOp::OpOrientation, modifyId, -1 );
4233 createMenu( SMESHOp::OpReorientFaces, modifyId, -1 );
4234 createMenu( SMESHOp::OpUnionOfTriangles, modifyId, -1 );
4235 createMenu( SMESHOp::OpCuttingOfQuadrangles, modifyId, -1 );
4236 createMenu( SMESHOp::OpSplitVolumes, modifyId, -1 );
4237 createMenu( SMESHOp::OpSplitBiQuadratic, modifyId, -1 );
4238 createMenu( SMESHOp::OpSmoothing, modifyId, -1 );
4239 createMenu( SMESHOp::OpExtrusion, modifyId, -1 );
4240 createMenu( SMESHOp::OpExtrusionAlongAPath , modifyId, -1 );
4241 createMenu( SMESHOp::OpRevolution, modifyId, -1 );
4242 createMenu( SMESHOp::OpPatternMapping, modifyId, -1 );
4243 createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4244 createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4246 createMenu( SMESHOp::OpMinimumDistance, measureId, -1 );
4247 createMenu( SMESHOp::OpBoundingBox, measureId, -1 );
4248 createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4249 createMenu( SMESHOp::OpPropertiesArea, basicPropId, -1 );
4250 createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4251 createMenu( SMESHOp::OpUpdate, viewId, -1 );
4253 connect( nodeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4254 connect( edgeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4255 connect( faceMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4256 connect( volumeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4258 // ----- create toolbars --------------
4259 int meshTb = createTool( tr( "TB_MESH" ), QString( "SMESHMeshToolbar" ) ),
4260 info = createTool( tr( "TB_INFO" ), QString( "SMESHInformationToolbar" ) ),
4261 groupTb = createTool( tr( "TB_GROUP" ), QString( "SMESHGroupToolbar" ) ),
4262 ctrl0dTb = createTool( tr( "TB_CTRL0D" ), QString( "SMESHNodeControlsToolbar" ) ),
4263 ctrl1dTb = createTool( tr( "TB_CTRL1D" ), QString( "SMESHEdgeControlsToolbar" ) ),
4264 ctrl2dTb = createTool( tr( "TB_CTRL2D" ), QString( "SMESHFaceControlsToolbar" ) ),
4265 ctrl3dTb = createTool( tr( "TB_CTRL3D" ), QString( "SMESHVolumeControlsToolbar" ) ),
4266 addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ),
4267 addNonElemTb = createTool( tr( "TB_ADDNON" ), QString( "SMESHAddElementToolbar" ) ),
4268 remTb = createTool( tr( "TB_REM" ), QString( "SMESHRemoveToolbar" ) ),
4269 //renumbTb = createTool( tr( "TB_RENUMBER" ), QString( "SMESHRenumberingToolbar" ) ),
4270 transformTb = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ),
4271 modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ),
4272 measuremTb = createTool( tr( "TB_MEASUREM" ), QString( "SMESHMeasurementsToolbar" ) ),
4273 dispModeTb = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4275 createTool( SMESHOp::OpCreateMesh, meshTb );
4276 createTool( SMESHOp::OpCreateSubMesh, meshTb );
4277 createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4278 createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4279 createTool( SMESHOp::OpCopyMesh, meshTb );
4280 createTool( separator(), meshTb );
4281 createTool( SMESHOp::OpCompute, meshTb );
4282 createTool( SMESHOp::OpPreCompute, meshTb );
4283 createTool( SMESHOp::OpEvaluate, meshTb );
4284 createTool( SMESHOp::OpMeshOrder, meshTb );
4286 createTool( SMESHOp::OpCreateGroup, groupTb );
4287 createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4288 createTool( SMESHOp::OpConstructGroup, groupTb );
4289 createTool( SMESHOp::OpEditGroup, groupTb );
4291 createTool( SMESHOp::OpMeshInformation, info );
4292 //createTool( SMESHOp::OpStdInfo, meshTb );
4293 //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4294 createTool( SMESHOp::OpFindElementByPoint, info );
4296 createTool( SMESHOp::OpFreeNode, ctrl0dTb );
4297 createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4298 //createTool( SMESHOp::OpNodeConnectivityNb, ctrl0dTb );
4300 createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4301 createTool( SMESHOp::OpLength, ctrl1dTb );
4302 createTool( SMESHOp::OpConnection, ctrl1dTb );
4303 createTool( SMESHOp::OpEqualEdge, ctrl1dTb );
4305 createTool( SMESHOp::OpFreeEdge, ctrl2dTb );
4306 createTool( SMESHOp::OpFreeFace, ctrl2dTb );
4307 createTool( SMESHOp::OpBareBorderFace, ctrl2dTb );
4308 createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4309 createTool( SMESHOp::OpLength2D, ctrl2dTb );
4310 createTool( SMESHOp::OpConnection2D, ctrl2dTb );
4311 createTool( SMESHOp::OpArea, ctrl2dTb );
4312 createTool( SMESHOp::OpTaper, ctrl2dTb );
4313 createTool( SMESHOp::OpAspectRatio, ctrl2dTb );
4314 createTool( SMESHOp::OpMinimumAngle, ctrl2dTb );
4315 createTool( SMESHOp::OpWarpingAngle, ctrl2dTb );
4316 createTool( SMESHOp::OpSkew, ctrl2dTb );
4317 createTool( SMESHOp::OpMaxElementLength2D, ctrl2dTb );
4318 createTool( SMESHOp::OpEqualFace, ctrl2dTb );
4319 createTool( SMESHOp::OpDeflection2D, ctrl2dTb );
4321 createTool( SMESHOp::OpAspectRatio3D, ctrl3dTb );
4322 createTool( SMESHOp::OpVolume, ctrl3dTb );
4323 createTool( SMESHOp::OpMaxElementLength3D, ctrl3dTb );
4324 createTool( SMESHOp::OpBareBorderVolume, ctrl3dTb );
4325 createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
4326 createTool( SMESHOp::OpEqualVolume, ctrl3dTb );
4328 createTool( SMESHOp::OpNode, addElemTb );
4329 createTool( SMESHOp::OpElem0D, addElemTb );
4330 createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4331 createTool( SMESHOp::OpBall, addElemTb );
4332 createTool( SMESHOp::OpEdge, addElemTb );
4333 createTool( SMESHOp::OpTriangle, addElemTb );
4334 createTool( SMESHOp::OpQuadrangle, addElemTb );
4335 createTool( SMESHOp::OpPolygon, addElemTb );
4336 createTool( SMESHOp::OpTetrahedron, addElemTb );
4337 createTool( SMESHOp::OpHexahedron, addElemTb );
4338 createTool( SMESHOp::OpPentahedron, addElemTb );
4339 createTool( SMESHOp::OpPyramid, addElemTb );
4340 createTool( SMESHOp::OpHexagonalPrism, addElemTb );
4341 createTool( SMESHOp::OpPolyhedron, addElemTb );
4343 createTool( SMESHOp::OpQuadraticEdge, addNonElemTb );
4344 createTool( SMESHOp::OpQuadraticTriangle, addNonElemTb );
4345 createTool( SMESHOp::OpBiQuadraticTriangle, addNonElemTb );
4346 createTool( SMESHOp::OpQuadraticQuadrangle, addNonElemTb );
4347 createTool( SMESHOp::OpBiQuadraticQuadrangle, addNonElemTb );
4348 createTool( SMESHOp::OpQuadraticPolygon, addNonElemTb );
4349 createTool( SMESHOp::OpQuadraticTetrahedron, addNonElemTb );
4350 createTool( SMESHOp::OpQuadraticPyramid, addNonElemTb );
4351 createTool( SMESHOp::OpQuadraticPentahedron, addNonElemTb );
4352 createTool( SMESHOp::OpBiQuadraticPentahedron, addNonElemTb );
4353 createTool( SMESHOp::OpQuadraticHexahedron, addNonElemTb );
4354 createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4356 createTool( SMESHOp::OpRemoveNodes, remTb );
4357 createTool( SMESHOp::OpRemoveElements, remTb );
4358 createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4359 createTool( SMESHOp::OpClearMesh, remTb );
4361 //createTool( SMESHOp::OpRenumberingNodes, renumbTb );
4362 //createTool( SMESHOp::OpRenumberingElements, renumbTb );
4364 createTool( SMESHOp::OpTranslation, transformTb );
4365 createTool( SMESHOp::OpRotation, transformTb );
4366 createTool( SMESHOp::OpSymmetry, transformTb );
4367 createTool( SMESHOp::OpScale, transformTb );
4368 createTool( SMESHOp::OpSewing, transformTb );
4369 createTool( SMESHOp::OpMergeNodes, transformTb );
4370 createTool( SMESHOp::OpMergeElements, transformTb );
4371 createTool( SMESHOp::OpDuplicateNodes, transformTb );
4373 createTool( SMESHOp::OpMoveNode, modifyTb );
4374 createTool( SMESHOp::OpDiagonalInversion, modifyTb );
4375 createTool( SMESHOp::OpUnionOfTwoTriangle, modifyTb );
4376 createTool( SMESHOp::OpOrientation, modifyTb );
4377 createTool( SMESHOp::OpReorientFaces, modifyTb );
4378 createTool( SMESHOp::OpUnionOfTriangles, modifyTb );
4379 createTool( SMESHOp::OpCuttingOfQuadrangles, modifyTb );
4380 createTool( SMESHOp::OpSplitVolumes, modifyTb );
4381 createTool( SMESHOp::OpSplitBiQuadratic, modifyTb );
4382 createTool( SMESHOp::OpSmoothing, modifyTb );
4383 createTool( SMESHOp::OpExtrusion, modifyTb );
4384 createTool( SMESHOp::OpExtrusionAlongAPath, modifyTb );
4385 createTool( SMESHOp::OpRevolution, modifyTb );
4386 createTool( SMESHOp::OpPatternMapping, modifyTb );
4387 createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4388 createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4390 createTool( SMESHOp::OpMinimumDistance, measuremTb );
4392 createTool( SMESHOp::OpUpdate, dispModeTb );
4394 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4395 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4399 OB = "'ObjectBrowser'",
4400 View = "'" + SVTK_Viewer::Type() + "'",
4402 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4403 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4404 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4405 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4406 smesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::COMPONENT ) ),
4407 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4408 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4409 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4410 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4411 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4412 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4413 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4415 mesh_part = mesh + " " + subMesh + " " + group,
4416 mesh_group = mesh + " " + group,
4417 mesh_submesh = mesh + " " + subMesh,
4418 hyp_alg = hypo + " " + algo;
4420 // popup for object browser
4422 isInvisible("not( isVisible )"),
4423 isEmpty("numberOfNodes = 0"),
4424 isNotEmpty("numberOfNodes <> 0"),
4426 // has nodes, edges, etc in VISIBLE! actor
4427 hasNodes("(numberOfNodes > 0 ) && hasActor"),
4428 hasElems("(count( elemTypes ) > 0)"),
4429 hasDifferentElems("(count( elemTypes ) > 1)"),
4430 hasDifferentObjElems("(count( objElemTypes ) > 1)"),
4431 hasBalls("({'BallElem'} in elemTypes)"),
4432 hasElems0d("({'Elem0d'} in elemTypes)"),
4433 hasEdges("({'Edge'} in elemTypes)"),
4434 hasFaces("({'Face'} in elemTypes)"),
4435 hasVolumes("({'Volume'} in elemTypes)"),
4436 hasFacesOrVolumes("(({'Face'} in elemTypes) || ({'Volume'} in elemTypes)) ");
4438 createPopupItem( SMESHOp::OpFileInformation, OB, mesh, "&& selcount=1 && isImported" );
4439 createPopupItem( SMESHOp::OpCreateSubMesh, OB, mesh, "&& hasGeomReference");
4440 createPopupItem( SMESHOp::OpEditMesh, OB, mesh, "&& selcount=1" );
4441 createPopupItem( SMESHOp::OpEditSubMesh, OB, subMesh, "&& selcount=1 && hasGeomReference" );
4442 createPopupItem( SMESHOp::OpEditGroup, OB, group );
4443 createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4445 popupMgr()->insert( separator(), -1, 0 );
4446 createPopupItem( SMESHOp::OpCompute, OB, mesh, "&& selcount=1 && isComputable" );
4447 createPopupItem( SMESHOp::OpComputeSubMesh, OB, subMesh, "&& selcount=1 && isComputable" );
4448 createPopupItem( SMESHOp::OpPreCompute, OB, mesh, "&& selcount=1 && isPreComputable" );
4449 createPopupItem( SMESHOp::OpEvaluate, OB, mesh, "&& selcount=1 && isComputable" );
4450 createPopupItem( SMESHOp::OpMeshOrder, OB, mesh, "&& selcount=1 && isComputable && hasGeomReference" );
4451 createPopupItem( SMESHOp::OpUpdate, OB, mesh_part );
4452 createPopupItem( SMESHOp::OpMeshInformation, OB, mesh_part );
4453 createPopupItem( SMESHOp::OpFindElementByPoint,OB, mesh_group, "&& selcount=1" );
4454 createPopupItem( SMESHOp::OpOverallMeshQuality,OB, mesh_part );
4455 popupMgr()->insert( separator(), -1, 0 );
4456 createPopupItem( SMESHOp::OpCreateGroup, OB, mesh, "&& selcount=1" );
4457 createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh, "&& selcount=1 && hasGeomReference" );
4458 createPopupItem( SMESHOp::OpConstructGroup, OB, subMesh );
4459 popupMgr()->insert( separator(), -1, 0 );
4460 createPopupItem( SMESHOp::OpEditHypothesis, OB, hypo, "&& isEditableHyp");
4461 createPopupItem( SMESHOp::OpUnassign, OB, hyp_alg );
4462 popupMgr()->insert( separator(), -1, 0 );
4463 createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh_submesh );
4464 createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh_group, "&& selcount=1 && dim>=2");
4465 popupMgr()->insert( separator(), -1, 0 );
4466 createPopupItem( SMESHOp::OpClearMesh, OB, mesh );
4467 //popupMgr()->insert( separator(), -1, 0 );
4469 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4470 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4471 QString only_one_2D = only_one_non_empty + " && dim>1";
4473 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4474 createPopupItem( SMESHOp::OpPopupExportMED, OB, mesh_group, multiple_non_empty, anId );
4475 createPopupItem( SMESHOp::OpPopupExportUNV, OB, mesh_group, only_one_non_empty, anId );
4476 createPopupItem( SMESHOp::OpPopupExportSTL, OB, mesh_group, only_one_2D, anId );
4478 createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4480 createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, only_one_non_empty, anId );
4481 createPopupItem( SMESHOp::OpPopupExportGMF, OB, mesh_group, only_one_non_empty, anId );
4482 createPopupItem( SMESHOp::OpPopupExportDAT, OB, mesh_group, only_one_non_empty, anId );
4483 createPopupItem( SMESHOp::OpDelete, OB, mesh_part + " " + hyp_alg );
4484 createPopupItem( SMESHOp::OpDeleteGroup, OB, group );
4486 anId = popupMgr()->insert( tr( "MEN_IMPORT" ), -1, -1 ); // IMPORT submenu
4487 createPopupItem( SMESHOp::OpPopupImportMED, OB, smesh, "", anId );
4488 createPopupItem( SMESHOp::OpPopupImportUNV, OB, smesh, "", anId );
4489 createPopupItem( SMESHOp::OpPopupImportSTL, OB, smesh, "", anId );
4491 createPopupItem( SMESHOp::OpPopupImportCGNS, OB, smesh, "", anId );
4493 createPopupItem( SMESHOp::OpPopupImportSAUV, OB, smesh, "", anId );
4494 createPopupItem( SMESHOp::OpPopupImportGMF, OB, smesh, "", anId );
4495 createPopupItem( SMESHOp::OpPopupImportDAT, OB, smesh, "", anId );
4496 popupMgr()->insert( separator(), -1, 0 );
4499 createPopupItem( SMESHOp::OpEditGroup, View, group );
4500 createPopupItem( SMESHOp::OpAddElemGroupPopup, View, elems, "&& guiState = 800" );
4501 createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems, "&& guiState = 800" );
4503 popupMgr()->insert( separator(), -1, 0 );
4504 createPopupItem( SMESHOp::OpUpdate, View, mesh_part );
4505 createPopupItem( SMESHOp::OpMeshInformation, View, mesh_part );
4506 createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4507 createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh );
4508 popupMgr()->insert( separator(), -1, 0 );
4510 createPopupItem( SMESHOp::OpAutoColor, OB + " " + View, mesh, "&& (not isAutoColor)" );
4511 createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4512 popupMgr()->insert( separator(), -1, 0 );
4514 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4515 QString aType = QString( "%1type in {%2}" ).arg( lc );
4516 aType = aType.arg( mesh_part );
4517 QString aMeshInVTK = aClient + "&&" + aType;
4519 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4520 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4521 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4523 //-------------------------------------------------
4525 //-------------------------------------------------
4526 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4528 popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4529 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4530 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4532 popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4533 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4534 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4536 popupMgr()->insert( separator(), -1, -1 );
4538 //-------------------------------------------------
4540 //-------------------------------------------------
4541 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4543 popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4544 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4545 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4547 popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4548 popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4549 popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4551 popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4552 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4553 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4555 popupMgr()->insert( separator(), anId, -1 );
4557 popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4558 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4559 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4561 //-------------------------------------------------
4563 //-------------------------------------------------
4564 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4566 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4568 popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4569 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4570 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4572 popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4573 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4574 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4576 popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4577 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4578 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4580 popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4581 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4582 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4584 popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4585 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4586 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4588 popupMgr()->insert( separator(), anId, -1 );
4590 popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4591 popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&& $type in {" + mesh + "} &&" + hasDifferentObjElems, QtxPopupMgr::VisibleRule );
4593 popupMgr()->insert( separator(), anId, -1 );
4595 popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4596 popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4599 //-------------------------------------------------
4600 // Representation of the 2D Quadratic elements
4601 //-------------------------------------------------
4602 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4603 popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4604 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "&& isVisible && isQuadratic",QtxPopupMgr::VisibleRule );
4605 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4607 popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4608 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "&& isVisible && isQuadratic", QtxPopupMgr::VisibleRule );
4609 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4611 //-------------------------------------------------
4612 // Orientation of faces
4613 //-------------------------------------------------
4614 popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4615 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4616 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4618 //-------------------------------------------------
4620 //-------------------------------------------------
4621 popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4622 popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4624 //-------------------------------------------------
4626 //-------------------------------------------------
4627 popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4628 popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4630 //-------------------------------------------------
4632 //-------------------------------------------------
4634 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4635 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4636 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4637 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4639 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4641 popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4642 popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4644 popupMgr()->insert( separator(), anId, -1 );
4646 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4648 popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4649 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4650 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4652 popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4653 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4654 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4656 // popupMgr()->insert( action( SMESHOp::OpNodeConnectivityNb ), aSubId, -1 );
4657 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4658 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), "controlMode = 'eNodeConnectivityNb'", QtxPopupMgr::ToggleRule );
4660 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4662 popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4663 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVTK + "&&" + hasEdges + "&&" + hasFacesOrVolumes, QtxPopupMgr::VisibleRule );
4664 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4666 popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4667 popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4668 popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4670 popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4671 popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4672 popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4673 popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4674 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4675 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4677 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4679 popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4680 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4681 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4683 popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4684 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4685 QtxPopupMgr::VisibleRule );
4686 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4688 popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4689 popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4690 popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4692 popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4693 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4694 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4696 popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
4697 popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4698 popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4700 popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
4701 popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4702 popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4704 popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
4705 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4706 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4708 popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
4709 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4710 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4712 popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
4713 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4714 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4716 popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
4717 popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4718 popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4720 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
4721 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4722 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4724 popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
4725 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4726 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4728 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
4729 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4730 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4732 popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
4733 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4734 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4736 popupMgr()->insert ( action( SMESHOp::OpDeflection2D ), aSubId, -1 );
4737 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), aMeshInVtkHasFaces + " && hasGeomReference", QtxPopupMgr::VisibleRule );
4738 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), "controlMode = 'eDeflection2D'", QtxPopupMgr::ToggleRule );
4740 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4742 popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D ), aSubId, -1 );
4743 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4744 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4746 popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
4747 popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4748 popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4750 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
4751 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4752 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4754 popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
4755 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4756 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4758 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
4759 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4760 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4762 popupMgr()->insert ( action( SMESHOp::OpEqualVolume ), aSubId, -1 );
4763 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4764 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4766 popupMgr()->insert( separator(), anId, -1 );
4768 popupMgr()->insert( action( SMESHOp::OpShowScalarBar ), anId, -1 );
4769 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4770 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone' && isScalarBarVisible", QtxPopupMgr::ToggleRule );
4771 popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
4772 popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4774 popupMgr()->insert( separator(), anId, -1 );
4776 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4778 popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
4779 popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4781 popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
4782 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4783 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isScalarBarVisible && isDistributionVisible", QtxPopupMgr::ToggleRule);
4785 #ifndef DISABLE_PLOT2DVIEWER
4786 popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
4787 popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4790 //-------------------------------------------------
4792 //-------------------------------------------------
4793 popupMgr()->insert( separator(), -1, -1 );
4794 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4795 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4796 popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
4797 popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4799 popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
4800 popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4802 popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
4803 popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4805 popupMgr()->insert( separator(), -1, -1 );
4807 //-------------------------------------------------
4809 //-------------------------------------------------
4810 popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
4811 popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4813 popupMgr()->insert( separator(), -1, -1 );
4815 popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
4816 popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
4817 popupMgr()->insert( separator(), -1, -1 );
4819 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4820 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4822 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4823 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4826 //================================================================================
4828 * \brief Return true if SMESH or GEOM objects are selected.
4829 * Is called form LightApp_Module::activateModule() which clear selection if
4830 * not isSelectionCompatible()
4832 //================================================================================
4834 bool SMESHGUI::isSelectionCompatible()
4836 bool isCompatible = true;
4837 SALOME_ListIO selected;
4838 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4839 Sel->selectedObjects( selected );
4841 SALOME_ListIteratorOfListIO It( selected );
4842 for ( ; isCompatible && It.More(); It.Next())
4844 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4845 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4847 return isCompatible;
4851 bool SMESHGUI::reusableOperation( const int id )
4853 // compute, evaluate and precompute are not reusable operations
4854 return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate ) ? false : SalomeApp_Module::reusableOperation( id );
4857 bool SMESHGUI::activateModule( SUIT_Study* study )
4859 bool res = SalomeApp_Module::activateModule( study );
4861 setMenuShown( true );
4862 setToolShown( true );
4864 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4865 PyGILState_STATE gstate = PyGILState_Ensure();
4866 PyObject* pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4867 if ( !pluginsmanager ) {
4871 PyObject* result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toUtf8().data(),tr("SMESH_PLUGINS_OTHER").toUtf8().data());
4876 PyGILState_Release(gstate);
4877 // end of SMESH plugins loading
4879 // Reset actions accelerator keys
4880 action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
4882 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4883 GetSMESHGen()->SetCurrentStudy(SALOMEDS::Study::_nil());
4884 if ( SalomeApp_Study* s = dynamic_cast<SalomeApp_Study*>( study )) {
4885 if ( _PTR(Study) aStudy = s->studyDS() )
4886 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
4889 // get all view currently opened in the study and connect their signals to
4890 // the corresponding slots of the class.
4891 SUIT_Desktop* aDesk = study->application()->desktop();
4893 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4894 SUIT_ViewWindow* wnd;
4895 foreach ( wnd, wndList )
4899 Py_XDECREF(pluginsmanager);
4903 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4905 setMenuShown( false );
4906 setToolShown( false );
4908 EmitSignalCloseAllDialogs();
4910 // Unset actions accelerator keys
4911 action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
4913 return SalomeApp_Module::deactivateModule( study );
4916 void SMESHGUI::studyClosed( SUIT_Study* s )
4920 SMESH::RemoveVisuData( s->id() );
4921 SalomeApp_Module::studyClosed( s );
4924 void SMESHGUI::OnGUIEvent()
4926 const QObject* obj = sender();
4927 if ( !obj || !obj->inherits( "QAction" ) )
4929 int id = actionId((QAction*)obj);
4934 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4936 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
4937 if ( CORBA::is_nil( myComponentSMESH ) )
4939 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4941 aGUI.myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4942 return aGUI.myComponentSMESH;
4945 myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4946 return myComponentSMESH;
4949 QString SMESHGUI::engineIOR() const
4951 CORBA::ORB_var anORB = getApp()->orb();
4952 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4953 return QString( anIOR.in() );
4956 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4958 SalomeApp_Module::contextMenuPopup( client, menu, title );
4960 selectionMgr()->selectedObjects( lst );
4961 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4962 Handle(SALOME_InteractiveObject) io = lst.First();
4963 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4964 _PTR(Study) study = appStudy->studyDS();
4965 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4967 QString aName = QString( SMESH::fromUtf8(obj->GetName()) );
4968 while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4969 aName.remove( (aName.length() - 1), 1 );
4975 LightApp_Selection* SMESHGUI::createSelection() const
4977 return new SMESHGUI_Selection();
4980 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4982 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4983 aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
4984 #ifndef DISABLE_PYCONSOLE
4985 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4989 void SMESHGUI::viewManagers( QStringList& list ) const
4991 list.append( SVTK_Viewer::Type() );
4994 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4996 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4997 SMESH::UpdateSelectionProp( this );
4999 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
5000 for(int i = 0; i < aViews.count() ; i++){
5001 SUIT_ViewWindow *sf = aViews[i];
5004 EmitSignalActivatedViewManager();
5008 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
5010 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
5011 myClippingPlaneInfoMap.erase( theViewManager );
5014 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
5016 theActor->AddObserver( SMESH::DeleteActorEvent,
5017 myEventCallbackCommand.GetPointer(),
5021 void SMESHGUI::ProcessEvents( vtkObject* theObject,
5022 unsigned long theEvent,
5023 void* theClientData,
5026 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
5027 if( theObject && (int) theEvent == SMESH::DeleteActorEvent ) {
5028 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
5029 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
5030 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
5031 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
5032 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
5033 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
5034 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
5035 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
5036 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
5037 SMESH::TActorList::iterator anIter3 = anActorList.begin();
5038 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
5039 if( anActor == *anIter3 ) {
5040 anActorList.erase( anIter3 );
5051 void SMESHGUI::createPreferences()
5053 // General tab ------------------------------------------------------------------------
5054 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
5056 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
5057 setPreferenceProperty( autoUpdate, "columns", 2 );
5058 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
5059 setPreferenceProperty( lim, "min", 0 );
5060 setPreferenceProperty( lim, "max", 100000000 );
5061 setPreferenceProperty( lim, "step", 1000 );
5062 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5063 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
5065 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
5066 setPreferenceProperty( dispgroup, "columns", 2 );
5067 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
5069 modes.append( tr("MEN_WIRE") );
5070 modes.append( tr("MEN_SHADE") );
5071 modes.append( tr("MEN_NODES") );
5072 modes.append( tr("MEN_SHRINK") );
5073 QList<QVariant> indices;
5074 indices.append( 0 );
5075 indices.append( 1 );
5076 indices.append( 2 );
5077 indices.append( 3 );
5078 setPreferenceProperty( dispmode, "strings", modes );
5079 setPreferenceProperty( dispmode, "indexes", indices );
5081 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
5082 setPreferenceProperty( arcgroup, "columns", 2 );
5083 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
5084 QStringList quadraticModes;
5085 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
5086 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
5088 indices.append( 0 );
5089 indices.append( 1 );
5090 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
5091 setPreferenceProperty( quadraticmode, "indexes", indices );
5093 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
5094 "SMESH", "max_angle" );
5095 setPreferenceProperty( maxAngle, "min", 1 );
5096 setPreferenceProperty( maxAngle, "max", 90 );
5098 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
5099 setPreferenceProperty( qaGroup, "columns", 2 );
5100 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
5101 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
5102 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
5103 setPreferenceProperty( prec, "min", 0 );
5104 setPreferenceProperty( prec, "max", 100 );
5105 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
5106 setPreferenceProperty( doubleNodesTol, "precision", 10 );
5107 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
5108 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
5109 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
5112 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
5113 setPreferenceProperty( exportgroup, "columns", 2 );
5114 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
5115 addPreference( tr( "PREF_SHOW_WARN" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "show_warning" );
5116 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
5118 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
5119 setPreferenceProperty( computeGroup, "columns", 2 );
5120 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
5122 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5123 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5124 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5126 indices.append( 0 );
5127 indices.append( 1 );
5128 indices.append( 2 );
5129 setPreferenceProperty( notifyMode, "strings", modes );
5130 setPreferenceProperty( notifyMode, "indexes", indices );
5132 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5133 setPreferenceProperty( infoGroup, "columns", 2 );
5134 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5136 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5137 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5139 indices.append( 0 );
5140 indices.append( 1 );
5141 setPreferenceProperty( elemInfo, "strings", modes );
5142 setPreferenceProperty( elemInfo, "indexes", indices );
5143 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5144 setPreferenceProperty( nodesLim, "min", 0 );
5145 setPreferenceProperty( nodesLim, "max", 10000000 );
5146 setPreferenceProperty( nodesLim, "step", 10000 );
5147 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5148 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5149 setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5150 setPreferenceProperty( ctrlLim, "min", 0 );
5151 setPreferenceProperty( ctrlLim, "max", 10000000 );
5152 setPreferenceProperty( ctrlLim, "step", 1000 );
5153 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5154 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5155 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5156 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5157 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5159 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5160 setPreferenceProperty( segGroup, "columns", 2 );
5161 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5162 "SMESH", "segmentation" );
5163 setPreferenceProperty( segLen, "min", 1 );
5164 setPreferenceProperty( segLen, "max", 10000000 );
5165 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5166 "SMESH", "nb_segments_per_edge" );
5167 setPreferenceProperty( nbSeg, "min", 1 );
5168 setPreferenceProperty( nbSeg, "max", 10000000 );
5170 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5171 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5172 "SMESH", "forget_mesh_on_hyp_modif" );
5175 // Quantities with individual precision settings
5176 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5177 setPreferenceProperty( precGroup, "columns", 2 );
5179 const int nbQuantities = 6;
5180 int precs[nbQuantities], ii = 0;
5181 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5182 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5183 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5184 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5185 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5186 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5187 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5188 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5189 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5190 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5191 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5192 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5194 // Set property for precision value for spinboxes
5195 for ( ii = 0; ii < nbQuantities; ii++ ){
5196 setPreferenceProperty( precs[ii], "min", -14 );
5197 setPreferenceProperty( precs[ii], "max", 14 );
5198 setPreferenceProperty( precs[ii], "precision", 2 );
5201 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5202 setPreferenceProperty( previewGroup, "columns", 2 );
5203 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5204 setPreferenceProperty( chunkSize, "min", 1 );
5205 setPreferenceProperty( chunkSize, "max", 1000 );
5206 setPreferenceProperty( chunkSize, "step", 50 );
5208 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5209 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5211 // Mesh tab ------------------------------------------------------------------------
5212 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5213 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5214 setPreferenceProperty( nodeGroup, "columns", 3 );
5216 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5218 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5220 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5221 QList<QVariant> aMarkerTypeIndicesList;
5222 QList<QVariant> aMarkerTypeIconsList;
5223 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5224 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5225 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5226 aMarkerTypeIndicesList << i;
5227 aMarkerTypeIconsList << pixmap;
5229 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5230 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
5232 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5234 QList<QVariant> aMarkerScaleIndicesList;
5235 QStringList aMarkerScaleValuesList;
5236 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5237 aMarkerScaleIndicesList << i;
5238 //aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5239 aMarkerScaleValuesList << QString::number( i );
5241 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5242 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5244 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5245 //setPreferenceProperty( elemGroup, "columns", 2 );
5247 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5248 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5249 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5250 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5251 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5252 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5253 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5254 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5255 addPreference( tr( "PREF_PREVIEW_COLOR" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5258 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5259 setPreferenceProperty( grpGroup, "columns", 2 );
5261 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5262 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5264 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5265 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5266 /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5267 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5268 double ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5269 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5270 double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5271 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5272 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
5273 LightApp_Preferences::IntSpin, "SMESH", "element_width");
5274 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5275 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5276 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5277 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5279 setPreferenceProperty( size0d, "min", 1 );
5280 setPreferenceProperty( size0d, "max", 10 );
5282 // setPreferenceProperty( ballSize, "min", 1 );
5283 // setPreferenceProperty( ballSize, "max", 10 );
5285 setPreferenceProperty( ballDiameter, "min", 1e-7 );
5286 setPreferenceProperty( ballDiameter, "max", 1e9 );
5287 setPreferenceProperty( ballDiameter, "step", 0.1 );
5289 setPreferenceProperty( ballScale, "min", 1e-2 );
5290 setPreferenceProperty( ballScale, "max", 1e7 );
5291 setPreferenceProperty( ballScale, "step", 0.5 );
5293 setPreferenceProperty( elemW, "min", 1 );
5294 setPreferenceProperty( elemW, "max", 5 );
5296 setPreferenceProperty( outW, "min", 1 );
5297 setPreferenceProperty( outW, "max", 5 );
5299 setPreferenceProperty( shrink, "min", 0 );
5300 setPreferenceProperty( shrink, "max", 100 );
5302 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5303 setPreferenceProperty( numGroup, "columns", 2 );
5305 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5306 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5308 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5309 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5311 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5312 setPreferenceProperty( orientGroup, "columns", 1 );
5314 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5315 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5317 setPreferenceProperty( orientScale, "min", 0.05 );
5318 setPreferenceProperty( orientScale, "max", 0.5 );
5319 setPreferenceProperty( orientScale, "step", 0.05 );
5321 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5323 // Selection tab ------------------------------------------------------------------------
5324 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5326 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5327 setPreferenceProperty( selGroup, "columns", 2 );
5329 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5330 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5332 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5333 setPreferenceProperty( preGroup, "columns", 2 );
5335 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5337 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5338 setPreferenceProperty( precSelGroup, "columns", 2 );
5340 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5341 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5342 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5344 // Scalar Bar tab ------------------------------------------------------------------------
5345 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5346 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5347 setPreferenceProperty( fontGr, "columns", 2 );
5349 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5350 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5352 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5353 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5355 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5356 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5358 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5359 setPreferenceProperty( numcol, "min", 2 );
5360 setPreferenceProperty( numcol, "max", 256 );
5362 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5363 setPreferenceProperty( numlab, "min", 2 );
5364 setPreferenceProperty( numlab, "max", 65 );
5366 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5367 setPreferenceProperty( orientGr, "columns", 2 );
5368 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5369 QStringList orients;
5370 orients.append( tr( "SMESH_VERTICAL" ) );
5371 orients.append( tr( "SMESH_HORIZONTAL" ) );
5372 indices.clear(); indices.append( 0 ); indices.append( 1 );
5373 setPreferenceProperty( orient, "strings", orients );
5374 setPreferenceProperty( orient, "indexes", indices );
5376 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5377 setPreferenceProperty( posVSizeGr, "columns", 2 );
5378 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5379 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5380 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5381 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5382 setPreferenceProperty( xv, "step", 0.1 );
5383 setPreferenceProperty( xv, "min", 0.0 );
5384 setPreferenceProperty( xv, "max", 1.0 );
5385 setPreferenceProperty( yv, "step", 0.1 );
5386 setPreferenceProperty( yv, "min", 0.0 );
5387 setPreferenceProperty( yv, "max", 1.0 );
5388 setPreferenceProperty( wv, "step", 0.1 );
5389 setPreferenceProperty( wv, "min", 0.0 );
5390 setPreferenceProperty( wv, "max", 1.0 );
5391 setPreferenceProperty( hv, "min", 0.0 );
5392 setPreferenceProperty( hv, "max", 1.0 );
5393 setPreferenceProperty( hv, "step", 0.1 );
5395 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5396 setPreferenceProperty( posHSizeGr, "columns", 2 );
5397 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5398 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5399 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5400 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5401 setPreferenceProperty( xv, "min", 0.0 );
5402 setPreferenceProperty( xv, "max", 1.0 );
5403 setPreferenceProperty( xv, "step", 0.1 );
5404 setPreferenceProperty( xh, "min", 0.0 );
5405 setPreferenceProperty( xh, "max", 1.0 );
5406 setPreferenceProperty( xh, "step", 0.1 );
5407 setPreferenceProperty( yh, "min", 0.0 );
5408 setPreferenceProperty( yh, "max", 1.0 );
5409 setPreferenceProperty( yh, "step", 0.1 );
5410 setPreferenceProperty( wh, "min", 0.0 );
5411 setPreferenceProperty( wh, "max", 1.0 );
5412 setPreferenceProperty( wh, "step", 0.1 );
5413 setPreferenceProperty( hh, "min", 0.0 );
5414 setPreferenceProperty( hh, "max", 1.0 );
5415 setPreferenceProperty( hh, "step", 0.1 );
5417 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5418 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5419 setPreferenceProperty( distributionGr, "columns", 3 );
5421 types.append( tr( "SMESH_MONOCOLOR" ) );
5422 types.append( tr( "SMESH_MULTICOLOR" ) );
5423 indices.clear(); indices.append( 0 ); indices.append( 1 );
5424 setPreferenceProperty( coloringType, "strings", types );
5425 setPreferenceProperty( coloringType, "indexes", indices );
5426 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5430 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5432 if ( sect=="SMESH" ) {
5433 float sbX1 = 0.01, sbY1 = 0.01, sbW = 0.08, sbH = 0.08;
5434 float aTol = 1.00000009999999;
5435 std::string aWarning;
5436 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5438 if ( name== "selection_object_color" ||
5439 name=="selection_element_color" ||
5440 name== "highlight_color" ||
5441 name=="selection_precision_node" ||
5442 name=="selection_precision_element" ||
5443 name=="selection_precision_object" )
5445 SMESH::UpdateSelectionProp( this );
5447 else if (name == "scalar_bar_vertical_x" || name == "scalar_bar_vertical_width")
5449 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5450 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5451 if ( sbX1+sbW > aTol ) {
5452 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5455 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5456 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5459 else if (name == "scalar_bar_vertical_y" || name == "scalar_bar_vertical_height" )
5461 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5462 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5463 if ( sbY1 + sbH > aTol ) {
5464 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5465 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5466 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5469 else if (name == "scalar_bar_horizontal_x" || name == "scalar_bar_horizontal_width")
5471 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5472 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5473 if ( sbX1 + sbW > aTol ) {
5474 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5477 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5478 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5481 else if (name == "scalar_bar_horizontal_y" || name == "scalar_bar_horizontal_height")
5483 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5484 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5485 if ( sbY1 + sbH > aTol ) {
5486 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5489 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5490 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5493 else if ( name == "segmentation" )
5495 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5496 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5498 else if ( name == "nb_segments_per_edge" )
5500 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5501 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5503 else if ( name == "historical_python_dump" || name == "forget_mesh_on_hyp_modif" || name == "default_grp_color" )
5505 QString val = aResourceMgr->stringValue( "SMESH", name );
5506 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5508 else if ( name == "numbering_node_color" || name == "numbering_node_font" )
5510 SMESH::UpdateFontProp( this );
5512 else if ( name == "numbering_elem_color" || name == "numbering_elem_font" )
5514 SMESH::UpdateFontProp( this );
5517 if ( aWarning.size() != 0 ) {
5518 aWarning += "The default values are applied instead.";
5519 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5520 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5521 QObject::tr(aWarning.c_str()));
5526 //================================================================================
5528 * \brief Update something in accordance with update flags
5529 * \param theFlags - update flags
5531 * Update viewer or/and object browser etc. in accordance with update flags ( see
5532 * LightApp_UpdateFlags enumeration ).
5534 //================================================================================
5535 void SMESHGUI::update( const int flags )
5537 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5538 SMESH::UpdateView();
5540 SalomeApp_Module::update( flags );
5543 //================================================================================
5545 * \brief Set default selection mode
5547 * SLOT called when operation committed. Sets default selection mode
5549 //================================================================================
5550 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5552 SVTK_ViewWindow* vtkWnd =
5553 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5555 vtkWnd->SetSelectionMode( ActorSelection );
5558 //================================================================================
5560 * \brief Set default selection mode
5562 * SLOT called when operation aborted. Sets default selection mode
5564 //================================================================================
5565 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5567 SVTK_ViewWindow* vtkWnd =
5568 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5570 vtkWnd->SetSelectionMode( ActorSelection );
5573 //================================================================================
5575 * \brief Creates operation with given identifier
5576 * \param id - identifier of operation to be started
5577 * \return Pointer on created operation or NULL if operation is not created
5579 * Virtual method redefined from the base class creates operation with given id.
5580 * It is called called automatically from startOperation method of base class.
5582 //================================================================================
5583 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5585 LightApp_Operation* op = 0;
5586 // to do : create operation here
5589 case SMESHOp::OpSplitBiQuadratic:
5590 op = new SMESHGUI_SplitBiQuadOp();
5592 case SMESHOp::OpConvertMeshToQuadratic:
5593 op = new SMESHGUI_ConvToQuadOp();
5595 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5596 op = new SMESHGUI_Make2DFrom3DOp();
5598 case SMESHOp::OpReorientFaces:
5599 op = new SMESHGUI_ReorientFacesOp();
5601 case SMESHOp::OpCreateMesh:
5602 op = new SMESHGUI_MeshOp( true, true );
5604 case SMESHOp::OpCreateSubMesh:
5605 op = new SMESHGUI_MeshOp( true, false );
5607 case SMESHOp::OpEditMeshOrSubMesh:
5608 case SMESHOp::OpEditMesh:
5609 case SMESHOp::OpEditSubMesh:
5610 op = new SMESHGUI_MeshOp( false );
5612 case SMESHOp::OpCompute:
5613 case SMESHOp::OpComputeSubMesh:
5614 op = new SMESHGUI_ComputeOp();
5616 case SMESHOp::OpPreCompute:
5617 op = new SMESHGUI_PrecomputeOp();
5619 case SMESHOp::OpEvaluate:
5620 op = new SMESHGUI_EvaluateOp();
5622 case SMESHOp::OpMeshOrder:
5623 op = new SMESHGUI_MeshOrderOp();
5625 case SMESHOp::OpCreateGeometryGroup:
5626 op = new SMESHGUI_GroupOnShapeOp();
5628 case SMESHOp::OpFindElementByPoint:
5629 op = new SMESHGUI_FindElemByPointOp();
5631 case SMESHOp::OpMoveNode: // Make mesh pass through point
5632 op = new SMESHGUI_MakeNodeAtPointOp();
5634 case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
5635 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5642 op = SalomeApp_Module::createOperation( id );
5646 //================================================================================
5648 * \brief Stops current operations and starts a given one
5649 * \param id - The id of the operation to start
5651 //================================================================================
5653 void SMESHGUI::switchToOperation(int id)
5655 if ( _PTR(Study) aStudy = SMESH::GetActiveStudyDocument() )
5656 activeStudy()->abortAllOperations();
5657 startOperation( id );
5660 LightApp_Displayer* SMESHGUI::displayer()
5663 myDisplayer = new SMESHGUI_Displayer( getApp() );
5667 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5670 int aTolerance = 64;
5671 int anIterations = 0;
5677 if( anIterations % aPeriod == 0 )
5680 if( aTolerance < 1 )
5684 aHue = (int)( 360.0 * rand() / RAND_MAX );
5687 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5688 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5689 for( ; it != itEnd; ++it )
5691 SALOMEDS::Color anAutoColor = *it;
5692 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5695 aQColor.getHsv( &h, &s, &v );
5696 if( abs( h - aHue ) < aTolerance )
5708 aColor.setHsv( aHue, 255, 255 );
5710 SALOMEDS::Color aSColor;
5711 aSColor.R = aColor.redF();
5712 aSColor.G = aColor.greenF();
5713 aSColor.B = aColor.blueF();
5718 const char* gSeparator = "_"; // character used to separate parameter names
5719 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5720 const char* gPathSep = "|"; // character used to separate paths
5723 * \brief Store visual parameters
5725 * This method is called just before the study document is saved.
5726 * Store visual parameters in AttributeParameter attribue(s)
5728 void SMESHGUI::storeVisualParameters (int savePoint)
5731 Kernel_Utils::Localizer loc;
5733 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5734 if (!appStudy || !appStudy->studyDS())
5736 _PTR(Study) studyDS = appStudy->studyDS();
5738 // componentName is used for encoding of entries when storing them in IParameters
5739 std::string componentName = myComponentSMESH->ComponentDataType();
5740 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5741 //if (!aSComponent) return;
5744 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5745 componentName.c_str(),
5747 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5749 // store map of custom markers
5750 const VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5751 if( !aMarkerMap.empty() )
5753 VTK::MarkerMap::const_iterator anIter = aMarkerMap.begin();
5754 for( ; anIter != aMarkerMap.end(); anIter++ )
5756 int anId = anIter->first;
5757 VTK::MarkerData aMarkerData = anIter->second;
5758 std::string aMarkerFileName = aMarkerData.first;
5759 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5760 if( aMarkerTexture.size() < 3 )
5761 continue; // should contain at least width, height and the first value
5763 QString aPropertyName( "texture" );
5764 aPropertyName += gSeparator;
5765 aPropertyName += QString::number( anId );
5767 QString aPropertyValue = aMarkerFileName.c_str();
5768 aPropertyValue += gPathSep;
5770 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5771 ushort aWidth = *aTextureIter++;
5772 ushort aHeight = *aTextureIter++;
5773 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5774 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5775 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5776 aPropertyValue += QString::number( *aTextureIter );
5778 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5782 // viewers counters are used for storing view_numbers in IParameters
5785 // main cycle to store parameters of displayed objects
5786 QList<SUIT_ViewManager*> lst;
5787 QList<SUIT_ViewManager*>::Iterator it;
5788 getApp()->viewManagers(lst);
5789 for (it = lst.begin(); it != lst.end(); it++)
5791 SUIT_ViewManager* vman = *it;
5792 QString vType = vman->getType();
5794 // saving VTK actors properties
5795 if (vType == SVTK_Viewer::Type())
5797 // store the clipping planes attached to the view manager
5798 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5799 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5800 if( anIter != myClippingPlaneInfoMap.end() )
5801 aClippingPlaneInfoList = anIter->second;
5803 if( !aClippingPlaneInfoList.empty() ) {
5804 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5805 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5807 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5808 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5810 QString aPropertyName( "ClippingPlane" );
5811 aPropertyName += gSeparator;
5812 aPropertyName += QString::number( vtkViewers );
5813 aPropertyName += gSeparator;
5814 aPropertyName += QString::number( anId );
5816 QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
5817 aPropertyValue += gDigitsSep;
5818 aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
5819 aPropertyValue += gDigitsSep;
5820 if ( aPlane->PlaneMode == SMESH::Absolute ) {
5821 aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
5822 aPropertyValue += gDigitsSep;
5823 aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
5824 aPropertyValue += gDigitsSep;
5825 aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
5826 aPropertyValue += gDigitsSep;
5827 aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
5828 aPropertyValue += gDigitsSep;
5829 aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
5830 aPropertyValue += gDigitsSep;
5831 aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
5832 aPropertyValue += gDigitsSep;
5833 aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
5835 else if ( aPlane->PlaneMode == SMESH::Relative ) {
5836 aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
5837 aPropertyValue += gDigitsSep;
5838 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5839 aPropertyValue += gDigitsSep;
5840 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5841 aPropertyValue += gDigitsSep;
5842 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5845 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5849 QVector<SUIT_ViewWindow*> views = vman->getViews();
5850 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5852 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5854 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5855 vtkActorCollection* allActors = aCopy.GetActors();
5856 allActors->InitTraversal();
5857 while (vtkActor* actor = allActors->GetNextActor())
5859 if (actor->GetVisibility()) // store only visible actors
5861 SMESH_Actor* aSmeshActor = 0;
5862 if (actor->IsA("SMESH_Actor"))
5863 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5864 if (aSmeshActor && aSmeshActor->hasIO())
5866 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5869 // entry is "encoded" = it does NOT contain component address,
5870 // since it is a subject to change on next component loading
5871 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5873 std::string param, vtkParam = vType.toLatin1().data();
5874 vtkParam += gSeparator;
5875 vtkParam += QString::number(vtkViewers).toLatin1().data();
5876 vtkParam += gSeparator;
5879 param = vtkParam + "Visibility";
5880 ip->setParameter(entry, param, "On");
5883 param = vtkParam + "Representation";
5884 ip->setParameter(entry, param, QString::number
5885 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5888 param = vtkParam + "IsShrunk";
5889 ip->setParameter(entry, param, QString::number
5890 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5892 // Displayed entities
5893 unsigned int aMode = aSmeshActor->GetEntityMode();
5894 bool isE = aMode & SMESH_Actor::eEdges;
5895 bool isF = aMode & SMESH_Actor::eFaces;
5896 bool isV = aMode & SMESH_Actor::eVolumes;
5897 bool is0d = aMode & SMESH_Actor::e0DElements;
5898 bool isB = aMode & SMESH_Actor::eBallElem;
5900 QString modeStr ("e");
5901 modeStr += gDigitsSep; modeStr += QString::number(isE);
5902 modeStr += gDigitsSep; modeStr += "f";
5903 modeStr += gDigitsSep; modeStr += QString::number(isF);
5904 modeStr += gDigitsSep; modeStr += "v";
5905 modeStr += gDigitsSep; modeStr += QString::number(isV);
5906 modeStr += gDigitsSep; modeStr += "0d";
5907 modeStr += gDigitsSep; modeStr += QString::number(is0d);
5908 modeStr += gDigitsSep; modeStr += "b";
5909 modeStr += gDigitsSep; modeStr += QString::number(isB);
5911 param = vtkParam + "Entities";
5912 ip->setParameter(entry, param, modeStr.toLatin1().data());
5918 aSmeshActor->GetSufaceColor(r, g, b, delta);
5919 QStringList colorStr;
5920 colorStr << "surface";
5921 colorStr << QString::number(r);
5922 colorStr << QString::number(g);
5923 colorStr << QString::number(b);
5925 colorStr << "backsurface";
5926 colorStr << QString::number(delta);
5928 aSmeshActor->GetVolumeColor(r, g, b, delta);
5929 colorStr << "volume";
5930 colorStr << QString::number(r);
5931 colorStr << QString::number(g);
5932 colorStr << QString::number(b);
5933 colorStr << QString::number(delta);
5935 aSmeshActor->GetEdgeColor(r, g, b);
5937 colorStr << QString::number(r);
5938 colorStr << QString::number(g);
5939 colorStr << QString::number(b);
5941 aSmeshActor->GetNodeColor(r, g, b);
5943 colorStr << QString::number(r);
5944 colorStr << QString::number(g);
5945 colorStr << QString::number(b);
5947 aSmeshActor->GetOutlineColor(r, g, b);
5948 colorStr << "outline";
5949 colorStr << QString::number(r);
5950 colorStr << QString::number(g);
5951 colorStr << QString::number(b);
5953 aSmeshActor->Get0DColor(r, g, b);
5954 colorStr << "elem0d";
5955 colorStr << QString::number(r);
5956 colorStr << QString::number(g);
5957 colorStr << QString::number(b);
5959 aSmeshActor->GetBallColor(r, g, b);
5961 colorStr << QString::number(r);
5962 colorStr << QString::number(g);
5963 colorStr << QString::number(b);
5965 aSmeshActor->GetFacesOrientationColor(r, g, b);
5966 colorStr << "orientation";
5967 colorStr << QString::number(r);
5968 colorStr << QString::number(g);
5969 colorStr << QString::number(b);
5971 param = vtkParam + "Colors";
5972 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
5975 QStringList sizeStr;
5977 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
5978 sizeStr << "outline";
5979 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
5980 sizeStr << "elem0d";
5981 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
5983 //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
5984 sizeStr << QString::number((double)aSmeshActor->GetBallSize());
5985 sizeStr << QString::number((double)aSmeshActor->GetBallScale());
5986 sizeStr << "shrink";
5987 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
5988 sizeStr << "orientation";
5989 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
5990 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
5992 param = vtkParam + "Sizes";
5993 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
5998 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5999 if( aMarkerType == VTK::MT_USER ) {
6000 markerStr += "custom";
6001 markerStr += gDigitsSep;
6002 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
6006 markerStr += gDigitsSep;
6007 markerStr += QString::number( (int)aMarkerType );
6008 markerStr += gDigitsSep;
6009 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
6012 param = vtkParam + "PointMarker";
6013 ip->setParameter(entry, param, markerStr.toLatin1().data());
6016 param = vtkParam + "Opacity";
6017 ip->setParameter(entry, param,
6018 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
6021 param = vtkParam + "ClippingPlane";
6023 if( !aClippingPlaneInfoList.empty() ) {
6024 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
6025 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
6027 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
6028 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
6029 SMESH::TActorList::iterator anIter2 = anActorList.begin();
6030 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
6031 if( aSmeshActor == *anIter2 ) {
6032 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
6033 QString::number( anId ).toLatin1().constData() );
6040 ip->setParameter( entry, param, "Off" );
6041 } // if (io->hasEntry())
6042 } // SMESH_Actor && hasIO
6044 } // while.. actors traversal
6048 } // if (SVTK view model)
6049 } // for (viewManagers)
6052 // data structures for clipping planes processing
6056 bool isOpenGLClipping;
6057 vtkIdType RelativeOrientation;
6060 int AbsoluteOrientation;
6061 double X, Y, Z, Dx, Dy, Dz;
6063 typedef std::list<TPlaneData> TPlaneDataList;
6064 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
6066 typedef std::list<vtkActor*> TActorList;
6069 TActorList ActorList;
6070 SUIT_ViewManager* ViewManager;
6072 typedef std::list<TPlaneInfo> TPlaneInfoList;
6073 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
6076 * \brief Restore visual parameters
6078 * This method is called after the study document is opened.
6079 * Restore visual parameters from AttributeParameter attribue(s)
6081 void SMESHGUI::restoreVisualParameters (int savePoint)
6084 Kernel_Utils::Localizer loc;
6086 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6087 if (!appStudy || !appStudy->studyDS())
6089 _PTR(Study) studyDS = appStudy->studyDS();
6091 // componentName is used for encoding of entries when storing them in IParameters
6092 std::string componentName = myComponentSMESH->ComponentDataType();
6093 //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
6094 //if (!aSComponent) return;
6097 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6098 componentName.c_str(),
6100 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6102 // restore map of custom markers and map of clipping planes
6103 VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
6104 TPlaneDataMap aPlaneDataMap;
6106 std::vector<std::string> properties = ip->getProperties();
6107 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
6109 std::string property = *propIt;
6110 QString aPropertyName( property.c_str() );
6111 QString aPropertyValue( ip->getProperty( property ).c_str() );
6113 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
6114 if( aPropertyNameList.isEmpty() )
6117 QString aPropertyType = aPropertyNameList[0];
6118 if( aPropertyType == "texture" )
6120 if( aPropertyNameList.size() != 2 )
6124 int anId = aPropertyNameList[1].toInt( &ok );
6125 if( !ok || anId < 1 )
6128 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
6129 if( aPropertyValueList.size() != 2 )
6132 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
6133 QString aMarkerTextureString = aPropertyValueList[1];
6134 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
6135 if( aMarkerTextureStringList.size() != 3 )
6139 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6144 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6148 VTK::MarkerTexture aMarkerTexture;
6149 aMarkerTexture.push_back( aWidth );
6150 aMarkerTexture.push_back( aHeight );
6152 QString aMarkerTextureData = aMarkerTextureStringList[2];
6153 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6155 QChar aChar = aMarkerTextureData.at( i );
6156 if( aChar.isDigit() )
6157 aMarkerTexture.push_back( aChar.digitValue() );
6160 aMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6162 else if( aPropertyType == "ClippingPlane" )
6164 if( aPropertyNameList.size() != 3 )
6168 int aViewId = aPropertyNameList[1].toInt( &ok );
6169 if( !ok || aViewId < 0 )
6173 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6174 if( !ok || aClippingPlaneId < 0 )
6177 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6178 if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6181 TPlaneData aPlaneData;
6182 aPlaneData.AbsoluteOrientation = false;
6183 aPlaneData.RelativeOrientation = 0;
6184 aPlaneData.Distance = aPlaneData.Angle[0] = aPlaneData.Angle[1] = 0;
6185 aPlaneData.X = aPlaneData.Y = aPlaneData.Z = 0;
6186 aPlaneData.Dx = aPlaneData.Dy = aPlaneData.Dz = 0;
6188 aPlaneData.Id = aClippingPlaneId;
6191 aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6196 aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6200 if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6203 aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6208 aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6213 aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6218 aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6223 aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6228 aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6233 aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6237 else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6239 aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6244 aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6249 aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6254 aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6259 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6260 aPlaneDataList.push_back( aPlaneData );
6264 TPlaneInfoMap aPlaneInfoMap;
6266 std::vector<std::string> entries = ip->getEntries();
6268 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6270 // entry is a normal entry - it should be "decoded" (setting base address of component)
6271 QString entry (ip->decodeEntry(*entIt).c_str());
6273 // Check that the entry corresponds to a real object in the Study
6274 // as the object may be deleted or modified after the visual state is saved.
6275 _PTR(SObject) so = studyDS->FindObjectID(entry.toLatin1().data());
6276 if (!so) continue; //Skip the not existent entry
6278 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6279 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6281 std::vector<std::string>::iterator namesIt = paramNames.begin();
6282 std::vector<std::string>::iterator valuesIt = paramValues.begin();
6284 // actors are stored in a map after displaying of them for
6285 // quicker access in the future: map < viewID to actor >
6286 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6288 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6290 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6291 // '_' is used as separator and should not be used in viewer type or parameter names.
6292 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6293 if (lst.size() != 3)
6296 QString viewerTypStr = lst[0];
6297 QString viewIndexStr = lst[1];
6298 QString paramNameStr = lst[2];
6301 int viewIndex = viewIndexStr.toUInt(&ok);
6302 if (!ok) // bad conversion of view index to integer
6306 if (viewerTypStr == SVTK_Viewer::Type())
6308 SMESH_Actor* aSmeshActor = 0;
6309 if (vtkActors.IsBound(viewIndex))
6310 aSmeshActor = vtkActors.Find(viewIndex);
6312 QList<SUIT_ViewManager*> lst;
6313 getApp()->viewManagers(viewerTypStr, lst);
6315 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6316 SUIT_ViewManager* vman = NULL;
6317 if (viewIndex >= 0 && viewIndex < lst.count())
6318 vman = lst.at(viewIndex);
6320 if (paramNameStr == "Visibility")
6322 if (!aSmeshActor && displayer() && vman)
6324 SUIT_ViewModel* vmodel = vman->getViewModel();
6325 // SVTK view model can be casted to SALOME_View
6326 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6328 // store displayed actor in a temporary map for quicker
6329 // access later when restoring other parameters
6330 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6331 vtkRenderer* Renderer = vtkView->getRenderer();
6332 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6333 vtkActorCollection* theActors = aCopy.GetActors();
6334 theActors->InitTraversal();
6335 bool isFound = false;
6336 vtkActor *ac = theActors->GetNextActor();
6337 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6338 if (ac->IsA("SMESH_Actor")) {
6339 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6340 if (aGeomAc->hasIO()) {
6341 Handle(SALOME_InteractiveObject) io = aGeomAc->getIO();
6342 if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) {
6344 vtkActors.Bind(viewIndex, aGeomAc);
6350 } // if (paramNameStr == "Visibility")
6353 // the rest properties "work" with SMESH_Actor
6356 QString val ((*valuesIt).c_str());
6359 if (paramNameStr == "Representation") {
6360 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6363 else if (paramNameStr == "IsShrunk") {
6365 if (!aSmeshActor->IsShrunk())
6366 aSmeshActor->SetShrink();
6369 if (aSmeshActor->IsShrunk())
6370 aSmeshActor->UnShrink();
6373 // Displayed entities
6374 else if (paramNameStr == "Entities") {
6375 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6376 int aEntityMode = SMESH_Actor::eAllEntity;
6377 for ( int i = 0; i < mode.count(); i+=2 ) {
6378 if ( i < mode.count()-1 ) {
6379 QString type = mode[i];
6380 bool val = mode[i+1].toInt();
6381 if ( type == "e" && !val )
6382 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6383 else if ( type == "f" && !val )
6384 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6385 else if ( type == "v" && !val )
6386 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6387 else if ( type == "0d" && !val )
6388 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6389 else if ( type == "b" && !val )
6390 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6393 aSmeshActor->SetEntityMode( aEntityMode );
6396 else if (paramNameStr == "Colors") {
6397 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6404 QColor outlineColor;
6405 QColor orientationColor;
6411 // below lines are required to get default values for delta coefficients
6412 // of backface color for faces and color of reversed volumes
6413 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
6414 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6415 for ( int i = 0; i < colors.count(); i++ ) {
6416 QString type = colors[i];
6417 if ( type == "surface" ) {
6418 // face color is set by 3 values r:g:b, where
6419 // - r,g,b - is rgb color components
6420 if ( i+1 >= colors.count() ) break; // format error
6421 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6422 if ( i+2 >= colors.count() ) break; // format error
6423 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6424 if ( i+3 >= colors.count() ) break; // format error
6425 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6426 faceColor.setRgbF( r, g, b );
6429 else if ( type == "backsurface" ) {
6430 // backface color can be defined in several ways
6431 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6432 // - in latest versions, it is set as delta coefficient
6433 bool rgbOk = false, deltaOk;
6434 if ( i+1 >= colors.count() ) break; // format error
6435 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6436 int delta = colors[i+1].toInt( &deltaOk );
6438 if ( i+1 < colors.count() ) // index is shifted to 1
6439 g = colors[i+1].toDouble( &rgbOk );
6440 if ( rgbOk ) i++; // shift index
6441 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6442 b = colors[i+1].toDouble( &rgbOk );
6444 // - as currently there's no way to set directly backsurface color as it was before,
6445 // we ignore old dump where r,g,b triple was set
6446 // - also we check that delta parameter is set properly
6447 if ( !rgbOk && deltaOk )
6450 else if ( type == "volume" ) {
6451 // volume color is set by 4 values r:g:b:delta, where
6452 // - r,g,b - is a normal volume rgb color components
6453 // - delta - is a reversed volume color delta coefficient
6454 if ( i+1 >= colors.count() ) break; // format error
6455 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6456 if ( i+2 >= colors.count() ) break; // format error
6457 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6458 if ( i+3 >= colors.count() ) break; // format error
6459 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6460 if ( i+4 >= colors.count() ) break; // format error
6461 int delta = colors[i+4].toInt( &bOk );
6462 if ( !bOk ) break; // format error
6463 volumeColor.setRgbF( r, g, b );
6467 else if ( type == "edge" ) {
6468 // edge color is set by 3 values r:g:b, where
6469 // - r,g,b - is rgb color components
6470 if ( i+1 >= colors.count() ) break; // format error
6471 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6472 if ( i+2 >= colors.count() ) break; // format error
6473 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6474 if ( i+3 >= colors.count() ) break; // format error
6475 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6476 edgeColor.setRgbF( r, g, b );
6479 else if ( type == "node" ) {
6480 // node color is set by 3 values r:g:b, where
6481 // - r,g,b - is rgb color components
6482 if ( i+1 >= colors.count() ) break; // format error
6483 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6484 if ( i+2 >= colors.count() ) break; // format error
6485 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6486 if ( i+3 >= colors.count() ) break; // format error
6487 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6488 nodeColor.setRgbF( r, g, b );
6491 else if ( type == "elem0d" ) {
6492 // 0d element color is set by 3 values r:g:b, where
6493 // - r,g,b - is rgb color components
6494 if ( i+1 >= colors.count() ) break; // format error
6495 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6496 if ( i+2 >= colors.count() ) break; // format error
6497 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6498 if ( i+3 >= colors.count() ) break; // format error
6499 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6500 elem0dColor.setRgbF( r, g, b );
6503 else if ( type == "ball" ) {
6504 // ball color is set by 3 values r:g:b, where
6505 // - r,g,b - is rgb color components
6506 if ( i+1 >= colors.count() ) break; // format error
6507 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6508 if ( i+2 >= colors.count() ) break; // format error
6509 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6510 if ( i+3 >= colors.count() ) break; // format error
6511 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6512 ballColor.setRgbF( r, g, b );
6515 else if ( type == "outline" ) {
6516 // outline color is set by 3 values r:g:b, where
6517 // - r,g,b - is rgb color components
6518 if ( i+1 >= colors.count() ) break; // format error
6519 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6520 if ( i+2 >= colors.count() ) break; // format error
6521 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6522 if ( i+3 >= colors.count() ) break; // format error
6523 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6524 outlineColor.setRgbF( r, g, b );
6527 else if ( type == "orientation" ) {
6528 // orientation color is set by 3 values r:g:b, where
6529 // - r,g,b - is rgb color components
6530 if ( i+1 >= colors.count() ) break; // format error
6531 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6532 if ( i+2 >= colors.count() ) break; // format error
6533 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6534 if ( i+3 >= colors.count() ) break; // format error
6535 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6536 orientationColor.setRgbF( r, g, b );
6541 if ( nodeColor.isValid() )
6542 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6544 if ( edgeColor.isValid() )
6545 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6547 if ( faceColor.isValid() )
6548 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6550 if ( volumeColor.isValid() )
6551 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6552 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6553 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6555 if ( elem0dColor.isValid() )
6556 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6558 if ( ballColor.isValid() )
6559 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6561 if ( outlineColor.isValid() )
6562 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6563 // orientation color
6564 if ( orientationColor.isValid() )
6565 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6568 else if (paramNameStr == "Sizes") {
6569 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6572 int outlineWidth = -1;
6573 int elem0dSize = -1;
6574 //int ballSize = -1;
6575 double ballDiameter = -1.0;
6576 double ballScale = -1.0;
6577 double shrinkSize = -1;
6578 double orientationSize = -1;
6579 bool orientation3d = false;
6580 for ( int i = 0; i < sizes.count(); i++ ) {
6581 QString type = sizes[i];
6582 if ( type == "line" ) {
6583 // line (wireframe) width is given as single integer value
6584 if ( i+1 >= sizes.count() ) break; // format error
6585 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6589 if ( type == "outline" ) {
6590 // outline width is given as single integer value
6591 if ( i+1 >= sizes.count() ) break; // format error
6592 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6596 else if ( type == "elem0d" ) {
6597 // 0d element size is given as single integer value
6598 if ( i+1 >= sizes.count() ) break; // format error
6599 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6603 else if ( type == "ball" ) {
6604 // balls are specified by two values: size:scale, where
6605 // - size - is a integer value specifying size
6606 // - scale - is a double value specifying scale factor
6607 if ( i+1 >= sizes.count() ) break; // format error
6608 //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6609 double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6610 if ( i+2 >= sizes.count() ) break; // format error
6611 double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6617 else if ( type == "shrink" ) {
6618 // shrink factor is given as single floating point value
6619 if ( i+1 >= sizes.count() ) break; // format error
6620 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6624 else if ( type == "orientation" ) {
6625 // orientation vectors are specified by two values size:3d, where
6626 // - size - is a floating point value specifying scale factor
6627 // - 3d - is a boolean
6628 if ( i+1 >= sizes.count() ) break; // format error
6629 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6630 if ( i+2 >= sizes.count() ) break; // format error
6631 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6632 orientationSize = v1;
6633 orientation3d = (bool)v2;
6637 // line (wireframe) width
6638 if ( lineWidth > 0 )
6639 aSmeshActor->SetLineWidth( lineWidth );
6641 if ( outlineWidth > 0 )
6642 aSmeshActor->SetOutlineWidth( outlineWidth );
6643 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6644 aSmeshActor->SetOutlineWidth( lineWidth );
6646 if ( elem0dSize > 0 )
6647 aSmeshActor->Set0DSize( elem0dSize );
6649 /*if ( ballSize > 0 )
6650 aSmeshActor->SetBallSize( ballSize );*/
6652 if ( ballDiameter > 0 )
6653 aSmeshActor->SetBallSize( ballDiameter );
6655 if ( ballScale > 0.0 )
6656 aSmeshActor->SetBallScale( ballScale );
6658 if ( shrinkSize > 0 )
6659 aSmeshActor->SetShrinkFactor( shrinkSize );
6660 // orientation vectors
6661 if ( orientationSize > 0 ) {
6662 aSmeshActor->SetFacesOrientationScale( orientationSize );
6663 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6667 else if (paramNameStr == "PointMarker") {
6668 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6669 if( data.count() >= 2 ) {
6671 int aParam1 = data[1].toInt( &ok );
6673 if( data[0] == "std" && data.count() == 3 ) {
6674 int aParam2 = data[2].toInt( &ok );
6675 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6677 else if( data[0] == "custom" ) {
6678 VTK::MarkerMap::const_iterator markerIt = aMarkerMap.find( aParam1 );
6679 if( markerIt != aMarkerMap.end() ) {
6680 VTK::MarkerData aMarkerData = markerIt->second;
6681 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6688 else if (paramNameStr == "Opacity") {
6689 aSmeshActor->SetOpacity(val.toFloat());
6692 else if (paramNameStr.startsWith("ClippingPlane")) {
6693 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6694 // old format - val looks like "Off" or "1:0:0:0.5:0:0"
6695 // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
6696 // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
6697 // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
6698 // new format - val looks like "Off" or "0" (plane id)
6699 // (note: in new format "Off" value is used only for consistency,
6700 // so it is processed together with values in old format)
6701 bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
6702 if( anIsOldFormat ) {
6703 if (paramNameStr == "ClippingPlane1" || val == "Off")
6704 aSmeshActor->RemoveAllClippingPlanes();
6706 QList<SUIT_ViewManager*> lst;
6707 getApp()->viewManagers(viewerTypStr, lst);
6708 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6709 if (viewIndex >= 0 && viewIndex < lst.count()) {
6710 SUIT_ViewManager* vman = lst.at(viewIndex);
6711 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6713 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6715 SMESH::TActorList anActorList;
6716 anActorList.push_back( aSmeshActor );
6717 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
6718 aPlane->myViewWindow = vtkView;
6719 SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
6720 aPlane->PlaneMode = aMode;
6721 bool isOpenGLClipping = ( bool )vals[1].toInt();
6722 aPlane->IsOpenGLClipping = isOpenGLClipping;
6723 if ( aMode == SMESH::Absolute ) {
6724 aPlane->myAbsoluteOrientation = vals[2].toInt();
6725 aPlane->X = vals[3].toFloat();
6726 aPlane->Y = vals[4].toFloat();
6727 aPlane->Z = vals[5].toFloat();
6728 aPlane->Dx = vals[6].toFloat();
6729 aPlane->Dy = vals[7].toFloat();
6730 aPlane->Dz = vals[8].toFloat();
6732 else if ( aMode == SMESH::Relative ) {
6733 aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
6734 aPlane->myDistance = vals[3].toFloat();
6735 aPlane->myAngle[0] = vals[4].toFloat();
6736 aPlane->myAngle[1] = vals[5].toFloat();
6740 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6741 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6742 aClippingPlaneInfo.Plane = aPlane;
6743 aClippingPlaneInfo.ActorList = anActorList;
6744 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6752 int aPlaneId = val.toInt( &ok );
6753 if( ok && aPlaneId >= 0 ) {
6754 bool anIsDefinedPlane = false;
6755 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6756 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6757 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6758 TPlaneInfo& aPlaneInfo = *anIter;
6759 if( aPlaneInfo.PlaneId == aPlaneId ) {
6760 aPlaneInfo.ActorList.push_back( aSmeshActor );
6761 anIsDefinedPlane = true;
6765 if( !anIsDefinedPlane ) {
6766 TPlaneInfo aPlaneInfo;
6767 aPlaneInfo.PlaneId = aPlaneId;
6768 aPlaneInfo.ActorList.push_back( aSmeshActor );
6769 aPlaneInfo.ViewManager = vman;
6771 // to make the list sorted by plane id
6772 anIter = aPlaneInfoList.begin();
6773 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6774 const TPlaneInfo& aPlaneInfoRef = *anIter;
6775 if( aPlaneInfoRef.PlaneId > aPlaneId )
6778 aPlaneInfoList.insert( anIter, aPlaneInfo );
6783 } // if (aSmeshActor)
6784 } // other parameters than Visibility
6786 } // for names/parameters iterator
6787 } // for entries iterator
6789 // take into account planes with empty list of actors referred to them
6790 QList<SUIT_ViewManager*> aVMList;
6791 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6793 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6794 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6795 int aViewId = aPlaneDataIter->first;
6796 if( aViewId >= 0 && aViewId < aVMList.count() ) {
6797 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6799 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6801 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6802 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6803 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6804 const TPlaneData& aPlaneData = *anIter2;
6805 int aPlaneId = aPlaneData.Id;
6807 bool anIsFound = false;
6808 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6809 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6810 const TPlaneInfo& aPlaneInfo = *anIter3;
6811 if( aPlaneInfo.PlaneId == aPlaneId ) {
6818 TPlaneInfo aPlaneInfo; // ActorList field is empty
6819 aPlaneInfo.PlaneId = aPlaneId;
6820 aPlaneInfo.ViewManager = aViewManager;
6822 // to make the list sorted by plane id
6823 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6824 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6825 const TPlaneInfo& aPlaneInfoRef = *anIter4;
6826 if( aPlaneInfoRef.PlaneId > aPlaneId )
6829 aPlaneInfoList.insert( anIter4, aPlaneInfo );
6835 // add clipping planes to actors according to the restored parameters
6836 // and update the clipping plane map
6837 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6838 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6839 int aViewId = anIter1->first;
6840 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6842 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6843 if( anIter2 == aPlaneDataMap.end() )
6845 const TPlaneDataList& aPlaneDataList = anIter2->second;
6847 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6848 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6849 const TPlaneInfo& aPlaneInfo = *anIter3;
6850 int aPlaneId = aPlaneInfo.PlaneId;
6851 const TActorList& anActorList = aPlaneInfo.ActorList;
6852 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6856 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6860 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6862 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6863 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6864 const TPlaneData& aPlaneData = *anIter4;
6865 if( aPlaneData.Id == aPlaneId ) {
6866 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
6867 aPlane->myViewWindow = aViewWindow;
6868 aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
6869 aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
6870 if ( aPlane->PlaneMode == SMESH::Absolute ) {
6871 aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
6872 aPlane->X = aPlaneData.X;
6873 aPlane->Y = aPlaneData.Y;
6874 aPlane->Z = aPlaneData.Z;
6875 aPlane->Dx = aPlaneData.Dx;
6876 aPlane->Dy = aPlaneData.Dy;
6877 aPlane->Dz = aPlaneData.Dz;
6879 else if ( aPlane->PlaneMode == SMESH::Relative ) {
6880 aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
6881 aPlane->myDistance = aPlaneData.Distance;
6882 aPlane->myAngle[0] = aPlaneData.Angle[0];
6883 aPlane->myAngle[1] = aPlaneData.Angle[1];
6886 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6887 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6888 aClippingPlaneInfo.Plane = aPlane;
6889 aClippingPlaneInfo.ActorList = anActorList;
6890 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6901 // update all VTK views
6902 QList<SUIT_ViewManager*> lst;
6903 getApp()->viewManagers(lst);
6904 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6905 SUIT_ViewModel* vmodel = (*it)->getViewModel();
6906 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6907 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6908 // set OpenGL clipping planes
6909 VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
6910 vtkActorCollection* anAllActors = aCopy.GetActors();
6911 anAllActors->InitTraversal();
6912 while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
6913 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
6914 anActor->SetOpenGLClippingPlane();
6916 vtkView->getRenderer()->ResetCameraClippingRange();
6923 \brief Adds preferences for dfont of VTK viewer
6925 \param pIf group identifier
6926 \param param parameter
6927 \return identifier of preferences
6929 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
6931 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6933 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6936 fam.append( tr( "SMESH_FONT_ARIAL" ) );
6937 fam.append( tr( "SMESH_FONT_COURIER" ) );
6938 fam.append( tr( "SMESH_FONT_TIMES" ) );
6940 setPreferenceProperty( tfont, "fonts", fam );
6942 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6943 if ( needSize ) f = f | QtxFontEdit::Size;
6944 setPreferenceProperty( tfont, "features", f );
6950 \brief Actions after hypothesis edition
6951 Updates object browser after hypothesis edition
6953 void SMESHGUI::onHypothesisEdit( int result )
6956 SMESHGUI::Modified();
6957 updateObjBrowser( true );
6961 \brief Actions after choosing menu of control modes
6962 Updates control mode actions according to current selection
6964 void SMESHGUI::onUpdateControlActions()
6966 SALOME_ListIO selected;
6967 if ( LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr() )
6968 aSel->selectedObjects( selected );
6970 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
6971 if ( selected.Extent() ) {
6972 if ( selected.First()->hasEntry() ) {
6973 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( selected.First()->getEntry() )) {
6974 aControl = anActor->GetControlMode();
6975 SALOME_ListIteratorOfListIO it(selected);
6976 for ( it.Next(); it.More(); it.Next() ) {
6977 Handle(SALOME_InteractiveObject) anIO = it.Value();
6978 if ( anIO->hasEntry() ) {
6979 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
6980 if ( aControl != anActor->GetControlMode() ) {
6981 aControl = SMESH_Actor::eNone;
6991 int anAction = ActionToControl( aControl, true );
6993 action( anAction )->setChecked( true );
6995 QMenu* send = (QMenu*)sender();
6996 QList<QAction*> actions = send->actions();
6997 for ( int i = 0; i < actions.size(); i++ )
6998 actions[i]->setChecked( false );
7004 \brief Signal handler closing(SUIT_ViewWindow*) of a view
7005 \param pview view being closed
7007 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
7008 #ifndef DISABLE_PLOT2DVIEWER
7009 //Crear all Plot2d Viewers if need.
7010 SMESH::ClearPlot2Viewers(pview);
7012 EmitSignalCloseView();
7015 void SMESHGUI::message( const QString& msg )
7018 QStringList data = msg.split("/");
7019 if ( data.count() > 0 ) {
7020 if ( data.first() == "mesh_loading" ) {
7022 QString entry = data.count() > 1 ? data[1] : QString();
7023 if ( entry.isEmpty() )
7026 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
7028 _PTR(SObject) obj = study->FindObjectID( entry.toLatin1().constData() );
7031 name = SMESH::fromUtf8(obj->GetName());
7032 if ( name.isEmpty() )
7035 if ( data.last() == "stop" )
7036 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
7038 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
7039 QApplication::processEvents();
7045 \brief Connects or disconnects signals about activating and cloning view on the module slots
7046 \param pview view which is connected/disconnected
7048 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
7052 SUIT_ViewManager* viewMgr = pview->getViewManager();
7054 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7055 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7057 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7058 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7063 \brief Return \c true if object can be renamed
7065 bool SMESHGUI::renameAllowed( const QString& entry) const {
7066 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7070 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7074 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
7079 if(appStudy->isComponent(entry) || obj->isReference())
7082 // check type to prevent renaming of inappropriate objects
7083 int aType = SMESHGUI_Selection::type(qPrintable(entry), SMESH::GetActiveStudyDocument());
7084 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7085 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7086 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7087 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7088 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
7095 Rename object by entry.
7096 \param entry entry of the object
7097 \param name new name of the object
7098 \brief Return \c true if rename operation finished successfully, \c false otherwise.
7100 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
7102 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7106 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7111 _PTR(Study) aStudy = appStudy->studyDS();
7116 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
7118 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
7123 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
7124 _PTR(GenericAttribute) anAttr;
7125 _PTR(AttributeName) aName;
7127 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
7129 // check type to prevent renaming of inappropriate objects
7130 int aType = SMESHGUI_Selection::type( qPrintable(entry), SMESH::GetActiveStudyDocument() );
7131 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7132 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7133 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7134 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7135 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
7136 if ( !name.isEmpty() ) {
7137 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
7139 // update name of group object and its actor
7140 Handle(SALOME_InteractiveObject) IObject =
7141 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
7143 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
7144 if( !aGroupObject->_is_nil() ) {
7145 aGroupObject->SetName( qPrintable(name) );
7146 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
7147 anActor->setName( qPrintable(name) );
7157 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
7159 static QList<QColor> colors;
7161 if ( colors.isEmpty() ) {
7163 for (int s = 0; s < 2 ; s++)
7165 for (int v = 100; v >= 40; v = v - 20)
7167 for (int h = 0; h < 359 ; h = h + 60)
7169 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
7174 static int currentColor = randomize( colors.size() );
7176 SALOMEDS::Color color;
7177 color.R = (double)colors[currentColor].red() / 255.0;
7178 color.G = (double)colors[currentColor].green() / 255.0;
7179 color.B = (double)colors[currentColor].blue() / 255.0;
7181 currentColor = (currentColor+1) % colors.count();