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::MultiConnection* >( f.get() ) )
1142 type = QObject::tr( "MULTI_BORDERS" );
1143 else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) )
1144 type = QObject::tr( "MULTI2D_BORDERS" );
1145 else if ( dynamic_cast< SMESH::Controls::FreeNodes* >( f.get() ) )
1146 type = QObject::tr( "FREE_NODES" );
1147 else if ( dynamic_cast< SMESH::Controls::FreeEdges* >( f.get() ) )
1148 type = QObject::tr( "FREE_EDGES" );
1149 else if ( dynamic_cast< SMESH::Controls::FreeBorders* >( f.get() ) )
1150 type = QObject::tr( "FREE_BORDERS" );
1151 else if ( dynamic_cast< SMESH::Controls::FreeFaces* >( f.get() ) )
1152 type = QObject::tr( "FREE_FACES" );
1153 else if ( dynamic_cast< SMESH::Controls::BareBorderVolume* >( f.get() ) )
1154 type = QObject::tr( "BARE_BORDER_VOLUME" );
1155 else if ( dynamic_cast< SMESH::Controls::BareBorderFace* >( f.get() ) )
1156 type = QObject::tr( "BARE_BORDER_FACE" );
1157 else if ( dynamic_cast< SMESH::Controls::OverConstrainedVolume* >( f.get() ) )
1158 type = QObject::tr( "OVER_CONSTRAINED_VOLUME" );
1159 else if ( dynamic_cast< SMESH::Controls::OverConstrainedFace* >( f.get() ) )
1160 type = QObject::tr( "OVER_CONSTRAINED_FACE" );
1161 else if ( dynamic_cast< SMESH::Controls::CoincidentNodes* >( f.get() ) )
1162 type = QObject::tr( "EQUAL_NODE" );
1163 else if ( dynamic_cast< SMESH::Controls::CoincidentElements1D* >( f.get() ) )
1164 type = QObject::tr( "EQUAL_EDGE" );
1165 else if ( dynamic_cast< SMESH::Controls::CoincidentElements2D* >( f.get() ) )
1166 type = QObject::tr( "EQUAL_FACE" );
1167 else if ( dynamic_cast< SMESH::Controls::CoincidentElements3D* >( f.get() ) )
1168 type = QObject::tr( "EQUAL_VOLUME" );
1169 else if ( dynamic_cast< SMESH::Controls::NodeConnectivityNumber* >( f.get() ) )
1170 type = QObject::tr( "NODE_CONNECTIVITY_NB" );
1174 void SaveDistribution()
1176 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1177 SALOME_ListIO selected;
1179 aSel->selectedObjects( selected );
1181 if ( selected.Extent() == 1 ) {
1182 Handle(SALOME_InteractiveObject) anIO = selected.First();
1183 if ( anIO->hasEntry() ) {
1184 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1186 anActor->GetScalarBarActor() &&
1187 anActor->GetControlMode() != SMESH_Actor::eNone )
1189 SMESH_ScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor();
1190 SMESH::Controls::FunctorPtr aFunctor = anActor->GetFunctor();
1191 if ( aScalarBarActor && aFunctor ) {
1192 SMESH::Controls::NumericalFunctor* aNumFun =
1193 dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
1195 std::vector<int> elements;
1196 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
1197 if ( mesh->_is_nil() ) {
1198 SMESH::SMESH_IDSource_var idSource =
1199 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
1200 if ( !idSource->_is_nil() )
1202 SMESH::long_array_var ids = idSource->GetIDs();
1203 elements.resize( ids->length() );
1204 for ( unsigned i = 0; i < elements.size(); ++i )
1205 elements[i] = ids[i];
1208 int nbIntervals = aScalarBarActor->GetMaximumNumberOfColors();
1209 vtkLookupTable* lookupTable =
1210 static_cast<vtkLookupTable*>(aScalarBarActor->GetLookupTable());
1211 double * minmax = lookupTable->GetRange();
1212 bool isLogarithmic = lookupTable->GetScale() == VTK_SCALE_LOG10;
1213 std::vector<int> nbEvents;
1214 std::vector<double> funValues;
1215 aNumFun->GetHistogram( nbIntervals, nbEvents, funValues,
1216 elements, minmax, isLogarithmic );
1217 QString anInitialPath = "";
1218 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
1219 anInitialPath = QDir::currentPath();
1220 QString aMeshName = anIO->getName();
1222 filter.append( QObject::tr( "TEXT_FILES_FILTER" ) + " (*.txt)" );
1223 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
1224 QString aFilename = anInitialPath + "/" + aMeshName + "_" +
1225 functorToString( aFunctor ).toLower().simplified().replace( QRegExp( " |-" ), "_" ) + ".txt";
1226 aFilename = SUIT_FileDlg::getFileName( SMESHGUI::desktop(),
1229 QObject::tr( "SMESH_SAVE_DISTRIBUTION" ),
1231 if ( !aFilename.isEmpty() ) {
1232 QFile f( aFilename );
1233 if ( f.open( QFile::WriteOnly | QFile::Truncate ) ) {
1234 QTextStream out( &f );
1235 out << "# Mesh: " << aMeshName << endl;
1236 out << "# Control: " << functorToString( aFunctor ) << endl;
1238 out.setFieldWidth( 10 );
1239 for ( int i = 0; i < (int)qMin( nbEvents.size(), funValues.size()-1 ); i++ )
1240 out << funValues[i] << "\t" << funValues[i+1] << "\t" << nbEvents[i] << endl;
1251 void ShowElement( int theCommandID )
1253 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1254 SALOME_ListIO selected;
1256 aSel->selectedObjects( selected );
1258 if ( selected.Extent() == 1 ) {
1259 Handle(SALOME_InteractiveObject) anIO = selected.First();
1260 if ( anIO->hasEntry() ) {
1261 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1263 anActor->GetScalarBarActor() &&
1264 anActor->GetControlMode() != SMESH_Actor::eNone )
1266 SMESH_ScalarBarActor *aScalarBarActor = anActor->GetScalarBarActor();
1267 if ( theCommandID == SMESHOp::OpShowDistribution ) {
1268 aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility());
1270 else if ( theCommandID == SMESHOp::OpShowScalarBar ) {
1271 aScalarBarActor->SetVisibility( !aScalarBarActor->GetVisibility());
1278 #ifndef DISABLE_PLOT2DVIEWER
1279 void PlotDistribution()
1281 SalomeApp_Application* app =
1282 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1286 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1287 SALOME_ListIO selected;
1289 aSel->selectedObjects( selected );
1291 if ( selected.Extent() == 1 ) {
1292 Handle(SALOME_InteractiveObject) anIO = selected.First();
1293 if ( anIO->hasEntry() ) {
1294 //Find Actor by entry before getting Plot2d viewer,
1295 //because after call getViewManager( Plot2d_Viewer::Type(), true ) active window is Plot2d Viewer
1296 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1298 SUIT_ViewManager* aViewManager =
1299 app->getViewManager( Plot2d_Viewer::Type(), true ); // create if necessary
1303 SPlot2d_Viewer* aView = dynamic_cast<SPlot2d_Viewer*>(aViewManager->getViewModel());
1307 Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
1311 if ( anActor && anActor->GetControlMode() != SMESH_Actor::eNone )
1313 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1314 QString functorName = functorToString( anActor->GetFunctor());
1315 QString aHistogramName("%1 : %2");
1316 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1317 aHistogram->setName(aHistogramName);
1318 aHistogram->setHorTitle(functorName);
1319 aHistogram->setVerTitle(QObject::tr("DISTRIBUTION_NB_ENT"));
1320 aPlot->displayObject(aHistogram, true);
1325 #endif //DISABLE_PLOT2DVIEWER
1327 void DisableAutoColor()
1329 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1330 SALOME_ListIO selected;
1332 aSel->selectedObjects( selected );
1334 if ( selected.Extent() ) {
1335 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1336 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1337 if ( !aMesh->_is_nil() ) {
1338 aMesh->SetAutoColor( false );
1345 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1346 SALOME_ListIO selected;
1348 aSel->selectedObjects( selected );
1349 if ( selected.Extent() )
1351 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1352 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1353 _PTR(SObject) aSObj = aStudy->FindObjectID(anIObject->getEntry());
1355 if ( aStudy->GetUseCaseBuilder()->SortChildren( aSObj, true/*AscendingOrder*/ ) ) {
1356 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1363 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap)
1365 SALOME_ListIO selected;
1366 SalomeApp_Application* app =
1367 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1371 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1372 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1373 if ( !aSel || !appStudy )
1376 if ( theCommandID == SMESHOp::OpClipping ) { // Clipping dialog can be activated without selection
1377 if ( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
1378 aModule->EmitSignalDeactivateDialog();
1379 if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
1380 (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
1385 _PTR(Study) aStudy = appStudy->studyDS();
1387 aSel->selectedObjects( selected );
1389 if ( selected.Extent() >= 1 )
1391 switch ( theCommandID ) {
1392 case SMESHOp::OpTransparency:
1394 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1395 (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
1398 case SMESHOp::OpProperties:
1401 QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
1402 QColor orientationColor, outlineColor, volumeColor;
1403 int deltaF = 0, deltaV = 0;
1406 double ballScale = 1.0;
1408 int outlineWidth = 1;
1409 double shrinkCoef = 0.0;
1410 double orientationScale = 0.0;
1411 bool orientation3d = false;
1412 VTK::MarkerType markerType = VTK::MT_NONE;
1413 VTK::MarkerScale markerScale = VTK::MS_NONE;
1415 bool hasNodes = false;
1416 int presentEntities = 0;
1417 bool firstTime = true;
1419 SALOME_ListIteratorOfListIO It( selected );
1420 for ( ; It.More(); It.Next() ) {
1421 Handle(SALOME_InteractiveObject) IObject = It.Value();
1422 if ( !IObject->hasEntry() ) continue;
1423 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1424 if ( !anActor || !anActor->GetObject() ) continue;
1427 // nodes: color, marker
1428 anActor->GetNodeColor( color[0], color[1], color[2] );
1429 nodeColor.setRgbF( color[0], color[1], color[2] );
1430 markerType = anActor->GetMarkerType();
1431 markerScale = anActor->GetMarkerScale();
1432 markerId = anActor->GetMarkerTexture();
1433 // edges: color, width
1434 anActor->GetEdgeColor( color[0], color[1], color[2] );
1435 edgeColor.setRgbF( color[0], color[1], color[2] );
1436 edgeWidth = qMax( (int)anActor->GetLineWidth(), 1 ); // minimum allowed width is 1
1437 // faces: front color, back color (delta)
1438 anActor->GetSufaceColor( color[0], color[1], color[2], deltaF );
1439 faceColor.setRgbF( color[0], color[1], color[2] );
1440 // faces: front color, back color (delta)
1441 anActor->GetVolumeColor( color[0], color[1], color[2], deltaV );
1442 volumeColor.setRgbF( color[0], color[1], color[2] );
1443 // 0d elements: color, size
1444 anActor->Get0DColor( color[0], color[1], color[2] );
1445 elem0dColor.setRgbF( color[0], color[1], color[2] );
1446 elem0dSize = qMax( (int)anActor->Get0DSize(), 1 ); // minimum allowed size is 1
1447 // balls: color, size
1448 anActor->GetBallColor( color[0], color[1], color[2] );
1449 ballColor.setRgbF( color[0], color[1], color[2] );
1450 //ballSize = qMax( (int)anActor->GetBallSize(), 1 ); // minimum allowed size is 1
1451 ballScale = qMax( (double)anActor->GetBallScale(), 1e-2 ); // minimum allowed scale is 1e-2
1453 anActor->GetOutlineColor( color[0], color[1], color[2] );
1454 outlineColor.setRgbF( color[0], color[1], color[2] );
1455 outlineWidth = qMax( (int)anActor->GetOutlineWidth(), 1 ); // minimum allowed width is 1
1456 // orientation vectors: color, scale, 3d flag
1457 anActor->GetFacesOrientationColor( color[0], color[1], color[2] );
1458 orientationColor.setRgbF( color[0], color[1], color[2] );
1459 orientationScale = anActor->GetFacesOrientationScale();
1460 orientation3d = anActor->GetFacesOrientation3DVectors();
1462 shrinkCoef = anActor->GetShrinkFactor();
1465 firstTime = false; // we only take properties from first object (for performance reasons)
1468 hasNodes = anActor->GetObject()->GetNbEntities( SMDSAbs_Node );
1469 if ( !(presentEntities & SMESH_Actor::eEdges) && anActor->GetObject()->GetNbEntities( SMDSAbs_Edge ) )
1470 presentEntities = presentEntities | SMESH_Actor::eEdges;
1471 if ( !(presentEntities & SMESH_Actor::eFaces) && anActor->GetObject()->GetNbEntities( SMDSAbs_Face ) )
1472 presentEntities = presentEntities | SMESH_Actor::eFaces;
1473 if ( !(presentEntities & SMESH_Actor::eVolumes) && anActor->GetObject()->GetNbEntities( SMDSAbs_Volume ) )
1474 presentEntities = presentEntities | SMESH_Actor::eVolumes;
1475 if ( !(presentEntities & SMESH_Actor::e0DElements) && anActor->GetObject()->GetNbEntities( SMDSAbs_0DElement ) )
1476 presentEntities = presentEntities | SMESH_Actor::e0DElements;
1477 if ( !(presentEntities & SMESH_Actor::eBallElem) && anActor->GetObject()->GetNbEntities( SMDSAbs_Ball ) )
1478 presentEntities = presentEntities | SMESH_Actor::eBallElem;
1480 // as we know that all types of elements are present, we can exit the loop
1481 if ( presentEntities == SMESH_Actor::eAllEntity )
1485 SMESHGUI_PropertiesDlg dlg( theMarkerMap[ aStudy->StudyId() ], SMESHGUI::desktop() );
1486 // nodes: color, marker
1487 dlg.setNodeColor( nodeColor );
1488 if( markerType != VTK::MT_USER )
1489 dlg.setNodeMarker( markerType, markerScale );
1491 dlg.setNodeCustomMarker( markerId );
1492 // edges: color, line width
1493 dlg.setEdgeColor( edgeColor );
1494 dlg.setEdgeWidth( edgeWidth );
1495 // faces: front color, back color
1496 dlg.setFaceColor( faceColor, deltaF );
1497 // volumes: normal color, reversed color
1498 dlg.setVolumeColor( volumeColor, deltaV );
1499 // outlines: color, line width
1500 dlg.setOutlineColor( outlineColor );
1501 dlg.setOutlineWidth( outlineWidth );
1502 // 0d elements: color, size
1503 dlg.setElem0dColor( elem0dColor );
1504 dlg.setElem0dSize( elem0dSize );
1505 // balls: color, size
1506 dlg.setBallColor( ballColor );
1507 //dlg.setBallSize( ballSize );
1508 dlg.setBallScale( ballScale );
1509 // orientation: color, scale, 3d flag
1510 dlg.setOrientationColor( orientationColor );
1511 dlg.setOrientationSize( int( orientationScale * 100. ) );
1512 dlg.setOrientation3d( orientation3d );
1513 // shrink: scale factor
1514 dlg.setShrinkCoef( int( shrinkCoef * 100. ) );
1515 // hide unused controls
1516 dlg.showControls( presentEntities, hasNodes );
1519 nodeColor = dlg.nodeColor();
1520 markerType = dlg.nodeMarkerType();
1521 markerScale = dlg.nodeMarkerScale();
1522 markerId = dlg.nodeMarkerId();
1523 edgeColor = dlg.edgeColor();
1524 edgeWidth = dlg.edgeWidth();
1525 faceColor = dlg.faceColor();
1526 deltaF = dlg.faceColorDelta();
1527 volumeColor = dlg.volumeColor();
1528 deltaV = dlg.volumeColorDelta();
1529 outlineColor = dlg.outlineColor();
1530 outlineWidth = dlg.outlineWidth();
1531 elem0dColor = dlg.elem0dColor();
1532 elem0dSize = dlg.elem0dSize();
1533 ballColor = dlg.ballColor();
1534 // ballSize = dlg.ballSize();
1535 ballScale = dlg.ballScale();
1536 orientationColor = dlg.orientationColor();
1537 orientationScale = dlg.orientationSize() / 100.;
1538 orientation3d = dlg.orientation3d();
1539 shrinkCoef = dlg.shrinkCoef() / 100.;
1541 // store point markers map that might be changed by the user
1542 theMarkerMap[ aStudy->StudyId() ] = dlg.customMarkers();
1544 // set properties from dialog box to the presentations
1545 SALOME_ListIteratorOfListIO It( selected );
1546 for ( ; It.More(); It.Next() ) {
1547 Handle(SALOME_InteractiveObject) IObject = It.Value();
1548 if ( !IObject->hasEntry() ) continue;
1549 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1550 if ( !anActor ) continue;
1552 // nodes: color, marker
1553 anActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
1554 if ( markerType != VTK::MT_USER ) {
1555 anActor->SetMarkerStd( markerType, markerScale );
1558 const VTK::MarkerMap& markerMap = theMarkerMap[ aStudy->StudyId() ];
1559 VTK::MarkerMap::const_iterator iter = markerMap.find( markerId );
1560 if ( iter != markerMap.end() )
1561 anActor->SetMarkerTexture( markerId, iter->second.second );
1563 // volumes: normal color, reversed color (delta)
1564 anActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
1565 // faces: front color, back color (delta)
1566 anActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
1567 // edges: color, width
1568 anActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
1569 anActor->SetLineWidth( edgeWidth );
1571 anActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
1572 anActor->SetOutlineWidth( outlineWidth );
1573 // 0D elements: color, size
1574 anActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
1575 anActor->Set0DSize( elem0dSize );
1576 // balls: color, size
1577 anActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
1578 // anActor->SetBallSize( ballSize );
1579 anActor->SetBallScale( ballScale );
1580 // orientation: color, scale, 3d flag
1581 anActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
1582 anActor->SetFacesOrientationScale( orientationScale );
1583 anActor->SetFacesOrientation3DVectors( orientation3d );
1585 anActor->SetShrinkFactor( shrinkCoef );
1587 // for groups, set also proper color
1588 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1589 if ( !aGroupObject->_is_nil() ) {
1590 SMESH::ElementType anElementType = aGroupObject->GetType();
1592 switch( anElementType ) {
1594 aColor = nodeColor; break;
1596 aColor = edgeColor; break;
1598 aColor = faceColor; break;
1600 aColor = volumeColor; break;
1602 aColor = elem0dColor; break;
1604 aColor = ballColor; break;
1608 if ( aColor.isValid() ) {
1609 SALOMEDS::Color aGroupColor;
1610 aGroupColor.R = aColor.redF();
1611 aGroupColor.G = aColor.greenF();
1612 aGroupColor.B = aColor.blueF();
1613 aGroupObject->SetColor( aGroupColor );
1615 } // if ( !aGroupObject->_is_nil() )
1616 } // for ( ; It.More(); It.Next() )
1617 SMESH::RepaintCurrentView();
1618 } // if ( dlg.exec() )
1620 } // case SMESHOp::OpProperties:
1621 } // switch(theCommandID)
1622 SUIT_OverrideCursor wc;
1623 SALOME_ListIteratorOfListIO It( selected );
1624 for( ; It.More(); It.Next()){
1625 Handle(SALOME_InteractiveObject) IObject = It.Value();
1626 if(IObject->hasEntry()){
1627 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1628 switch(theCommandID){
1629 case SMESHOp::OpDMWireframe:
1630 anActor->SetRepresentation(SMESH_Actor::eEdge);
1632 case SMESHOp::OpDMShading:
1633 anActor->SetRepresentation(SMESH_Actor::eSurface);
1635 case SMESHOp::OpDMShrink:
1636 if(anActor->IsShrunk())
1637 anActor->UnShrink();
1639 anActor->SetShrink();
1641 case SMESHOp::OpDMNodes:
1642 anActor->SetRepresentation(SMESH_Actor::ePoint);
1644 case SMESHOp::OpRepresentationLines:
1645 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1646 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1648 case SMESHOp::OpRepresentationArcs:
1649 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1650 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1656 SMESH::RepaintCurrentView();
1660 int ActionToControl( int theID, bool theReversed )
1662 NCollection_DoubleMap<int,int> ActionControl;
1663 ActionControl.Bind( 0, SMESH_Actor::eNone );
1664 ActionControl.Bind( SMESHOp::OpFreeNode, SMESH_Actor::eFreeNodes );
1665 ActionControl.Bind( SMESHOp::OpEqualNode, SMESH_Actor::eCoincidentNodes );
1666 ActionControl.Bind( SMESHOp::OpNodeConnectivityNb, SMESH_Actor::eNodeConnectivityNb );
1667 ActionControl.Bind( SMESHOp::OpFreeEdge, SMESH_Actor::eFreeEdges );
1668 ActionControl.Bind( SMESHOp::OpFreeBorder, SMESH_Actor::eFreeBorders );
1669 ActionControl.Bind( SMESHOp::OpLength, SMESH_Actor::eLength );
1670 ActionControl.Bind( SMESHOp::OpConnection, SMESH_Actor::eMultiConnection );
1671 ActionControl.Bind( SMESHOp::OpEqualEdge, SMESH_Actor::eCoincidentElems1D );
1672 ActionControl.Bind( SMESHOp::OpFreeFace, SMESH_Actor::eFreeFaces );
1673 ActionControl.Bind( SMESHOp::OpBareBorderFace, SMESH_Actor::eBareBorderFace );
1674 ActionControl.Bind( SMESHOp::OpOverConstrainedFace, SMESH_Actor::eOverConstrainedFace );
1675 ActionControl.Bind( SMESHOp::OpLength2D, SMESH_Actor::eLength2D );
1676 ActionControl.Bind( SMESHOp::OpConnection2D, SMESH_Actor::eMultiConnection2D );
1677 ActionControl.Bind( SMESHOp::OpArea, SMESH_Actor::eArea );
1678 ActionControl.Bind( SMESHOp::OpTaper, SMESH_Actor::eTaper );
1679 ActionControl.Bind( SMESHOp::OpAspectRatio, SMESH_Actor::eAspectRatio );
1680 ActionControl.Bind( SMESHOp::OpMinimumAngle, SMESH_Actor::eMinimumAngle );
1681 ActionControl.Bind( SMESHOp::OpWarpingAngle, SMESH_Actor::eWarping );
1682 ActionControl.Bind( SMESHOp::OpSkew, SMESH_Actor::eSkew );
1683 ActionControl.Bind( SMESHOp::OpMaxElementLength2D, SMESH_Actor::eMaxElementLength2D );
1684 ActionControl.Bind( SMESHOp::OpEqualFace, SMESH_Actor::eCoincidentElems2D );
1685 ActionControl.Bind( SMESHOp::OpAspectRatio3D, SMESH_Actor::eAspectRatio3D );
1686 ActionControl.Bind( SMESHOp::OpVolume, SMESH_Actor::eVolume3D );
1687 ActionControl.Bind( SMESHOp::OpMaxElementLength3D, SMESH_Actor::eMaxElementLength3D );
1688 ActionControl.Bind( SMESHOp::OpBareBorderVolume, SMESH_Actor::eBareBorderVolume );
1689 ActionControl.Bind( SMESHOp::OpOverConstrainedVolume, SMESH_Actor::eOverConstrainedVolume );
1690 ActionControl.Bind( SMESHOp::OpEqualVolume, SMESH_Actor::eCoincidentElems3D );
1692 return theReversed ? ActionControl.Find2( theID ) : ActionControl.Find1( theID );
1695 void Control( int theCommandID )
1697 SMESH_Actor::eControl aControl = SMESH_Actor::eControl( ActionToControl( theCommandID ));
1698 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1700 SALOME_ListIO selected;
1701 if ( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
1702 aSel->selectedObjects( selected );
1704 if ( !selected.IsEmpty() ) {
1705 SALOME_ListIteratorOfListIO It(selected);
1706 for ( ; It.More(); It.Next())
1708 Handle(SALOME_InteractiveObject) anIO = It.Value();
1709 if ( !anIO.IsNull() ) {
1710 _PTR(SObject) SO = aStudy->FindObjectID( It.Value()->getEntry() );
1712 CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
1713 SMESH::SMESH_IDSource_var anIDSrc = SMESH::SMESH_IDSource::_narrow( aObject );
1714 if ( !anIDSrc->_is_nil() ) {
1715 SMESH_Actor *anActor = SMESH::FindActorByEntry( anIO->getEntry());
1716 if (( !anActor && selected.Extent() == 1 ) &&
1717 ( anActor = SMESH::CreateActor( aStudy, anIO->getEntry() )))
1719 anActor->SetControlMode( aControl );
1720 SMESH::DisplayActor( SMESH::GetCurrentVtkView(), anActor );
1721 SMESH::UpdateView ( SMESH::eDisplay, anIO->getEntry() );
1725 if ( anActor->GetControlMode() != aControl )
1726 anActor->SetControlMode( aControl );
1727 QString functorName = functorToString( anActor->GetFunctor() );
1728 int anEntitiesCount = anActor->GetNumberControlEntities();
1729 if (anEntitiesCount >= 0)
1730 functorName = functorName + ": " + QString::number(anEntitiesCount);
1731 anActor->GetScalarBarActor()->SetTitle( functorName.toLatin1().constData() );
1732 SMESH::RepaintCurrentView();
1733 #ifndef DISABLE_PLOT2DVIEWER
1734 if ( anActor->GetPlot2Histogram() ) {
1735 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1736 QString aHistogramName("%1 : %2");
1737 aHistogramName = aHistogramName.arg( anIO->getName() ).arg( functorName );
1738 aHistogram->setName( aHistogramName );
1739 aHistogram->setHorTitle( functorName );
1740 SMESH::ProcessIn2DViewers( anActor );
1752 bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1753 SMESH::MeshObjectType theType,
1754 const QString theInTypeName,
1755 QString & theOutTypeName)
1757 SMESH_TypeFilter aTypeFilter( theType );
1759 if ( !theIO.IsNull() )
1761 entry = theIO->getEntry();
1762 LightApp_DataOwner owner( entry );
1763 if ( aTypeFilter.isOk( &owner )) {
1764 theOutTypeName = theInTypeName;
1772 QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1774 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1775 _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1777 _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1778 CORBA::String_var anID = aSComp->GetID().c_str();
1779 if ( !strcmp(anID.in(),theIO->getEntry()) )
1785 CheckOIType ( theIO, SMESH::HYPOTHESIS, "Hypothesis", aTypeName ) ||
1786 CheckOIType ( theIO, SMESH::ALGORITHM, "Algorithm", aTypeName ) ||
1787 CheckOIType ( theIO, SMESH::MESH, "Mesh", aTypeName ) ||
1788 CheckOIType ( theIO, SMESH::SUBMESH, "SubMesh", aTypeName ) ||
1789 CheckOIType ( theIO, SMESH::GROUP, "Group", aTypeName )
1797 // QString CheckHomogeneousSelection()
1799 // LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1800 // SALOME_ListIO selected;
1802 // aSel->selectedObjects( selected );
1804 // QString RefType = CheckTypeObject(selected.First());
1805 // SALOME_ListIteratorOfListIO It(selected);
1806 // for ( ; It.More(); It.Next())
1808 // Handle(SALOME_InteractiveObject) IObject = It.Value();
1809 // QString Type = CheckTypeObject(IObject);
1810 // if ( Type.compare(RefType) != 0 )
1811 // return "Heterogeneous Selection";
1817 uint randomize( uint size )
1819 static bool initialized = false;
1820 if ( !initialized ) {
1821 qsrand( QDateTime::currentDateTime().toTime_t() );
1825 v = uint( (double)( v ) / RAND_MAX * size );
1826 v = qMax( uint(0), qMin ( v, size-1 ) );
1832 void SMESHGUI::OnEditDelete()
1834 // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1835 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1836 SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1838 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1839 _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1840 _PTR(GenericAttribute) anAttr;
1841 _PTR(AttributeIOR) anIOR;
1843 int objectCount = 0;
1845 QString aParentComponent = QString::null;
1846 Handle(SALOME_InteractiveObject) anIO;
1847 for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1849 anIO = anIt.Value();
1850 QString cur = anIO->getComponentDataType();
1851 _PTR(SObject) aSO = aStudy->FindObjectID(anIO->getEntry());
1853 // check if object is reference
1854 _PTR(SObject) aRefSObj;
1855 aNameList.append("\n - ");
1856 if ( aSO->ReferencedObject( aRefSObj ) ) {
1857 QString aRefName = QString::fromStdString ( aRefSObj->GetName() );
1858 aNameList.append( aRefName );
1859 cur = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1862 aNameList.append(anIO->getName());
1866 if( aParentComponent.isNull() )
1867 aParentComponent = cur;
1868 else if( !aParentComponent.isEmpty() && aParentComponent!=cur )
1869 aParentComponent = "";
1872 if ( objectCount == 0 )
1873 return; // No Valid Objects Selected
1875 if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
1876 SUIT_MessageBox::warning( SMESHGUI::desktop(),
1877 QObject::tr("ERR_ERROR"),
1878 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
1881 // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
1882 if (SUIT_MessageBox::warning
1883 (SMESHGUI::desktop(),
1884 QObject::tr("SMESH_WRN_WARNING"),
1885 QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
1886 SUIT_MessageBox::Yes | SUIT_MessageBox::No,
1887 SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
1890 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1892 // Put the whole hierarchy of sub-objects of the selected SO's into a list and
1893 // then treat them all starting from the deepest objects (at list back)
1894 std::list< _PTR(SObject) > listSO;
1895 SALOME_ListIteratorOfListIO It(selected);
1896 for( ; It.More(); It.Next()) // loop on selected IO's
1898 Handle(SALOME_InteractiveObject) IObject = It.Value();
1899 if(IObject->hasEntry()) {
1900 _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
1902 // disable removal of "SMESH" component object
1903 if(aSO->FindAttribute(anAttr, "AttributeIOR")){
1905 if ( engineIOR() == anIOR->Value().c_str() )
1908 //Check the referenced object
1909 _PTR(SObject) aRefSObject;
1910 if ( aSO && aSO->ReferencedObject( aRefSObject ) )
1911 aSO = aRefSObject; // Delete main Object instead of reference
1913 listSO.push_back( aSO );
1914 std::list< _PTR(SObject) >::iterator itSO = --listSO.end();
1915 for ( ; itSO != listSO.end(); ++itSO ) {
1916 _PTR(ChildIterator) it = aStudy->NewChildIterator( *itSO );
1917 for (it->InitEx(false); it->More(); it->Next())
1918 listSO.push_back( it->Value() );
1922 // Check if none of objects to delete is referred from outside
1923 std::list< _PTR(SObject) >::reverse_iterator ritSO;
1924 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1926 _PTR(SObject) SO = *ritSO;
1927 if ( !SO ) continue;
1928 std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( *ritSO );
1929 for (size_t i = 0; i < aReferences.size(); i++) {
1930 _PTR(SComponent) aComponent = aReferences[i]->GetFatherComponent();
1931 std::string type = aComponent->ComponentDataType();
1932 if ( type != "SMESH" )
1934 SUIT_MessageBox::warning( anApp->desktop(),
1935 QObject::tr("WRN_WARNING"),
1936 QObject::tr("DEP_OBJECT") );
1937 return; // outside SMESH, there is an object depending on a SMESH object
1942 // Call mesh->Clear() to prevent loading mesh from file caused by hypotheses removal
1943 for( It.Initialize( selected ); It.More(); It.Next()) // loop on selected IO's
1945 Handle(SALOME_InteractiveObject) IObject = It.Value();
1946 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface< SMESH::SMESH_Mesh >( IObject );
1947 if ( !mesh->_is_nil() )
1951 // Treat SO's in the list starting from the back
1952 aStudyBuilder->NewCommand(); // There is a transaction
1953 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1955 _PTR(SObject) SO = *ritSO;
1956 if ( !SO ) continue;
1957 std::string anEntry = SO->GetID();
1959 /** Erase graphical object and remove all its data **/
1960 if(SO->FindAttribute(anAttr, "AttributeIOR")) {
1961 SMESH::RemoveVisualObjectWithActors( anEntry.c_str(), true);
1963 /** Remove an object from data structures **/
1964 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
1965 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
1966 if ( !aGroup->_is_nil() ) { // DELETE GROUP
1967 SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
1968 aMesh->RemoveGroup( aGroup );
1970 else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
1971 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
1972 aMesh->RemoveSubMesh( aSubMesh );
1974 _PTR(SObject) aMeshSO = SMESH::FindSObject(aMesh);
1976 SMESH::ModifiedMesh(aMeshSO, false, aMesh->NbNodes()==0);
1979 Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
1980 ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
1981 QString objType = CheckTypeObject(IObject);
1982 if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
1983 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
1984 aStudyBuilder->RemoveObjectWithChildren( SO );
1986 else {// default action: remove SObject from the study
1987 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
1988 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
1990 aStudyBuilder->RemoveObjectWithChildren( SO );
1994 } /* listSO back loop */
1996 aStudyBuilder->CommitCommand();
1998 /* Clear any previous selection */
2000 aSel->setSelectedObjects( l1 );
2002 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
2006 SMESHGUI_EXPORT CAM_Module* createModule()
2008 return new SMESHGUI();
2011 SMESHGUI_EXPORT char* getModuleVersion() {
2012 return (char*)SMESH_VERSION_STR;
2016 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
2018 //=============================================================================
2022 //=============================================================================
2023 SMESHGUI::SMESHGUI() :
2024 SalomeApp_Module( "SMESH" )
2026 if ( CORBA::is_nil( myComponentSMESH ) )
2028 CORBA::Boolean anIsEmbeddedMode;
2029 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
2030 //MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
2032 // 0019923: EDF 765 SMESH : default values of hypothesis
2033 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
2034 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
2035 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
2036 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
2037 myComponentSMESH->SetDefaultNbSegments( nbSeg );
2039 const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif", "default_grp_color" };
2040 for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
2041 if ( aResourceMgr->hasValue( "SMESH", options[i] ))
2043 QString val = aResourceMgr->stringValue( "SMESH", options[i] );
2044 myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
2048 myActiveDialogBox = 0;
2049 myFilterLibraryDlg = 0;
2053 myEventCallbackCommand = vtkCallbackCommand::New();
2054 myEventCallbackCommand->Delete();
2055 myEventCallbackCommand->SetClientData( this );
2056 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
2059 /* load resources for all available meshers */
2060 SMESH::InitAvailableHypotheses();
2063 //=============================================================================
2067 //=============================================================================
2068 SMESHGUI::~SMESHGUI()
2072 //=============================================================================
2076 //=============================================================================
2077 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
2079 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2081 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
2086 //=============================================================================
2090 //=============================================================================
2091 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
2093 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2097 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2098 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2099 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2100 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2101 return autoUpdate && !exceeded;
2104 //=============================================================================
2108 //=============================================================================
2109 bool SMESHGUI::automaticUpdate( SMESH::SMESH_IDSource_ptr theMesh,
2110 int* entities, bool* limitExceeded, int* hidden, long* nbElements )
2112 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2116 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2117 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2118 bool incrementalLimit = resMgr->booleanValue( "SMESH", "incremental_limit", false );
2120 SMESH::long_array_var info = theMesh->GetMeshInfo();
2121 long nbOdElems = info[SMDSEntity_0D];
2122 long nbEdges = info[SMDSEntity_Edge] + info[SMDSEntity_Quad_Edge];
2123 long nbFaces = info[SMDSEntity_Triangle] + info[SMDSEntity_Quad_Triangle] + info[SMDSEntity_BiQuad_Triangle] +
2124 info[SMDSEntity_Quadrangle] + info[SMDSEntity_Quad_Quadrangle] + info[SMDSEntity_BiQuad_Quadrangle] +
2125 info[SMDSEntity_Polygon] + info[SMDSEntity_Quad_Polygon];
2126 long nbVolumes = info[SMDSEntity_Tetra] + info[SMDSEntity_Quad_Tetra] +
2127 info[SMDSEntity_Hexa] + info[SMDSEntity_Quad_Hexa] + info[SMDSEntity_TriQuad_Hexa] +
2128 info[SMDSEntity_Pyramid] + info[SMDSEntity_Quad_Pyramid] +
2129 info[SMDSEntity_Penta] + info[SMDSEntity_Quad_Penta] + info[SMDSEntity_BiQuad_Penta] +
2130 info[SMDSEntity_Polyhedra] +
2131 info[SMDSEntity_Hexagonal_Prism];
2132 long nbBalls = info[SMDSEntity_Ball];
2134 long requestedSize = nbOdElems + nbBalls + nbEdges + nbFaces + nbVolumes;
2135 *nbElements = requestedSize;
2137 *entities = SMESH_Actor::eAllEntity;
2140 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2142 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2144 if ( incrementalLimit ) {
2147 if ( nbOdElems > 0 ) {
2148 if ( total + nbOdElems > updateLimit ) {
2149 *entities = *entities & ~SMESH_Actor::e0DElements;
2150 *hidden = *hidden | SMESH_Actor::e0DElements;
2157 if ( nbEdges > 0 ) {
2158 if ( total + nbEdges > updateLimit ) {
2159 *entities = *entities & ~SMESH_Actor::eEdges;
2160 *hidden = *hidden | SMESH_Actor::eEdges;
2167 if ( nbFaces > 0 ) {
2168 if ( total + nbFaces > updateLimit ) {
2169 *entities = *entities & ~SMESH_Actor::eFaces;
2170 *hidden = *hidden | SMESH_Actor::eFaces;
2177 if ( nbVolumes > 0 ) {
2178 if ( total + nbVolumes > updateLimit ) {
2179 *entities = *entities & ~SMESH_Actor::eVolumes;
2180 *hidden = *hidden | SMESH_Actor::eVolumes;
2187 if ( nbBalls > 0 ) {
2188 if ( total + nbBalls > updateLimit ) {
2189 *entities = *entities & ~SMESH_Actor::eBallElem;
2190 *hidden = *hidden | SMESH_Actor::eBallElem;
2198 return autoUpdate && !exceeded;
2201 //=============================================================================
2205 //=============================================================================
2206 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
2208 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
2211 //=============================================================================
2215 //=============================================================================
2216 SMESHGUI* SMESHGUI::GetSMESHGUI()
2218 SMESHGUI* smeshMod = 0;
2219 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
2222 CAM_Module* module = app->module( "Mesh" );
2223 smeshMod = dynamic_cast<SMESHGUI*>( module );
2226 if ( smeshMod && smeshMod->application() && smeshMod->application()->activeStudy() )
2228 SalomeApp_Study* study = dynamic_cast<SalomeApp_Study*>( smeshMod->application()->activeStudy() );
2231 _PTR(Study) aStudy = study->studyDS();
2233 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
2242 Standard_EXPORT SMESHGUI* GetComponentGUI()
2244 return SMESHGUI::GetSMESHGUI();
2248 //=============================================================================
2252 //=============================================================================
2253 void SMESHGUI::SetState(int aState)
2258 //=============================================================================
2262 //=============================================================================
2263 void SMESHGUI::ResetState()
2268 //=============================================================================
2272 //=============================================================================
2273 void SMESHGUI::EmitSignalDeactivateDialog()
2275 emit SignalDeactivateActiveDialog();
2278 //=============================================================================
2282 //=============================================================================
2283 void SMESHGUI::EmitSignalStudyFrameChanged()
2285 emit SignalStudyFrameChanged();
2288 //=============================================================================
2292 //=============================================================================
2293 void SMESHGUI::EmitSignalCloseAllDialogs()
2295 emit SignalCloseAllDialogs();
2298 //=============================================================================
2302 //=============================================================================
2303 void SMESHGUI::EmitSignalVisibilityChanged()
2305 emit SignalVisibilityChanged();
2308 //=============================================================================
2312 //=============================================================================
2313 void SMESHGUI::EmitSignalCloseView()
2315 emit SignalCloseView();
2318 //=============================================================================
2322 //=============================================================================
2323 void SMESHGUI::EmitSignalActivatedViewManager()
2325 emit SignalActivatedViewManager();
2328 //=============================================================================
2332 //=============================================================================
2333 QDialog *SMESHGUI::GetActiveDialogBox()
2335 return myActiveDialogBox;
2338 //=============================================================================
2342 //=============================================================================
2343 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2345 myActiveDialogBox = (QDialog *) aDlg;
2349 //=============================================================================
2353 //=============================================================================
2354 SUIT_Desktop* SMESHGUI::desktop()
2356 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2358 return app->desktop();
2363 //=============================================================================
2367 //=============================================================================
2368 SalomeApp_Study* SMESHGUI::activeStudy()
2370 SUIT_Application* app = SUIT_Session::session()->activeApplication();
2372 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2377 //=============================================================================
2381 //=============================================================================
2382 void SMESHGUI::Modified( bool theIsUpdateActions )
2384 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2385 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2386 appStudy->Modified();
2387 if( theIsUpdateActions )
2388 app->updateActions();
2393 //=============================================================================
2397 //=============================================================================
2398 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2400 /* Here the position is on the bottom right corner - 10 */
2401 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2403 SUIT_Desktop *PP = desktop();
2404 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2405 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2409 //=============================================================================
2413 //=============================================================================
2414 static int isStudyLocked(_PTR(Study) theStudy){
2415 return theStudy->GetProperties()->IsLocked();
2418 static bool checkLock(_PTR(Study) theStudy) {
2419 if (isStudyLocked(theStudy)) {
2420 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2421 QObject::tr("WRN_WARNING"),
2422 QObject::tr("WRN_STUDY_LOCKED") );
2428 //=======================================================================
2429 //function : CheckActiveStudyLocked
2431 //=======================================================================
2433 bool SMESHGUI::isActiveStudyLocked()
2435 _PTR(Study) aStudy = activeStudy()->studyDS();
2436 return checkLock( aStudy );
2439 //=============================================================================
2443 //=============================================================================
2444 bool SMESHGUI::OnGUIEvent( int theCommandID )
2446 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2450 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
2451 SUIT_ResourceMgr* mgr = resourceMgr();
2455 if (CORBA::is_nil(GetSMESHGen()->GetCurrentStudy())) {
2456 GetSMESHGen()->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
2459 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2460 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2462 //QAction* act = action( theCommandID );
2464 switch (theCommandID) {
2465 case SMESHOp::OpDelete:
2466 if(checkLock(aStudy)) break;
2469 case SMESHOp::OpImportDAT:
2470 case SMESHOp::OpImportUNV:
2471 case SMESHOp::OpImportMED:
2472 case SMESHOp::OpImportSTL:
2473 case SMESHOp::OpImportCGNS:
2474 case SMESHOp::OpImportSAUV:
2475 case SMESHOp::OpImportGMF:
2476 case SMESHOp::OpPopupImportDAT:
2477 case SMESHOp::OpPopupImportUNV:
2478 case SMESHOp::OpPopupImportMED:
2479 case SMESHOp::OpPopupImportSTL:
2480 case SMESHOp::OpPopupImportCGNS:
2481 case SMESHOp::OpPopupImportSAUV:
2482 case SMESHOp::OpPopupImportGMF:
2484 if(checkLock(aStudy)) break;
2485 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2489 case SMESHOp::OpFileInformation:
2491 SALOME_ListIO selected;
2492 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2494 aSel->selectedObjects( selected );
2495 if( selected.Extent() )
2497 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2498 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2499 if ( !aMesh->_is_nil() )
2501 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2507 case SMESHOp::OpExportDAT:
2508 case SMESHOp::OpExportMED:
2509 case SMESHOp::OpExportUNV:
2510 case SMESHOp::OpExportSTL:
2511 case SMESHOp::OpExportCGNS:
2512 case SMESHOp::OpExportSAUV:
2513 case SMESHOp::OpExportGMF:
2514 case SMESHOp::OpPopupExportDAT:
2515 case SMESHOp::OpPopupExportMED:
2516 case SMESHOp::OpPopupExportUNV:
2517 case SMESHOp::OpPopupExportSTL:
2518 case SMESHOp::OpPopupExportCGNS:
2519 case SMESHOp::OpPopupExportSAUV:
2520 case SMESHOp::OpPopupExportGMF:
2522 ::ExportMeshToFile(theCommandID);
2526 case SMESHOp::OpReset: // SCALAR BAR
2528 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2529 SALOME_ListIO selected;
2531 aSel->selectedObjects( selected );
2533 SALOME_ListIteratorOfListIO it(selected);
2534 for( ; it.More(); it.Next()) {
2535 Handle(SALOME_InteractiveObject) anIO = it.Value();
2536 if( anIO->hasEntry() ) {
2537 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2538 anActor->SetControlMode( SMESH_Actor::eNone );
2539 #ifndef DISABLE_PLOT2DVIEWER
2540 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2545 SMESH::UpdateView();
2548 case SMESHOp::OpScalarBarProperties:
2550 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2553 case SMESHOp::OpShowScalarBar:
2555 // show/hide scalar bar
2556 ::ShowElement(theCommandID);
2559 case SMESHOp::OpSaveDistribution:
2561 // dump control distribution data to the text file
2562 ::SaveDistribution();
2566 case SMESHOp::OpShowDistribution:
2568 // show/hide distribution
2569 ::ShowElement(theCommandID);
2573 #ifndef DISABLE_PLOT2DVIEWER
2574 case SMESHOp::OpPlotDistribution:
2576 // plot distribution
2577 ::PlotDistribution();
2583 case SMESHOp::OpAutoColor:
2587 case SMESHOp::OpDisableAutoColor:
2588 ::DisableAutoColor();
2591 case SMESHOp::OpClipping:
2592 case SMESHOp::OpTransparency:
2593 case SMESHOp::OpProperties: // Display preferences (colors, shrink size, line width, ...)
2596 case SMESHOp::OpDMWireframe:
2597 case SMESHOp::OpDMShading:
2598 case SMESHOp::OpDMNodes:
2599 case SMESHOp::OpDMShrink:
2600 ::SetDisplayMode(theCommandID, myMarkerMap);
2603 //2D quadratic representation
2604 case SMESHOp::OpRepresentationLines:
2605 case SMESHOp::OpRepresentationArcs:
2606 ::SetDisplayMode(theCommandID, myMarkerMap);
2610 case SMESHOp::OpDE0DElements:
2611 case SMESHOp::OpDEEdges:
2612 case SMESHOp::OpDEFaces:
2613 case SMESHOp::OpDEVolumes:
2614 case SMESHOp::OpDEBalls:
2615 case SMESHOp::OpDEAllEntity:
2616 ::SetDisplayEntity(theCommandID);
2619 // Choose entities to be displayed
2620 case SMESHOp::OpDEChoose:
2622 ( new SMESHGUI_DisplayEntitiesDlg( SMESHGUI::desktop() ) )->exec();
2626 case SMESHOp::OpOrientationOnFaces:
2628 SUIT_OverrideCursor wc;
2629 LightApp_SelectionMgr* mgr = selectionMgr();
2630 SALOME_ListIO selected; mgr->selectedObjects( selected );
2632 SALOME_ListIteratorOfListIO it(selected);
2633 for( ; it.More(); it.Next()) {
2634 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2635 if(anIObject->hasEntry()) {
2636 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2637 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2644 case SMESHOp::OpUpdate:
2646 if(checkLock(aStudy)) break;
2647 SUIT_OverrideCursor wc;
2649 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2652 SMESH::UpdateView();
2654 catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2655 SMESH::OnVisuException();
2657 catch (...) { // PAL16774 (Crash after display of many groups)
2658 SMESH::OnVisuException();
2662 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2663 aSel->selectedObjects( l );
2664 aSel->setSelectedObjects( l );
2668 case SMESHOp::OpHide:
2669 case SMESHOp::OpShow:
2670 case SMESHOp::OpShowOnly:
2672 SUIT_OverrideCursor wc;
2673 SMESH::EDisplaing anAction;
2674 switch (theCommandID) {
2675 case SMESHOp::OpHide: anAction = SMESH::eErase; break;
2676 case SMESHOp::OpShow: anAction = SMESH::eDisplay; break;
2677 case SMESHOp::OpShowOnly: anAction = SMESH::eDisplayOnly; break;
2680 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2681 SALOME_ListIO sel_objects, to_process;
2683 aSel->selectedObjects( sel_objects );
2685 if ( theCommandID==SMESHOp::OpShowOnly )
2687 //MESSAGE("anAction = SMESH::eDisplayOnly");
2688 startOperation( myEraseAll );
2691 extractContainers( sel_objects, to_process );
2696 SALOME_ListIteratorOfListIO It( to_process );
2697 for ( ; It.More(); It.Next())
2699 Handle(SALOME_InteractiveObject) IOS = It.Value();
2700 if ( IOS->hasEntry() )
2702 if ( !SMESH::UpdateView( anAction, IOS->getEntry() )) {
2703 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2704 break; // PAL16774 (Crash after display of many groups)
2706 if (anAction == SMESH::eDisplayOnly)
2707 anAction = SMESH::eDisplay;
2712 // PAL13338 + PAL15161 -->
2713 if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !checkLock(aStudy)) {
2714 SMESH::UpdateView();
2715 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2717 // PAL13338 + PAL15161 <--
2719 catch (...) { // PAL16774 (Crash after display of many groups)
2720 SMESH::OnVisuException();
2723 if (anAction == SMESH::eErase) {
2725 aSel->setSelectedObjects( l1 );
2728 aSel->setSelectedObjects( to_process );
2733 case SMESHOp::OpNode:
2735 if(checkLock(aStudy)) break;
2738 EmitSignalDeactivateDialog();
2740 ( new SMESHGUI_NodesDlg( this ) )->show();
2743 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"),tr("SMESH_WRN_VIEWER_VTK"));
2748 case SMESHOp::OpCreateMesh:
2749 case SMESHOp::OpCreateSubMesh:
2750 case SMESHOp::OpEditMeshOrSubMesh:
2751 case SMESHOp::OpEditMesh:
2752 case SMESHOp::OpEditSubMesh:
2753 case SMESHOp::OpCompute:
2754 case SMESHOp::OpComputeSubMesh:
2755 case SMESHOp::OpPreCompute:
2756 case SMESHOp::OpEvaluate:
2757 case SMESHOp::OpMeshOrder:
2758 startOperation( theCommandID );
2760 case SMESHOp::OpCopyMesh:
2762 if (checkLock(aStudy)) break;
2763 EmitSignalDeactivateDialog();
2764 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2767 case SMESHOp::OpBuildCompoundMesh:
2769 if (checkLock(aStudy)) break;
2770 EmitSignalDeactivateDialog();
2771 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2775 case SMESHOp::OpDiagonalInversion:
2776 case SMESHOp::OpUnionOfTwoTriangle:
2780 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2784 if ( checkLock( aStudy ) )
2787 /*Standard_Boolean aRes;
2788 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2789 if ( aMesh->_is_nil() )
2791 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2792 tr( "SMESH_BAD_SELECTION" ) );
2796 EmitSignalDeactivateDialog();
2797 if ( theCommandID == SMESHOp::OpDiagonalInversion )
2798 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2800 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2803 case SMESHOp::OpOrientation:
2804 case SMESHOp::OpUnionOfTriangles:
2805 case SMESHOp::OpCuttingOfQuadrangles:
2806 case SMESHOp::OpSplitVolumes:
2810 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2814 if ( checkLock( aStudy ) )
2817 EmitSignalDeactivateDialog();
2818 SMESHGUI_MultiEditDlg* aDlg = NULL;
2819 if ( theCommandID == SMESHOp::OpOrientation )
2820 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2821 else if ( theCommandID == SMESHOp::OpUnionOfTriangles )
2822 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2823 else if ( theCommandID == SMESHOp::OpSplitVolumes )
2824 aDlg = new SMESHGUI_SplitVolumesDlg(this);
2826 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2831 case SMESHOp::OpSmoothing:
2833 if(checkLock(aStudy)) break;
2835 EmitSignalDeactivateDialog();
2836 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2839 SUIT_MessageBox::warning(desktop(), tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2843 case SMESHOp::OpExtrusion:
2845 if (checkLock(aStudy)) break;
2847 EmitSignalDeactivateDialog();
2848 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2850 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2854 case SMESHOp::OpExtrusionAlongAPath:
2856 if (checkLock(aStudy)) break;
2858 EmitSignalDeactivateDialog();
2859 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2861 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2865 case SMESHOp::OpRevolution:
2867 if(checkLock(aStudy)) break;
2869 EmitSignalDeactivateDialog();
2870 ( new SMESHGUI_RevolutionDlg( this ) )->show();
2873 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2877 case SMESHOp::OpPatternMapping:
2879 if ( checkLock( aStudy ) )
2883 EmitSignalDeactivateDialog();
2884 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2887 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2891 case SMESHOp::OpSplitBiQuadratic:
2892 case SMESHOp::OpConvertMeshToQuadratic:
2893 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
2894 case SMESHOp::OpReorientFaces:
2895 case SMESHOp::OpCreateGeometryGroup:
2897 startOperation( theCommandID );
2900 case SMESHOp::OpCreateGroup:
2904 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2908 if(checkLock(aStudy)) break;
2909 EmitSignalDeactivateDialog();
2910 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2912 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2913 SALOME_ListIO selected;
2915 aSel->selectedObjects( selected );
2917 int nbSel = selected.Extent();
2919 // check if mesh is selected
2920 aMesh = SMESH::GetMeshByIO( selected.First() );
2922 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2927 case SMESHOp::OpConstructGroup:
2931 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2935 if(checkLock(aStudy)) break;
2936 EmitSignalDeactivateDialog();
2938 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2939 SALOME_ListIO selected;
2941 aSel->selectedObjects( selected );
2943 int nbSel = selected.Extent();
2945 // check if submesh is selected
2946 Handle(SALOME_InteractiveObject) IObject = selected.First();
2947 if (IObject->hasEntry()) {
2948 _PTR(SObject) aSObj = aStudy->FindObjectID(IObject->getEntry());
2950 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2951 if (!aSubMesh->_is_nil()) {
2953 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2954 // get submesh elements list by types
2955 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2956 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2957 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2958 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2959 // create group for each type o elements
2960 QString aName = IObject->getName();
2961 QStringList anEntryList;
2962 if (aNodes->length() > 0) {
2963 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2964 aGroup->Add(aNodes.inout());
2965 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2966 anEntryList.append( aSObject->GetID().c_str() );
2968 if (aEdges->length() > 0) {
2969 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2970 aGroup->Add(aEdges.inout());
2971 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2972 anEntryList.append( aSObject->GetID().c_str() );
2974 if (aFaces->length() > 0) {
2975 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2976 aGroup->Add(aFaces.inout());
2977 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2978 anEntryList.append( aSObject->GetID().c_str() );
2980 if (aVolumes->length() > 0) {
2981 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2982 aGroup->Add(aVolumes.inout());
2983 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2984 anEntryList.append( aSObject->GetID().c_str() );
2987 anApp->browseObjects( anEntryList );
2989 catch(const SALOME::SALOME_Exception & S_ex){
2990 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2997 SUIT_MessageBox::warning(desktop(),
2998 tr("SMESH_WRN_WARNING"),
2999 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
3004 case SMESHOp::OpEditGroup:
3008 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3012 if(checkLock(aStudy)) break;
3013 EmitSignalDeactivateDialog();
3015 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3016 SALOME_ListIO selected;
3018 aSel->selectedObjects( selected );
3020 SALOME_ListIteratorOfListIO It (selected);
3021 int nbSelectedGroups = 0;
3022 for ( ; It.More(); It.Next() )
3024 SMESH::SMESH_GroupBase_var aGroup =
3025 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
3026 if (!aGroup->_is_nil()) {
3028 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
3032 if (nbSelectedGroups == 0)
3034 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
3040 case SMESHOp::OpAddElemGroupPopup: // Add elements to group
3042 if(checkLock(aStudy)) break;
3043 if (myState == 800) {
3044 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3045 if (aDlg) aDlg->onAdd();
3050 case SMESHOp::OpRemoveElemGroupPopup: // Remove elements from group
3052 if(checkLock(aStudy)) break;
3053 if (myState == 800) {
3054 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3055 if (aDlg) aDlg->onRemove();
3060 case SMESHOp::OpEditGeomGroupAsGroup:
3064 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3068 if(checkLock(aStudy)) break;
3069 EmitSignalDeactivateDialog();
3071 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3072 SALOME_ListIO selected;
3074 aSel->selectedObjects( selected );
3076 SALOME_ListIteratorOfListIO It (selected);
3077 for ( ; It.More(); It.Next() )
3079 SMESH::SMESH_GroupOnGeom_var aGroup =
3080 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
3081 if (!aGroup->_is_nil()) {
3082 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3087 SMESH::SMESH_GroupOnFilter_var aGroup =
3088 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
3089 if (!aGroup->_is_nil()) {
3090 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3098 case SMESHOp::OpUnionGroups:
3099 case SMESHOp::OpIntersectGroups:
3100 case SMESHOp::OpCutGroups:
3104 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3108 if ( checkLock( aStudy ) )
3111 EmitSignalDeactivateDialog();
3113 SMESHGUI_GroupOpDlg* aDlg = 0;
3114 if ( theCommandID == SMESHOp::OpUnionGroups )
3115 aDlg = new SMESHGUI_UnionGroupsDlg( this );
3116 else if ( theCommandID == SMESHOp::OpIntersectGroups )
3117 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3119 aDlg = new SMESHGUI_CutGroupsDlg( this );
3126 case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
3128 if ( checkLock( aStudy ) )
3131 EmitSignalDeactivateDialog();
3132 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3138 case SMESHOp::OpDeleteGroup: // Delete groups with their contents
3142 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3146 if ( checkLock( aStudy ) )
3149 EmitSignalDeactivateDialog();
3151 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3155 case SMESHOp::OpMeshInformation:
3156 case SMESHOp::OpWhatIs:
3158 int page = theCommandID == SMESHOp::OpMeshInformation ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3159 EmitSignalDeactivateDialog();
3160 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3161 SALOME_ListIO selected;
3163 aSel->selectedObjects( selected );
3165 if ( selected.Extent() > 1 ) { // a dlg for each IO
3166 SALOME_ListIteratorOfListIO It( selected );
3167 for ( ; It.More(); It.Next() ) {
3168 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3169 dlg->showInfo( It.Value() );
3174 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3180 case SMESHOp::OpFindElementByPoint:
3182 startOperation( theCommandID );
3186 case SMESHOp::OpEditHypothesis:
3188 if(checkLock(aStudy)) break;
3190 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3191 SALOME_ListIO selected;
3193 aSel->selectedObjects( selected );
3195 int nbSel = selected.Extent();
3198 Handle(SALOME_InteractiveObject) anIObject = selected.First();
3199 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3201 if ( !aHypothesis->_is_nil() )
3203 SMESHGUI_GenericHypothesisCreator* aCreator =
3204 SMESH::GetHypothesisCreator( SMESH::toQStr( aHypothesis->GetName() ));
3207 // set geometry of mesh and sub-mesh to aCreator
3208 aSel->selectedObjects( selected, "", /*convertReferences=*/false);
3209 if ( selected.Extent() == 1 )
3211 QString subGeomID, meshGeomID;
3212 Handle(SALOME_InteractiveObject) hypIO = selected.First();
3213 if ( SMESH::GetGeomEntries( hypIO, subGeomID, meshGeomID ))
3215 if ( subGeomID.isEmpty() ) subGeomID = meshGeomID;
3216 aCreator->setShapeEntry( subGeomID );
3217 aCreator->setMainShapeEntry( meshGeomID );
3221 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3231 case SMESHOp::OpUnassign: // REMOVE HYPOTHESIS / ALGORITHMS
3233 if(checkLock(aStudy)) break;
3234 SUIT_OverrideCursor wc;
3236 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3237 SALOME_ListIO selected;
3239 aSel->selectedObjects( selected, QString::null, false );
3241 SALOME_ListIteratorOfListIO It(selected);
3242 for (int i = 0; It.More(); It.Next(), i++) {
3243 Handle(SALOME_InteractiveObject) IObject = It.Value();
3244 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3247 aSel->setSelectedObjects( l1 );
3252 case SMESHOp::OpElem0D:
3253 case SMESHOp::OpBall:
3254 case SMESHOp::OpEdge:
3255 case SMESHOp::OpTriangle:
3256 case SMESHOp::OpQuadrangle:
3257 case SMESHOp::OpPolygon:
3258 case SMESHOp::OpTetrahedron:
3259 case SMESHOp::OpHexahedron:
3260 case SMESHOp::OpPentahedron:
3261 case SMESHOp::OpPyramid:
3262 case SMESHOp::OpHexagonalPrism:
3264 if(checkLock(aStudy)) break;
3266 EmitSignalDeactivateDialog();
3267 SMDSAbs_EntityType type = SMDSEntity_Edge;
3268 switch (theCommandID) {
3269 case SMESHOp::OpElem0D: type = SMDSEntity_0D; break;
3270 case SMESHOp::OpBall: type = SMDSEntity_Ball; break;
3271 case SMESHOp::OpTriangle: type = SMDSEntity_Triangle; break;
3272 case SMESHOp::OpQuadrangle: type = SMDSEntity_Quadrangle; break;
3273 case SMESHOp::OpTetrahedron: type = SMDSEntity_Tetra; break;
3274 case SMESHOp::OpPolygon: type = SMDSEntity_Polygon; break;
3275 case SMESHOp::OpHexahedron: type = SMDSEntity_Hexa; break;
3276 case SMESHOp::OpPentahedron: type = SMDSEntity_Penta; break;
3277 case SMESHOp::OpPyramid: type = SMDSEntity_Pyramid; break;
3278 case SMESHOp::OpHexagonalPrism: type = SMDSEntity_Hexagonal_Prism; break;
3281 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3284 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3288 case SMESHOp::OpPolyhedron:
3290 if(checkLock(aStudy)) break;
3292 EmitSignalDeactivateDialog();
3293 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3296 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3300 case SMESHOp::OpQuadraticEdge:
3301 case SMESHOp::OpQuadraticTriangle:
3302 case SMESHOp::OpBiQuadraticTriangle:
3303 case SMESHOp::OpQuadraticQuadrangle:
3304 case SMESHOp::OpBiQuadraticQuadrangle:
3305 case SMESHOp::OpQuadraticPolygon:
3306 case SMESHOp::OpQuadraticTetrahedron:
3307 case SMESHOp::OpQuadraticPyramid:
3308 case SMESHOp::OpQuadraticPentahedron:
3309 case SMESHOp::OpBiQuadraticPentahedron:
3310 case SMESHOp::OpQuadraticHexahedron:
3311 case SMESHOp::OpTriQuadraticHexahedron:
3313 if(checkLock(aStudy)) break;
3315 EmitSignalDeactivateDialog();
3316 SMDSAbs_EntityType type = SMDSEntity_Last;
3318 switch (theCommandID) {
3319 case SMESHOp::OpQuadraticEdge: type = SMDSEntity_Quad_Edge; break;
3320 case SMESHOp::OpQuadraticTriangle: type = SMDSEntity_Quad_Triangle; break;
3321 case SMESHOp::OpBiQuadraticTriangle: type = SMDSEntity_BiQuad_Triangle; break;
3322 case SMESHOp::OpQuadraticQuadrangle: type = SMDSEntity_Quad_Quadrangle; break;
3323 case SMESHOp::OpBiQuadraticQuadrangle: type = SMDSEntity_BiQuad_Quadrangle; break;
3324 case SMESHOp::OpQuadraticPolygon: type = SMDSEntity_Quad_Polygon; break;
3325 case SMESHOp::OpQuadraticTetrahedron: type = SMDSEntity_Quad_Tetra; break;
3326 case SMESHOp::OpQuadraticPyramid: type = SMDSEntity_Quad_Pyramid; break;
3327 case SMESHOp::OpQuadraticPentahedron: type = SMDSEntity_Quad_Penta; break;
3328 case SMESHOp::OpBiQuadraticPentahedron: type = SMDSEntity_BiQuad_Penta; break;
3329 case SMESHOp::OpQuadraticHexahedron: type = SMDSEntity_Quad_Hexa; break;
3330 case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
3333 if ( type != SMDSEntity_Last )
3334 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3337 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3338 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3342 case SMESHOp::OpRemoveNodes:
3344 if(checkLock(aStudy)) break;
3346 EmitSignalDeactivateDialog();
3347 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3350 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3351 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3355 case SMESHOp::OpRemoveElements: // REMOVES ELEMENTS
3357 if(checkLock(aStudy)) break;
3359 EmitSignalDeactivateDialog();
3360 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3364 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3365 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3369 case SMESHOp::OpClearMesh: {
3371 if(checkLock(aStudy)) break;
3373 SALOME_ListIO selected;
3374 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3375 aSel->selectedObjects( selected );
3377 SUIT_OverrideCursor wc;
3378 SALOME_ListIteratorOfListIO It (selected);
3379 for ( ; It.More(); It.Next() )
3381 Handle(SALOME_InteractiveObject) IOS = It.Value();
3382 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3383 if ( aMesh->_is_nil()) continue;
3386 if ( aMesh->NbNodes() == 0 ) // imported mesh is not empty
3387 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3388 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3389 SMESH::ModifiedMesh( aMeshSObj, false, true);
3390 // hide groups and submeshes
3391 _PTR(ChildIterator) anIter =
3392 SMESH::GetActiveStudyDocument()->NewChildIterator( aMeshSObj );
3393 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3395 _PTR(SObject) so = anIter->Value();
3396 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3399 catch (const SALOME::SALOME_Exception& S_ex){
3401 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3405 SMESH::UpdateView();
3409 case SMESHOp::OpRemoveOrphanNodes:
3411 if(checkLock(aStudy)) break;
3412 SALOME_ListIO selected;
3413 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3414 aSel->selectedObjects( selected );
3415 if ( selected.Extent() == 1 ) {
3416 Handle(SALOME_InteractiveObject) anIO = selected.First();
3417 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3418 if ( !aMesh->_is_nil() ) {
3419 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3420 tr( "SMESH_WARNING" ),
3421 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3422 SUIT_MessageBox::Yes |
3423 SUIT_MessageBox::No,
3424 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3427 SUIT_OverrideCursor wc;
3428 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3429 int removed = aMeshEditor->RemoveOrphanNodes();
3430 SUIT_MessageBox::information(SMESHGUI::desktop(),
3431 tr("SMESH_INFORMATION"),
3432 tr("NB_NODES_REMOVED").arg(removed));
3433 if ( removed > 0 ) {
3434 SMESH::UpdateView();
3435 SMESHGUI::Modified();
3438 catch (const SALOME::SALOME_Exception& S_ex) {
3439 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3448 case SMESHOp::OpRenumberingNodes:
3450 if(checkLock(aStudy)) break;
3452 EmitSignalDeactivateDialog();
3453 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3457 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3458 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3462 case SMESHOp::OpRenumberingElements:
3464 if(checkLock(aStudy)) break;
3466 EmitSignalDeactivateDialog();
3467 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3471 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3472 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3476 case SMESHOp::OpTranslation:
3478 if(checkLock(aStudy)) break;
3480 EmitSignalDeactivateDialog();
3481 ( new SMESHGUI_TranslationDlg( this ) )->show();
3484 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3485 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3489 case SMESHOp::OpRotation:
3491 if(checkLock(aStudy)) break;
3493 EmitSignalDeactivateDialog();
3494 ( new SMESHGUI_RotationDlg( this ) )->show();
3497 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3498 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3502 case SMESHOp::OpSymmetry:
3504 if(checkLock(aStudy)) break;
3506 EmitSignalDeactivateDialog();
3507 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3510 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3511 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3515 case SMESHOp::OpScale:
3517 if(checkLock(aStudy)) break;
3519 EmitSignalDeactivateDialog();
3520 ( new SMESHGUI_ScaleDlg( this ) )->show();
3523 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3524 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3529 case SMESHOp::OpSewing:
3531 if(checkLock(aStudy)) break;
3533 EmitSignalDeactivateDialog();
3534 ( new SMESHGUI_SewingDlg( this ) )->show();
3537 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3538 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3542 case SMESHOp::OpMergeNodes:
3544 if(checkLock(aStudy)) break;
3546 EmitSignalDeactivateDialog();
3547 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3550 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3551 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3555 case SMESHOp::OpMergeElements:
3557 if (checkLock(aStudy)) break;
3559 EmitSignalDeactivateDialog();
3560 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3562 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3563 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3568 case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
3569 startOperation( SMESHOp::OpMoveNode );
3572 case SMESHOp::OpDuplicateNodes:
3574 if(checkLock(aStudy)) break;
3576 EmitSignalDeactivateDialog();
3577 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3580 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3581 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3586 case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
3587 startOperation( SMESHOp::OpElem0DOnElemNodes );
3590 case SMESHOp::OpSelectFiltersLibrary: // Library of selection filters
3592 static QList<int> aTypes;
3593 if ( aTypes.isEmpty() )
3595 aTypes.append( SMESH::NODE );
3596 aTypes.append( SMESH::EDGE );
3597 aTypes.append( SMESH::FACE );
3598 aTypes.append( SMESH::VOLUME );
3600 if (!myFilterLibraryDlg)
3601 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3602 else if (myFilterLibraryDlg->isHidden())
3603 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3604 myFilterLibraryDlg->raise();
3608 case SMESHOp::OpFreeNode:
3609 case SMESHOp::OpEqualNode:
3610 case SMESHOp::OpNodeConnectivityNb:
3611 case SMESHOp::OpFreeEdge:
3612 case SMESHOp::OpFreeBorder:
3613 case SMESHOp::OpLength:
3614 case SMESHOp::OpConnection:
3615 case SMESHOp::OpEqualEdge:
3616 case SMESHOp::OpFreeFace:
3617 case SMESHOp::OpBareBorderFace:
3618 case SMESHOp::OpOverConstrainedFace:
3619 case SMESHOp::OpLength2D:
3620 case SMESHOp::OpConnection2D:
3621 case SMESHOp::OpArea:
3622 case SMESHOp::OpTaper:
3623 case SMESHOp::OpAspectRatio:
3624 case SMESHOp::OpMinimumAngle:
3625 case SMESHOp::OpWarpingAngle:
3626 case SMESHOp::OpSkew:
3627 case SMESHOp::OpMaxElementLength2D:
3628 case SMESHOp::OpEqualFace:
3629 case SMESHOp::OpAspectRatio3D:
3630 case SMESHOp::OpVolume:
3631 case SMESHOp::OpMaxElementLength3D:
3632 case SMESHOp::OpBareBorderVolume:
3633 case SMESHOp::OpOverConstrainedVolume:
3634 case SMESHOp::OpEqualVolume:
3637 LightApp_SelectionMgr* mgr = selectionMgr();
3638 SALOME_ListIO selected; mgr->selectedObjects( selected );
3640 if( !selected.IsEmpty() ) {
3641 SUIT_OverrideCursor wc;
3642 ::Control( theCommandID );
3645 SUIT_MessageBox::warning(desktop(),
3646 tr( "SMESH_WRN_WARNING" ),
3647 tr( "SMESH_BAD_SELECTION" ) );
3651 SUIT_MessageBox::warning(desktop(),
3652 tr( "SMESH_WRN_WARNING" ),
3653 tr( "NOT_A_VTK_VIEWER" ) );
3656 case SMESHOp::OpOverallMeshQuality:
3657 OverallMeshQuality();
3659 case SMESHOp::OpNumberingNodes:
3661 SUIT_OverrideCursor wc;
3662 LightApp_SelectionMgr* mgr = selectionMgr();
3663 SALOME_ListIO selected; mgr->selectedObjects( selected );
3665 SALOME_ListIteratorOfListIO it(selected);
3666 for( ; it.More(); it.Next()) {
3667 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3668 if(anIObject->hasEntry()) {
3669 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3670 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3676 case SMESHOp::OpNumberingElements:
3678 SUIT_OverrideCursor wc;
3679 LightApp_SelectionMgr* mgr = selectionMgr();
3680 SALOME_ListIO selected; mgr->selectedObjects( selected );
3682 SALOME_ListIteratorOfListIO it(selected);
3683 for( ; it.More(); it.Next()) {
3684 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3685 if(anIObject->hasEntry())
3686 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3687 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3692 case SMESHOp::OpPropertiesLength:
3693 case SMESHOp::OpPropertiesArea:
3694 case SMESHOp::OpPropertiesVolume:
3695 case SMESHOp::OpMinimumDistance:
3696 case SMESHOp::OpBoundingBox:
3698 int page = SMESHGUI_MeasureDlg::MinDistance;
3699 if ( theCommandID == SMESHOp::OpBoundingBox )
3700 page = SMESHGUI_MeasureDlg::BoundingBox;
3701 else if ( theCommandID == SMESHOp::OpPropertiesLength )
3702 page = SMESHGUI_MeasureDlg::Length;
3703 else if ( theCommandID == SMESHOp::OpPropertiesArea )
3704 page = SMESHGUI_MeasureDlg::Area;
3705 else if ( theCommandID == SMESHOp::OpPropertiesVolume )
3706 page = SMESHGUI_MeasureDlg::Volume;
3708 EmitSignalDeactivateDialog();
3709 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3713 case SMESHOp::OpSortChild:
3719 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3720 //updateObjBrowser();
3724 //=============================================================================
3728 //=============================================================================
3729 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3734 //=============================================================================
3738 //=============================================================================
3739 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3744 //=============================================================================
3748 //=============================================================================
3749 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3754 //=============================================================================
3755 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3756 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3758 //=============================================================================
3759 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3760 SUIT_ViewWindow* wnd )
3762 if(theIO->hasEntry()){
3763 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3764 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3768 //=======================================================================
3769 // function : createSMESHAction
3771 //=======================================================================
3772 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3773 const int key, const bool toggle, const QString& shortcutAction )
3776 QWidget* parent = application()->desktop();
3777 SUIT_ResourceMgr* resMgr = resourceMgr();
3779 if ( !icon_id.isEmpty() )
3780 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3782 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3783 if ( !pix.isNull() )
3784 icon = QIcon( pix );
3786 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3787 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3788 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3790 createAction( id, tooltip, icon, menu, status_bar, key, parent,
3791 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3794 //=======================================================================
3795 // function : createPopupItem
3797 //=======================================================================
3798 void SMESHGUI::createPopupItem( const int id,
3799 const QString& clients,
3800 const QString& types,
3801 const QString& theRule,
3804 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3805 popupMgr()->insert( action( id ), pId, 0 );
3807 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3808 QString dc = "selcount"; // VSR : insetad of QtxPopupSelection::defSelCountParam()
3809 QString rule = "(%1) and (%2) and (%3)";
3810 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3811 if( clients.isEmpty() )
3812 rule = rule.arg( QString( "true" ) );
3814 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3815 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3818 bool cont = myRules.contains( id );
3820 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3822 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3823 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3826 //=======================================================================
3827 // function : initialize
3829 //=======================================================================
3830 void SMESHGUI::initialize( CAM_Application* app )
3832 SalomeApp_Module::initialize( app );
3834 // SUIT_ResourceMgr* mgr = app->resourceMgr();
3836 /* Automatic Update flag */
3837 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3839 // ----- create actions --------------
3841 //createSMESHAction( SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
3842 createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_I) );
3843 createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
3844 createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL" );
3846 createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
3848 createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
3849 createSMESHAction( SMESHOp::OpImportGMF, "IMPORT_GMF" );
3850 createSMESHAction( SMESHOp::OpPopupImportUNV, "IMPORT_UNV");
3851 createSMESHAction( SMESHOp::OpPopupImportMED, "IMPORT_MED");
3852 createSMESHAction( SMESHOp::OpPopupImportSTL, "IMPORT_STL" );
3854 createSMESHAction( SMESHOp::OpPopupImportCGNS, "IMPORT_CGNS" );
3856 createSMESHAction( SMESHOp::OpPopupImportSAUV, "IMPORT_SAUV" );
3857 createSMESHAction( SMESHOp::OpPopupImportGMF, "IMPORT_GMF" );
3859 createSMESHAction( SMESHOp::OpExportDAT, "DAT" );
3860 createSMESHAction( SMESHOp::OpExportMED, "MED" );
3861 createSMESHAction( SMESHOp::OpExportUNV, "UNV" );
3862 createSMESHAction( SMESHOp::OpExportSTL, "STL" );
3864 createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
3866 createSMESHAction( SMESHOp::OpExportSAUV, "SAUV");
3867 createSMESHAction( SMESHOp::OpExportGMF, "GMF" );
3868 createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
3869 createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
3870 createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
3871 createSMESHAction( SMESHOp::OpPopupExportSTL, "STL" );
3873 createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
3875 createSMESHAction( SMESHOp::OpPopupExportSAUV, "SAUV");
3876 createSMESHAction( SMESHOp::OpPopupExportGMF, "GMF" );
3877 createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
3878 createSMESHAction( SMESHOp::OpDelete, "DELETE", "ICON_DELETE", Qt::Key_Delete );
3879 createSMESHAction( SMESHOp::OpSelectFiltersLibrary, "SEL_FILTER_LIB" );
3880 createSMESHAction( SMESHOp::OpCreateMesh, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
3881 createSMESHAction( SMESHOp::OpCreateSubMesh, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
3882 createSMESHAction( SMESHOp::OpEditMeshOrSubMesh, "EDIT_MESHSUBMESH", "ICON_DLG_EDIT_MESH" );
3883 createSMESHAction( SMESHOp::OpEditMesh, "EDIT_MESH", "ICON_DLG_EDIT_MESH" );
3884 createSMESHAction( SMESHOp::OpEditSubMesh, "EDIT_SUBMESH", "ICON_DLG_EDIT_MESH" );
3885 createSMESHAction( SMESHOp::OpBuildCompoundMesh, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
3886 createSMESHAction( SMESHOp::OpCopyMesh, "COPY_MESH", "ICON_COPY_MESH" );
3887 createSMESHAction( SMESHOp::OpCompute, "COMPUTE", "ICON_COMPUTE" );
3888 createSMESHAction( SMESHOp::OpComputeSubMesh, "COMPUTE_SUBMESH", "ICON_COMPUTE" );
3889 createSMESHAction( SMESHOp::OpPreCompute, "PRECOMPUTE", "ICON_PRECOMPUTE" );
3890 createSMESHAction( SMESHOp::OpEvaluate, "EVALUATE", "ICON_EVALUATE" );
3891 createSMESHAction( SMESHOp::OpMeshOrder, "MESH_ORDER", "ICON_MESH_ORDER");
3892 createSMESHAction( SMESHOp::OpCreateGroup, "CREATE_GROUP", "ICON_CREATE_GROUP" );
3893 createSMESHAction( SMESHOp::OpCreateGeometryGroup, "CREATE_GEO_GROUP", "ICON_CREATE_GEO_GROUP" );
3894 createSMESHAction( SMESHOp::OpConstructGroup, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
3895 createSMESHAction( SMESHOp::OpEditGroup, "EDIT_GROUP", "ICON_EDIT_GROUP" );
3896 createSMESHAction( SMESHOp::OpEditGeomGroupAsGroup, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3897 createSMESHAction( SMESHOp::OpUnionGroups, "UN_GROUP", "ICON_UNION" );
3898 createSMESHAction( SMESHOp::OpIntersectGroups, "INT_GROUP", "ICON_INTERSECT" );
3899 createSMESHAction( SMESHOp::OpCutGroups, "CUT_GROUP", "ICON_CUT" );
3900 createSMESHAction( SMESHOp::OpGroupUnderlyingElem, "UNDERLYING_ELEMS", "ICON_UNDERLYING_ELEMS" );
3901 createSMESHAction( SMESHOp::OpAddElemGroupPopup, "ADD_TO_GROUP" );
3902 createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE_FROM_GROUP" );
3903 createSMESHAction( SMESHOp::OpDeleteGroup, "DEL_GROUP", "ICON_DEL_GROUP" );
3904 createSMESHAction( SMESHOp::OpMeshInformation , "ADV_INFO", "ICON_ADV_INFO" );
3905 //createSMESHAction( SMESHOp::OpStdInfo, "STD_INFO", "ICON_STD_INFO" );
3906 //createSMESHAction( SMESHOp::OpWhatIs, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3907 createSMESHAction( SMESHOp::OpFindElementByPoint, "FIND_ELEM", "ICON_FIND_ELEM" );
3909 createSMESHAction( SMESHOp::OpFreeNode, "FREE_NODE", "ICON_FREE_NODE", 0, true );
3910 createSMESHAction( SMESHOp::OpEqualNode, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
3911 createSMESHAction( SMESHOp::OpNodeConnectivityNb, "NODE_CONNECTIVITY_NB", "ICON_NODE_CONN_NB", 0, true );
3912 createSMESHAction( SMESHOp::OpFreeEdge, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
3913 createSMESHAction( SMESHOp::OpFreeBorder, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
3914 createSMESHAction( SMESHOp::OpLength, "LENGTH", "ICON_LENGTH", 0, true );
3915 createSMESHAction( SMESHOp::OpConnection, "CONNECTION", "ICON_CONNECTION", 0, true );
3916 createSMESHAction( SMESHOp::OpEqualEdge, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
3917 createSMESHAction( SMESHOp::OpFreeFace, "FREE_FACES", "ICON_FREE_FACES", 0, true );
3918 createSMESHAction( SMESHOp::OpBareBorderFace, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
3919 createSMESHAction( SMESHOp::OpOverConstrainedFace, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
3920 createSMESHAction( SMESHOp::OpLength2D, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
3921 createSMESHAction( SMESHOp::OpConnection2D, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
3922 createSMESHAction( SMESHOp::OpArea, "AREA", "ICON_AREA", 0, true );
3923 createSMESHAction( SMESHOp::OpTaper, "TAPER", "ICON_TAPER", 0, true );
3924 createSMESHAction( SMESHOp::OpAspectRatio, "ASPECT", "ICON_ASPECT", 0, true );
3925 createSMESHAction( SMESHOp::OpMinimumAngle, "MIN_ANG", "ICON_ANGLE", 0, true );
3926 createSMESHAction( SMESHOp::OpWarpingAngle, "WARP", "ICON_WARP", 0, true );
3927 createSMESHAction( SMESHOp::OpSkew, "SKEW", "ICON_SKEW", 0, true );
3928 createSMESHAction( SMESHOp::OpMaxElementLength2D, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
3929 createSMESHAction( SMESHOp::OpEqualFace, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
3930 createSMESHAction( SMESHOp::OpAspectRatio3D, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
3931 createSMESHAction( SMESHOp::OpVolume, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
3932 createSMESHAction( SMESHOp::OpMaxElementLength3D, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
3933 createSMESHAction( SMESHOp::OpBareBorderVolume, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
3934 createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
3935 createSMESHAction( SMESHOp::OpEqualVolume, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
3936 createSMESHAction( SMESHOp::OpOverallMeshQuality, "OVERALL_MESH_QUALITY", "ICON_OVL_MESH_QUALITY" );
3938 createSMESHAction( SMESHOp::OpNode, "NODE", "ICON_DLG_NODE" );
3939 createSMESHAction( SMESHOp::OpElem0D, "ELEM0D", "ICON_DLG_ELEM0D" );
3940 createSMESHAction( SMESHOp::OpElem0DOnElemNodes, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
3941 createSMESHAction( SMESHOp::OpBall, "BALL", "ICON_DLG_BALL" );
3942 createSMESHAction( SMESHOp::OpEdge, "EDGE", "ICON_DLG_EDGE" );
3943 createSMESHAction( SMESHOp::OpTriangle, "TRIANGLE", "ICON_DLG_TRIANGLE" );
3944 createSMESHAction( SMESHOp::OpQuadrangle, "QUAD", "ICON_DLG_QUADRANGLE" );
3945 createSMESHAction( SMESHOp::OpPolygon, "POLYGON", "ICON_DLG_POLYGON" );
3946 createSMESHAction( SMESHOp::OpTetrahedron, "TETRA", "ICON_DLG_TETRAS" );
3947 createSMESHAction( SMESHOp::OpHexahedron, "HEXA", "ICON_DLG_HEXAS" );
3948 createSMESHAction( SMESHOp::OpPentahedron, "PENTA", "ICON_DLG_PENTA" );
3949 createSMESHAction( SMESHOp::OpPyramid , "PYRAMID", "ICON_DLG_PYRAMID" );
3950 createSMESHAction( SMESHOp::OpHexagonalPrism, "OCTA", "ICON_DLG_OCTA" );
3951 createSMESHAction( SMESHOp::OpPolyhedron, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
3952 createSMESHAction( SMESHOp::OpQuadraticEdge, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
3953 createSMESHAction( SMESHOp::OpQuadraticTriangle, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
3954 createSMESHAction( SMESHOp::OpBiQuadraticTriangle, "BIQUADRATIC_TRIANGLE", "ICON_DLG_BIQUADRATIC_TRIANGLE" );
3955 createSMESHAction( SMESHOp::OpQuadraticQuadrangle, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
3956 createSMESHAction( SMESHOp::OpBiQuadraticQuadrangle, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
3957 createSMESHAction( SMESHOp::OpQuadraticPolygon, "QUADRATIC_POLYGON", "ICON_DLG_QUADRATIC_POLYGON" );
3958 createSMESHAction( SMESHOp::OpQuadraticTetrahedron, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
3959 createSMESHAction( SMESHOp::OpQuadraticPyramid, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
3960 createSMESHAction( SMESHOp::OpQuadraticPentahedron, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
3961 createSMESHAction( SMESHOp::OpBiQuadraticPentahedron, "BIQUADRATIC_PENTAHEDRON", "ICON_DLG_BIQUADRATIC_PENTAHEDRON" );
3962 createSMESHAction( SMESHOp::OpQuadraticHexahedron, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
3963 createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
3965 createSMESHAction( SMESHOp::OpRemoveNodes, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
3966 createSMESHAction( SMESHOp::OpRemoveElements, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
3967 createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
3968 createSMESHAction( SMESHOp::OpClearMesh, "CLEAR_MESH", "ICON_CLEAR_MESH" );
3970 //createSMESHAction( SMESHOp::OpRenumberingNodes, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
3971 //createSMESHAction( SMESHOp::OpRenumberingElements, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
3973 createSMESHAction( SMESHOp::OpTranslation, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
3974 createSMESHAction( SMESHOp::OpRotation, "ROT", "ICON_DLG_MESH_ROTATION" );
3975 createSMESHAction( SMESHOp::OpSymmetry, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
3976 createSMESHAction( SMESHOp::OpScale, "SCALE", "ICON_DLG_MESH_SCALE" );
3977 createSMESHAction( SMESHOp::OpSewing, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
3978 createSMESHAction( SMESHOp::OpMergeNodes, "MERGE", "ICON_SMESH_MERGE_NODES" );
3979 createSMESHAction( SMESHOp::OpMergeElements, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
3980 createSMESHAction( SMESHOp::OpMoveNode, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
3981 createSMESHAction( SMESHOp::OpDuplicateNodes, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
3982 createSMESHAction( SMESHOp::OpDiagonalInversion, "INV", "ICON_DLG_MESH_DIAGONAL" );
3983 createSMESHAction( SMESHOp::OpUnionOfTwoTriangle, "UNION2", "ICON_UNION2TRI" );
3984 createSMESHAction( SMESHOp::OpOrientation, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
3985 createSMESHAction( SMESHOp::OpReorientFaces, "REORIENT_2D", "ICON_REORIENT_2D" );
3986 createSMESHAction( SMESHOp::OpUnionOfTriangles, "UNION", "ICON_UNIONTRI" );
3987 createSMESHAction( SMESHOp::OpCuttingOfQuadrangles, "CUT", "ICON_CUTQUAD" );
3988 createSMESHAction( SMESHOp::OpSplitVolumes, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
3989 createSMESHAction( SMESHOp::OpSplitBiQuadratic, "SPLIT_BIQUAD", "ICON_SPLIT_BIQUAD" );
3990 createSMESHAction( SMESHOp::OpSmoothing, "SMOOTH", "ICON_DLG_SMOOTHING" );
3991 createSMESHAction( SMESHOp::OpExtrusion, "EXTRUSION", "ICON_EXTRUSION" );
3992 createSMESHAction( SMESHOp::OpExtrusionAlongAPath, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
3993 createSMESHAction( SMESHOp::OpRevolution, "REVOLUTION", "ICON_REVOLUTION" );
3994 createSMESHAction( SMESHOp::OpPatternMapping, "MAP", "ICON_MAP" );
3995 createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
3996 createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D", "ICON_2D_FROM_3D" );
3998 createSMESHAction( SMESHOp::OpReset, "RESET" );
3999 createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
4000 createSMESHAction( SMESHOp::OpShowScalarBar, "SHOW_SCALAR_BAR","",0, true );
4001 createSMESHAction( SMESHOp::OpSaveDistribution, "SAVE_DISTRIBUTION" );
4002 createSMESHAction( SMESHOp::OpShowDistribution, "SHOW_DISTRIBUTION","",0, true );
4003 #ifndef DISABLE_PLOT2DVIEWER
4004 createSMESHAction( SMESHOp::OpPlotDistribution, "PLOT_DISTRIBUTION" );
4006 createSMESHAction( SMESHOp::OpDMWireframe, "WIRE", "ICON_WIRE", 0, true );
4007 createSMESHAction( SMESHOp::OpDMShading, "SHADE", "ICON_SHADE", 0, true );
4008 createSMESHAction( SMESHOp::OpDMNodes, "NODES", "ICON_POINTS", 0, true );
4009 createSMESHAction( SMESHOp::OpDMShrink, "SHRINK", "ICON_SHRINK", 0, true );
4010 createSMESHAction( SMESHOp::OpUpdate, "UPDATE", "ICON_UPDATE" );
4011 createSMESHAction( SMESHOp::OpDE0DElements, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
4012 createSMESHAction( SMESHOp::OpDEEdges, "EDGES", "ICON_DLG_EDGE", 0, true );
4013 createSMESHAction( SMESHOp::OpDEFaces, "FACES", "ICON_DLG_TRIANGLE", 0, true );
4014 createSMESHAction( SMESHOp::OpDEVolumes, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
4015 createSMESHAction( SMESHOp::OpDEBalls, "BALLS", "ICON_DLG_BALL", 0, true );
4016 createSMESHAction( SMESHOp::OpDEChoose, "CHOOSE", "ICON_DLG_CHOOSE", 0, false );
4017 createSMESHAction( SMESHOp::OpDEAllEntity, "ALL", "ICON_DLG_CHOOSE_ALL", 0, false );
4018 createSMESHAction( SMESHOp::OpOrientationOnFaces, "FACE_ORIENTATION", "", 0, true );
4020 createSMESHAction( SMESHOp::OpRepresentationLines, "LINE_REPRESENTATION", "", 0, true );
4021 createSMESHAction( SMESHOp::OpRepresentationArcs, "ARC_REPRESENTATION", "", 0, true );
4023 createSMESHAction( SMESHOp::OpEditHypothesis, "EDIT_HYPO" );
4024 createSMESHAction( SMESHOp::OpUnassign, "UNASSIGN" );
4025 createSMESHAction( SMESHOp::OpNumberingNodes, "NUM_NODES", "", 0, true );
4026 createSMESHAction( SMESHOp::OpNumberingElements, "NUM_ELEMENTS", "", 0, true );
4027 createSMESHAction( SMESHOp::OpProperties, "COLORS" );
4028 createSMESHAction( SMESHOp::OpTransparency, "TRANSP" );
4029 createSMESHAction( SMESHOp::OpClipping, "CLIP" );
4030 createSMESHAction( SMESHOp::OpAutoColor, "AUTO_COLOR" );
4031 createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
4033 createSMESHAction( SMESHOp::OpMinimumDistance, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
4034 createSMESHAction( SMESHOp::OpBoundingBox, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
4035 createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH", "ICON_MEASURE_LENGTH" );
4036 createSMESHAction( SMESHOp::OpPropertiesArea, "MEASURE_AREA", "ICON_MEASURE_AREA" );
4037 createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME", "ICON_MEASURE_VOLUME" );
4039 createSMESHAction( SMESHOp::OpHide, "HIDE", "ICON_HIDE" );
4040 createSMESHAction( SMESHOp::OpShow, "SHOW", "ICON_SHOW" );
4041 createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
4043 createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
4045 QList<int> aCtrlActions;
4046 aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode
4047 << SMESHOp::OpNodeConnectivityNb // node controls
4048 << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
4049 << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge // edge controls
4050 << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
4051 << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
4052 << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
4053 << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
4054 << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace // face controls
4055 << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
4056 << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
4057 << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume; // volume controls
4058 QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
4059 aCtrlGroup->setExclusive( true );
4060 for( int i = 0; i < aCtrlActions.size(); i++ )
4061 aCtrlGroup->addAction( action( aCtrlActions[i] ) );
4063 // ----- create menu --------------
4064 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
4065 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
4066 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
4067 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
4068 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
4069 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
4070 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
4071 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
4073 createMenu( separator(), fileId );
4075 QMenu* nodeMenu = new QMenu(); QMenu* edgeMenu = new QMenu();
4076 QMenu* faceMenu = new QMenu(); QMenu* volumeMenu = new QMenu();
4077 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
4078 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
4079 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10, -1, nodeMenu ),
4080 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10, -1, edgeMenu ),
4081 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10, -1, faceMenu ),
4082 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10, -1, volumeMenu ),
4083 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
4084 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
4085 //renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
4086 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
4087 basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
4089 //createMenu( SMESHOp::OpImportDAT, importId, -1 );
4090 createMenu( SMESHOp::OpImportUNV, importId, -1 );
4091 createMenu( SMESHOp::OpImportMED, importId, -1 );
4092 createMenu( SMESHOp::OpImportSTL, importId, -1 );
4094 createMenu( SMESHOp::OpImportCGNS, importId, -1 );
4096 createMenu( SMESHOp::OpImportSAUV, importId, -1 );
4097 createMenu( SMESHOp::OpImportGMF, importId, -1 );
4098 createMenu( SMESHOp::OpExportDAT, exportId, -1 );
4099 createMenu( SMESHOp::OpExportMED, exportId, -1 );
4100 createMenu( SMESHOp::OpExportUNV, exportId, -1 );
4101 createMenu( SMESHOp::OpExportSTL, exportId, -1 );
4103 createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
4105 createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
4106 createMenu( SMESHOp::OpExportGMF, exportId, -1 );
4107 createMenu( separator(), fileId, 10 );
4109 createMenu( SMESHOp::OpDelete, editId, -1 );
4111 createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
4113 createMenu( SMESHOp::OpCreateMesh, meshId, -1 ); // "Mesh" menu
4114 createMenu( SMESHOp::OpCreateSubMesh, meshId, -1 );
4115 createMenu( SMESHOp::OpEditMeshOrSubMesh, meshId, -1 );
4116 createMenu( SMESHOp::OpBuildCompoundMesh, meshId, -1 );
4117 createMenu( SMESHOp::OpCopyMesh, meshId, -1 );
4118 createMenu( separator(), meshId, -1 );
4119 createMenu( SMESHOp::OpCompute, meshId, -1 );
4120 createMenu( SMESHOp::OpPreCompute, meshId, -1 );
4121 createMenu( SMESHOp::OpEvaluate, meshId, -1 );
4122 createMenu( SMESHOp::OpMeshOrder, meshId, -1 );
4123 createMenu( separator(), meshId, -1 );
4124 createMenu( SMESHOp::OpCreateGroup, meshId, -1 );
4125 createMenu( SMESHOp::OpCreateGeometryGroup, meshId, -1 );
4126 createMenu( SMESHOp::OpConstructGroup, meshId, -1 );
4127 createMenu( SMESHOp::OpEditGroup, meshId, -1 );
4128 createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4129 createMenu( separator(), meshId, -1 );
4130 createMenu( SMESHOp::OpUnionGroups, meshId, -1 );
4131 createMenu( SMESHOp::OpIntersectGroups, meshId, -1 );
4132 createMenu( SMESHOp::OpCutGroups, meshId, -1 );
4133 createMenu( separator(), meshId, -1 );
4134 createMenu( SMESHOp::OpGroupUnderlyingElem, meshId, -1 );
4135 createMenu( separator(), meshId, -1 );
4136 createMenu( SMESHOp::OpMeshInformation, meshId, -1 );
4137 //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4138 //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4139 createMenu( SMESHOp::OpFindElementByPoint, meshId, -1 );
4140 createMenu( separator(), meshId, -1 );
4142 createMenu( SMESHOp::OpFreeNode, nodeId, -1 );
4143 createMenu( SMESHOp::OpEqualNode, nodeId, -1 );
4144 //createMenu( SMESHOp::OpNodeConnectivityNb, nodeId, -1 );
4145 createMenu( SMESHOp::OpFreeBorder, edgeId, -1 );
4146 createMenu( SMESHOp::OpLength, edgeId, -1 );
4147 createMenu( SMESHOp::OpConnection, edgeId, -1 );
4148 createMenu( SMESHOp::OpEqualEdge, edgeId, -1 );
4149 createMenu( SMESHOp::OpFreeEdge, faceId, -1 );
4150 createMenu( SMESHOp::OpFreeFace, faceId, -1 );
4151 createMenu( SMESHOp::OpBareBorderFace, faceId, -1 );
4152 createMenu( SMESHOp::OpOverConstrainedFace, faceId, -1 );
4153 createMenu( SMESHOp::OpLength2D, faceId, -1 );
4154 createMenu( SMESHOp::OpConnection2D, faceId, -1 );
4155 createMenu( SMESHOp::OpArea, faceId, -1 );
4156 createMenu( SMESHOp::OpTaper, faceId, -1 );
4157 createMenu( SMESHOp::OpAspectRatio, faceId, -1 );
4158 createMenu( SMESHOp::OpMinimumAngle, faceId, -1 );
4159 createMenu( SMESHOp::OpWarpingAngle, faceId, -1 );
4160 createMenu( SMESHOp::OpSkew, faceId, -1 );
4161 createMenu( SMESHOp::OpMaxElementLength2D, faceId, -1 );
4162 createMenu( SMESHOp::OpEqualFace, faceId, -1 );
4163 createMenu( SMESHOp::OpAspectRatio3D, volumeId, -1 );
4164 createMenu( SMESHOp::OpVolume, volumeId, -1 );
4165 createMenu( SMESHOp::OpMaxElementLength3D, volumeId, -1 );
4166 createMenu( SMESHOp::OpBareBorderVolume, volumeId, -1 );
4167 createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4168 createMenu( SMESHOp::OpEqualVolume, volumeId, -1 );
4169 createMenu( separator(), ctrlId, -1 );
4170 createMenu( SMESHOp::OpReset, ctrlId, -1 );
4171 createMenu( separator(), ctrlId, -1 );
4172 createMenu( SMESHOp::OpOverallMeshQuality, ctrlId, -1 );
4174 createMenu( SMESHOp::OpNode, addId, -1 );
4175 createMenu( SMESHOp::OpElem0D, addId, -1 );
4176 createMenu( SMESHOp::OpElem0DOnElemNodes, addId, -1 );
4177 createMenu( SMESHOp::OpBall, addId, -1 );
4178 createMenu( SMESHOp::OpEdge, addId, -1 );
4179 createMenu( SMESHOp::OpTriangle, addId, -1 );
4180 createMenu( SMESHOp::OpQuadrangle, addId, -1 );
4181 createMenu( SMESHOp::OpPolygon, addId, -1 );
4182 createMenu( SMESHOp::OpTetrahedron, addId, -1 );
4183 createMenu( SMESHOp::OpHexahedron, addId, -1 );
4184 createMenu( SMESHOp::OpPentahedron, addId, -1 );
4185 createMenu( SMESHOp::OpPyramid, addId, -1 );
4186 createMenu( SMESHOp::OpHexagonalPrism, addId, -1 );
4187 createMenu( SMESHOp::OpPolyhedron, addId, -1 );
4188 createMenu( separator(), addId, -1 );
4189 createMenu( SMESHOp::OpQuadraticEdge, addId, -1 );
4190 createMenu( SMESHOp::OpQuadraticTriangle, addId, -1 );
4191 createMenu( SMESHOp::OpBiQuadraticTriangle , addId, -1 );
4192 createMenu( SMESHOp::OpQuadraticQuadrangle, addId, -1 );
4193 createMenu( SMESHOp::OpBiQuadraticQuadrangle, addId, -1 );
4194 createMenu( SMESHOp::OpQuadraticPolygon, addId, -1 );
4195 createMenu( SMESHOp::OpQuadraticTetrahedron, addId, -1 );
4196 createMenu( SMESHOp::OpQuadraticPyramid, addId, -1 );
4197 createMenu( SMESHOp::OpQuadraticPentahedron, addId, -1 );
4198 createMenu( SMESHOp::OpBiQuadraticPentahedron, addId, -1 );
4199 createMenu( SMESHOp::OpQuadraticHexahedron, addId, -1 );
4200 createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4202 createMenu( SMESHOp::OpRemoveNodes, removeId, -1 );
4203 createMenu( SMESHOp::OpRemoveElements, removeId, -1 );
4204 createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4205 createMenu( separator(), removeId, -1 );
4206 createMenu( SMESHOp::OpDeleteGroup, removeId, -1 );
4207 createMenu( separator(), removeId, -1 );
4208 createMenu( SMESHOp::OpClearMesh, removeId, -1 );
4210 //createMenu( SMESHOp::OpRenumberingNodes, renumId, -1 );
4211 //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4213 createMenu( SMESHOp::OpTranslation, transfId, -1 );
4214 createMenu( SMESHOp::OpRotation, transfId, -1 );
4215 createMenu( SMESHOp::OpSymmetry, transfId, -1 );
4216 createMenu( SMESHOp::OpScale, transfId, -1 );
4217 createMenu( SMESHOp::OpSewing, transfId, -1 );
4218 createMenu( SMESHOp::OpMergeNodes, transfId, -1 );
4219 createMenu( SMESHOp::OpMergeElements, transfId, -1 );
4220 createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4222 createMenu( SMESHOp::OpMoveNode, modifyId, -1 );
4223 createMenu( SMESHOp::OpDiagonalInversion, modifyId, -1 );
4224 createMenu( SMESHOp::OpUnionOfTwoTriangle, modifyId, -1 );
4225 createMenu( SMESHOp::OpOrientation, modifyId, -1 );
4226 createMenu( SMESHOp::OpReorientFaces, modifyId, -1 );
4227 createMenu( SMESHOp::OpUnionOfTriangles, modifyId, -1 );
4228 createMenu( SMESHOp::OpCuttingOfQuadrangles, modifyId, -1 );
4229 createMenu( SMESHOp::OpSplitVolumes, modifyId, -1 );
4230 createMenu( SMESHOp::OpSplitBiQuadratic, modifyId, -1 );
4231 createMenu( SMESHOp::OpSmoothing, modifyId, -1 );
4232 createMenu( SMESHOp::OpExtrusion, modifyId, -1 );
4233 createMenu( SMESHOp::OpExtrusionAlongAPath , modifyId, -1 );
4234 createMenu( SMESHOp::OpRevolution, modifyId, -1 );
4235 createMenu( SMESHOp::OpPatternMapping, modifyId, -1 );
4236 createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4237 createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4239 createMenu( SMESHOp::OpMinimumDistance, measureId, -1 );
4240 createMenu( SMESHOp::OpBoundingBox, measureId, -1 );
4241 createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4242 createMenu( SMESHOp::OpPropertiesArea, basicPropId, -1 );
4243 createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4244 createMenu( SMESHOp::OpUpdate, viewId, -1 );
4246 connect( nodeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4247 connect( edgeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4248 connect( faceMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4249 connect( volumeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4251 // ----- create toolbars --------------
4252 int meshTb = createTool( tr( "TB_MESH" ), QString( "SMESHMeshToolbar" ) ),
4253 info = createTool( tr( "TB_INFO" ), QString( "SMESHInformationToolbar" ) ),
4254 groupTb = createTool( tr( "TB_GROUP" ), QString( "SMESHGroupToolbar" ) ),
4255 ctrl0dTb = createTool( tr( "TB_CTRL0D" ), QString( "SMESHNodeControlsToolbar" ) ),
4256 ctrl1dTb = createTool( tr( "TB_CTRL1D" ), QString( "SMESHEdgeControlsToolbar" ) ),
4257 ctrl2dTb = createTool( tr( "TB_CTRL2D" ), QString( "SMESHFaceControlsToolbar" ) ),
4258 ctrl3dTb = createTool( tr( "TB_CTRL3D" ), QString( "SMESHVolumeControlsToolbar" ) ),
4259 addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ),
4260 addNonElemTb = createTool( tr( "TB_ADDNON" ), QString( "SMESHAddElementToolbar" ) ),
4261 remTb = createTool( tr( "TB_REM" ), QString( "SMESHRemoveToolbar" ) ),
4262 //renumbTb = createTool( tr( "TB_RENUMBER" ), QString( "SMESHRenumberingToolbar" ) ),
4263 transformTb = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ),
4264 modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ),
4265 measuremTb = createTool( tr( "TB_MEASUREM" ), QString( "SMESHMeasurementsToolbar" ) ),
4266 dispModeTb = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4268 createTool( SMESHOp::OpCreateMesh, meshTb );
4269 createTool( SMESHOp::OpCreateSubMesh, meshTb );
4270 createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4271 createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4272 createTool( SMESHOp::OpCopyMesh, meshTb );
4273 createTool( separator(), meshTb );
4274 createTool( SMESHOp::OpCompute, meshTb );
4275 createTool( SMESHOp::OpPreCompute, meshTb );
4276 createTool( SMESHOp::OpEvaluate, meshTb );
4277 createTool( SMESHOp::OpMeshOrder, meshTb );
4279 createTool( SMESHOp::OpCreateGroup, groupTb );
4280 createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4281 createTool( SMESHOp::OpConstructGroup, groupTb );
4282 createTool( SMESHOp::OpEditGroup, groupTb );
4284 createTool( SMESHOp::OpMeshInformation, info );
4285 //createTool( SMESHOp::OpStdInfo, meshTb );
4286 //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4287 createTool( SMESHOp::OpFindElementByPoint, info );
4289 createTool( SMESHOp::OpFreeNode, ctrl0dTb );
4290 createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4291 //createTool( SMESHOp::OpNodeConnectivityNb, ctrl0dTb );
4293 createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4294 createTool( SMESHOp::OpLength, ctrl1dTb );
4295 createTool( SMESHOp::OpConnection, ctrl1dTb );
4296 createTool( SMESHOp::OpEqualEdge, ctrl1dTb );
4298 createTool( SMESHOp::OpFreeEdge, ctrl2dTb );
4299 createTool( SMESHOp::OpFreeFace, ctrl2dTb );
4300 createTool( SMESHOp::OpBareBorderFace, ctrl2dTb );
4301 createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4302 createTool( SMESHOp::OpLength2D, ctrl2dTb );
4303 createTool( SMESHOp::OpConnection2D, ctrl2dTb );
4304 createTool( SMESHOp::OpArea, ctrl2dTb );
4305 createTool( SMESHOp::OpTaper, ctrl2dTb );
4306 createTool( SMESHOp::OpAspectRatio, ctrl2dTb );
4307 createTool( SMESHOp::OpMinimumAngle, ctrl2dTb );
4308 createTool( SMESHOp::OpWarpingAngle, ctrl2dTb );
4309 createTool( SMESHOp::OpSkew, ctrl2dTb );
4310 createTool( SMESHOp::OpMaxElementLength2D, ctrl2dTb );
4311 createTool( SMESHOp::OpEqualFace, ctrl2dTb );
4313 createTool( SMESHOp::OpAspectRatio3D, ctrl3dTb );
4314 createTool( SMESHOp::OpVolume, ctrl3dTb );
4315 createTool( SMESHOp::OpMaxElementLength3D, ctrl3dTb );
4316 createTool( SMESHOp::OpBareBorderVolume, ctrl3dTb );
4317 createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
4318 createTool( SMESHOp::OpEqualVolume, ctrl3dTb );
4320 createTool( SMESHOp::OpNode, addElemTb );
4321 createTool( SMESHOp::OpElem0D, addElemTb );
4322 createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4323 createTool( SMESHOp::OpBall, addElemTb );
4324 createTool( SMESHOp::OpEdge, addElemTb );
4325 createTool( SMESHOp::OpTriangle, addElemTb );
4326 createTool( SMESHOp::OpQuadrangle, addElemTb );
4327 createTool( SMESHOp::OpPolygon, addElemTb );
4328 createTool( SMESHOp::OpTetrahedron, addElemTb );
4329 createTool( SMESHOp::OpHexahedron, addElemTb );
4330 createTool( SMESHOp::OpPentahedron, addElemTb );
4331 createTool( SMESHOp::OpPyramid, addElemTb );
4332 createTool( SMESHOp::OpHexagonalPrism, addElemTb );
4333 createTool( SMESHOp::OpPolyhedron, addElemTb );
4335 createTool( SMESHOp::OpQuadraticEdge, addNonElemTb );
4336 createTool( SMESHOp::OpQuadraticTriangle, addNonElemTb );
4337 createTool( SMESHOp::OpBiQuadraticTriangle, addNonElemTb );
4338 createTool( SMESHOp::OpQuadraticQuadrangle, addNonElemTb );
4339 createTool( SMESHOp::OpBiQuadraticQuadrangle, addNonElemTb );
4340 createTool( SMESHOp::OpQuadraticPolygon, addNonElemTb );
4341 createTool( SMESHOp::OpQuadraticTetrahedron, addNonElemTb );
4342 createTool( SMESHOp::OpQuadraticPyramid, addNonElemTb );
4343 createTool( SMESHOp::OpQuadraticPentahedron, addNonElemTb );
4344 createTool( SMESHOp::OpBiQuadraticPentahedron, addNonElemTb );
4345 createTool( SMESHOp::OpQuadraticHexahedron, addNonElemTb );
4346 createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4348 createTool( SMESHOp::OpRemoveNodes, remTb );
4349 createTool( SMESHOp::OpRemoveElements, remTb );
4350 createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4351 createTool( SMESHOp::OpClearMesh, remTb );
4353 //createTool( SMESHOp::OpRenumberingNodes, renumbTb );
4354 //createTool( SMESHOp::OpRenumberingElements, renumbTb );
4356 createTool( SMESHOp::OpTranslation, transformTb );
4357 createTool( SMESHOp::OpRotation, transformTb );
4358 createTool( SMESHOp::OpSymmetry, transformTb );
4359 createTool( SMESHOp::OpScale, transformTb );
4360 createTool( SMESHOp::OpSewing, transformTb );
4361 createTool( SMESHOp::OpMergeNodes, transformTb );
4362 createTool( SMESHOp::OpMergeElements, transformTb );
4363 createTool( SMESHOp::OpDuplicateNodes, transformTb );
4365 createTool( SMESHOp::OpMoveNode, modifyTb );
4366 createTool( SMESHOp::OpDiagonalInversion, modifyTb );
4367 createTool( SMESHOp::OpUnionOfTwoTriangle, modifyTb );
4368 createTool( SMESHOp::OpOrientation, modifyTb );
4369 createTool( SMESHOp::OpReorientFaces, modifyTb );
4370 createTool( SMESHOp::OpUnionOfTriangles, modifyTb );
4371 createTool( SMESHOp::OpCuttingOfQuadrangles, modifyTb );
4372 createTool( SMESHOp::OpSplitVolumes, modifyTb );
4373 createTool( SMESHOp::OpSplitBiQuadratic, modifyTb );
4374 createTool( SMESHOp::OpSmoothing, modifyTb );
4375 createTool( SMESHOp::OpExtrusion, modifyTb );
4376 createTool( SMESHOp::OpExtrusionAlongAPath, modifyTb );
4377 createTool( SMESHOp::OpRevolution, modifyTb );
4378 createTool( SMESHOp::OpPatternMapping, modifyTb );
4379 createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4380 createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4382 createTool( SMESHOp::OpMinimumDistance, measuremTb );
4384 createTool( SMESHOp::OpUpdate, dispModeTb );
4386 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4387 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4391 OB = "'ObjectBrowser'",
4392 View = "'" + SVTK_Viewer::Type() + "'",
4394 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4395 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4396 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4397 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4398 smesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::COMPONENT ) ),
4399 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4400 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4401 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4402 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4403 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4404 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4405 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4407 mesh_part = mesh + " " + subMesh + " " + group,
4408 mesh_group = mesh + " " + group,
4409 mesh_submesh = mesh + " " + subMesh,
4410 hyp_alg = hypo + " " + algo;
4412 // popup for object browser
4414 isInvisible("not( isVisible )"),
4415 isEmpty("numberOfNodes = 0"),
4416 isNotEmpty("numberOfNodes <> 0"),
4418 // has nodes, edges, etc in VISIBLE! actor
4419 hasNodes("(numberOfNodes > 0 ) && hasActor"),
4420 hasElems("(count( elemTypes ) > 0)"),
4421 hasDifferentElems("(count( elemTypes ) > 1)"),
4422 hasDifferentObjElems("(count( objElemTypes ) > 1)"),
4423 hasBalls("({'BallElem'} in elemTypes)"),
4424 hasElems0d("({'Elem0d'} in elemTypes)"),
4425 hasEdges("({'Edge'} in elemTypes)"),
4426 hasFaces("({'Face'} in elemTypes)"),
4427 hasVolumes("({'Volume'} in elemTypes)"),
4428 hasFacesOrVolumes("(({'Face'} in elemTypes) || ({'Volume'} in elemTypes)) ");
4430 createPopupItem( SMESHOp::OpFileInformation, OB, mesh, "&& selcount=1 && isImported" );
4431 createPopupItem( SMESHOp::OpCreateSubMesh, OB, mesh, "&& hasGeomReference");
4432 createPopupItem( SMESHOp::OpEditMesh, OB, mesh, "&& selcount=1" );
4433 createPopupItem( SMESHOp::OpEditSubMesh, OB, subMesh, "&& selcount=1 && hasGeomReference" );
4434 createPopupItem( SMESHOp::OpEditGroup, OB, group );
4435 createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4437 popupMgr()->insert( separator(), -1, 0 );
4438 createPopupItem( SMESHOp::OpCompute, OB, mesh, "&& selcount=1 && isComputable" );
4439 createPopupItem( SMESHOp::OpComputeSubMesh, OB, subMesh, "&& selcount=1 && isComputable" );
4440 createPopupItem( SMESHOp::OpPreCompute, OB, mesh, "&& selcount=1 && isPreComputable" );
4441 createPopupItem( SMESHOp::OpEvaluate, OB, mesh, "&& selcount=1 && isComputable" );
4442 createPopupItem( SMESHOp::OpMeshOrder, OB, mesh, "&& selcount=1 && isComputable && hasGeomReference" );
4443 createPopupItem( SMESHOp::OpUpdate, OB, mesh_part );
4444 createPopupItem( SMESHOp::OpMeshInformation, OB, mesh_part );
4445 createPopupItem( SMESHOp::OpFindElementByPoint,OB, mesh_group, "&& selcount=1" );
4446 createPopupItem( SMESHOp::OpOverallMeshQuality,OB, mesh_part );
4447 popupMgr()->insert( separator(), -1, 0 );
4448 createPopupItem( SMESHOp::OpCreateGroup, OB, mesh, "&& selcount=1" );
4449 createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh, "&& selcount=1 && hasGeomReference" );
4450 createPopupItem( SMESHOp::OpConstructGroup, OB, subMesh );
4451 popupMgr()->insert( separator(), -1, 0 );
4452 createPopupItem( SMESHOp::OpEditHypothesis, OB, hypo, "&& isEditableHyp");
4453 createPopupItem( SMESHOp::OpUnassign, OB, hyp_alg );
4454 popupMgr()->insert( separator(), -1, 0 );
4455 createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh_submesh );
4456 createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh_group, "&& selcount=1 && dim>=2");
4457 popupMgr()->insert( separator(), -1, 0 );
4458 createPopupItem( SMESHOp::OpClearMesh, OB, mesh );
4459 //popupMgr()->insert( separator(), -1, 0 );
4461 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4462 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4463 QString only_one_2D = only_one_non_empty + " && dim>1";
4465 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4466 createPopupItem( SMESHOp::OpPopupExportMED, OB, mesh_group, multiple_non_empty, anId );
4467 createPopupItem( SMESHOp::OpPopupExportUNV, OB, mesh_group, only_one_non_empty, anId );
4468 createPopupItem( SMESHOp::OpPopupExportSTL, OB, mesh_group, only_one_2D, anId );
4470 createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4472 createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, only_one_non_empty, anId );
4473 createPopupItem( SMESHOp::OpPopupExportGMF, OB, mesh_group, only_one_non_empty, anId );
4474 createPopupItem( SMESHOp::OpPopupExportDAT, OB, mesh_group, only_one_non_empty, anId );
4475 createPopupItem( SMESHOp::OpDelete, OB, mesh_part + " " + hyp_alg );
4476 createPopupItem( SMESHOp::OpDeleteGroup, OB, group );
4478 anId = popupMgr()->insert( tr( "MEN_IMPORT" ), -1, -1 ); // IMPORT submenu
4479 createPopupItem( SMESHOp::OpPopupImportMED, OB, smesh, "", anId );
4480 createPopupItem( SMESHOp::OpPopupImportUNV, OB, smesh, "", anId );
4481 createPopupItem( SMESHOp::OpPopupImportSTL, OB, smesh, "", anId );
4483 createPopupItem( SMESHOp::OpPopupImportCGNS, OB, smesh, "", anId );
4485 createPopupItem( SMESHOp::OpPopupImportSAUV, OB, smesh, "", anId );
4486 createPopupItem( SMESHOp::OpPopupImportGMF, OB, smesh, "", anId );
4487 createPopupItem( SMESHOp::OpPopupImportDAT, OB, smesh, "", anId );
4488 popupMgr()->insert( separator(), -1, 0 );
4491 createPopupItem( SMESHOp::OpEditGroup, View, group );
4492 createPopupItem( SMESHOp::OpAddElemGroupPopup, View, elems, "&& guiState = 800" );
4493 createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems, "&& guiState = 800" );
4495 popupMgr()->insert( separator(), -1, 0 );
4496 createPopupItem( SMESHOp::OpUpdate, View, mesh_part );
4497 createPopupItem( SMESHOp::OpMeshInformation, View, mesh_part );
4498 createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4499 createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh );
4500 popupMgr()->insert( separator(), -1, 0 );
4502 createPopupItem( SMESHOp::OpAutoColor, OB + " " + View, mesh, "&& (not isAutoColor)" );
4503 createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4504 popupMgr()->insert( separator(), -1, 0 );
4506 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4507 QString aType = QString( "%1type in {%2}" ).arg( lc );
4508 aType = aType.arg( mesh_part );
4509 QString aMeshInVTK = aClient + "&&" + aType;
4511 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4512 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4513 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4515 //-------------------------------------------------
4517 //-------------------------------------------------
4518 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4520 popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4521 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4522 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4524 popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4525 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4526 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4528 popupMgr()->insert( separator(), -1, -1 );
4530 //-------------------------------------------------
4532 //-------------------------------------------------
4533 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4535 popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4536 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4537 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4539 popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4540 popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4541 popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4543 popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4544 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4545 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4547 popupMgr()->insert( separator(), anId, -1 );
4549 popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4550 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4551 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4553 //-------------------------------------------------
4555 //-------------------------------------------------
4556 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4558 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4560 popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4561 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4562 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4564 popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4565 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4566 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4568 popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4569 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4570 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4572 popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4573 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4574 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4576 popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4577 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4578 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4580 popupMgr()->insert( separator(), anId, -1 );
4582 popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4583 popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&& $type in {" + mesh + "} &&" + hasDifferentObjElems, QtxPopupMgr::VisibleRule );
4585 popupMgr()->insert( separator(), anId, -1 );
4587 popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4588 popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4591 //-------------------------------------------------
4592 // Representation of the 2D Quadratic elements
4593 //-------------------------------------------------
4594 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4595 popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4596 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "&& isVisible && isQuadratic",QtxPopupMgr::VisibleRule );
4597 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4599 popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4600 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "&& isVisible && isQuadratic", QtxPopupMgr::VisibleRule );
4601 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4603 //-------------------------------------------------
4604 // Orientation of faces
4605 //-------------------------------------------------
4606 popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4607 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4608 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4610 //-------------------------------------------------
4612 //-------------------------------------------------
4613 popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4614 popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4616 //-------------------------------------------------
4618 //-------------------------------------------------
4619 popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4620 popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4622 //-------------------------------------------------
4624 //-------------------------------------------------
4626 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4627 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4628 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4629 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4631 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4633 popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4634 popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4636 popupMgr()->insert( separator(), anId, -1 );
4638 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4640 popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4641 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4642 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4644 popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4645 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4646 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4648 // popupMgr()->insert( action( SMESHOp::OpNodeConnectivityNb ), aSubId, -1 );
4649 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4650 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), "controlMode = 'eNodeConnectivityNb'", QtxPopupMgr::ToggleRule );
4652 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4654 popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4655 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVTK + "&&" + hasEdges + "&&" + hasFacesOrVolumes, QtxPopupMgr::VisibleRule );
4656 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4658 popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4659 popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4660 popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4662 popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4663 popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4664 popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4665 popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4666 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4667 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4669 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4671 popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4672 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4673 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4675 popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4676 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4677 QtxPopupMgr::VisibleRule );
4678 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4680 popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4681 popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4682 popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4684 popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4685 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4686 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4688 popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
4689 popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4690 popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4692 popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
4693 popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4694 popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4696 popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
4697 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4698 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4700 popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
4701 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4702 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4704 popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
4705 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4706 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4708 popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
4709 popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4710 popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4712 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
4713 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4714 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4716 popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
4717 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4718 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4720 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
4721 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4722 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4723 popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
4724 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4725 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4727 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4729 popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D ), aSubId, -1 );
4730 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4731 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4733 popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
4734 popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4735 popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4737 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
4738 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4739 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4741 popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
4742 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4743 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4745 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
4746 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4747 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4749 popupMgr()->insert ( action( SMESHOp::OpEqualVolume ), aSubId, -1 );
4750 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4751 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4753 popupMgr()->insert( separator(), anId, -1 );
4755 popupMgr()->insert( action( SMESHOp::OpShowScalarBar ), anId, -1 );
4756 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4757 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone' && isScalarBarVisible", QtxPopupMgr::ToggleRule );
4758 popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
4759 popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4761 popupMgr()->insert( separator(), anId, -1 );
4763 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4765 popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
4766 popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4768 popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
4769 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4770 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isScalarBarVisible && isDistributionVisible", QtxPopupMgr::ToggleRule);
4772 #ifndef DISABLE_PLOT2DVIEWER
4773 popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
4774 popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4777 //-------------------------------------------------
4779 //-------------------------------------------------
4780 popupMgr()->insert( separator(), -1, -1 );
4781 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4782 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4783 popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
4784 popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4786 popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
4787 popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4789 popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
4790 popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4792 popupMgr()->insert( separator(), -1, -1 );
4794 //-------------------------------------------------
4796 //-------------------------------------------------
4797 popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
4798 popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4800 popupMgr()->insert( separator(), -1, -1 );
4802 popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
4803 popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
4804 popupMgr()->insert( separator(), -1, -1 );
4806 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4807 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4809 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4810 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4813 //================================================================================
4815 * \brief Return true if SMESH or GEOM objects are selected.
4816 * Is called form LightApp_Module::activateModule() which clear selection if
4817 * not isSelectionCompatible()
4819 //================================================================================
4821 bool SMESHGUI::isSelectionCompatible()
4823 bool isCompatible = true;
4824 SALOME_ListIO selected;
4825 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4826 Sel->selectedObjects( selected );
4828 SALOME_ListIteratorOfListIO It( selected );
4829 for ( ; isCompatible && It.More(); It.Next())
4831 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4832 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4834 return isCompatible;
4838 bool SMESHGUI::reusableOperation( const int id )
4840 // compute, evaluate and precompute are not reusable operations
4841 return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate ) ? false : SalomeApp_Module::reusableOperation( id );
4844 bool SMESHGUI::activateModule( SUIT_Study* study )
4846 bool res = SalomeApp_Module::activateModule( study );
4848 setMenuShown( true );
4849 setToolShown( true );
4851 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4852 PyGILState_STATE gstate = PyGILState_Ensure();
4853 PyObject* pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4854 if ( !pluginsmanager ) {
4858 PyObject* result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toUtf8().data(),tr("SMESH_PLUGINS_OTHER").toUtf8().data());
4863 PyGILState_Release(gstate);
4864 // end of SMESH plugins loading
4866 // Reset actions accelerator keys
4867 action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
4869 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4870 GetSMESHGen()->SetCurrentStudy(SALOMEDS::Study::_nil());
4871 if ( SalomeApp_Study* s = dynamic_cast<SalomeApp_Study*>( study )) {
4872 if ( _PTR(Study) aStudy = s->studyDS() )
4873 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
4876 // get all view currently opened in the study and connect their signals to
4877 // the corresponding slots of the class.
4878 SUIT_Desktop* aDesk = study->application()->desktop();
4880 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4881 SUIT_ViewWindow* wnd;
4882 foreach ( wnd, wndList )
4886 Py_XDECREF(pluginsmanager);
4890 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4892 setMenuShown( false );
4893 setToolShown( false );
4895 EmitSignalCloseAllDialogs();
4897 // Unset actions accelerator keys
4898 action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
4900 return SalomeApp_Module::deactivateModule( study );
4903 void SMESHGUI::studyClosed( SUIT_Study* s )
4907 SMESH::RemoveVisuData( s->id() );
4908 SalomeApp_Module::studyClosed( s );
4911 void SMESHGUI::OnGUIEvent()
4913 const QObject* obj = sender();
4914 if ( !obj || !obj->inherits( "QAction" ) )
4916 int id = actionId((QAction*)obj);
4921 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4923 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
4924 if ( CORBA::is_nil( myComponentSMESH ) )
4926 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4928 aGUI.myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4929 return aGUI.myComponentSMESH;
4932 myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4933 return myComponentSMESH;
4936 QString SMESHGUI::engineIOR() const
4938 CORBA::ORB_var anORB = getApp()->orb();
4939 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4940 return QString( anIOR.in() );
4943 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4945 SalomeApp_Module::contextMenuPopup( client, menu, title );
4947 selectionMgr()->selectedObjects( lst );
4948 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4949 Handle(SALOME_InteractiveObject) io = lst.First();
4950 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4951 _PTR(Study) study = appStudy->studyDS();
4952 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4954 QString aName = QString( SMESH::fromUtf8(obj->GetName()) );
4955 while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4956 aName.remove( (aName.length() - 1), 1 );
4962 LightApp_Selection* SMESHGUI::createSelection() const
4964 return new SMESHGUI_Selection();
4967 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4969 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4970 aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
4971 #ifndef DISABLE_PYCONSOLE
4972 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4976 void SMESHGUI::viewManagers( QStringList& list ) const
4978 list.append( SVTK_Viewer::Type() );
4981 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4983 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4984 SMESH::UpdateSelectionProp( this );
4986 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
4987 for(int i = 0; i < aViews.count() ; i++){
4988 SUIT_ViewWindow *sf = aViews[i];
4991 EmitSignalActivatedViewManager();
4995 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
4997 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
4998 myClippingPlaneInfoMap.erase( theViewManager );
5001 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
5003 theActor->AddObserver( SMESH::DeleteActorEvent,
5004 myEventCallbackCommand.GetPointer(),
5008 void SMESHGUI::ProcessEvents( vtkObject* theObject,
5009 unsigned long theEvent,
5010 void* theClientData,
5013 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
5014 if( theObject && (int) theEvent == SMESH::DeleteActorEvent ) {
5015 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
5016 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
5017 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
5018 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
5019 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
5020 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
5021 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
5022 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
5023 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
5024 SMESH::TActorList::iterator anIter3 = anActorList.begin();
5025 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
5026 if( anActor == *anIter3 ) {
5027 anActorList.erase( anIter3 );
5038 void SMESHGUI::createPreferences()
5040 // General tab ------------------------------------------------------------------------
5041 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
5043 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
5044 setPreferenceProperty( autoUpdate, "columns", 2 );
5045 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
5046 setPreferenceProperty( lim, "min", 0 );
5047 setPreferenceProperty( lim, "max", 100000000 );
5048 setPreferenceProperty( lim, "step", 1000 );
5049 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5050 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
5052 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
5053 setPreferenceProperty( dispgroup, "columns", 2 );
5054 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
5056 modes.append( tr("MEN_WIRE") );
5057 modes.append( tr("MEN_SHADE") );
5058 modes.append( tr("MEN_NODES") );
5059 modes.append( tr("MEN_SHRINK") );
5060 QList<QVariant> indices;
5061 indices.append( 0 );
5062 indices.append( 1 );
5063 indices.append( 2 );
5064 indices.append( 3 );
5065 setPreferenceProperty( dispmode, "strings", modes );
5066 setPreferenceProperty( dispmode, "indexes", indices );
5068 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
5069 setPreferenceProperty( arcgroup, "columns", 2 );
5070 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
5071 QStringList quadraticModes;
5072 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
5073 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
5075 indices.append( 0 );
5076 indices.append( 1 );
5077 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
5078 setPreferenceProperty( quadraticmode, "indexes", indices );
5080 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
5081 "SMESH", "max_angle" );
5082 setPreferenceProperty( maxAngle, "min", 1 );
5083 setPreferenceProperty( maxAngle, "max", 90 );
5085 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
5086 setPreferenceProperty( qaGroup, "columns", 2 );
5087 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
5088 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
5089 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
5090 setPreferenceProperty( prec, "min", 0 );
5091 setPreferenceProperty( prec, "max", 100 );
5092 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
5093 setPreferenceProperty( doubleNodesTol, "precision", 10 );
5094 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
5095 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
5096 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
5099 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
5100 setPreferenceProperty( exportgroup, "columns", 2 );
5101 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
5102 addPreference( tr( "PREF_SHOW_WARN" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "show_warning" );
5103 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
5105 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
5106 setPreferenceProperty( computeGroup, "columns", 2 );
5107 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
5109 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5110 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5111 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5113 indices.append( 0 );
5114 indices.append( 1 );
5115 indices.append( 2 );
5116 setPreferenceProperty( notifyMode, "strings", modes );
5117 setPreferenceProperty( notifyMode, "indexes", indices );
5119 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5120 setPreferenceProperty( infoGroup, "columns", 2 );
5121 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5123 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5124 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5126 indices.append( 0 );
5127 indices.append( 1 );
5128 setPreferenceProperty( elemInfo, "strings", modes );
5129 setPreferenceProperty( elemInfo, "indexes", indices );
5130 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5131 setPreferenceProperty( nodesLim, "min", 0 );
5132 setPreferenceProperty( nodesLim, "max", 10000000 );
5133 setPreferenceProperty( nodesLim, "step", 10000 );
5134 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5135 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5136 setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5137 setPreferenceProperty( ctrlLim, "min", 0 );
5138 setPreferenceProperty( ctrlLim, "max", 10000000 );
5139 setPreferenceProperty( ctrlLim, "step", 1000 );
5140 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5141 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5142 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5143 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5144 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5146 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5147 setPreferenceProperty( segGroup, "columns", 2 );
5148 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5149 "SMESH", "segmentation" );
5150 setPreferenceProperty( segLen, "min", 1 );
5151 setPreferenceProperty( segLen, "max", 10000000 );
5152 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5153 "SMESH", "nb_segments_per_edge" );
5154 setPreferenceProperty( nbSeg, "min", 1 );
5155 setPreferenceProperty( nbSeg, "max", 10000000 );
5157 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5158 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5159 "SMESH", "forget_mesh_on_hyp_modif" );
5162 // Quantities with individual precision settings
5163 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5164 setPreferenceProperty( precGroup, "columns", 2 );
5166 const int nbQuantities = 6;
5167 int precs[nbQuantities], ii = 0;
5168 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5169 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5170 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5171 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5172 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5173 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5174 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5175 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5176 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5177 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5178 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5179 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5181 // Set property for precision value for spinboxes
5182 for ( ii = 0; ii < nbQuantities; ii++ ){
5183 setPreferenceProperty( precs[ii], "min", -14 );
5184 setPreferenceProperty( precs[ii], "max", 14 );
5185 setPreferenceProperty( precs[ii], "precision", 2 );
5188 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5189 setPreferenceProperty( previewGroup, "columns", 2 );
5190 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5191 setPreferenceProperty( chunkSize, "min", 1 );
5192 setPreferenceProperty( chunkSize, "max", 1000 );
5193 setPreferenceProperty( chunkSize, "step", 50 );
5195 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5196 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5198 // Mesh tab ------------------------------------------------------------------------
5199 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5200 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5201 setPreferenceProperty( nodeGroup, "columns", 3 );
5203 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5205 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5207 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5208 QList<QVariant> aMarkerTypeIndicesList;
5209 QList<QVariant> aMarkerTypeIconsList;
5210 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5211 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5212 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5213 aMarkerTypeIndicesList << i;
5214 aMarkerTypeIconsList << pixmap;
5216 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5217 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
5219 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5221 QList<QVariant> aMarkerScaleIndicesList;
5222 QStringList aMarkerScaleValuesList;
5223 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5224 aMarkerScaleIndicesList << i;
5225 //aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5226 aMarkerScaleValuesList << QString::number( i );
5228 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5229 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5231 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5232 //setPreferenceProperty( elemGroup, "columns", 2 );
5234 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5235 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5236 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5237 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5238 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5239 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5240 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5241 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5242 addPreference( tr( "PREF_PREVIEW_COLOR" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5245 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5246 setPreferenceProperty( grpGroup, "columns", 2 );
5248 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5249 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5251 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5252 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5253 /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5254 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5255 double ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5256 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5257 double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5258 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5259 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
5260 LightApp_Preferences::IntSpin, "SMESH", "element_width");
5261 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5262 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5263 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5264 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5266 setPreferenceProperty( size0d, "min", 1 );
5267 setPreferenceProperty( size0d, "max", 10 );
5269 // setPreferenceProperty( ballSize, "min", 1 );
5270 // setPreferenceProperty( ballSize, "max", 10 );
5272 setPreferenceProperty( ballDiameter, "min", 1e-7 );
5273 setPreferenceProperty( ballDiameter, "max", 1e9 );
5274 setPreferenceProperty( ballDiameter, "step", 0.1 );
5276 setPreferenceProperty( ballScale, "min", 1e-2 );
5277 setPreferenceProperty( ballScale, "max", 1e7 );
5278 setPreferenceProperty( ballScale, "step", 0.5 );
5280 setPreferenceProperty( elemW, "min", 1 );
5281 setPreferenceProperty( elemW, "max", 5 );
5283 setPreferenceProperty( outW, "min", 1 );
5284 setPreferenceProperty( outW, "max", 5 );
5286 setPreferenceProperty( shrink, "min", 0 );
5287 setPreferenceProperty( shrink, "max", 100 );
5289 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5290 setPreferenceProperty( numGroup, "columns", 2 );
5292 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5293 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5295 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5296 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5298 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5299 setPreferenceProperty( orientGroup, "columns", 1 );
5301 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5302 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5304 setPreferenceProperty( orientScale, "min", 0.05 );
5305 setPreferenceProperty( orientScale, "max", 0.5 );
5306 setPreferenceProperty( orientScale, "step", 0.05 );
5308 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5310 // Selection tab ------------------------------------------------------------------------
5311 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5313 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5314 setPreferenceProperty( selGroup, "columns", 2 );
5316 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5317 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5319 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5320 setPreferenceProperty( preGroup, "columns", 2 );
5322 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5324 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5325 setPreferenceProperty( precSelGroup, "columns", 2 );
5327 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5328 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5329 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5331 // Scalar Bar tab ------------------------------------------------------------------------
5332 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5333 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5334 setPreferenceProperty( fontGr, "columns", 2 );
5336 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5337 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5339 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5340 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5342 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5343 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5345 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5346 setPreferenceProperty( numcol, "min", 2 );
5347 setPreferenceProperty( numcol, "max", 256 );
5349 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5350 setPreferenceProperty( numlab, "min", 2 );
5351 setPreferenceProperty( numlab, "max", 65 );
5353 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5354 setPreferenceProperty( orientGr, "columns", 2 );
5355 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5356 QStringList orients;
5357 orients.append( tr( "SMESH_VERTICAL" ) );
5358 orients.append( tr( "SMESH_HORIZONTAL" ) );
5359 indices.clear(); indices.append( 0 ); indices.append( 1 );
5360 setPreferenceProperty( orient, "strings", orients );
5361 setPreferenceProperty( orient, "indexes", indices );
5363 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5364 setPreferenceProperty( posVSizeGr, "columns", 2 );
5365 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5366 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5367 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5368 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5369 setPreferenceProperty( xv, "step", 0.1 );
5370 setPreferenceProperty( xv, "min", 0.0 );
5371 setPreferenceProperty( xv, "max", 1.0 );
5372 setPreferenceProperty( yv, "step", 0.1 );
5373 setPreferenceProperty( yv, "min", 0.0 );
5374 setPreferenceProperty( yv, "max", 1.0 );
5375 setPreferenceProperty( wv, "step", 0.1 );
5376 setPreferenceProperty( wv, "min", 0.0 );
5377 setPreferenceProperty( wv, "max", 1.0 );
5378 setPreferenceProperty( hv, "min", 0.0 );
5379 setPreferenceProperty( hv, "max", 1.0 );
5380 setPreferenceProperty( hv, "step", 0.1 );
5382 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5383 setPreferenceProperty( posHSizeGr, "columns", 2 );
5384 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5385 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5386 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5387 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5388 setPreferenceProperty( xv, "min", 0.0 );
5389 setPreferenceProperty( xv, "max", 1.0 );
5390 setPreferenceProperty( xv, "step", 0.1 );
5391 setPreferenceProperty( xh, "min", 0.0 );
5392 setPreferenceProperty( xh, "max", 1.0 );
5393 setPreferenceProperty( xh, "step", 0.1 );
5394 setPreferenceProperty( yh, "min", 0.0 );
5395 setPreferenceProperty( yh, "max", 1.0 );
5396 setPreferenceProperty( yh, "step", 0.1 );
5397 setPreferenceProperty( wh, "min", 0.0 );
5398 setPreferenceProperty( wh, "max", 1.0 );
5399 setPreferenceProperty( wh, "step", 0.1 );
5400 setPreferenceProperty( hh, "min", 0.0 );
5401 setPreferenceProperty( hh, "max", 1.0 );
5402 setPreferenceProperty( hh, "step", 0.1 );
5404 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5405 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5406 setPreferenceProperty( distributionGr, "columns", 3 );
5408 types.append( tr( "SMESH_MONOCOLOR" ) );
5409 types.append( tr( "SMESH_MULTICOLOR" ) );
5410 indices.clear(); indices.append( 0 ); indices.append( 1 );
5411 setPreferenceProperty( coloringType, "strings", types );
5412 setPreferenceProperty( coloringType, "indexes", indices );
5413 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5417 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5419 if ( sect=="SMESH" ) {
5420 float sbX1 = 0.01, sbY1 = 0.01, sbW = 0.08, sbH = 0.08;
5421 float aTol = 1.00000009999999;
5422 std::string aWarning;
5423 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5425 if ( name== "selection_object_color" ||
5426 name=="selection_element_color" ||
5427 name== "highlight_color" ||
5428 name=="selection_precision_node" ||
5429 name=="selection_precision_element" ||
5430 name=="selection_precision_object" )
5432 SMESH::UpdateSelectionProp( this );
5434 else if (name == "scalar_bar_vertical_x" || name == "scalar_bar_vertical_width")
5436 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5437 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5438 if ( sbX1+sbW > aTol ) {
5439 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5442 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5443 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5446 else if (name == "scalar_bar_vertical_y" || name == "scalar_bar_vertical_height" )
5448 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5449 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5450 if ( sbY1 + sbH > aTol ) {
5451 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5452 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5453 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5456 else if (name == "scalar_bar_horizontal_x" || name == "scalar_bar_horizontal_width")
5458 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5459 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5460 if ( sbX1 + sbW > aTol ) {
5461 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5464 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5465 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5468 else if (name == "scalar_bar_horizontal_y" || name == "scalar_bar_horizontal_height")
5470 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5471 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5472 if ( sbY1 + sbH > aTol ) {
5473 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5476 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5477 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5480 else if ( name == "segmentation" )
5482 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5483 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5485 else if ( name == "nb_segments_per_edge" )
5487 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5488 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5490 else if ( name == "historical_python_dump" || name == "forget_mesh_on_hyp_modif" || name == "default_grp_color" )
5492 QString val = aResourceMgr->stringValue( "SMESH", name );
5493 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5495 else if ( name == "numbering_node_color" || name == "numbering_node_font" )
5497 SMESH::UpdateFontProp( this );
5499 else if ( name == "numbering_elem_color" || name == "numbering_elem_font" )
5501 SMESH::UpdateFontProp( this );
5504 if ( aWarning.size() != 0 ) {
5505 aWarning += "The default values are applied instead.";
5506 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5507 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5508 QObject::tr(aWarning.c_str()));
5513 //================================================================================
5515 * \brief Update something in accordance with update flags
5516 * \param theFlags - update flags
5518 * Update viewer or/and object browser etc. in accordance with update flags ( see
5519 * LightApp_UpdateFlags enumeration ).
5521 //================================================================================
5522 void SMESHGUI::update( const int flags )
5524 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5525 SMESH::UpdateView();
5527 SalomeApp_Module::update( flags );
5530 //================================================================================
5532 * \brief Set default selection mode
5534 * SLOT called when operation committed. Sets default selection mode
5536 //================================================================================
5537 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5539 SVTK_ViewWindow* vtkWnd =
5540 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5542 vtkWnd->SetSelectionMode( ActorSelection );
5545 //================================================================================
5547 * \brief Set default selection mode
5549 * SLOT called when operation aborted. Sets default selection mode
5551 //================================================================================
5552 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5554 SVTK_ViewWindow* vtkWnd =
5555 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5557 vtkWnd->SetSelectionMode( ActorSelection );
5560 //================================================================================
5562 * \brief Creates operation with given identifier
5563 * \param id - identifier of operation to be started
5564 * \return Pointer on created operation or NULL if operation is not created
5566 * Virtual method redefined from the base class creates operation with given id.
5567 * It is called called automatically from startOperation method of base class.
5569 //================================================================================
5570 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5572 LightApp_Operation* op = 0;
5573 // to do : create operation here
5576 case SMESHOp::OpSplitBiQuadratic:
5577 op = new SMESHGUI_SplitBiQuadOp();
5579 case SMESHOp::OpConvertMeshToQuadratic:
5580 op = new SMESHGUI_ConvToQuadOp();
5582 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5583 op = new SMESHGUI_Make2DFrom3DOp();
5585 case SMESHOp::OpReorientFaces:
5586 op = new SMESHGUI_ReorientFacesOp();
5588 case SMESHOp::OpCreateMesh:
5589 op = new SMESHGUI_MeshOp( true, true );
5591 case SMESHOp::OpCreateSubMesh:
5592 op = new SMESHGUI_MeshOp( true, false );
5594 case SMESHOp::OpEditMeshOrSubMesh:
5595 case SMESHOp::OpEditMesh:
5596 case SMESHOp::OpEditSubMesh:
5597 op = new SMESHGUI_MeshOp( false );
5599 case SMESHOp::OpCompute:
5600 case SMESHOp::OpComputeSubMesh:
5601 op = new SMESHGUI_ComputeOp();
5603 case SMESHOp::OpPreCompute:
5604 op = new SMESHGUI_PrecomputeOp();
5606 case SMESHOp::OpEvaluate:
5607 op = new SMESHGUI_EvaluateOp();
5609 case SMESHOp::OpMeshOrder:
5610 op = new SMESHGUI_MeshOrderOp();
5612 case SMESHOp::OpCreateGeometryGroup:
5613 op = new SMESHGUI_GroupOnShapeOp();
5615 case SMESHOp::OpFindElementByPoint:
5616 op = new SMESHGUI_FindElemByPointOp();
5618 case SMESHOp::OpMoveNode: // Make mesh pass through point
5619 op = new SMESHGUI_MakeNodeAtPointOp();
5621 case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
5622 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5629 op = SalomeApp_Module::createOperation( id );
5633 //================================================================================
5635 * \brief Stops current operations and starts a given one
5636 * \param id - The id of the operation to start
5638 //================================================================================
5640 void SMESHGUI::switchToOperation(int id)
5642 if ( _PTR(Study) aStudy = SMESH::GetActiveStudyDocument() )
5643 activeStudy()->abortAllOperations();
5644 startOperation( id );
5647 LightApp_Displayer* SMESHGUI::displayer()
5650 myDisplayer = new SMESHGUI_Displayer( getApp() );
5654 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5657 int aTolerance = 64;
5658 int anIterations = 0;
5664 if( anIterations % aPeriod == 0 )
5667 if( aTolerance < 1 )
5671 aHue = (int)( 360.0 * rand() / RAND_MAX );
5674 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5675 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5676 for( ; it != itEnd; ++it )
5678 SALOMEDS::Color anAutoColor = *it;
5679 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5682 aQColor.getHsv( &h, &s, &v );
5683 if( abs( h - aHue ) < aTolerance )
5695 aColor.setHsv( aHue, 255, 255 );
5697 SALOMEDS::Color aSColor;
5698 aSColor.R = aColor.redF();
5699 aSColor.G = aColor.greenF();
5700 aSColor.B = aColor.blueF();
5705 const char* gSeparator = "_"; // character used to separate parameter names
5706 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5707 const char* gPathSep = "|"; // character used to separate paths
5710 * \brief Store visual parameters
5712 * This method is called just before the study document is saved.
5713 * Store visual parameters in AttributeParameter attribue(s)
5715 void SMESHGUI::storeVisualParameters (int savePoint)
5718 Kernel_Utils::Localizer loc;
5720 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5721 if (!appStudy || !appStudy->studyDS())
5723 _PTR(Study) studyDS = appStudy->studyDS();
5725 // componentName is used for encoding of entries when storing them in IParameters
5726 std::string componentName = myComponentSMESH->ComponentDataType();
5727 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5728 //if (!aSComponent) return;
5731 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5732 componentName.c_str(),
5734 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5736 // store map of custom markers
5737 const VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5738 if( !aMarkerMap.empty() )
5740 VTK::MarkerMap::const_iterator anIter = aMarkerMap.begin();
5741 for( ; anIter != aMarkerMap.end(); anIter++ )
5743 int anId = anIter->first;
5744 VTK::MarkerData aMarkerData = anIter->second;
5745 std::string aMarkerFileName = aMarkerData.first;
5746 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5747 if( aMarkerTexture.size() < 3 )
5748 continue; // should contain at least width, height and the first value
5750 QString aPropertyName( "texture" );
5751 aPropertyName += gSeparator;
5752 aPropertyName += QString::number( anId );
5754 QString aPropertyValue = aMarkerFileName.c_str();
5755 aPropertyValue += gPathSep;
5757 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5758 ushort aWidth = *aTextureIter++;
5759 ushort aHeight = *aTextureIter++;
5760 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5761 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5762 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5763 aPropertyValue += QString::number( *aTextureIter );
5765 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5769 // viewers counters are used for storing view_numbers in IParameters
5772 // main cycle to store parameters of displayed objects
5773 QList<SUIT_ViewManager*> lst;
5774 QList<SUIT_ViewManager*>::Iterator it;
5775 getApp()->viewManagers(lst);
5776 for (it = lst.begin(); it != lst.end(); it++)
5778 SUIT_ViewManager* vman = *it;
5779 QString vType = vman->getType();
5781 // saving VTK actors properties
5782 if (vType == SVTK_Viewer::Type())
5784 // store the clipping planes attached to the view manager
5785 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5786 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5787 if( anIter != myClippingPlaneInfoMap.end() )
5788 aClippingPlaneInfoList = anIter->second;
5790 if( !aClippingPlaneInfoList.empty() ) {
5791 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5792 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5794 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5795 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5797 QString aPropertyName( "ClippingPlane" );
5798 aPropertyName += gSeparator;
5799 aPropertyName += QString::number( vtkViewers );
5800 aPropertyName += gSeparator;
5801 aPropertyName += QString::number( anId );
5803 QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
5804 aPropertyValue += gDigitsSep;
5805 aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
5806 aPropertyValue += gDigitsSep;
5807 if ( aPlane->PlaneMode == SMESH::Absolute ) {
5808 aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
5809 aPropertyValue += gDigitsSep;
5810 aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
5811 aPropertyValue += gDigitsSep;
5812 aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
5813 aPropertyValue += gDigitsSep;
5814 aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
5815 aPropertyValue += gDigitsSep;
5816 aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
5817 aPropertyValue += gDigitsSep;
5818 aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
5819 aPropertyValue += gDigitsSep;
5820 aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
5822 else if ( aPlane->PlaneMode == SMESH::Relative ) {
5823 aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
5824 aPropertyValue += gDigitsSep;
5825 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5826 aPropertyValue += gDigitsSep;
5827 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5828 aPropertyValue += gDigitsSep;
5829 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5832 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5836 QVector<SUIT_ViewWindow*> views = vman->getViews();
5837 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5839 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5841 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5842 vtkActorCollection* allActors = aCopy.GetActors();
5843 allActors->InitTraversal();
5844 while (vtkActor* actor = allActors->GetNextActor())
5846 if (actor->GetVisibility()) // store only visible actors
5848 SMESH_Actor* aSmeshActor = 0;
5849 if (actor->IsA("SMESH_Actor"))
5850 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5851 if (aSmeshActor && aSmeshActor->hasIO())
5853 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5856 // entry is "encoded" = it does NOT contain component address,
5857 // since it is a subject to change on next component loading
5858 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5860 std::string param, vtkParam = vType.toLatin1().data();
5861 vtkParam += gSeparator;
5862 vtkParam += QString::number(vtkViewers).toLatin1().data();
5863 vtkParam += gSeparator;
5866 param = vtkParam + "Visibility";
5867 ip->setParameter(entry, param, "On");
5870 param = vtkParam + "Representation";
5871 ip->setParameter(entry, param, QString::number
5872 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5875 param = vtkParam + "IsShrunk";
5876 ip->setParameter(entry, param, QString::number
5877 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5879 // Displayed entities
5880 unsigned int aMode = aSmeshActor->GetEntityMode();
5881 bool isE = aMode & SMESH_Actor::eEdges;
5882 bool isF = aMode & SMESH_Actor::eFaces;
5883 bool isV = aMode & SMESH_Actor::eVolumes;
5884 bool is0d = aMode & SMESH_Actor::e0DElements;
5885 bool isB = aMode & SMESH_Actor::eBallElem;
5887 QString modeStr ("e");
5888 modeStr += gDigitsSep; modeStr += QString::number(isE);
5889 modeStr += gDigitsSep; modeStr += "f";
5890 modeStr += gDigitsSep; modeStr += QString::number(isF);
5891 modeStr += gDigitsSep; modeStr += "v";
5892 modeStr += gDigitsSep; modeStr += QString::number(isV);
5893 modeStr += gDigitsSep; modeStr += "0d";
5894 modeStr += gDigitsSep; modeStr += QString::number(is0d);
5895 modeStr += gDigitsSep; modeStr += "b";
5896 modeStr += gDigitsSep; modeStr += QString::number(isB);
5898 param = vtkParam + "Entities";
5899 ip->setParameter(entry, param, modeStr.toLatin1().data());
5905 aSmeshActor->GetSufaceColor(r, g, b, delta);
5906 QStringList colorStr;
5907 colorStr << "surface";
5908 colorStr << QString::number(r);
5909 colorStr << QString::number(g);
5910 colorStr << QString::number(b);
5912 colorStr << "backsurface";
5913 colorStr << QString::number(delta);
5915 aSmeshActor->GetVolumeColor(r, g, b, delta);
5916 colorStr << "volume";
5917 colorStr << QString::number(r);
5918 colorStr << QString::number(g);
5919 colorStr << QString::number(b);
5920 colorStr << QString::number(delta);
5922 aSmeshActor->GetEdgeColor(r, g, b);
5924 colorStr << QString::number(r);
5925 colorStr << QString::number(g);
5926 colorStr << QString::number(b);
5928 aSmeshActor->GetNodeColor(r, g, b);
5930 colorStr << QString::number(r);
5931 colorStr << QString::number(g);
5932 colorStr << QString::number(b);
5934 aSmeshActor->GetOutlineColor(r, g, b);
5935 colorStr << "outline";
5936 colorStr << QString::number(r);
5937 colorStr << QString::number(g);
5938 colorStr << QString::number(b);
5940 aSmeshActor->Get0DColor(r, g, b);
5941 colorStr << "elem0d";
5942 colorStr << QString::number(r);
5943 colorStr << QString::number(g);
5944 colorStr << QString::number(b);
5946 aSmeshActor->GetBallColor(r, g, b);
5948 colorStr << QString::number(r);
5949 colorStr << QString::number(g);
5950 colorStr << QString::number(b);
5952 aSmeshActor->GetFacesOrientationColor(r, g, b);
5953 colorStr << "orientation";
5954 colorStr << QString::number(r);
5955 colorStr << QString::number(g);
5956 colorStr << QString::number(b);
5958 param = vtkParam + "Colors";
5959 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
5962 QStringList sizeStr;
5964 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
5965 sizeStr << "outline";
5966 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
5967 sizeStr << "elem0d";
5968 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
5970 //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
5971 sizeStr << QString::number((double)aSmeshActor->GetBallSize());
5972 sizeStr << QString::number((double)aSmeshActor->GetBallScale());
5973 sizeStr << "shrink";
5974 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
5975 sizeStr << "orientation";
5976 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
5977 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
5979 param = vtkParam + "Sizes";
5980 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
5985 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5986 if( aMarkerType == VTK::MT_USER ) {
5987 markerStr += "custom";
5988 markerStr += gDigitsSep;
5989 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
5993 markerStr += gDigitsSep;
5994 markerStr += QString::number( (int)aMarkerType );
5995 markerStr += gDigitsSep;
5996 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
5999 param = vtkParam + "PointMarker";
6000 ip->setParameter(entry, param, markerStr.toLatin1().data());
6003 param = vtkParam + "Opacity";
6004 ip->setParameter(entry, param,
6005 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
6008 param = vtkParam + "ClippingPlane";
6010 if( !aClippingPlaneInfoList.empty() ) {
6011 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
6012 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
6014 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
6015 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
6016 SMESH::TActorList::iterator anIter2 = anActorList.begin();
6017 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
6018 if( aSmeshActor == *anIter2 ) {
6019 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
6020 QString::number( anId ).toLatin1().constData() );
6027 ip->setParameter( entry, param, "Off" );
6028 } // if (io->hasEntry())
6029 } // SMESH_Actor && hasIO
6031 } // while.. actors traversal
6035 } // if (SVTK view model)
6036 } // for (viewManagers)
6039 // data structures for clipping planes processing
6043 bool isOpenGLClipping;
6044 vtkIdType RelativeOrientation;
6047 int AbsoluteOrientation;
6048 double X, Y, Z, Dx, Dy, Dz;
6050 typedef std::list<TPlaneData> TPlaneDataList;
6051 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
6053 typedef std::list<vtkActor*> TActorList;
6056 TActorList ActorList;
6057 SUIT_ViewManager* ViewManager;
6059 typedef std::list<TPlaneInfo> TPlaneInfoList;
6060 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
6063 * \brief Restore visual parameters
6065 * This method is called after the study document is opened.
6066 * Restore visual parameters from AttributeParameter attribue(s)
6068 void SMESHGUI::restoreVisualParameters (int savePoint)
6071 Kernel_Utils::Localizer loc;
6073 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6074 if (!appStudy || !appStudy->studyDS())
6076 _PTR(Study) studyDS = appStudy->studyDS();
6078 // componentName is used for encoding of entries when storing them in IParameters
6079 std::string componentName = myComponentSMESH->ComponentDataType();
6080 //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
6081 //if (!aSComponent) return;
6084 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6085 componentName.c_str(),
6087 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6089 // restore map of custom markers and map of clipping planes
6090 VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
6091 TPlaneDataMap aPlaneDataMap;
6093 std::vector<std::string> properties = ip->getProperties();
6094 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
6096 std::string property = *propIt;
6097 QString aPropertyName( property.c_str() );
6098 QString aPropertyValue( ip->getProperty( property ).c_str() );
6100 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
6101 if( aPropertyNameList.isEmpty() )
6104 QString aPropertyType = aPropertyNameList[0];
6105 if( aPropertyType == "texture" )
6107 if( aPropertyNameList.size() != 2 )
6111 int anId = aPropertyNameList[1].toInt( &ok );
6112 if( !ok || anId < 1 )
6115 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
6116 if( aPropertyValueList.size() != 2 )
6119 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
6120 QString aMarkerTextureString = aPropertyValueList[1];
6121 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
6122 if( aMarkerTextureStringList.size() != 3 )
6126 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6131 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6135 VTK::MarkerTexture aMarkerTexture;
6136 aMarkerTexture.push_back( aWidth );
6137 aMarkerTexture.push_back( aHeight );
6139 QString aMarkerTextureData = aMarkerTextureStringList[2];
6140 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6142 QChar aChar = aMarkerTextureData.at( i );
6143 if( aChar.isDigit() )
6144 aMarkerTexture.push_back( aChar.digitValue() );
6147 aMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6149 else if( aPropertyType == "ClippingPlane" )
6151 if( aPropertyNameList.size() != 3 )
6155 int aViewId = aPropertyNameList[1].toInt( &ok );
6156 if( !ok || aViewId < 0 )
6160 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6161 if( !ok || aClippingPlaneId < 0 )
6164 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6165 if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6168 TPlaneData aPlaneData;
6169 aPlaneData.AbsoluteOrientation = false;
6170 aPlaneData.RelativeOrientation = 0;
6171 aPlaneData.Distance = aPlaneData.Angle[0] = aPlaneData.Angle[1] = 0;
6172 aPlaneData.X = aPlaneData.Y = aPlaneData.Z = 0;
6173 aPlaneData.Dx = aPlaneData.Dy = aPlaneData.Dz = 0;
6175 aPlaneData.Id = aClippingPlaneId;
6178 aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6183 aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6187 if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6190 aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6195 aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6200 aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6205 aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6210 aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6215 aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6220 aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6224 else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6226 aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6231 aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6236 aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6241 aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6246 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6247 aPlaneDataList.push_back( aPlaneData );
6251 TPlaneInfoMap aPlaneInfoMap;
6253 std::vector<std::string> entries = ip->getEntries();
6255 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6257 // entry is a normal entry - it should be "decoded" (setting base address of component)
6258 QString entry (ip->decodeEntry(*entIt).c_str());
6260 // Check that the entry corresponds to a real object in the Study
6261 // as the object may be deleted or modified after the visual state is saved.
6262 _PTR(SObject) so = studyDS->FindObjectID(entry.toLatin1().data());
6263 if (!so) continue; //Skip the not existent entry
6265 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6266 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6268 std::vector<std::string>::iterator namesIt = paramNames.begin();
6269 std::vector<std::string>::iterator valuesIt = paramValues.begin();
6271 // actors are stored in a map after displaying of them for
6272 // quicker access in the future: map < viewID to actor >
6273 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6275 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6277 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6278 // '_' is used as separator and should not be used in viewer type or parameter names.
6279 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6280 if (lst.size() != 3)
6283 QString viewerTypStr = lst[0];
6284 QString viewIndexStr = lst[1];
6285 QString paramNameStr = lst[2];
6288 int viewIndex = viewIndexStr.toUInt(&ok);
6289 if (!ok) // bad conversion of view index to integer
6293 if (viewerTypStr == SVTK_Viewer::Type())
6295 SMESH_Actor* aSmeshActor = 0;
6296 if (vtkActors.IsBound(viewIndex))
6297 aSmeshActor = vtkActors.Find(viewIndex);
6299 QList<SUIT_ViewManager*> lst;
6300 getApp()->viewManagers(viewerTypStr, lst);
6302 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6303 SUIT_ViewManager* vman = NULL;
6304 if (viewIndex >= 0 && viewIndex < lst.count())
6305 vman = lst.at(viewIndex);
6307 if (paramNameStr == "Visibility")
6309 if (!aSmeshActor && displayer() && vman)
6311 SUIT_ViewModel* vmodel = vman->getViewModel();
6312 // SVTK view model can be casted to SALOME_View
6313 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6315 // store displayed actor in a temporary map for quicker
6316 // access later when restoring other parameters
6317 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6318 vtkRenderer* Renderer = vtkView->getRenderer();
6319 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6320 vtkActorCollection* theActors = aCopy.GetActors();
6321 theActors->InitTraversal();
6322 bool isFound = false;
6323 vtkActor *ac = theActors->GetNextActor();
6324 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6325 if (ac->IsA("SMESH_Actor")) {
6326 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6327 if (aGeomAc->hasIO()) {
6328 Handle(SALOME_InteractiveObject) io = aGeomAc->getIO();
6329 if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) {
6331 vtkActors.Bind(viewIndex, aGeomAc);
6337 } // if (paramNameStr == "Visibility")
6340 // the rest properties "work" with SMESH_Actor
6343 QString val ((*valuesIt).c_str());
6346 if (paramNameStr == "Representation") {
6347 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6350 else if (paramNameStr == "IsShrunk") {
6352 if (!aSmeshActor->IsShrunk())
6353 aSmeshActor->SetShrink();
6356 if (aSmeshActor->IsShrunk())
6357 aSmeshActor->UnShrink();
6360 // Displayed entities
6361 else if (paramNameStr == "Entities") {
6362 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6363 int aEntityMode = SMESH_Actor::eAllEntity;
6364 for ( int i = 0; i < mode.count(); i+=2 ) {
6365 if ( i < mode.count()-1 ) {
6366 QString type = mode[i];
6367 bool val = mode[i+1].toInt();
6368 if ( type == "e" && !val )
6369 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6370 else if ( type == "f" && !val )
6371 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6372 else if ( type == "v" && !val )
6373 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6374 else if ( type == "0d" && !val )
6375 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6376 else if ( type == "b" && !val )
6377 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6380 aSmeshActor->SetEntityMode( aEntityMode );
6383 else if (paramNameStr == "Colors") {
6384 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6391 QColor outlineColor;
6392 QColor orientationColor;
6398 // below lines are required to get default values for delta coefficients
6399 // of backface color for faces and color of reversed volumes
6400 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
6401 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6402 for ( int i = 0; i < colors.count(); i++ ) {
6403 QString type = colors[i];
6404 if ( type == "surface" ) {
6405 // face color is set by 3 values r:g:b, where
6406 // - r,g,b - is rgb color components
6407 if ( i+1 >= colors.count() ) break; // format error
6408 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6409 if ( i+2 >= colors.count() ) break; // format error
6410 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6411 if ( i+3 >= colors.count() ) break; // format error
6412 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6413 faceColor.setRgbF( r, g, b );
6416 else if ( type == "backsurface" ) {
6417 // backface color can be defined in several ways
6418 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6419 // - in latest versions, it is set as delta coefficient
6420 bool rgbOk = false, deltaOk;
6421 if ( i+1 >= colors.count() ) break; // format error
6422 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6423 int delta = colors[i+1].toInt( &deltaOk );
6425 if ( i+1 < colors.count() ) // index is shifted to 1
6426 g = colors[i+1].toDouble( &rgbOk );
6427 if ( rgbOk ) i++; // shift index
6428 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6429 b = colors[i+1].toDouble( &rgbOk );
6431 // - as currently there's no way to set directly backsurface color as it was before,
6432 // we ignore old dump where r,g,b triple was set
6433 // - also we check that delta parameter is set properly
6434 if ( !rgbOk && deltaOk )
6437 else if ( type == "volume" ) {
6438 // volume color is set by 4 values r:g:b:delta, where
6439 // - r,g,b - is a normal volume rgb color components
6440 // - delta - is a reversed volume color delta coefficient
6441 if ( i+1 >= colors.count() ) break; // format error
6442 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6443 if ( i+2 >= colors.count() ) break; // format error
6444 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6445 if ( i+3 >= colors.count() ) break; // format error
6446 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6447 if ( i+4 >= colors.count() ) break; // format error
6448 int delta = colors[i+4].toInt( &bOk );
6449 if ( !bOk ) break; // format error
6450 volumeColor.setRgbF( r, g, b );
6454 else if ( type == "edge" ) {
6455 // edge color is set by 3 values r:g:b, where
6456 // - r,g,b - is rgb color components
6457 if ( i+1 >= colors.count() ) break; // format error
6458 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6459 if ( i+2 >= colors.count() ) break; // format error
6460 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6461 if ( i+3 >= colors.count() ) break; // format error
6462 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6463 edgeColor.setRgbF( r, g, b );
6466 else if ( type == "node" ) {
6467 // node color is set by 3 values r:g:b, where
6468 // - r,g,b - is rgb color components
6469 if ( i+1 >= colors.count() ) break; // format error
6470 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6471 if ( i+2 >= colors.count() ) break; // format error
6472 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6473 if ( i+3 >= colors.count() ) break; // format error
6474 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6475 nodeColor.setRgbF( r, g, b );
6478 else if ( type == "elem0d" ) {
6479 // 0d element color is set by 3 values r:g:b, where
6480 // - r,g,b - is rgb color components
6481 if ( i+1 >= colors.count() ) break; // format error
6482 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6483 if ( i+2 >= colors.count() ) break; // format error
6484 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6485 if ( i+3 >= colors.count() ) break; // format error
6486 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6487 elem0dColor.setRgbF( r, g, b );
6490 else if ( type == "ball" ) {
6491 // ball color is set by 3 values r:g:b, where
6492 // - r,g,b - is rgb color components
6493 if ( i+1 >= colors.count() ) break; // format error
6494 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6495 if ( i+2 >= colors.count() ) break; // format error
6496 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6497 if ( i+3 >= colors.count() ) break; // format error
6498 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6499 ballColor.setRgbF( r, g, b );
6502 else if ( type == "outline" ) {
6503 // outline color is set by 3 values r:g:b, where
6504 // - r,g,b - is rgb color components
6505 if ( i+1 >= colors.count() ) break; // format error
6506 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6507 if ( i+2 >= colors.count() ) break; // format error
6508 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6509 if ( i+3 >= colors.count() ) break; // format error
6510 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6511 outlineColor.setRgbF( r, g, b );
6514 else if ( type == "orientation" ) {
6515 // orientation color is set by 3 values r:g:b, where
6516 // - r,g,b - is rgb color components
6517 if ( i+1 >= colors.count() ) break; // format error
6518 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6519 if ( i+2 >= colors.count() ) break; // format error
6520 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6521 if ( i+3 >= colors.count() ) break; // format error
6522 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6523 orientationColor.setRgbF( r, g, b );
6528 if ( nodeColor.isValid() )
6529 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6531 if ( edgeColor.isValid() )
6532 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6534 if ( faceColor.isValid() )
6535 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6537 if ( volumeColor.isValid() )
6538 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6539 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6540 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6542 if ( elem0dColor.isValid() )
6543 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6545 if ( ballColor.isValid() )
6546 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6548 if ( outlineColor.isValid() )
6549 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6550 // orientation color
6551 if ( orientationColor.isValid() )
6552 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6555 else if (paramNameStr == "Sizes") {
6556 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6559 int outlineWidth = -1;
6560 int elem0dSize = -1;
6561 //int ballSize = -1;
6562 double ballDiameter = -1.0;
6563 double ballScale = -1.0;
6564 double shrinkSize = -1;
6565 double orientationSize = -1;
6566 bool orientation3d = false;
6567 for ( int i = 0; i < sizes.count(); i++ ) {
6568 QString type = sizes[i];
6569 if ( type == "line" ) {
6570 // line (wireframe) width is given as single integer value
6571 if ( i+1 >= sizes.count() ) break; // format error
6572 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6576 if ( type == "outline" ) {
6577 // outline width is given as single integer value
6578 if ( i+1 >= sizes.count() ) break; // format error
6579 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6583 else if ( type == "elem0d" ) {
6584 // 0d element size is given as single integer value
6585 if ( i+1 >= sizes.count() ) break; // format error
6586 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6590 else if ( type == "ball" ) {
6591 // balls are specified by two values: size:scale, where
6592 // - size - is a integer value specifying size
6593 // - scale - is a double value specifying scale factor
6594 if ( i+1 >= sizes.count() ) break; // format error
6595 //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6596 double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6597 if ( i+2 >= sizes.count() ) break; // format error
6598 double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6604 else if ( type == "shrink" ) {
6605 // shrink factor is given as single floating point value
6606 if ( i+1 >= sizes.count() ) break; // format error
6607 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6611 else if ( type == "orientation" ) {
6612 // orientation vectors are specified by two values size:3d, where
6613 // - size - is a floating point value specifying scale factor
6614 // - 3d - is a boolean
6615 if ( i+1 >= sizes.count() ) break; // format error
6616 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6617 if ( i+2 >= sizes.count() ) break; // format error
6618 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6619 orientationSize = v1;
6620 orientation3d = (bool)v2;
6624 // line (wireframe) width
6625 if ( lineWidth > 0 )
6626 aSmeshActor->SetLineWidth( lineWidth );
6628 if ( outlineWidth > 0 )
6629 aSmeshActor->SetOutlineWidth( outlineWidth );
6630 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6631 aSmeshActor->SetOutlineWidth( lineWidth );
6633 if ( elem0dSize > 0 )
6634 aSmeshActor->Set0DSize( elem0dSize );
6636 /*if ( ballSize > 0 )
6637 aSmeshActor->SetBallSize( ballSize );*/
6639 if ( ballDiameter > 0 )
6640 aSmeshActor->SetBallSize( ballDiameter );
6642 if ( ballScale > 0.0 )
6643 aSmeshActor->SetBallScale( ballScale );
6645 if ( shrinkSize > 0 )
6646 aSmeshActor->SetShrinkFactor( shrinkSize );
6647 // orientation vectors
6648 if ( orientationSize > 0 ) {
6649 aSmeshActor->SetFacesOrientationScale( orientationSize );
6650 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6654 else if (paramNameStr == "PointMarker") {
6655 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6656 if( data.count() >= 2 ) {
6658 int aParam1 = data[1].toInt( &ok );
6660 if( data[0] == "std" && data.count() == 3 ) {
6661 int aParam2 = data[2].toInt( &ok );
6662 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6664 else if( data[0] == "custom" ) {
6665 VTK::MarkerMap::const_iterator markerIt = aMarkerMap.find( aParam1 );
6666 if( markerIt != aMarkerMap.end() ) {
6667 VTK::MarkerData aMarkerData = markerIt->second;
6668 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6675 else if (paramNameStr == "Opacity") {
6676 aSmeshActor->SetOpacity(val.toFloat());
6679 else if (paramNameStr.startsWith("ClippingPlane")) {
6680 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6681 // old format - val looks like "Off" or "1:0:0:0.5:0:0"
6682 // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
6683 // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
6684 // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
6685 // new format - val looks like "Off" or "0" (plane id)
6686 // (note: in new format "Off" value is used only for consistency,
6687 // so it is processed together with values in old format)
6688 bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
6689 if( anIsOldFormat ) {
6690 if (paramNameStr == "ClippingPlane1" || val == "Off")
6691 aSmeshActor->RemoveAllClippingPlanes();
6693 QList<SUIT_ViewManager*> lst;
6694 getApp()->viewManagers(viewerTypStr, lst);
6695 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6696 if (viewIndex >= 0 && viewIndex < lst.count()) {
6697 SUIT_ViewManager* vman = lst.at(viewIndex);
6698 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6700 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6702 SMESH::TActorList anActorList;
6703 anActorList.push_back( aSmeshActor );
6704 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
6705 aPlane->myViewWindow = vtkView;
6706 SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
6707 aPlane->PlaneMode = aMode;
6708 bool isOpenGLClipping = ( bool )vals[1].toInt();
6709 aPlane->IsOpenGLClipping = isOpenGLClipping;
6710 if ( aMode == SMESH::Absolute ) {
6711 aPlane->myAbsoluteOrientation = vals[2].toInt();
6712 aPlane->X = vals[3].toFloat();
6713 aPlane->Y = vals[4].toFloat();
6714 aPlane->Z = vals[5].toFloat();
6715 aPlane->Dx = vals[6].toFloat();
6716 aPlane->Dy = vals[7].toFloat();
6717 aPlane->Dz = vals[8].toFloat();
6719 else if ( aMode == SMESH::Relative ) {
6720 aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
6721 aPlane->myDistance = vals[3].toFloat();
6722 aPlane->myAngle[0] = vals[4].toFloat();
6723 aPlane->myAngle[1] = vals[5].toFloat();
6727 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6728 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6729 aClippingPlaneInfo.Plane = aPlane;
6730 aClippingPlaneInfo.ActorList = anActorList;
6731 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6739 int aPlaneId = val.toInt( &ok );
6740 if( ok && aPlaneId >= 0 ) {
6741 bool anIsDefinedPlane = false;
6742 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6743 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6744 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6745 TPlaneInfo& aPlaneInfo = *anIter;
6746 if( aPlaneInfo.PlaneId == aPlaneId ) {
6747 aPlaneInfo.ActorList.push_back( aSmeshActor );
6748 anIsDefinedPlane = true;
6752 if( !anIsDefinedPlane ) {
6753 TPlaneInfo aPlaneInfo;
6754 aPlaneInfo.PlaneId = aPlaneId;
6755 aPlaneInfo.ActorList.push_back( aSmeshActor );
6756 aPlaneInfo.ViewManager = vman;
6758 // to make the list sorted by plane id
6759 anIter = aPlaneInfoList.begin();
6760 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6761 const TPlaneInfo& aPlaneInfoRef = *anIter;
6762 if( aPlaneInfoRef.PlaneId > aPlaneId )
6765 aPlaneInfoList.insert( anIter, aPlaneInfo );
6770 } // if (aSmeshActor)
6771 } // other parameters than Visibility
6773 } // for names/parameters iterator
6774 } // for entries iterator
6776 // take into account planes with empty list of actors referred to them
6777 QList<SUIT_ViewManager*> aVMList;
6778 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6780 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6781 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6782 int aViewId = aPlaneDataIter->first;
6783 if( aViewId >= 0 && aViewId < aVMList.count() ) {
6784 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6786 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6788 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6789 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6790 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6791 const TPlaneData& aPlaneData = *anIter2;
6792 int aPlaneId = aPlaneData.Id;
6794 bool anIsFound = false;
6795 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6796 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6797 const TPlaneInfo& aPlaneInfo = *anIter3;
6798 if( aPlaneInfo.PlaneId == aPlaneId ) {
6805 TPlaneInfo aPlaneInfo; // ActorList field is empty
6806 aPlaneInfo.PlaneId = aPlaneId;
6807 aPlaneInfo.ViewManager = aViewManager;
6809 // to make the list sorted by plane id
6810 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6811 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6812 const TPlaneInfo& aPlaneInfoRef = *anIter4;
6813 if( aPlaneInfoRef.PlaneId > aPlaneId )
6816 aPlaneInfoList.insert( anIter4, aPlaneInfo );
6822 // add clipping planes to actors according to the restored parameters
6823 // and update the clipping plane map
6824 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6825 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6826 int aViewId = anIter1->first;
6827 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6829 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6830 if( anIter2 == aPlaneDataMap.end() )
6832 const TPlaneDataList& aPlaneDataList = anIter2->second;
6834 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6835 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6836 const TPlaneInfo& aPlaneInfo = *anIter3;
6837 int aPlaneId = aPlaneInfo.PlaneId;
6838 const TActorList& anActorList = aPlaneInfo.ActorList;
6839 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6843 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6847 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6849 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6850 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6851 const TPlaneData& aPlaneData = *anIter4;
6852 if( aPlaneData.Id == aPlaneId ) {
6853 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
6854 aPlane->myViewWindow = aViewWindow;
6855 aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
6856 aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
6857 if ( aPlane->PlaneMode == SMESH::Absolute ) {
6858 aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
6859 aPlane->X = aPlaneData.X;
6860 aPlane->Y = aPlaneData.Y;
6861 aPlane->Z = aPlaneData.Z;
6862 aPlane->Dx = aPlaneData.Dx;
6863 aPlane->Dy = aPlaneData.Dy;
6864 aPlane->Dz = aPlaneData.Dz;
6866 else if ( aPlane->PlaneMode == SMESH::Relative ) {
6867 aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
6868 aPlane->myDistance = aPlaneData.Distance;
6869 aPlane->myAngle[0] = aPlaneData.Angle[0];
6870 aPlane->myAngle[1] = aPlaneData.Angle[1];
6873 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6874 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6875 aClippingPlaneInfo.Plane = aPlane;
6876 aClippingPlaneInfo.ActorList = anActorList;
6877 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6888 // update all VTK views
6889 QList<SUIT_ViewManager*> lst;
6890 getApp()->viewManagers(lst);
6891 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6892 SUIT_ViewModel* vmodel = (*it)->getViewModel();
6893 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6894 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6895 // set OpenGL clipping planes
6896 VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
6897 vtkActorCollection* anAllActors = aCopy.GetActors();
6898 anAllActors->InitTraversal();
6899 while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
6900 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
6901 anActor->SetOpenGLClippingPlane();
6903 vtkView->getRenderer()->ResetCameraClippingRange();
6910 \brief Adds preferences for dfont of VTK viewer
6912 \param pIf group identifier
6913 \param param parameter
6914 \return identifier of preferences
6916 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
6918 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6920 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6923 fam.append( tr( "SMESH_FONT_ARIAL" ) );
6924 fam.append( tr( "SMESH_FONT_COURIER" ) );
6925 fam.append( tr( "SMESH_FONT_TIMES" ) );
6927 setPreferenceProperty( tfont, "fonts", fam );
6929 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6930 if ( needSize ) f = f | QtxFontEdit::Size;
6931 setPreferenceProperty( tfont, "features", f );
6937 \brief Actions after hypothesis edition
6938 Updates object browser after hypothesis edition
6940 void SMESHGUI::onHypothesisEdit( int result )
6943 SMESHGUI::Modified();
6944 updateObjBrowser( true );
6948 \brief Actions after choosing menu of control modes
6949 Updates control mode actions according to current selection
6951 void SMESHGUI::onUpdateControlActions()
6953 SALOME_ListIO selected;
6954 if ( LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr() )
6955 aSel->selectedObjects( selected );
6957 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
6958 if ( selected.Extent() ) {
6959 if ( selected.First()->hasEntry() ) {
6960 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( selected.First()->getEntry() )) {
6961 aControl = anActor->GetControlMode();
6962 SALOME_ListIteratorOfListIO it(selected);
6963 for ( it.Next(); it.More(); it.Next() ) {
6964 Handle(SALOME_InteractiveObject) anIO = it.Value();
6965 if ( anIO->hasEntry() ) {
6966 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
6967 if ( aControl != anActor->GetControlMode() ) {
6968 aControl = SMESH_Actor::eNone;
6978 int anAction = ActionToControl( aControl, true );
6980 action( anAction )->setChecked( true );
6982 QMenu* send = (QMenu*)sender();
6983 QList<QAction*> actions = send->actions();
6984 for ( int i = 0; i < actions.size(); i++ )
6985 actions[i]->setChecked( false );
6991 \brief Signal handler closing(SUIT_ViewWindow*) of a view
6992 \param pview view being closed
6994 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
6995 #ifndef DISABLE_PLOT2DVIEWER
6996 //Crear all Plot2d Viewers if need.
6997 SMESH::ClearPlot2Viewers(pview);
6999 EmitSignalCloseView();
7002 void SMESHGUI::message( const QString& msg )
7005 QStringList data = msg.split("/");
7006 if ( data.count() > 0 ) {
7007 if ( data.first() == "mesh_loading" ) {
7009 QString entry = data.count() > 1 ? data[1] : QString();
7010 if ( entry.isEmpty() )
7013 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
7015 _PTR(SObject) obj = study->FindObjectID( entry.toLatin1().constData() );
7018 name = SMESH::fromUtf8(obj->GetName());
7019 if ( name.isEmpty() )
7022 if ( data.last() == "stop" )
7023 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
7025 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
7026 QApplication::processEvents();
7032 \brief Connects or disconnects signals about activating and cloning view on the module slots
7033 \param pview view which is connected/disconnected
7035 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
7039 SUIT_ViewManager* viewMgr = pview->getViewManager();
7041 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7042 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7044 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7045 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7050 \brief Return \c true if object can be renamed
7052 bool SMESHGUI::renameAllowed( const QString& entry) const {
7053 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7057 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7061 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
7066 if(appStudy->isComponent(entry) || obj->isReference())
7069 // check type to prevent renaming of inappropriate objects
7070 int aType = SMESHGUI_Selection::type(qPrintable(entry), SMESH::GetActiveStudyDocument());
7071 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7072 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7073 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7074 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7075 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
7082 Rename object by entry.
7083 \param entry entry of the object
7084 \param name new name of the object
7085 \brief Return \c true if rename operation finished successfully, \c false otherwise.
7087 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
7089 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7093 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7098 _PTR(Study) aStudy = appStudy->studyDS();
7103 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
7105 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
7110 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
7111 _PTR(GenericAttribute) anAttr;
7112 _PTR(AttributeName) aName;
7114 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
7116 // check type to prevent renaming of inappropriate objects
7117 int aType = SMESHGUI_Selection::type( qPrintable(entry), SMESH::GetActiveStudyDocument() );
7118 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7119 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7120 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7121 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7122 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
7123 if ( !name.isEmpty() ) {
7124 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
7126 // update name of group object and its actor
7127 Handle(SALOME_InteractiveObject) IObject =
7128 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
7130 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
7131 if( !aGroupObject->_is_nil() ) {
7132 aGroupObject->SetName( qPrintable(name) );
7133 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
7134 anActor->setName( qPrintable(name) );
7144 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
7146 static QList<QColor> colors;
7148 if ( colors.isEmpty() ) {
7150 for (int s = 0; s < 2 ; s++)
7152 for (int v = 100; v >= 40; v = v - 20)
7154 for (int h = 0; h < 359 ; h = h + 60)
7156 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
7161 static int currentColor = randomize( colors.size() );
7163 SALOMEDS::Color color;
7164 color.R = (double)colors[currentColor].red() / 255.0;
7165 color.G = (double)colors[currentColor].green() / 255.0;
7166 color.B = (double)colors[currentColor].blue() / 255.0;
7168 currentColor = (currentColor+1) % colors.count();