1 // Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
3 // Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
6 // This library is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU Lesser General Public
8 // License as published by the Free Software Foundation; either
9 // version 2.1 of the License, or (at your option) any later version.
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 // Lesser General Public License for more details.
16 // You should have received a copy of the GNU Lesser General Public
17 // License along with this library; if not, write to the Free Software
18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
22 // File : SMESHGUI.cxx
23 // Author : Nicolas REJNERI, Open CASCADE S.A.S.
25 #include <Standard_math.hxx> // E.A. must be included before Python.h to fix compilation on windows
27 #undef HAVE_FINITE // VSR: avoid compilation warning on Linux : "HAVE_FINITE" redefined
33 #include "SMESHGUI_Add0DElemsOnAllNodesDlg.h"
34 #include "SMESHGUI_AddMeshElementDlg.h"
35 #include "SMESHGUI_AddQuadraticElementDlg.h"
36 #include "SMESHGUI_BuildCompoundDlg.h"
37 #include "SMESHGUI_ClippingDlg.h"
38 #include "SMESHGUI_ComputeDlg.h"
39 #include "SMESHGUI_ConvToQuadOp.h"
40 #include "SMESHGUI_CopyMeshDlg.h"
41 #include "SMESHGUI_CreatePolyhedralVolumeDlg.h"
42 #include "SMESHGUI_DeleteGroupDlg.h"
43 #include "SMESHGUI_DisplayEntitiesDlg.h"
44 #include "SMESHGUI_Displayer.h"
45 #include "SMESHGUI_DuplicateNodesDlg.h"
46 #include "SMESHGUI_ExtrusionAlongPathDlg.h"
47 #include "SMESHGUI_ExtrusionDlg.h"
48 #include "SMESHGUI_FaceGroupsSeparatedByEdgesDlg.h"
49 #include "SMESHGUI_FieldSelectorWdg.h"
50 #include "SMESHGUI_FileInfoDlg.h"
51 #include "SMESHGUI_FileValidator.h"
52 #include "SMESHGUI_FilterDlg.h"
53 #include "SMESHGUI_FilterLibraryDlg.h"
54 #include "SMESHGUI_FilterUtils.h"
55 #include "SMESHGUI_FindElemByPointDlg.h"
56 #include "SMESHGUI_GEOMGenUtils.h"
57 #include "SMESHGUI_GroupDlg.h"
58 #include "SMESHGUI_GroupOnShapeDlg.h"
59 #include "SMESHGUI_GroupOpDlg.h"
60 #include "SMESHGUI_GroupUtils.h"
61 #include "SMESHGUI_Hypotheses.h"
62 #include "SMESHGUI_HypothesesUtils.h"
63 #include "SMESHGUI_Make2DFrom3DOp.h"
64 #include "SMESHGUI_MakeNodeAtPointDlg.h"
65 #include "SMESHGUI_Measurements.h"
66 #include "SMESHGUI_MergeDlg.h"
67 #include "SMESHGUI_MeshInfo.h"
68 #include "SMESHGUI_MeshOp.h"
69 #include "SMESHGUI_MeshOrderOp.h"
70 #include "SMESHGUI_MeshPatternDlg.h"
71 #include "SMESHGUI_MeshUtils.h"
72 #include "SMESHGUI_MultiEditDlg.h"
73 #include "SMESHGUI_NodesDlg.h"
74 #include "SMESHGUI_OffsetDlg.h"
75 #include "SMESHGUI_Operations.h"
76 #include "SMESHGUI_PatternUtils.h"
77 #include "SMESHGUI_Preferences_ScalarBarDlg.h"
78 #include "SMESHGUI_PropertiesDlg.h"
79 #include "SMESHGUI_RemoveElementsDlg.h"
80 #include "SMESHGUI_RemoveNodesDlg.h"
81 #include "SMESHGUI_RenumberingDlg.h"
82 #include "SMESHGUI_ReorientFacesDlg.h"
83 #include "SMESHGUI_RevolutionDlg.h"
84 #include "SMESHGUI_RotationDlg.h"
85 #include "SMESHGUI_ScaleDlg.h"
86 #include "SMESHGUI_Selection.h"
87 #include "SMESHGUI_SewingDlg.h"
88 #include "SMESHGUI_SingleEditDlg.h"
89 #include "SMESHGUI_SmoothingDlg.h"
90 #include "SMESHGUI_SpinBox.h"
91 #include "SMESHGUI_SplitBiQuad.h"
92 #include "SMESHGUI_SymmetryDlg.h"
93 #include "SMESHGUI_TranslationDlg.h"
94 #include "SMESHGUI_TransparencyDlg.h"
95 #include "SMESHGUI_Utils.h"
96 #include "SMESHGUI_VTKUtils.h"
98 #include "SMESH_version.h"
100 #include "SMESH_ControlsDef.hxx"
101 #include "SMESH_Actor.h"
102 #include "SMESH_ActorUtils.h"
103 #include "SMESH_Client.hxx"
104 #include "SMESH_ScalarBarActor.h"
105 #include <SMESH_Comment.hxx>
106 #include "SMESH_TypeFilter.hxx"
108 // SALOME GUI includes
109 #include <LightApp_DataOwner.h>
110 #include <LightApp_NameDlg.h>
111 #include <LightApp_Preferences.h>
112 #include <LightApp_SelectionMgr.h>
113 #include <LightApp_UpdateFlags.h>
114 #include <QtxFontEdit.h>
115 #include <QtxPopupMgr.h>
116 #include <SALOME_ListIO.hxx>
117 #include <SUIT_Desktop.h>
118 #include <SUIT_FileDlg.h>
119 #include <SUIT_MessageBox.h>
120 #include <SUIT_OverrideCursor.h>
121 #include <SUIT_ResourceMgr.h>
122 #include <SUIT_Session.h>
123 #include <SVTK_Renderer.h>
124 #include <SVTK_ViewManager.h>
125 #include <SVTK_ViewModel.h>
126 #include <SVTK_ViewWindow.h>
127 #include <SalomeApp_Application.h>
128 #include <SalomeApp_CheckFileDlg.h>
129 #include <SalomeApp_DataObject.h>
130 #include <SalomeApp_Study.h>
131 #include <SalomeApp_Tools.h>
132 #include <VTKViewer_Algorithm.h>
134 #ifndef DISABLE_PLOT2DVIEWER
135 #include <SPlot2d_ViewModel.h>
136 #include <SPlot2d_Histogram.h>
140 #include <SALOMEconfig.h>
141 #include CORBA_CLIENT_HEADER(SALOMEDS_Attributes)
142 #include CORBA_CLIENT_HEADER(SMESH_MeshEditor)
143 #include CORBA_CLIENT_HEADER(SMESH_Measurements)
144 #include CORBA_CLIENT_HEADER(SMESH_Mesh)
147 // #define INCLUDE_MENUITEM_DEF // VSR commented ????????
148 #include <QApplication>
150 #include <QDialogButtonBox>
154 #include <QTextStream>
158 #include <boost/shared_ptr.hpp>
161 #include <vtkCallbackCommand.h>
162 #include <vtkCamera.h>
163 #include <vtkLookupTable.h>
164 #include <vtkPlane.h>
165 #include <vtkRenderer.h>
167 // SALOME KERNEL includes
168 #include <SALOMEDSClient_ClientFactory.hxx>
169 #include <SALOMEDSClient_IParameters.hxx>
170 #include <SALOMEDSClient_SComponent.hxx>
171 #include <SALOMEDSClient_StudyBuilder.hxx>
172 #include <SALOMEDS_Study.hxx>
173 #include <SALOMEDS_SObject.hxx>
174 #include "utilities.h"
177 #include <Standard_ErrorHandler.hxx>
178 #include <NCollection_DataMap.hxx>
179 #include <NCollection_DoubleMap.hxx>
181 #include <Basics_Utils.hxx>
183 // Below macro, when uncommented, switches on simplified (more performant) algorithm
184 // of auto-color picking up
185 #define SIMPLE_AUTOCOLOR
190 //=============================================================
191 void ImportMeshesFromFile(SMESH::SMESH_Gen_ptr theComponentMesh,
194 void ExportMeshToFile(int theCommandID);
196 void SetDisplayMode(int theCommandID, VTK::MarkerMap& theMarkerMap);
198 void SetDisplayEntity(int theCommandID);
200 int ActionToControl( int theID, bool theReversed = false );
202 void Control( int theCommandID );
205 //================================================================================
207 * \brief Reads meshes from file
209 //================================================================================
211 void ImportMeshesFromFile( SMESH::SMESH_Gen_ptr theComponentMesh,
215 std::string myExtension;
217 if ( theCommandID == SMESHOp::OpImportMED ||
218 theCommandID == SMESHOp::OpPopupImportMED ) {
219 filter.append( QObject::tr( "MED_FILES_FILTER" ) + " (*.*med)" );
220 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
222 else if ( theCommandID == SMESHOp::OpImportUNV ||
223 theCommandID == SMESHOp::OpPopupImportUNV ) {
224 filter.append( QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)" );
226 else if ( theCommandID == SMESHOp::OpImportDAT ||
227 theCommandID == SMESHOp::OpPopupImportDAT ) {
228 filter.append( QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)" );
230 else if ( theCommandID == SMESHOp::OpImportSTL ||
231 theCommandID == SMESHOp::OpPopupImportSTL ) {
232 filter.append( QObject::tr( "STL_FILES_FILTER" ) + " (*.stl)" );
234 else if ( theCommandID == SMESHOp::OpImportCGNS ||
235 theCommandID == SMESHOp::OpPopupImportCGNS ) {
236 filter.append( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
238 else if ( theCommandID == SMESHOp::OpImportSAUV ||
239 theCommandID == SMESHOp::OpPopupImportSAUV ) {
240 filter.append( QObject::tr( "SAUV_FILES_FILTER" ) + " (*.sauv *.sauve)" );
241 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
243 else if ( theCommandID == SMESHOp::OpImportGMF ||
244 theCommandID == SMESHOp::OpPopupImportGMF ) {
245 filter.append( QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" );
246 filter.append( QObject::tr( "GMF_BINARY_FILES_FILTER") + " (*.meshb)" );
249 QString anInitialPath = "";
250 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
251 anInitialPath = QDir::currentPath();
253 QStringList filenames;
254 bool toCreateGroups = true;
256 // if ( theCommandID == SMESHOp::OpImportGMF ) { // GMF
257 // SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg
258 // ( SMESHGUI::desktop(), true, QObject::tr("SMESH_REQUIRED_GROUPS"), true, true );
259 // fd->setWindowTitle( QObject::tr( "SMESH_IMPORT_MESH" ) );
260 // fd->setNameFilters( filter );
261 // fd->SetChecked( true );
263 // filenames << fd->selectedFile();
264 // toCreateGroups = fd->IsChecked();
270 filenames = SUIT_FileDlg::getOpenFileNames( SMESHGUI::desktop(),
273 QObject::tr( "SMESH_IMPORT_MESH" ) );
275 if ( filenames.count() > 0 )
277 SUIT_OverrideCursor wc;
278 _PTR(Study) aStudy = SMESH::getStudy();
281 QStringList anEntryList;
282 bool isEmpty = false;
283 for ( QStringList::ConstIterator it = filenames.begin(); it != filenames.end(); ++it )
285 QString filename = *it;
286 SMESH::mesh_array_var aMeshes = new SMESH::mesh_array;
288 switch ( theCommandID ) {
289 case SMESHOp::OpImportDAT:
290 case SMESHOp::OpPopupImportDAT:
292 // DAT format (currently unsupported)
293 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
294 arg( QObject::tr( "SMESH_ERR_NOT_SUPPORTED_FORMAT" ) ) );
297 case SMESHOp::OpImportUNV:
298 case SMESHOp::OpPopupImportUNV:
301 aMeshes->length( 1 );
302 aMeshes[0] = theComponentMesh->CreateMeshesFromUNV( filename.toUtf8().constData() );
303 if ( aMeshes[0]->_is_nil() )
304 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
305 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
308 case SMESHOp::OpImportMED:
309 case SMESHOp::OpPopupImportMED:
312 SMESH::DriverMED_ReadStatus res;
313 aMeshes = theComponentMesh->CreateMeshesFromMED( filename.toUtf8().constData(), res );
314 if ( res != SMESH::DRS_OK ) {
315 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
316 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
320 case SMESHOp::OpImportSTL:
321 case SMESHOp::OpPopupImportSTL:
324 aMeshes->length( 1 );
325 aMeshes[0] = theComponentMesh->CreateMeshesFromSTL( filename.toUtf8().constData() );
326 if ( aMeshes[0]->_is_nil() ) {
327 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
328 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
332 case SMESHOp::OpImportCGNS:
333 case SMESHOp::OpPopupImportCGNS:
336 SMESH::DriverMED_ReadStatus res;
337 aMeshes = theComponentMesh->CreateMeshesFromCGNS( filename.toUtf8().constData(), res );
338 if ( res != SMESH::DRS_OK ) {
339 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
340 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
344 case SMESHOp::OpImportSAUV:
345 case SMESHOp::OpPopupImportSAUV:
348 SMESH::DriverMED_ReadStatus res;
349 aMeshes = theComponentMesh->CreateMeshesFromSAUV( filename.toUtf8().constData(), res );
350 if ( res != SMESH::DRS_OK ) {
351 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
352 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
356 case SMESHOp::OpImportGMF:
357 case SMESHOp::OpPopupImportGMF:
360 SMESH::ComputeError_var res;
361 aMeshes->length( 1 );
362 aMeshes[0] = theComponentMesh->CreateMeshesFromGMF( filename.toUtf8().constData(),
365 if ( res->code != SMESH::DRS_OK ) {
366 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
367 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res->code ).toLatin1().data() ) ) );
368 if ( strlen( res->comment.in() ) > 0 ) {
369 errors.back() += ": ";
370 errors.back() += res->comment.in();
377 catch ( const SALOME::SALOME_Exception& S_ex ) {
378 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
379 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
382 for ( int i = 0, iEnd = aMeshes->length(); i < iEnd; i++ )
384 _PTR(SObject) aMeshSO = SMESH::FindSObject( aMeshes[i] );
386 _PTR(StudyBuilder) aBuilder = aStudy->NewBuilder();
387 _PTR(AttributePixMap) aPixmap = aBuilder->FindOrCreateAttribute( aMeshSO, "AttributePixMap" );
388 aPixmap->SetPixMap( "ICON_SMESH_TREE_MESH_IMPORTED" );
389 if ( theCommandID == SMESHOp::OpImportUNV ) // mesh names aren't taken from the file for UNV import
390 SMESH::SetName( aMeshSO, QFileInfo(filename).fileName() );
392 anEntryList.append( aMeshSO->GetID().c_str() );
400 // update Object browser
401 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
403 // browse to the published meshes
404 if( LightApp_Application* anApp =
405 dynamic_cast<LightApp_Application*>( SUIT_Session::session()->activeApplication() ) )
406 anApp->browseObjects( anEntryList );
408 // show Error message box if there were errors
409 if ( errors.count() > 0 ) {
410 SUIT_MessageBox::critical( SMESHGUI::desktop(),
411 QObject::tr( "SMESH_ERROR" ),
412 QObject::tr( "SMESH_IMPORT_ERRORS" ) + "\n" + errors.join( "\n" ) );
415 // show warning message box, if some imported mesh is empty
417 SUIT_MessageBox::warning( SMESHGUI::desktop(),
418 QObject::tr( "SMESH_WRN_WARNING" ),
419 QObject::tr( "SMESH_DRS_SOME_EMPTY" ) );
424 //================================================================================
426 * \brief Export selected meshes or groups into a file
428 //================================================================================
430 void ExportMeshToFile( int theCommandID )
432 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
433 SALOME_ListIO selected;
435 aSel->selectedObjects( selected );
437 const bool isDAT = ( theCommandID == SMESHOp::OpExportDAT ||
438 theCommandID == SMESHOp::OpPopupExportDAT );
439 const bool isMED = ( theCommandID == SMESHOp::OpExportMED ||
440 theCommandID == SMESHOp::OpPopupExportMED );
441 const bool isUNV = ( theCommandID == SMESHOp::OpExportUNV ||
442 theCommandID == SMESHOp::OpPopupExportUNV );
443 const bool isSTL = ( theCommandID == SMESHOp::OpExportSTL ||
444 theCommandID == SMESHOp::OpPopupExportSTL );
445 const bool isCGNS= ( theCommandID == SMESHOp::OpExportCGNS ||
446 theCommandID == SMESHOp::OpPopupExportCGNS );
447 const bool isSAUV= ( theCommandID == SMESHOp::OpExportSAUV ||
448 theCommandID == SMESHOp::OpPopupExportSAUV );
449 const bool isGMF = ( theCommandID == SMESHOp::OpExportGMF ||
450 theCommandID == SMESHOp::OpPopupExportGMF );
452 const bool multiMeshSupported = ( isMED || isCGNS ); // file can hold several meshes
453 if ( selected.Extent() == 0 || ( selected.Extent() > 1 && !multiMeshSupported ))
455 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
456 bool aCheckWarn = true;
458 aCheckWarn = resMgr->booleanValue( "SMESH", "show_warning", false );
459 // get mesh object from selection and check duplication of their names
460 bool hasDuplicatedMeshNames = false;
461 QList< QPair< SMESH::SMESH_IDSource_var, QString > > aMeshList;
462 QList< QPair< SMESH::SMESH_IDSource_var, QString > >::iterator aMeshIter;
463 SALOME_ListIteratorOfListIO It( selected );
464 for( ; It.More(); It.Next() )
466 Handle(SALOME_InteractiveObject) anIObject = It.Value();
467 SMESH::SMESH_IDSource_var aMeshItem =
468 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIObject);
469 if ( aMeshItem->_is_nil() ) {
470 SUIT_MessageBox::warning( SMESHGUI::desktop(),
471 QObject::tr( "SMESH_WRN_WARNING" ),
472 QObject::tr( "SMESH_BAD_MESH_SELECTION" ));
475 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( aMeshItem );
476 if ( aCheckWarn && !aGroup->_is_nil() )
478 QMessageBox msgBox(SUIT_MessageBox::Warning,
479 QObject::tr("SMESH_WRN_WARNING"),
480 QObject::tr("SMESH_EXPORT_ONLY_GPOUP"),
481 QMessageBox::StandardButton::NoButton,
482 SMESHGUI::desktop());
483 QCheckBox dontShowCheckBox(QObject::tr("SMESH_WRN_SHOW_DLG_CHECKBOX"));
484 msgBox.addButton(QMessageBox::Ok);
485 msgBox.addButton(QMessageBox::Cancel);
486 msgBox.setDefaultButton(QMessageBox::Cancel);
487 QGridLayout* lt = qobject_cast<QGridLayout*>(msgBox.layout());
488 QDialogButtonBox* btnbox = msgBox.findChild<QDialogButtonBox*>();
489 lt->addWidget(&dontShowCheckBox, lt->rowCount(), lt->columnCount()-1, lt->rowCount(), lt->columnCount());
490 lt->addWidget(btnbox, lt->rowCount(), 0, lt->rowCount(), lt->columnCount());
491 if ( msgBox.exec() != QMessageBox::Ok )
494 if ( dontShowCheckBox.checkState() == Qt::Checked && resMgr )
495 resMgr->setValue( "SMESH", "show_warning", false);
498 QString aMeshName = anIObject->getName();
500 // check for name duplications
501 if ( !hasDuplicatedMeshNames )
502 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
503 if( aMeshName == (*aMeshIter).second ) {
504 hasDuplicatedMeshNames = true;
509 aMeshList.append( QPair< SMESH::SMESH_IDSource_var, QString >( aMeshItem, aMeshName ) );
512 if( hasDuplicatedMeshNames && isMED ) {
513 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
514 QObject::tr("SMESH_WRN_WARNING"),
515 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_MESH_NAMES"),
516 QObject::tr("SMESH_BUT_YES"),
517 QObject::tr("SMESH_BUT_NO"), 0, 1);
522 aMeshIter = aMeshList.begin();
523 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
524 SMESH::SMESH_Mesh_var aMesh = aMeshOrGroup->GetMesh();
525 QString aMeshName = (*aMeshIter).second;
527 if ( isMED || isCGNS || isSAUV ) // formats where group names must be unique
529 // check for equal group names within each mesh
530 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
531 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
532 if ( !aMeshItem->_is_nil() && aMeshItem->HasDuplicatedGroupNamesMED()) {
533 int aRet = SUIT_MessageBox::warning
534 (SMESHGUI::desktop(),
535 QObject::tr("SMESH_WRN_WARNING"),
536 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_GRP").arg((*aMeshIter).second),
537 QObject::tr("SMESH_BUT_YES"),
538 QObject::tr("SMESH_BUT_NO"), 0, 1);
545 // Warn the user about presence of not supported elements
547 std::vector< SMESH::EntityType > notSupportedElemTypes, presentNotSupported;
551 notSupportedElemTypes.push_back( SMESH::Entity_0D );
552 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
557 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
558 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
559 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
560 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
561 notSupportedElemTypes.push_back( SMESH::Entity_Pyramid );
562 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
563 notSupportedElemTypes.push_back( SMESH::Entity_0D );
564 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
569 notSupportedElemTypes.push_back( SMESH::Entity_Edge );
570 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Edge );
571 notSupportedElemTypes.push_back( SMESH::Entity_0D );
572 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
577 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
582 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
583 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Triangle );
584 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Quadrangle );
585 notSupportedElemTypes.push_back( SMESH::Entity_TriQuad_Hexa );
586 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
587 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
588 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
589 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
594 notSupportedElemTypes.push_back( SMESH::Entity_0D );
595 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
596 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
597 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Pyramid );
598 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Penta );
599 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Penta );
600 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
601 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
602 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
603 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
605 if ( ! notSupportedElemTypes.empty() )
607 SMESH::long_array_var nbElems = aMeshOrGroup->GetMeshInfo();
608 for ( size_t iType = 0; iType < notSupportedElemTypes.size(); ++iType )
609 if ( nbElems[ notSupportedElemTypes[ iType ]] > 0 )
610 presentNotSupported.push_back( notSupportedElemTypes[ iType ]);
612 if ( !presentNotSupported.empty() )
615 const char* typeMsg[] = {
616 "SMESH_NODES", "SMESH_ELEMS0D","SMESH_EDGES","SMESH_QUADRATIC_EDGES",
617 "SMESH_TRIANGLES", "SMESH_QUADRATIC_TRIANGLES", "SMESH_BIQUADRATIC_TRIANGLES",
618 "SMESH_QUADRANGLES","SMESH_QUADRATIC_QUADRANGLES", "SMESH_BIQUADRATIC_QUADRANGLES",
619 "SMESH_POLYGONS","SMESH_QUADRATIC_POLYGONS",
620 "SMESH_TETRAHEDRA","SMESH_QUADRATIC_TETRAHEDRONS","SMESH_PYRAMIDS",
621 "SMESH_QUADRATIC_PYRAMIDS","SMESH_HEXAHEDRA","SMESH_QUADRATIC_HEXAHEDRONS",
622 "SMESH_TRIQUADRATIC_HEXAHEDRONS","SMESH_PENTAHEDRA","SMESH_QUADRATIC_PENTAHEDRONS",
623 "SMESH_BIQUADRATIC_PENTAHEDRONS",
624 "SMESH_OCTAHEDRA","SMESH_POLYEDRONS","SMESH_QUADRATIC_POLYEDRONS","SMESH_BALLS"
626 // is typeMsg complete? (compilation failure mains that enum SMDSAbs_EntityType changed)
627 const int nbTypes = sizeof( typeMsg ) / sizeof( const char* );
628 int _assert[( nbTypes == SMESH::Entity_Last ) ? 2 : -1 ]; _assert[0]=_assert[1]=0;
630 QString andStr = " " + QObject::tr("SMESH_AND") + " ", comma(", ");
631 for ( size_t iType = 0; iType < presentNotSupported.size(); ++iType ) {
632 typeNames += QObject::tr( typeMsg[ presentNotSupported[ iType ]]);
633 if ( iType != presentNotSupported.size() - 1 )
634 typeNames += ( iType == presentNotSupported.size() - 2 ) ? andStr : comma;
636 int aRet = SUIT_MessageBox::warning
637 (SMESHGUI::desktop(),
638 QObject::tr("SMESH_WRN_WARNING"),
639 QObject::tr("EXPORT_NOT_SUPPORTED").arg(aMeshName).arg(format).arg(typeNames),
640 QObject::tr("SMESH_BUT_YES"),
641 QObject::tr("SMESH_BUT_NO"), 0, 1);
646 // Get parameters of export operation
649 int aFormat =-1; // for MED version used for write
650 bool isOkToWrite = true; // to check MED file version compatibility before adding a mesh in an existing file
652 // Init the parameters with the default values
653 bool aIsASCII_STL = true;
654 bool toCreateGroups = false;
656 toCreateGroups = resMgr->booleanValue( "SMESH", "auto_groups", false );
657 bool toOverwrite = true;
658 bool toFindOutDim = true;
659 double zTol = resMgr ? resMgr->doubleValue( "SMESH", "med_ztolerance", 0. ) : 0.;
661 QString aFilter, aTitle = QObject::tr("SMESH_EXPORT_MESH");
662 QString anInitialPath = "";
663 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
664 anInitialPath = QDir::currentPath();
666 QList< QPair< GEOM::ListOfFields_var, QString > > aFieldList;
668 // Get a file name to write in and additional options
669 if ( isUNV || isDAT || isGMF ) // Export w/o options
672 aFilter = QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)";
674 aFilter = QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)";
676 aFilter = QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" +
677 ";;" + QObject::tr( "GMF_BINARY_FILES_FILTER" ) + " (*.meshb)";
678 if ( anInitialPath.isEmpty() ) anInitialPath = SUIT_FileDlg::getLastVisitedPath();
679 aFilename = SUIT_FileDlg::getFileName(SMESHGUI::desktop(),
680 anInitialPath + QString("/") + aMeshName,
681 aFilter, aTitle, false);
683 else if ( isCGNS )// Export to CGNS
685 const char* theByTypeResource = "cgns_group_elems_by_type";
686 toCreateGroups = SMESHGUI::resourceMgr()->booleanValue( "SMESH", theByTypeResource, false );
688 QStringList checkBoxes;
689 checkBoxes << QObject::tr("CGNS_EXPORT_ELEMS_BY_TYPE");
691 SalomeApp_CheckFileDlg* fd =
692 new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true );
693 fd->setWindowTitle( aTitle );
694 fd->setNameFilter( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
695 if ( !anInitialPath.isEmpty() )
696 fd->setDirectory( anInitialPath );
697 fd->selectFile(aMeshName);
698 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
699 fd->setValidator( fv );
700 fd->SetChecked( toCreateGroups, 0 );
703 aFilename = fd->selectedFile();
704 toOverwrite = fv->isOverwrite(aFilename);
705 toCreateGroups = fd->IsChecked(0);
706 SMESHGUI::resourceMgr()->setValue("SMESH", theByTypeResource, toCreateGroups );
710 else if ( isSTL ) // Export to STL
712 QMap<QString, int> aFilterMap;
713 aFilterMap.insert( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)", 1 );
714 aFilterMap.insert( QObject::tr( "STL_BIN_FILES_FILTER" ) + " (*.stl)", 0 );
717 QMap<QString, int>::const_iterator it = aFilterMap.begin();
718 for ( ; it != aFilterMap.end(); ++it )
719 filters.push_back( it.key() );
721 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
722 fd->setWindowTitle( aTitle );
723 fd->setNameFilters( filters );
724 fd->selectNameFilter( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
725 if ( !anInitialPath.isEmpty() )
726 fd->setDirectory( anInitialPath );
727 fd->selectFile(aMeshName);
731 aFilename = fd->selectedFile();
732 aIsASCII_STL = (aFilterMap[fd->selectedNameFilter()]) == 1 ? true: false;
737 else if ( isMED || isSAUV ) // Export to MED or SAUV
739 int defaultVersion = 0;
740 QMap<QString, int> aFilterMap;
742 //filters << QObject::tr( "MED_FILES_FILTER" ) + " (*.med)";
743 //QString vmed (aMesh->GetVersionString(-1, 2));
744 SMESH::long_array_var mvok = aMesh->GetMEDVersionsCompatibleForAppend();
745 if ( mvok->length() > 0)
746 defaultVersion = mvok[0]; // the current version to set the default filter on it
747 for ( CORBA::ULong i = 0; i < mvok->length(); ++i )
749 QString vs = (char*)( SMESH_Comment( mvok[i]/10 ) << "." << mvok[i]%10 );
750 MESSAGE("MED version: " << vs.toStdString());
751 aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( vs ) + " (*.med)", mvok[i]);
755 aFilterMap.insert("All files (*)", -1 );
756 aFilterMap.insert("SAUV files (*.sauv)", defaultVersion ); // 0 = default filter (defaultVersion)
757 aFilterMap.insert("SAUV files (*.sauve)", -1 );
760 QMap<QString, int>::const_iterator it = aFilterMap.begin();
761 QString aDefaultFilter = it.key();
762 for ( ; it != aFilterMap.end(); ++it ) {
763 filters.push_back( it.key() );
764 if (it.value() == defaultVersion) // explicit default for MED = current MED version
765 aDefaultFilter = it.key();
767 QStringList checkBoxes;
768 checkBoxes << QObject::tr("SMESH_AUTO_GROUPS") << QObject::tr("SMESH_AUTO_DIM");
770 SMESHGUI_FieldSelectorWdg* fieldSelWdg = new SMESHGUI_FieldSelectorWdg();
771 QList< QWidget* > wdgList;
772 if ( fieldSelWdg->GetAllFields( aMeshList, aFieldList ))
773 wdgList.append( fieldSelWdg );
775 QWidget* zTolWdg = new QWidget();
776 QCheckBox* zTolCheck = new QCheckBox( QObject::tr( "SMESH_ZTOLERANCE" ), zTolWdg );
777 SMESHGUI_SpinBox* zTolSpin = new SMESHGUI_SpinBox( zTolWdg );
778 QHBoxLayout* zTolLayout = new QHBoxLayout( zTolWdg );
779 zTolLayout->addWidget( zTolCheck );
780 zTolLayout->addWidget( zTolSpin );
781 zTolLayout->setMargin( 0 );
782 zTolSpin->RangeStepAndValidator( 0, 1e+100, 1., "length_precision" );
783 zTolSpin->setValue( zTol );
784 QObject::connect( zTolCheck, SIGNAL( toggled(bool)), zTolSpin, SLOT( setEnabled(bool)));
785 zTolCheck->setChecked( resMgr->booleanValue( "SMESH", "enable_ztolerance", false ));
786 zTolSpin ->setEnabled( zTolCheck->isChecked() );
787 wdgList.append( zTolWdg );
789 SalomeApp_CheckFileDlg* fd =
790 new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true, wdgList );
791 fd->setWindowTitle( aTitle );
792 fd->setNameFilters( filters );
793 fd->selectNameFilter( aDefaultFilter );
794 fd->SetChecked( toCreateGroups, 0 );
795 fd->SetChecked( toFindOutDim, 1 );
796 if ( !anInitialPath.isEmpty() )
797 fd->setDirectory( anInitialPath );
798 fd->selectFile(aMeshName);
801 QListView *lview = fd->findChild<QListView*>("listView");
803 lview->setMinimumHeight(200);
805 QTreeView *tview = fd->findChild<QTreeView*>("treeView");
807 tview->setMinimumHeight(200);
810 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
811 fd->setValidator( fv );
816 //MESSAGE("******* Loop on file dialog ***********");
819 aFilename = fd->selectedFile();
821 aFilename = QString::null;
824 aFormat = aFilterMap[fd->selectedNameFilter()];
825 //MESSAGE("selected version: " << aFormat << " file: " << aFilename.toUtf8().constData());
826 toOverwrite = fv->isOverwrite(aFilename);
827 //MESSAGE("toOverwrite:" << toOverwrite);
829 if ( !aFilename.isEmpty() ) {
831 // append is only possible if the existing file format is compatible
832 bool isVersionOk = SMESHGUI::GetSMESHGen()->CheckWriteCompatibility( aFilename.toUtf8().constData() );
833 MESSAGE("Append check, isVersionOk:" << isVersionOk);
834 if ( !isVersionOk ) {
835 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
836 QObject::tr("SMESH_WRN_WARNING"),
837 QObject::tr("SMESH_EXPORT_MED_VERSION_COLLISION").arg(aFilename),
838 QObject::tr("SMESH_BUT_YES"),
839 QObject::tr("SMESH_BUT_NO"), 0, 1);
843 //MESSAGE("incompatible MED file version for add, overwrite accepted");
849 //MESSAGE("incompatible MED file version for add, overwrite refused");
852 QStringList aMeshNamesCollisionList;
853 SMESH::string_array_var aMeshNames = SMESHGUI::GetSMESHGen()->GetMeshNames( aFilename.toUtf8().constData() );
854 for( int i = 0, n = aMeshNames->length(); i < n; i++ ) {
855 QString anExistingMeshName( aMeshNames[ i ] );
856 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
857 QString anExportMeshName = (*aMeshIter).second;
858 if( anExportMeshName == anExistingMeshName ) {
859 aMeshNamesCollisionList.append( anExportMeshName );
864 if( !aMeshNamesCollisionList.isEmpty() ) {
866 QString aMeshNamesCollisionString = aMeshNamesCollisionList.join( ", " );
867 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
868 QObject::tr("SMESH_WRN_WARNING"),
869 QObject::tr("SMESH_EXPORT_MED_MESH_NAMES_COLLISION").arg(aMeshNamesCollisionString),
870 QObject::tr("SMESH_BUT_YES"),
871 QObject::tr("SMESH_BUT_NO"),
872 QObject::tr("SMESH_BUT_CANCEL"), 0, 2);
873 MESSAGE("answer collision name " << aRet);
884 toCreateGroups = fd->IsChecked(0);
885 toFindOutDim = fd->IsChecked(1);
886 zTol = zTolCheck->isChecked() ? zTolSpin->value() : -1;
887 fieldSelWdg->GetSelectedFields();
888 if ( resMgr ) resMgr->setValue( "SMESH", "enable_ztolerance", zTolCheck->isChecked() );
890 if ( !fieldSelWdg->parent() )
892 if ( !zTolWdg->parent() )
903 if ( !aFilename.isEmpty() ) {
904 // Check whether the file already exists and delete it if yes
905 QFile aFile( aFilename );
906 if ( aFile.exists() && toOverwrite )
908 SUIT_OverrideCursor wc;
911 // Renumbering is not needed since SMDS redesign in V6.2.0 (Nov 2010)
912 // bool Renumber = false;
913 // // PAL 14172 : Check of we have to renumber or not from the preferences before export
915 // Renumber= resMgr->booleanValue("renumbering");
917 // SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
918 // aMeshEditor->RenumberNodes();
919 // aMeshEditor->RenumberElements();
920 // if ( SMESHGUI::automaticUpdate() )
921 // SMESH::UpdateView();
923 if ( isMED && isOkToWrite)
925 MESSAGE("OK to write MED file "<< aFilename.toUtf8().constData());
926 aMeshIter = aMeshList.begin();
927 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
929 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
930 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
931 const GEOM::ListOfFields& fields = aFieldList[ aMeshIndex ].first.in();
932 const QString& geoAssFields = aFieldList[ aMeshIndex ].second;
933 const bool hasFields = ( fields.length() || !geoAssFields.isEmpty() );
934 if ( !hasFields && aMeshOrGroup->_is_equivalent( aMeshItem ) && zTol < 0 )
935 aMeshItem->ExportMED( aFilename.toUtf8().data(), toCreateGroups, aFormat,
936 toOverwrite && aMeshIndex == 0, toFindOutDim );
938 aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toUtf8().data(),
939 toCreateGroups, aFormat,
940 toOverwrite && aMeshIndex == 0, toFindOutDim,
941 fields, geoAssFields.toLatin1().data(), zTol );
946 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ )
948 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
949 if( !aMeshItem->_is_nil() )
950 aMeshItem->ExportSAUV( aFilename.toUtf8().data(), toCreateGroups );
955 if ( aMeshOrGroup->_is_equivalent( aMesh ))
956 aMesh->ExportDAT( aFilename.toUtf8().data() );
958 aMesh->ExportPartToDAT( aMeshOrGroup, aFilename.toUtf8().data() );
962 if ( aMeshOrGroup->_is_equivalent( aMesh ))
963 aMesh->ExportUNV( aFilename.toUtf8().data() );
965 aMesh->ExportPartToUNV( aMeshOrGroup, aFilename.toUtf8().data() );
969 if ( aMeshOrGroup->_is_equivalent( aMesh ))
970 aMesh->ExportSTL( aFilename.toUtf8().data(), aIsASCII_STL );
972 aMesh->ExportPartToSTL( aMeshOrGroup, aFilename.toUtf8().data(), aIsASCII_STL );
976 aMeshIter = aMeshList.begin();
977 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
979 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
980 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
981 aMeshItem->ExportCGNS( aMeshOrGroup,
982 aFilename.toUtf8().data(),
983 toOverwrite && aMeshIndex == 0,
989 toCreateGroups = true;
990 aMesh->ExportGMF( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups );
993 catch (const SALOME::SALOME_Exception& S_ex){
995 SUIT_MessageBox::warning(SMESHGUI::desktop(),
996 QObject::tr("SMESH_WRN_WARNING"),
997 QObject::tr("SMESH_EXPORT_FAILED") + SalomeApp_Tools::ExceptionToString(S_ex));
1003 inline void InverseEntityMode(unsigned int& theOutputMode,
1004 unsigned int theMode)
1006 bool anIsNotPresent = ~theOutputMode & theMode;
1008 theOutputMode |= theMode;
1010 theOutputMode &= ~theMode;
1013 void SetDisplayEntity(int theCommandID)
1015 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1016 SALOME_ListIO selected;
1018 aSel->selectedObjects( selected );
1020 if ( selected.Extent() >= 1 ) {
1021 SUIT_OverrideCursor wc;
1022 SALOME_ListIteratorOfListIO It( selected );
1023 for( ; It.More(); It.Next()){
1024 Handle(SALOME_InteractiveObject) IObject = It.Value();
1025 if(IObject->hasEntry()){
1026 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1027 unsigned int aMode = anActor->GetEntityMode();
1028 switch(theCommandID){
1029 case SMESHOp::OpDE0DElements: InverseEntityMode(aMode,SMESH_Actor::e0DElements); break;
1030 case SMESHOp::OpDEEdges: InverseEntityMode(aMode,SMESH_Actor::eEdges); break;
1031 case SMESHOp::OpDEFaces: InverseEntityMode(aMode,SMESH_Actor::eFaces); break;
1032 case SMESHOp::OpDEVolumes: InverseEntityMode(aMode,SMESH_Actor::eVolumes); break;
1033 case SMESHOp::OpDEBalls: InverseEntityMode(aMode,SMESH_Actor::eBallElem); break;
1034 case SMESHOp::OpDEAllEntity: aMode = SMESH_Actor::eAllEntity; break;
1037 anActor->SetEntityMode(aMode);
1046 SalomeApp_Application* app =
1047 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1051 LightApp_SelectionMgr* aSel = app->selectionMgr();
1052 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1053 if ( !aSel || !appStudy )
1056 SALOME_ListIO selected;
1057 aSel->selectedObjects( selected );
1058 if ( selected.IsEmpty() )
1061 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1063 _PTR(Study) aStudy = appStudy->studyDS();
1064 _PTR(SObject) aMainSObject = aStudy->FindObjectID( anIObject->getEntry() );
1065 SMESH::SMESH_Mesh_var aMainObject = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1066 if ( aMainObject->_is_nil() )
1069 SUIT_OverrideCursor wc;
1071 aMainObject->SetAutoColor( true ); // mesh groups are re-colored here
1073 QList<SALOMEDS::Color> aReservedColors;
1075 SMESH::ListOfGroups aListOfGroups = *aMainObject->GetGroups();
1076 for ( int i = 0, n = aListOfGroups.length(); i < n; i++ )
1078 SMESH::SMESH_GroupBase_var aGroupObject = aListOfGroups[i];
1080 #ifdef SIMPLE_AUTOCOLOR // simplified algorithm for auto-colors
1081 SALOMEDS::Color aColor = SMESHGUI::getPredefinedUniqueColor();
1082 #else // old algorithm for auto-colors
1083 SALOMEDS::Color aColor = SMESHGUI::getUniqueColor( aReservedColors );
1084 aReservedColors.append( aColor );
1085 #endif // SIMPLE_AUTOCOLOR
1086 aGroupObject->SetColor( aColor );
1088 _PTR(SObject) aGroupSObject = SMESH::FindSObject(aGroupObject);
1089 if ( aGroupSObject ) {
1092 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry(aGroupSObject->GetID().c_str())) {
1093 switch ( aGroupObject->GetType ()) {
1095 anActor->SetNodeColor( aColor.R, aColor.G, aColor.B ); break;
1097 anActor->SetEdgeColor( aColor.R, aColor.G, aColor.B ); break;
1099 anActor->Set0DColor( aColor.R, aColor.G, aColor.B ); break;
1101 anActor->SetBallColor( aColor.R, aColor.G, aColor.B ); break;
1103 SMESH::GetColor("SMESH", "volume_color", c, delta, "255,0,170|-100");
1104 anActor->SetVolumeColor( aColor.R, aColor.G, aColor.B, delta ); break;
1107 SMESH::GetColor("SMESH", "fill_color", c, delta, "0,170,255|-100");
1108 anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B, delta );
1114 SMESH::RepaintCurrentView();
1117 void OverallMeshQuality()
1119 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1120 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1121 SALOME_ListIO selected;
1123 aSel->selectedObjects( selected );
1125 if ( selected.IsEmpty() ) return;
1126 SALOME_ListIteratorOfListIO It( selected );
1127 for ( ; It.More(); It.Next() ) {
1128 SMESHGUI_CtrlInfoDlg* ctrlDlg = new SMESHGUI_CtrlInfoDlg( SMESHGUI::desktop() );
1129 ctrlDlg->showInfo( It.Value() );
1134 QString functorToString( SMESH::Controls::FunctorPtr f )
1136 QString type = QObject::tr( "UNKNOWN_CONTROL" );
1137 if ( dynamic_cast< SMESH::Controls::Volume* >( f.get() ) )
1138 type = QObject::tr( "VOLUME_3D_ELEMENTS" );
1139 else if ( dynamic_cast< SMESH::Controls::MaxElementLength2D* >( f.get() ) )
1140 type = QObject::tr( "MAX_ELEMENT_LENGTH_2D" );
1141 else if ( dynamic_cast< SMESH::Controls::MaxElementLength3D* >( f.get() ) )
1142 type = QObject::tr( "MAX_ELEMENT_LENGTH_3D" );
1143 else if ( dynamic_cast< SMESH::Controls::MinimumAngle* >( f.get() ) )
1144 type = QObject::tr( "MINIMUMANGLE_ELEMENTS" );
1145 else if ( dynamic_cast< SMESH::Controls::AspectRatio* >( f.get() ) )
1146 type = QObject::tr( "ASPECTRATIO_ELEMENTS" );
1147 else if ( dynamic_cast< SMESH::Controls::AspectRatio3D* >( f.get() ) )
1148 type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" );
1149 else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) )
1150 type = QObject::tr( "WARP_ELEMENTS" );
1151 else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) )
1152 type = QObject::tr( "TAPER_ELEMENTS" );
1153 else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) )
1154 type = QObject::tr( "SKEW_ELEMENTS" );
1155 else if ( dynamic_cast< SMESH::Controls::Area* >( f.get() ) )
1156 type = QObject::tr( "AREA_ELEMENTS" );
1157 else if ( dynamic_cast< SMESH::Controls::Length* >( f.get() ) )
1158 type = QObject::tr( "LENGTH_EDGES" );
1159 else if ( dynamic_cast< SMESH::Controls::Length2D* >( f.get() ) )
1160 type = QObject::tr( "LENGTH2D_EDGES" );
1161 else if ( dynamic_cast< SMESH::Controls::Deflection2D* >( f.get() ) )
1162 type = QObject::tr( "DEFLECTION2D_FACES" );
1163 else if ( dynamic_cast< SMESH::Controls::MultiConnection* >( f.get() ) )
1164 type = QObject::tr( "MULTI_BORDERS" );
1165 else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) )
1166 type = QObject::tr( "MULTI2D_BORDERS" );
1167 else if ( dynamic_cast< SMESH::Controls::FreeNodes* >( f.get() ) )
1168 type = QObject::tr( "FREE_NODES" );
1169 else if ( dynamic_cast< SMESH::Controls::FreeEdges* >( f.get() ) )
1170 type = QObject::tr( "FREE_EDGES" );
1171 else if ( dynamic_cast< SMESH::Controls::FreeBorders* >( f.get() ) )
1172 type = QObject::tr( "FREE_BORDERS" );
1173 else if ( dynamic_cast< SMESH::Controls::FreeFaces* >( f.get() ) )
1174 type = QObject::tr( "FREE_FACES" );
1175 else if ( dynamic_cast< SMESH::Controls::BareBorderVolume* >( f.get() ) )
1176 type = QObject::tr( "BARE_BORDER_VOLUME" );
1177 else if ( dynamic_cast< SMESH::Controls::BareBorderFace* >( f.get() ) )
1178 type = QObject::tr( "BARE_BORDER_FACE" );
1179 else if ( dynamic_cast< SMESH::Controls::OverConstrainedVolume* >( f.get() ) )
1180 type = QObject::tr( "OVER_CONSTRAINED_VOLUME" );
1181 else if ( dynamic_cast< SMESH::Controls::OverConstrainedFace* >( f.get() ) )
1182 type = QObject::tr( "OVER_CONSTRAINED_FACE" );
1183 else if ( dynamic_cast< SMESH::Controls::CoincidentNodes* >( f.get() ) )
1184 type = QObject::tr( "EQUAL_NODE" );
1185 else if ( dynamic_cast< SMESH::Controls::CoincidentElements1D* >( f.get() ) )
1186 type = QObject::tr( "EQUAL_EDGE" );
1187 else if ( dynamic_cast< SMESH::Controls::CoincidentElements2D* >( f.get() ) )
1188 type = QObject::tr( "EQUAL_FACE" );
1189 else if ( dynamic_cast< SMESH::Controls::CoincidentElements3D* >( f.get() ) )
1190 type = QObject::tr( "EQUAL_VOLUME" );
1191 else if ( dynamic_cast< SMESH::Controls::NodeConnectivityNumber* >( f.get() ) )
1192 type = QObject::tr( "NODE_CONNECTIVITY_NB" );
1196 void SaveDistribution()
1198 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1199 SALOME_ListIO selected;
1201 aSel->selectedObjects( selected );
1203 if ( selected.Extent() == 1 ) {
1204 Handle(SALOME_InteractiveObject) anIO = selected.First();
1205 if ( anIO->hasEntry() ) {
1206 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1208 anActor->GetScalarBarActor() &&
1209 anActor->GetControlMode() != SMESH_Actor::eNone )
1211 SMESH_ScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor();
1212 SMESH::Controls::FunctorPtr aFunctor = anActor->GetFunctor();
1213 if ( aScalarBarActor && aFunctor ) {
1214 SMESH::Controls::NumericalFunctor* aNumFun =
1215 dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
1217 std::vector<int> elements;
1218 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
1219 if ( mesh->_is_nil() ) {
1220 SMESH::SMESH_IDSource_var idSource =
1221 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
1222 if ( !idSource->_is_nil() )
1224 SMESH::long_array_var ids = idSource->GetIDs();
1225 elements.resize( ids->length() );
1226 for ( unsigned i = 0; i < elements.size(); ++i )
1227 elements[i] = ids[i];
1230 int nbIntervals = aScalarBarActor->GetMaximumNumberOfColors();
1231 vtkLookupTable* lookupTable =
1232 static_cast<vtkLookupTable*>(aScalarBarActor->GetLookupTable());
1233 double * minmax = lookupTable->GetRange();
1234 bool isLogarithmic = lookupTable->GetScale() == VTK_SCALE_LOG10;
1235 std::vector<int> nbEvents;
1236 std::vector<double> funValues;
1237 aNumFun->GetHistogram( nbIntervals, nbEvents, funValues,
1238 elements, minmax, isLogarithmic );
1239 QString anInitialPath = "";
1240 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
1241 anInitialPath = QDir::currentPath();
1242 QString aMeshName = anIO->getName();
1244 filter.append( QObject::tr( "TEXT_FILES_FILTER" ) + " (*.txt)" );
1245 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
1246 QString aFilename = anInitialPath + "/" + aMeshName + "_" +
1247 functorToString( aFunctor ).toLower().simplified().replace( QRegExp( " |-" ), "_" ) + ".txt";
1248 aFilename = SUIT_FileDlg::getFileName( SMESHGUI::desktop(),
1251 QObject::tr( "SMESH_SAVE_DISTRIBUTION" ),
1253 if ( !aFilename.isEmpty() ) {
1254 QFile f( aFilename );
1255 if ( f.open( QFile::WriteOnly | QFile::Truncate ) ) {
1256 QTextStream out( &f );
1257 out << "# Mesh: " << aMeshName << endl;
1258 out << "# Control: " << functorToString( aFunctor ) << endl;
1260 out.setFieldWidth( 10 );
1261 for ( int i = 0; i < (int)qMin( nbEvents.size(), funValues.size()-1 ); i++ )
1262 out << funValues[i] << "\t" << funValues[i+1] << "\t" << nbEvents[i] << endl;
1273 void ShowElement( int theCommandID )
1275 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1276 SALOME_ListIO selected;
1278 aSel->selectedObjects( selected );
1280 if ( selected.Extent() == 1 ) {
1281 Handle(SALOME_InteractiveObject) anIO = selected.First();
1282 if ( anIO->hasEntry() ) {
1283 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1285 anActor->GetScalarBarActor() &&
1286 anActor->GetControlMode() != SMESH_Actor::eNone )
1288 SMESH_ScalarBarActor *aScalarBarActor = anActor->GetScalarBarActor();
1289 if ( theCommandID == SMESHOp::OpShowDistribution ) {
1290 aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility());
1292 else if ( theCommandID == SMESHOp::OpShowScalarBar ) {
1293 aScalarBarActor->SetVisibility( !aScalarBarActor->GetVisibility());
1300 #ifndef DISABLE_PLOT2DVIEWER
1301 void PlotDistribution()
1303 SalomeApp_Application* app =
1304 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1308 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1309 SALOME_ListIO selected;
1311 aSel->selectedObjects( selected );
1313 if ( selected.Extent() == 1 ) {
1314 Handle(SALOME_InteractiveObject) anIO = selected.First();
1315 if ( anIO->hasEntry() ) {
1316 //Find Actor by entry before getting Plot2d viewer,
1317 //because after call getViewManager( Plot2d_Viewer::Type(), true ) active window is Plot2d Viewer
1318 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1320 SUIT_ViewManager* aViewManager =
1321 app->getViewManager( Plot2d_Viewer::Type(), true ); // create if necessary
1325 SPlot2d_Viewer* aView = dynamic_cast<SPlot2d_Viewer*>(aViewManager->getViewModel());
1329 Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
1333 if ( anActor && anActor->GetControlMode() != SMESH_Actor::eNone )
1335 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1336 QString functorName = functorToString( anActor->GetFunctor());
1337 QString aHistogramName("%1 : %2");
1338 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1339 aHistogram->setName(aHistogramName);
1340 aHistogram->setHorTitle(functorName);
1341 aHistogram->setVerTitle(QObject::tr("DISTRIBUTION_NB_ENT"));
1342 aPlot->displayObject(aHistogram, true);
1347 #endif //DISABLE_PLOT2DVIEWER
1349 void DisableAutoColor()
1351 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1352 SALOME_ListIO selected;
1354 aSel->selectedObjects( selected );
1356 if ( selected.Extent() ) {
1357 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1358 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1359 if ( !aMesh->_is_nil() ) {
1360 aMesh->SetAutoColor( false );
1367 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1368 SALOME_ListIO selected;
1370 aSel->selectedObjects( selected );
1371 if ( selected.Extent() )
1373 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1374 _PTR(Study) aStudy = SMESH::getStudy();
1375 _PTR(SObject) aSObj = aStudy->FindObjectID(anIObject->getEntry());
1377 if ( aStudy->GetUseCaseBuilder()->SortChildren( aSObj, true/*AscendingOrder*/ ) ) {
1378 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1385 void SetDisplayMode(int theCommandID, VTK::MarkerMap& theMarkerMap)
1387 SALOME_ListIO selected;
1388 SalomeApp_Application* app =
1389 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1393 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1394 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1395 if ( !aSel || !appStudy )
1398 if ( theCommandID == SMESHOp::OpClipping ) { // Clipping dialog can be activated without selection
1399 if ( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
1400 aModule->EmitSignalDeactivateDialog();
1401 if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
1402 (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
1407 aSel->selectedObjects( selected );
1409 if ( selected.Extent() >= 1 )
1411 switch ( theCommandID ) {
1412 case SMESHOp::OpTransparency:
1414 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1415 (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
1418 case SMESHOp::OpProperties:
1421 QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
1422 QColor orientationColor, outlineColor, volumeColor;
1423 int deltaF = 0, deltaV = 0;
1426 double ballScale = 1.0;
1428 int outlineWidth = 1;
1429 double shrinkCoef = 0.0;
1430 double orientationScale = 0.0;
1431 bool orientation3d = false;
1432 VTK::MarkerType markerType = VTK::MT_NONE;
1433 VTK::MarkerScale markerScale = VTK::MS_NONE;
1435 bool hasNodes = false;
1436 int presentEntities = 0;
1437 bool firstTime = true;
1439 SALOME_ListIteratorOfListIO It( selected );
1440 for ( ; It.More(); It.Next() ) {
1441 Handle(SALOME_InteractiveObject) IObject = It.Value();
1442 if ( !IObject->hasEntry() ) continue;
1443 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1444 if ( !anActor || !anActor->GetObject() ) continue;
1447 // nodes: color, marker
1448 anActor->GetNodeColor( color[0], color[1], color[2] );
1449 nodeColor.setRgbF( color[0], color[1], color[2] );
1450 markerType = anActor->GetMarkerType();
1451 markerScale = anActor->GetMarkerScale();
1452 markerId = anActor->GetMarkerTexture();
1453 // edges: color, width
1454 anActor->GetEdgeColor( color[0], color[1], color[2] );
1455 edgeColor.setRgbF( color[0], color[1], color[2] );
1456 edgeWidth = qMax( (int)anActor->GetLineWidth(), 1 ); // minimum allowed width is 1
1457 // faces: front color, back color (delta)
1458 anActor->GetSufaceColor( color[0], color[1], color[2], deltaF );
1459 faceColor.setRgbF( color[0], color[1], color[2] );
1460 // faces: front color, back color (delta)
1461 anActor->GetVolumeColor( color[0], color[1], color[2], deltaV );
1462 volumeColor.setRgbF( color[0], color[1], color[2] );
1463 // 0d elements: color, size
1464 anActor->Get0DColor( color[0], color[1], color[2] );
1465 elem0dColor.setRgbF( color[0], color[1], color[2] );
1466 elem0dSize = qMax( (int)anActor->Get0DSize(), 1 ); // minimum allowed size is 1
1467 // balls: color, size
1468 anActor->GetBallColor( color[0], color[1], color[2] );
1469 ballColor.setRgbF( color[0], color[1], color[2] );
1470 //ballSize = qMax( (int)anActor->GetBallSize(), 1 ); // minimum allowed size is 1
1471 ballScale = qMax( (double)anActor->GetBallScale(), 1e-2 ); // minimum allowed scale is 1e-2
1473 anActor->GetOutlineColor( color[0], color[1], color[2] );
1474 outlineColor.setRgbF( color[0], color[1], color[2] );
1475 outlineWidth = qMax( (int)anActor->GetOutlineWidth(), 1 ); // minimum allowed width is 1
1476 // orientation vectors: color, scale, 3d flag
1477 anActor->GetFacesOrientationColor( color[0], color[1], color[2] );
1478 orientationColor.setRgbF( color[0], color[1], color[2] );
1479 orientationScale = anActor->GetFacesOrientationScale();
1480 orientation3d = anActor->GetFacesOrientation3DVectors();
1482 shrinkCoef = anActor->GetShrinkFactor();
1485 firstTime = false; // we only take properties from first object (for performance reasons)
1488 hasNodes = anActor->GetObject()->GetNbEntities( SMDSAbs_Node );
1489 if ( !(presentEntities & SMESH_Actor::eEdges) && anActor->GetObject()->GetNbEntities( SMDSAbs_Edge ) )
1490 presentEntities = presentEntities | SMESH_Actor::eEdges;
1491 if ( !(presentEntities & SMESH_Actor::eFaces) && anActor->GetObject()->GetNbEntities( SMDSAbs_Face ) )
1492 presentEntities = presentEntities | SMESH_Actor::eFaces;
1493 if ( !(presentEntities & SMESH_Actor::eVolumes) && anActor->GetObject()->GetNbEntities( SMDSAbs_Volume ) )
1494 presentEntities = presentEntities | SMESH_Actor::eVolumes;
1495 if ( !(presentEntities & SMESH_Actor::e0DElements) && anActor->GetObject()->GetNbEntities( SMDSAbs_0DElement ) )
1496 presentEntities = presentEntities | SMESH_Actor::e0DElements;
1497 if ( !(presentEntities & SMESH_Actor::eBallElem) && anActor->GetObject()->GetNbEntities( SMDSAbs_Ball ) )
1498 presentEntities = presentEntities | SMESH_Actor::eBallElem;
1500 // as we know that all types of elements are present, we can exit the loop
1501 if ( presentEntities == SMESH_Actor::eAllEntity )
1505 SMESHGUI_PropertiesDlg dlg( theMarkerMap, SMESHGUI::desktop() );
1506 // nodes: color, marker
1507 dlg.setNodeColor( nodeColor );
1508 if( markerType != VTK::MT_USER )
1509 dlg.setNodeMarker( markerType, markerScale );
1511 dlg.setNodeCustomMarker( markerId );
1512 // edges: color, line width
1513 dlg.setEdgeColor( edgeColor );
1514 dlg.setEdgeWidth( edgeWidth );
1515 // faces: front color, back color
1516 dlg.setFaceColor( faceColor, deltaF );
1517 // volumes: normal color, reversed color
1518 dlg.setVolumeColor( volumeColor, deltaV );
1519 // outlines: color, line width
1520 dlg.setOutlineColor( outlineColor );
1521 dlg.setOutlineWidth( outlineWidth );
1522 // 0d elements: color, size
1523 dlg.setElem0dColor( elem0dColor );
1524 dlg.setElem0dSize( elem0dSize );
1525 // balls: color, size
1526 dlg.setBallColor( ballColor );
1527 //dlg.setBallSize( ballSize );
1528 dlg.setBallScale( ballScale );
1529 // orientation: color, scale, 3d flag
1530 dlg.setOrientationColor( orientationColor );
1531 dlg.setOrientationSize( int( orientationScale * 100. ) );
1532 dlg.setOrientation3d( orientation3d );
1533 // shrink: scale factor
1534 dlg.setShrinkCoef( int( shrinkCoef * 100. ) );
1535 // hide unused controls
1536 dlg.showControls( presentEntities, hasNodes );
1539 nodeColor = dlg.nodeColor();
1540 markerType = dlg.nodeMarkerType();
1541 markerScale = dlg.nodeMarkerScale();
1542 markerId = dlg.nodeMarkerId();
1543 edgeColor = dlg.edgeColor();
1544 edgeWidth = dlg.edgeWidth();
1545 faceColor = dlg.faceColor();
1546 deltaF = dlg.faceColorDelta();
1547 volumeColor = dlg.volumeColor();
1548 deltaV = dlg.volumeColorDelta();
1549 outlineColor = dlg.outlineColor();
1550 outlineWidth = dlg.outlineWidth();
1551 elem0dColor = dlg.elem0dColor();
1552 elem0dSize = dlg.elem0dSize();
1553 ballColor = dlg.ballColor();
1554 // ballSize = dlg.ballSize();
1555 ballScale = dlg.ballScale();
1556 orientationColor = dlg.orientationColor();
1557 orientationScale = dlg.orientationSize() / 100.;
1558 orientation3d = dlg.orientation3d();
1559 shrinkCoef = dlg.shrinkCoef() / 100.;
1561 // store point markers that might be changed by the user
1562 theMarkerMap = dlg.customMarkers();
1564 // set properties from dialog box to the presentations
1565 SALOME_ListIteratorOfListIO It( selected );
1566 for ( ; It.More(); It.Next() ) {
1567 Handle(SALOME_InteractiveObject) IObject = It.Value();
1568 if ( !IObject->hasEntry() ) continue;
1569 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1570 if ( !anActor ) continue;
1572 // nodes: color, marker
1573 anActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
1574 if ( markerType != VTK::MT_USER ) {
1575 anActor->SetMarkerStd( markerType, markerScale );
1578 VTK::MarkerMap::const_iterator iter = theMarkerMap.find( markerId );
1579 if ( iter != theMarkerMap.end() )
1580 anActor->SetMarkerTexture( markerId, iter->second.second );
1582 // volumes: normal color, reversed color (delta)
1583 anActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
1584 // faces: front color, back color (delta)
1585 anActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
1586 // edges: color, width
1587 anActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
1588 anActor->SetLineWidth( edgeWidth );
1590 anActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
1591 anActor->SetOutlineWidth( outlineWidth );
1592 // 0D elements: color, size
1593 anActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
1594 anActor->Set0DSize( elem0dSize );
1595 // balls: color, size
1596 anActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
1597 // anActor->SetBallSize( ballSize );
1598 anActor->SetBallScale( ballScale );
1599 // orientation: color, scale, 3d flag
1600 anActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
1601 anActor->SetFacesOrientationScale( orientationScale );
1602 anActor->SetFacesOrientation3DVectors( orientation3d );
1604 anActor->SetShrinkFactor( shrinkCoef );
1606 // for groups, set also proper color
1607 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1608 if ( !aGroupObject->_is_nil() ) {
1609 SMESH::ElementType anElementType = aGroupObject->GetType();
1611 switch( anElementType ) {
1613 aColor = nodeColor; break;
1615 aColor = edgeColor; break;
1617 aColor = faceColor; break;
1619 aColor = volumeColor; break;
1621 aColor = elem0dColor; break;
1623 aColor = ballColor; break;
1627 if ( aColor.isValid() ) {
1628 SALOMEDS::Color aGroupColor;
1629 aGroupColor.R = aColor.redF();
1630 aGroupColor.G = aColor.greenF();
1631 aGroupColor.B = aColor.blueF();
1632 aGroupObject->SetColor( aGroupColor );
1634 } // if ( !aGroupObject->_is_nil() )
1635 } // for ( ; It.More(); It.Next() )
1636 SMESH::RepaintCurrentView();
1637 } // if ( dlg.exec() )
1639 } // case SMESHOp::OpProperties:
1640 } // switch(theCommandID)
1641 SUIT_OverrideCursor wc;
1642 SALOME_ListIteratorOfListIO It( selected );
1643 for( ; It.More(); It.Next()){
1644 Handle(SALOME_InteractiveObject) IObject = It.Value();
1645 if(IObject->hasEntry()){
1646 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1647 switch(theCommandID){
1648 case SMESHOp::OpDMWireframe:
1649 anActor->SetRepresentation(SMESH_Actor::eEdge);
1651 case SMESHOp::OpDMShading:
1652 anActor->SetRepresentation(SMESH_Actor::eSurface);
1654 case SMESHOp::OpDMShrink:
1655 if(anActor->IsShrunk())
1656 anActor->UnShrink();
1658 anActor->SetShrink();
1660 case SMESHOp::OpDMNodes:
1661 anActor->SetRepresentation(SMESH_Actor::ePoint);
1663 case SMESHOp::OpRepresentationLines:
1664 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1665 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1667 case SMESHOp::OpRepresentationArcs:
1668 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1669 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1675 SMESH::RepaintCurrentView();
1679 int ActionToControl( int theID, bool theReversed )
1681 NCollection_DoubleMap<int,int> ActionControl;
1682 ActionControl.Bind( 0, SMESH_Actor::eNone );
1683 ActionControl.Bind( SMESHOp::OpFreeNode, SMESH_Actor::eFreeNodes );
1684 ActionControl.Bind( SMESHOp::OpEqualNode, SMESH_Actor::eCoincidentNodes );
1685 ActionControl.Bind( SMESHOp::OpNodeConnectivityNb, SMESH_Actor::eNodeConnectivityNb );
1686 ActionControl.Bind( SMESHOp::OpFreeEdge, SMESH_Actor::eFreeEdges );
1687 ActionControl.Bind( SMESHOp::OpFreeBorder, SMESH_Actor::eFreeBorders );
1688 ActionControl.Bind( SMESHOp::OpLength, SMESH_Actor::eLength );
1689 ActionControl.Bind( SMESHOp::OpConnection, SMESH_Actor::eMultiConnection );
1690 ActionControl.Bind( SMESHOp::OpEqualEdge, SMESH_Actor::eCoincidentElems1D );
1691 ActionControl.Bind( SMESHOp::OpFreeFace, SMESH_Actor::eFreeFaces );
1692 ActionControl.Bind( SMESHOp::OpBareBorderFace, SMESH_Actor::eBareBorderFace );
1693 ActionControl.Bind( SMESHOp::OpOverConstrainedFace, SMESH_Actor::eOverConstrainedFace );
1694 ActionControl.Bind( SMESHOp::OpLength2D, SMESH_Actor::eLength2D );
1695 ActionControl.Bind( SMESHOp::OpDeflection2D, SMESH_Actor::eDeflection2D );
1696 ActionControl.Bind( SMESHOp::OpConnection2D, SMESH_Actor::eMultiConnection2D );
1697 ActionControl.Bind( SMESHOp::OpArea, SMESH_Actor::eArea );
1698 ActionControl.Bind( SMESHOp::OpTaper, SMESH_Actor::eTaper );
1699 ActionControl.Bind( SMESHOp::OpAspectRatio, SMESH_Actor::eAspectRatio );
1700 ActionControl.Bind( SMESHOp::OpMinimumAngle, SMESH_Actor::eMinimumAngle );
1701 ActionControl.Bind( SMESHOp::OpWarpingAngle, SMESH_Actor::eWarping );
1702 ActionControl.Bind( SMESHOp::OpSkew, SMESH_Actor::eSkew );
1703 ActionControl.Bind( SMESHOp::OpMaxElementLength2D, SMESH_Actor::eMaxElementLength2D );
1704 ActionControl.Bind( SMESHOp::OpEqualFace, SMESH_Actor::eCoincidentElems2D );
1705 ActionControl.Bind( SMESHOp::OpAspectRatio3D, SMESH_Actor::eAspectRatio3D );
1706 ActionControl.Bind( SMESHOp::OpVolume, SMESH_Actor::eVolume3D );
1707 ActionControl.Bind( SMESHOp::OpMaxElementLength3D, SMESH_Actor::eMaxElementLength3D );
1708 ActionControl.Bind( SMESHOp::OpBareBorderVolume, SMESH_Actor::eBareBorderVolume );
1709 ActionControl.Bind( SMESHOp::OpOverConstrainedVolume, SMESH_Actor::eOverConstrainedVolume );
1710 ActionControl.Bind( SMESHOp::OpEqualVolume, SMESH_Actor::eCoincidentElems3D );
1713 return ActionControl.IsBound2( theID ) ? ActionControl.Find2( theID ) : 0;
1714 return ActionControl.IsBound1( theID ) ? ActionControl.Find1( theID ) : 0;
1717 void Control( int theCommandID )
1719 SMESH_Actor::eControl aControl = SMESH_Actor::eControl( ActionToControl( theCommandID ));
1720 _PTR(Study) aStudy = SMESH::getStudy();
1722 SALOME_ListIO selected;
1723 if ( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
1724 aSel->selectedObjects( selected );
1726 if ( !selected.IsEmpty() ) {
1727 SALOME_ListIteratorOfListIO It(selected);
1728 for ( ; It.More(); It.Next())
1730 Handle(SALOME_InteractiveObject) anIO = It.Value();
1731 if ( !anIO.IsNull() ) {
1732 _PTR(SObject) SO = aStudy->FindObjectID( It.Value()->getEntry() );
1734 CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
1735 SMESH::SMESH_IDSource_var anIDSrc = SMESH::SMESH_IDSource::_narrow( aObject );
1736 if ( !anIDSrc->_is_nil() ) {
1737 SMESH_Actor *anActor = SMESH::FindActorByEntry( anIO->getEntry());
1738 if (( !anActor && selected.Extent() == 1 ) &&
1739 ( anActor = SMESH::CreateActor( anIO->getEntry() )))
1741 anActor->SetControlMode( aControl );
1742 SMESH::DisplayActor( SMESH::GetCurrentVtkView(), anActor );
1743 SMESH::UpdateView ( SMESH::eDisplay, anIO->getEntry() );
1747 if ( anActor->GetControlMode() != aControl )
1748 anActor->SetControlMode( aControl );
1749 QString functorName = functorToString( anActor->GetFunctor() );
1750 int anEntitiesCount = anActor->GetNumberControlEntities();
1751 if (anEntitiesCount >= 0)
1752 functorName = functorName + ": " + QString::number(anEntitiesCount);
1753 anActor->GetScalarBarActor()->SetTitle( functorName.toUtf8().constData() );
1754 SMESH::RepaintCurrentView();
1755 #ifndef DISABLE_PLOT2DVIEWER
1756 if ( anActor->GetPlot2Histogram() ) {
1757 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1758 QString aHistogramName("%1 : %2");
1759 aHistogramName = aHistogramName.arg( anIO->getName() ).arg( functorName );
1760 aHistogram->setName( aHistogramName );
1761 aHistogram->setHorTitle( functorName );
1762 SMESH::ProcessIn2DViewers( anActor );
1774 bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1775 SMESH::MeshObjectType theType,
1776 const QString theInTypeName,
1777 QString & theOutTypeName)
1779 SMESH_TypeFilter aTypeFilter( theType );
1781 if ( !theIO.IsNull() )
1783 entry = theIO->getEntry();
1784 LightApp_DataOwner owner( entry );
1785 if ( aTypeFilter.isOk( &owner )) {
1786 theOutTypeName = theInTypeName;
1794 QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1796 _PTR(Study) aStudy = SMESH::getStudy();
1797 _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1799 _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1800 CORBA::String_var anID = aSComp->GetID().c_str();
1801 if ( !strcmp(anID.in(),theIO->getEntry()) )
1807 CheckOIType ( theIO, SMESH::HYPOTHESIS, "Hypothesis", aTypeName ) ||
1808 CheckOIType ( theIO, SMESH::ALGORITHM, "Algorithm", aTypeName ) ||
1809 CheckOIType ( theIO, SMESH::MESH, "Mesh", aTypeName ) ||
1810 CheckOIType ( theIO, SMESH::SUBMESH, "SubMesh", aTypeName ) ||
1811 CheckOIType ( theIO, SMESH::GROUP, "Group", aTypeName )
1819 // QString CheckHomogeneousSelection()
1821 // LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1822 // SALOME_ListIO selected;
1824 // aSel->selectedObjects( selected );
1826 // QString RefType = CheckTypeObject(selected.First());
1827 // SALOME_ListIteratorOfListIO It(selected);
1828 // for ( ; It.More(); It.Next())
1830 // Handle(SALOME_InteractiveObject) IObject = It.Value();
1831 // QString Type = CheckTypeObject(IObject);
1832 // if ( Type.compare(RefType) != 0 )
1833 // return "Heterogeneous Selection";
1839 uint randomize( uint size )
1841 static bool initialized = false;
1842 if ( !initialized ) {
1843 qsrand( QDateTime::currentDateTime().toTime_t() );
1847 v = uint( (double)( v ) / RAND_MAX * size );
1848 v = qMax( uint(0), qMin ( v, size-1 ) );
1854 void SMESHGUI::OnEditDelete()
1856 // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1857 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1858 SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1860 _PTR(Study) aStudy = SMESH::getStudy();
1861 _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1862 _PTR(GenericAttribute) anAttr;
1863 _PTR(AttributeIOR) anIOR;
1865 const int objectCountLimit = 30; // PAL23599
1866 int objectCount = 0;
1868 QString aParentComponent = QString::null;
1870 for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1872 Handle(SALOME_InteractiveObject) anIO = anIt.Value();
1873 if ( anIO.IsNull() ) continue;
1875 QString father = "unknown", name;
1877 _PTR(SObject) aSO = aStudy->FindObjectID( anIO->getEntry() );
1879 father = QString::fromStdString( aSO->GetFatherComponent()->ComponentDataType() );
1880 // check if object is reference
1881 _PTR(SObject) aRefSObj;
1882 if ( aSO->ReferencedObject( aRefSObj ) ) {
1883 name = QString::fromStdString ( aRefSObj->GetName() );
1884 father = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1887 name = anIO->getName();
1890 if ( objectCount < objectCountLimit ) { // avoid occupying the whole screen
1891 aNameList.append("\n - ");
1892 aNameList.append( name );
1895 if( aParentComponent.isNull() )
1896 aParentComponent = father;
1897 else if( !aParentComponent.isEmpty() && aParentComponent!=father )
1898 aParentComponent = "";
1900 if ( objectCount >= objectCountLimit )
1901 aNameList.append("\n - ...");
1903 if ( objectCount == 0 )
1904 return; // No Valid Objects Selected
1906 if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
1907 SUIT_MessageBox::warning( SMESHGUI::desktop(),
1908 QObject::tr("ERR_ERROR"),
1909 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
1912 // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
1913 if (SUIT_MessageBox::warning
1914 (SMESHGUI::desktop(),
1915 QObject::tr("SMESH_WRN_WARNING"),
1916 QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
1917 SUIT_MessageBox::Yes | SUIT_MessageBox::No,
1918 SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
1921 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1923 // Put one level of sub-objects of the selected SO's into a list
1924 // in order to get objects inside folders like "Assigned Algorithms"
1925 std::list< _PTR(SObject) > listSO;
1926 SALOME_ListIteratorOfListIO It(selected);
1927 for( ; It.More(); It.Next()) // loop on selected IO's
1929 Handle(SALOME_InteractiveObject) IObject = It.Value();
1930 if(IObject->hasEntry()) {
1931 _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
1933 // disable removal of "SMESH" component object
1934 if(aSO->FindAttribute(anAttr, "AttributeIOR")){
1936 if ( engineIOR() == anIOR->Value().c_str() )
1939 //Check the referenced object
1940 _PTR(SObject) aRefSObject;
1941 if ( aSO && aSO->ReferencedObject( aRefSObject ) )
1942 aSO = aRefSObject; // Delete main Object instead of reference
1944 listSO.push_back( aSO );
1946 _PTR(ChildIterator) it = aStudy->NewChildIterator( aSO );
1947 for (it->InitEx(false); it->More(); it->Next())
1948 listSO.push_back( it->Value() );
1951 // Check if none of objects to delete is referred from outside
1952 std::list< _PTR(SObject) >::reverse_iterator ritSO;
1953 std::vector< _PTR(SObject) > subSO;
1954 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1956 _PTR(SObject) SO = *ritSO;
1957 if ( !SO ) continue;
1959 int nbChildren = SO->GetLastChildTag();
1961 subSO.reserve( 1 + nbChildren );
1962 subSO.push_back( SO );
1963 if ( nbChildren > 0 )
1965 _PTR(ChildIterator) it = aStudy->NewChildIterator( SO );
1966 for ( it->InitEx( true ); it->More(); it->Next() )
1967 subSO.push_back( it->Value() );
1969 for ( size_t i = 0; i < subSO.size(); ++i )
1971 std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( subSO[i] );
1972 for ( size_t j = 0; j < aReferences.size(); j++ ) {
1973 _PTR(SComponent) aComponent = aReferences[j]->GetFatherComponent();
1974 std::string type = aComponent->ComponentDataType();
1975 if ( type != "SMESH" )
1977 SUIT_MessageBox::warning( anApp->desktop(),
1978 QObject::tr("WRN_WARNING"),
1979 QObject::tr("DEP_OBJECT") );
1980 return; // outside SMESH, there is an object depending on a SMESH object
1986 // Treat SO's in the list starting from the back
1987 aStudyBuilder->NewCommand(); // There is a transaction
1988 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1990 _PTR(SObject) SO = *ritSO;
1991 if ( !SO ) continue;
1992 std::string anEntry = SO->GetID();
1994 /** Erase graphical object and remove all its data **/
1995 if ( SO->FindAttribute( anAttr, "AttributeIOR" )) {
1996 SMESH::RemoveVisualObjectWithActors( anEntry.c_str(), true);
1998 /** Remove an object from data structures **/
1999 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
2000 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
2001 if ( !aGroup->_is_nil() ) { // DELETE GROUP
2002 SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
2003 aMesh->RemoveGroup( aGroup );
2005 else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
2006 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2007 aMesh->RemoveSubMesh( aSubMesh );
2010 Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
2011 ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
2012 QString objType = CheckTypeObject(IObject);
2013 if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
2014 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
2015 aStudyBuilder->RemoveObjectWithChildren( SO );
2017 else {// default action: remove SObject from the study
2018 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
2019 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
2021 aStudyBuilder->RemoveObjectWithChildren( SO );
2025 } /* listSO back loop */
2027 aStudyBuilder->CommitCommand();
2029 /* Clear any previous selection */
2031 aSel->setSelectedObjects( l1 );
2033 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
2037 SMESHGUI_EXPORT CAM_Module* createModule()
2039 return new SMESHGUI();
2042 SMESHGUI_EXPORT char* getModuleVersion() {
2043 return (char*)SMESH_VERSION_STR;
2047 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
2049 //=============================================================================
2053 //=============================================================================
2054 SMESHGUI::SMESHGUI() :
2055 SalomeApp_Module( "SMESH" )
2057 if ( CORBA::is_nil( myComponentSMESH ) )
2059 CORBA::Boolean anIsEmbeddedMode;
2060 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
2061 //MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
2063 // 0019923: EDF 765 SMESH : default values of hypothesis
2064 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
2065 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
2066 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
2067 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
2068 myComponentSMESH->SetDefaultNbSegments( nbSeg );
2070 const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif", "default_grp_color" };
2071 for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
2072 if ( aResourceMgr->hasValue( "SMESH", options[i] ))
2074 QString val = aResourceMgr->stringValue( "SMESH", options[i] );
2075 myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
2079 myActiveDialogBox = 0;
2080 myFilterLibraryDlg = 0;
2084 myEventCallbackCommand = vtkCallbackCommand::New();
2085 myEventCallbackCommand->Delete();
2086 myEventCallbackCommand->SetClientData( this );
2087 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
2090 /* load resources for all available meshers */
2091 SMESH::InitAvailableHypotheses();
2094 //=============================================================================
2098 //=============================================================================
2099 SMESHGUI::~SMESHGUI()
2103 //=============================================================================
2107 //=============================================================================
2108 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
2110 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2112 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
2117 //=============================================================================
2121 //=============================================================================
2122 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
2124 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2128 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2129 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2130 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2131 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2132 return autoUpdate && !exceeded;
2135 //=============================================================================
2139 //=============================================================================
2140 bool SMESHGUI::automaticUpdate( SMESH::SMESH_IDSource_ptr theMesh,
2141 int* entities, bool* limitExceeded, int* hidden, long* nbElements )
2143 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2147 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2148 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2149 bool incrementalLimit = resMgr->booleanValue( "SMESH", "incremental_limit", false );
2151 SMESH::long_array_var info = theMesh->GetMeshInfo();
2152 long nbOdElems = info[SMDSEntity_0D];
2153 long nbEdges = info[SMDSEntity_Edge] + info[SMDSEntity_Quad_Edge];
2154 long nbFaces = info[SMDSEntity_Triangle] + info[SMDSEntity_Quad_Triangle] + info[SMDSEntity_BiQuad_Triangle] +
2155 info[SMDSEntity_Quadrangle] + info[SMDSEntity_Quad_Quadrangle] + info[SMDSEntity_BiQuad_Quadrangle] +
2156 info[SMDSEntity_Polygon] + info[SMDSEntity_Quad_Polygon];
2157 long nbVolumes = info[SMDSEntity_Tetra] + info[SMDSEntity_Quad_Tetra] +
2158 info[SMDSEntity_Hexa] + info[SMDSEntity_Quad_Hexa] + info[SMDSEntity_TriQuad_Hexa] +
2159 info[SMDSEntity_Pyramid] + info[SMDSEntity_Quad_Pyramid] +
2160 info[SMDSEntity_Penta] + info[SMDSEntity_Quad_Penta] + info[SMDSEntity_BiQuad_Penta] +
2161 info[SMDSEntity_Polyhedra] +
2162 info[SMDSEntity_Hexagonal_Prism];
2163 long nbBalls = info[SMDSEntity_Ball];
2165 long requestedSize = nbOdElems + nbBalls + nbEdges + nbFaces + nbVolumes;
2166 *nbElements = requestedSize;
2168 *entities = SMESH_Actor::eAllEntity;
2171 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2173 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2175 if ( incrementalLimit ) {
2178 if ( nbOdElems > 0 ) {
2179 if ( total + nbOdElems > updateLimit ) {
2180 *entities = *entities & ~SMESH_Actor::e0DElements;
2181 *hidden = *hidden | SMESH_Actor::e0DElements;
2188 if ( nbEdges > 0 ) {
2189 if ( total + nbEdges > updateLimit ) {
2190 *entities = *entities & ~SMESH_Actor::eEdges;
2191 *hidden = *hidden | SMESH_Actor::eEdges;
2198 if ( nbFaces > 0 ) {
2199 if ( total + nbFaces > updateLimit ) {
2200 *entities = *entities & ~SMESH_Actor::eFaces;
2201 *hidden = *hidden | SMESH_Actor::eFaces;
2208 if ( nbVolumes > 0 ) {
2209 if ( total + nbVolumes > updateLimit ) {
2210 *entities = *entities & ~SMESH_Actor::eVolumes;
2211 *hidden = *hidden | SMESH_Actor::eVolumes;
2218 if ( nbBalls > 0 ) {
2219 if ( total + nbBalls > updateLimit ) {
2220 *entities = *entities & ~SMESH_Actor::eBallElem;
2221 *hidden = *hidden | SMESH_Actor::eBallElem;
2229 return autoUpdate && !exceeded;
2232 //=============================================================================
2236 //=============================================================================
2237 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
2239 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
2242 //=============================================================================
2246 //=============================================================================
2247 SMESHGUI* SMESHGUI::GetSMESHGUI()
2249 SMESHGUI* smeshMod = 0;
2250 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
2253 CAM_Module* module = app->module( "Mesh" );
2254 smeshMod = dynamic_cast<SMESHGUI*>( module );
2262 Standard_EXPORT SMESHGUI* GetComponentGUI()
2264 return SMESHGUI::GetSMESHGUI();
2268 //=============================================================================
2272 //=============================================================================
2273 void SMESHGUI::SetState(int aState)
2278 //=============================================================================
2282 //=============================================================================
2283 void SMESHGUI::ResetState()
2288 //=============================================================================
2292 //=============================================================================
2293 void SMESHGUI::EmitSignalDeactivateDialog()
2295 emit SignalDeactivateActiveDialog();
2298 //=============================================================================
2302 //=============================================================================
2303 void SMESHGUI::EmitSignalStudyFrameChanged()
2305 emit SignalStudyFrameChanged();
2308 //=============================================================================
2312 //=============================================================================
2313 void SMESHGUI::EmitSignalCloseAllDialogs()
2315 emit SignalCloseAllDialogs();
2318 //=============================================================================
2322 //=============================================================================
2323 void SMESHGUI::EmitSignalVisibilityChanged()
2325 emit SignalVisibilityChanged();
2328 //=============================================================================
2332 //=============================================================================
2333 void SMESHGUI::EmitSignalCloseView()
2335 emit SignalCloseView();
2338 //=============================================================================
2342 //=============================================================================
2343 void SMESHGUI::EmitSignalActivatedViewManager()
2345 emit SignalActivatedViewManager();
2348 //=============================================================================
2352 //=============================================================================
2353 QDialog *SMESHGUI::GetActiveDialogBox()
2355 return myActiveDialogBox;
2358 //=============================================================================
2362 //=============================================================================
2363 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2365 myActiveDialogBox = (QDialog *) aDlg;
2369 //=============================================================================
2373 //=============================================================================
2374 SUIT_Desktop* SMESHGUI::desktop()
2376 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2378 return app->desktop();
2383 //=============================================================================
2387 //=============================================================================
2388 SalomeApp_Study* SMESHGUI::activeStudy()
2390 SUIT_Application* app = SUIT_Session::session()->activeApplication();
2392 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2397 //=============================================================================
2401 //=============================================================================
2402 void SMESHGUI::Modified( bool theIsUpdateActions )
2404 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2405 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2406 appStudy->Modified();
2407 if( theIsUpdateActions )
2408 app->updateActions();
2413 //=============================================================================
2417 //=============================================================================
2418 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2420 /* Here the position is on the bottom right corner - 10 */
2421 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2423 SUIT_Desktop *PP = desktop();
2424 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2425 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2430 * \brief Verifies whether study of operation is locked
2431 * \param theMess - specifies whether message box must be shown if study is locked
2432 * \return State of study.
2434 * Verifies whether study of operation is locked. If second parameter is TRUE and study
2435 * is locked when corresponding message box appears
2437 bool SMESHGUI::isStudyLocked( bool theMessage )
2439 if ( SMESH::getStudy()->GetProperties()->IsLocked() )
2442 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2443 QObject::tr( "WRN_WARNING" ),
2444 QObject::tr( "WRN_STUDY_LOCKED" ) );
2450 //=============================================================================
2454 //=============================================================================
2455 bool SMESHGUI::OnGUIEvent( int theCommandID )
2457 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2461 SUIT_ResourceMgr* mgr = resourceMgr();
2465 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2466 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2468 //QAction* act = action( theCommandID );
2470 switch (theCommandID) {
2471 case SMESHOp::OpDelete:
2472 if(isStudyLocked()) break;
2475 case SMESHOp::OpImportDAT:
2476 case SMESHOp::OpImportUNV:
2477 case SMESHOp::OpImportMED:
2478 case SMESHOp::OpImportSTL:
2479 case SMESHOp::OpImportCGNS:
2480 case SMESHOp::OpImportSAUV:
2481 case SMESHOp::OpImportGMF:
2482 case SMESHOp::OpPopupImportDAT:
2483 case SMESHOp::OpPopupImportUNV:
2484 case SMESHOp::OpPopupImportMED:
2485 case SMESHOp::OpPopupImportSTL:
2486 case SMESHOp::OpPopupImportCGNS:
2487 case SMESHOp::OpPopupImportSAUV:
2488 case SMESHOp::OpPopupImportGMF:
2490 if(isStudyLocked()) break;
2491 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2495 case SMESHOp::OpFileInformation:
2497 SALOME_ListIO selected;
2498 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2500 aSel->selectedObjects( selected );
2501 if( selected.Extent() )
2503 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2504 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2505 if ( !aMesh->_is_nil() )
2507 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2513 case SMESHOp::OpExportDAT:
2514 case SMESHOp::OpExportMED:
2515 case SMESHOp::OpExportUNV:
2516 case SMESHOp::OpExportSTL:
2517 case SMESHOp::OpExportCGNS:
2518 case SMESHOp::OpExportSAUV:
2519 case SMESHOp::OpExportGMF:
2520 case SMESHOp::OpPopupExportDAT:
2521 case SMESHOp::OpPopupExportMED:
2522 case SMESHOp::OpPopupExportUNV:
2523 case SMESHOp::OpPopupExportSTL:
2524 case SMESHOp::OpPopupExportCGNS:
2525 case SMESHOp::OpPopupExportSAUV:
2526 case SMESHOp::OpPopupExportGMF:
2528 ::ExportMeshToFile(theCommandID);
2532 case SMESHOp::OpReset: // SCALAR BAR
2534 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2535 SALOME_ListIO selected;
2537 aSel->selectedObjects( selected );
2539 SALOME_ListIteratorOfListIO it(selected);
2540 for( ; it.More(); it.Next()) {
2541 Handle(SALOME_InteractiveObject) anIO = it.Value();
2542 if( anIO->hasEntry() ) {
2543 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2544 anActor->SetControlMode( SMESH_Actor::eNone );
2545 #ifndef DISABLE_PLOT2DVIEWER
2546 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2548 anActor->UpdateFilter();
2552 SMESH::UpdateView();
2555 case SMESHOp::OpScalarBarProperties:
2557 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2560 case SMESHOp::OpShowScalarBar:
2562 // show/hide scalar bar
2563 ::ShowElement(theCommandID);
2566 case SMESHOp::OpSaveDistribution:
2568 // dump control distribution data to the text file
2569 ::SaveDistribution();
2573 case SMESHOp::OpShowDistribution:
2575 // show/hide distribution
2576 ::ShowElement(theCommandID);
2580 #ifndef DISABLE_PLOT2DVIEWER
2581 case SMESHOp::OpPlotDistribution:
2583 // plot distribution
2584 ::PlotDistribution();
2590 case SMESHOp::OpAutoColor:
2594 case SMESHOp::OpDisableAutoColor:
2595 ::DisableAutoColor();
2598 case SMESHOp::OpClipping:
2599 case SMESHOp::OpTransparency:
2600 case SMESHOp::OpProperties: // Display preferences (colors, shrink size, line width, ...)
2603 case SMESHOp::OpDMWireframe:
2604 case SMESHOp::OpDMShading:
2605 case SMESHOp::OpDMNodes:
2606 case SMESHOp::OpDMShrink:
2607 ::SetDisplayMode(theCommandID, myMarkerMap);
2610 //2D quadratic representation
2611 case SMESHOp::OpRepresentationLines:
2612 case SMESHOp::OpRepresentationArcs:
2613 ::SetDisplayMode(theCommandID, myMarkerMap);
2617 case SMESHOp::OpDE0DElements:
2618 case SMESHOp::OpDEEdges:
2619 case SMESHOp::OpDEFaces:
2620 case SMESHOp::OpDEVolumes:
2621 case SMESHOp::OpDEBalls:
2622 case SMESHOp::OpDEAllEntity:
2623 ::SetDisplayEntity(theCommandID);
2626 // Choose entities to be displayed
2627 case SMESHOp::OpDEChoose:
2629 ( new SMESHGUI_DisplayEntitiesDlg( SMESHGUI::desktop() ) )->exec();
2633 case SMESHOp::OpOrientationOnFaces:
2635 SUIT_OverrideCursor wc;
2636 LightApp_SelectionMgr* mgr = selectionMgr();
2637 SALOME_ListIO selected; mgr->selectedObjects( selected );
2639 SALOME_ListIteratorOfListIO it(selected);
2640 for( ; it.More(); it.Next()) {
2641 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2642 if(anIObject->hasEntry()) {
2643 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2644 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2651 case SMESHOp::OpUpdate:
2653 if(isStudyLocked()) break;
2654 SUIT_OverrideCursor wc;
2657 SMESH::UpdateView();
2659 catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2660 SMESH::OnVisuException();
2662 catch (...) { // PAL16774 (Crash after display of many groups)
2663 SMESH::OnVisuException();
2667 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2668 aSel->selectedObjects( l );
2669 aSel->setSelectedObjects( l );
2673 case SMESHOp::OpHide:
2674 case SMESHOp::OpShow:
2675 case SMESHOp::OpShowOnly:
2677 SUIT_OverrideCursor wc;
2678 SMESH::EDisplaing anAction;
2679 switch (theCommandID) {
2680 case SMESHOp::OpHide: anAction = SMESH::eErase; break;
2681 case SMESHOp::OpShow: anAction = SMESH::eDisplay; break;
2682 case SMESHOp::OpShowOnly: anAction = SMESH::eDisplayOnly; break;
2685 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2686 SALOME_ListIO sel_objects, to_process;
2688 aSel->selectedObjects( sel_objects );
2690 if ( theCommandID==SMESHOp::OpShowOnly )
2692 //MESSAGE("anAction = SMESH::eDisplayOnly");
2693 startOperation( myEraseAll );
2696 extractContainers( sel_objects, to_process );
2701 SALOME_ListIteratorOfListIO It( to_process );
2702 for ( ; It.More(); It.Next())
2704 Handle(SALOME_InteractiveObject) IOS = It.Value();
2705 if ( IOS->hasEntry() )
2707 if ( !SMESH::UpdateView( anAction, IOS->getEntry() )) {
2708 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2709 break; // PAL16774 (Crash after display of many groups)
2711 if (anAction == SMESH::eDisplayOnly)
2712 anAction = SMESH::eDisplay;
2717 // PAL13338 + PAL15161 -->
2718 if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !isStudyLocked()) {
2719 SMESH::UpdateView();
2720 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2722 // PAL13338 + PAL15161 <--
2724 catch (...) { // PAL16774 (Crash after display of many groups)
2725 SMESH::OnVisuException();
2728 if (anAction == SMESH::eErase) {
2730 aSel->setSelectedObjects( l1 );
2733 aSel->setSelectedObjects( to_process );
2735 if ( vtkwnd && vtkwnd->GetRenderer() && !isStudyLocked() &&
2736 ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) )
2737 vtkwnd->GetRenderer()->AdjustActors();
2742 case SMESHOp::OpNode:
2744 if(isStudyLocked()) break;
2747 EmitSignalDeactivateDialog();
2749 ( new SMESHGUI_NodesDlg( this ) )->show();
2752 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"),tr("SMESH_WRN_VIEWER_VTK"));
2757 case SMESHOp::OpCreateMesh:
2758 case SMESHOp::OpCreateSubMesh:
2759 case SMESHOp::OpEditMeshOrSubMesh:
2760 case SMESHOp::OpEditMesh:
2761 case SMESHOp::OpEditSubMesh:
2762 case SMESHOp::OpCompute:
2763 case SMESHOp::OpComputeSubMesh:
2764 case SMESHOp::OpPreCompute:
2765 case SMESHOp::OpEvaluate:
2766 case SMESHOp::OpMeshOrder:
2767 startOperation( theCommandID );
2769 case SMESHOp::OpCopyMesh:
2771 if (isStudyLocked()) break;
2772 EmitSignalDeactivateDialog();
2773 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2776 case SMESHOp::OpBuildCompoundMesh:
2778 if (isStudyLocked()) break;
2779 EmitSignalDeactivateDialog();
2780 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2784 case SMESHOp::OpDiagonalInversion:
2785 case SMESHOp::OpUnionOfTwoTriangle:
2789 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2793 if ( isStudyLocked() )
2796 /*Standard_Boolean aRes;
2797 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2798 if ( aMesh->_is_nil() )
2800 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2801 tr( "SMESH_BAD_SELECTION" ) );
2805 EmitSignalDeactivateDialog();
2806 if ( theCommandID == SMESHOp::OpDiagonalInversion )
2807 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2809 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2812 case SMESHOp::OpOrientation:
2813 case SMESHOp::OpUnionOfTriangles:
2814 case SMESHOp::OpCuttingOfQuadrangles:
2815 case SMESHOp::OpSplitVolumes:
2819 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2823 if ( isStudyLocked() )
2826 EmitSignalDeactivateDialog();
2827 SMESHGUI_MultiEditDlg* aDlg = NULL;
2828 if ( theCommandID == SMESHOp::OpOrientation )
2829 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2830 else if ( theCommandID == SMESHOp::OpUnionOfTriangles )
2831 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2832 else if ( theCommandID == SMESHOp::OpSplitVolumes )
2833 aDlg = new SMESHGUI_SplitVolumesDlg(this);
2835 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2840 case SMESHOp::OpSmoothing:
2842 if(isStudyLocked()) break;
2844 EmitSignalDeactivateDialog();
2845 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2848 SUIT_MessageBox::warning(desktop(), tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2852 case SMESHOp::OpExtrusion:
2854 if (isStudyLocked()) break;
2856 EmitSignalDeactivateDialog();
2857 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2859 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2863 case SMESHOp::OpExtrusionAlongAPath:
2865 if (isStudyLocked()) break;
2867 EmitSignalDeactivateDialog();
2868 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2870 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2874 case SMESHOp::OpRevolution:
2876 if(isStudyLocked()) break;
2878 EmitSignalDeactivateDialog();
2879 ( new SMESHGUI_RevolutionDlg( this ) )->show();
2882 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2886 case SMESHOp::OpPatternMapping:
2888 if ( isStudyLocked() )
2892 EmitSignalDeactivateDialog();
2893 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2896 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2900 case SMESHOp::OpSplitBiQuadratic:
2901 case SMESHOp::OpConvertMeshToQuadratic:
2902 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
2903 case SMESHOp::OpReorientFaces:
2904 case SMESHOp::OpCreateGeometryGroup:
2906 startOperation( theCommandID );
2909 case SMESHOp::OpCreateGroup:
2913 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2917 if(isStudyLocked()) break;
2918 EmitSignalDeactivateDialog();
2919 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2921 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2922 SALOME_ListIO selected;
2924 aSel->selectedObjects( selected );
2926 int nbSel = selected.Extent();
2928 // check if mesh is selected
2929 aMesh = SMESH::GetMeshByIO( selected.First() );
2931 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2936 case SMESHOp::OpConstructGroup:
2940 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2944 if(isStudyLocked()) break;
2945 EmitSignalDeactivateDialog();
2947 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2948 SALOME_ListIO selected;
2950 aSel->selectedObjects( selected );
2952 int nbSel = selected.Extent();
2954 // check if submesh is selected
2955 Handle(SALOME_InteractiveObject) IObject = selected.First();
2956 if (IObject->hasEntry()) {
2957 _PTR(SObject) aSObj = SMESH::getStudy()->FindObjectID(IObject->getEntry());
2959 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2960 if (!aSubMesh->_is_nil()) {
2962 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2963 // get submesh elements list by types
2964 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2965 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2966 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2967 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2968 // create group for each type o elements
2969 QString aName = IObject->getName();
2970 QStringList anEntryList;
2971 if (aNodes->length() > 0) {
2972 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2973 aGroup->Add(aNodes.inout());
2974 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2975 anEntryList.append( aSObject->GetID().c_str() );
2977 if (aEdges->length() > 0) {
2978 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2979 aGroup->Add(aEdges.inout());
2980 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2981 anEntryList.append( aSObject->GetID().c_str() );
2983 if (aFaces->length() > 0) {
2984 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2985 aGroup->Add(aFaces.inout());
2986 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2987 anEntryList.append( aSObject->GetID().c_str() );
2989 if (aVolumes->length() > 0) {
2990 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2991 aGroup->Add(aVolumes.inout());
2992 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2993 anEntryList.append( aSObject->GetID().c_str() );
2996 anApp->browseObjects( anEntryList );
2998 catch(const SALOME::SALOME_Exception & S_ex){
2999 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3006 SUIT_MessageBox::warning(desktop(),
3007 tr("SMESH_WRN_WARNING"),
3008 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
3013 case SMESHOp::OpEditGroup:
3017 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3021 if(isStudyLocked()) break;
3022 EmitSignalDeactivateDialog();
3024 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3025 SALOME_ListIO selected;
3027 aSel->selectedObjects( selected );
3029 SALOME_ListIteratorOfListIO It (selected);
3030 int nbSelectedGroups = 0;
3031 for ( ; It.More(); It.Next() )
3033 SMESH::SMESH_GroupBase_var aGroup =
3034 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
3035 if (!aGroup->_is_nil()) {
3037 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
3041 if (nbSelectedGroups == 0)
3043 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
3049 case SMESHOp::OpAddElemGroupPopup: // Add elements to group
3051 if(isStudyLocked()) break;
3052 if (myState == 800) {
3053 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3054 if (aDlg) aDlg->onAdd();
3059 case SMESHOp::OpRemoveElemGroupPopup: // Remove elements from group
3061 if(isStudyLocked()) break;
3062 if (myState == 800) {
3063 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3064 if (aDlg) aDlg->onRemove();
3069 case SMESHOp::OpEditGeomGroupAsGroup:
3073 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3077 if(isStudyLocked()) break;
3078 EmitSignalDeactivateDialog();
3080 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3081 SALOME_ListIO selected;
3083 aSel->selectedObjects( selected );
3085 SALOME_ListIteratorOfListIO It (selected);
3086 for ( ; It.More(); It.Next() )
3088 SMESH::SMESH_GroupOnGeom_var aGroup =
3089 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
3090 if (!aGroup->_is_nil()) {
3091 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3096 SMESH::SMESH_GroupOnFilter_var aGroup =
3097 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
3098 if (!aGroup->_is_nil()) {
3099 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3107 case SMESHOp::OpUnionGroups:
3108 case SMESHOp::OpIntersectGroups:
3109 case SMESHOp::OpCutGroups:
3113 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3117 if ( isStudyLocked() )
3120 EmitSignalDeactivateDialog();
3122 SMESHGUI_GroupOpDlg* aDlg = 0;
3123 if ( theCommandID == SMESHOp::OpUnionGroups )
3124 aDlg = new SMESHGUI_UnionGroupsDlg( this );
3125 else if ( theCommandID == SMESHOp::OpIntersectGroups )
3126 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3128 aDlg = new SMESHGUI_CutGroupsDlg( this );
3135 case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
3137 if ( isStudyLocked() )
3140 EmitSignalDeactivateDialog();
3141 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3147 case SMESHOp::OpFaceGroupsByEdges: // Create face groups separated by sharp edges
3149 if ( isStudyLocked() )
3152 EmitSignalDeactivateDialog();
3153 SMESHGUI_FaceGroupsSeparatedByEdgesDlg* aDlg = new SMESHGUI_FaceGroupsSeparatedByEdgesDlg( this );
3159 case SMESHOp::OpDeleteGroup: // Delete groups with their contents
3163 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3167 if ( isStudyLocked() )
3170 EmitSignalDeactivateDialog();
3172 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3176 case SMESHOp::OpMeshInformation:
3177 case SMESHOp::OpWhatIs:
3179 int page = theCommandID == SMESHOp::OpMeshInformation ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3180 EmitSignalDeactivateDialog();
3181 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3182 SALOME_ListIO selected;
3184 aSel->selectedObjects( selected );
3186 if ( selected.Extent() > 1 ) { // a dlg for each IO
3187 SALOME_ListIteratorOfListIO It( selected );
3188 for ( ; It.More(); It.Next() ) {
3189 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3190 dlg->showInfo( It.Value() );
3195 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3201 case SMESHOp::OpFindElementByPoint:
3203 startOperation( theCommandID );
3207 case SMESHOp::OpEditHypothesis:
3209 if(isStudyLocked()) break;
3211 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3212 SALOME_ListIO selected;
3214 aSel->selectedObjects( selected );
3216 int nbSel = selected.Extent();
3219 Handle(SALOME_InteractiveObject) anIObject = selected.First();
3220 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3222 if ( !aHypothesis->_is_nil() )
3224 SMESHGUI_GenericHypothesisCreator* aCreator =
3225 SMESH::GetHypothesisCreator( SMESH::toQStr( aHypothesis->GetName() ));
3228 // set geometry of mesh and sub-mesh to aCreator
3229 aSel->selectedObjects( selected, "", /*convertReferences=*/false);
3230 if ( selected.Extent() == 1 )
3232 QString subGeomID, meshGeomID;
3233 Handle(SALOME_InteractiveObject) hypIO = selected.First();
3234 if ( SMESH::GetGeomEntries( hypIO, subGeomID, meshGeomID ))
3236 if ( subGeomID.isEmpty() ) subGeomID = meshGeomID;
3237 aCreator->setShapeEntry( subGeomID );
3238 aCreator->setMainShapeEntry( meshGeomID );
3242 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3252 case SMESHOp::OpUnassign: // REMOVE HYPOTHESIS / ALGORITHMS
3254 if(isStudyLocked()) break;
3255 SUIT_OverrideCursor wc;
3257 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3258 SALOME_ListIO selected;
3260 aSel->selectedObjects( selected, QString::null, false );
3262 SALOME_ListIteratorOfListIO It(selected);
3263 for (int i = 0; It.More(); It.Next(), i++) {
3264 Handle(SALOME_InteractiveObject) IObject = It.Value();
3265 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3268 aSel->setSelectedObjects( l1 );
3273 case SMESHOp::OpElem0D:
3274 case SMESHOp::OpBall:
3275 case SMESHOp::OpEdge:
3276 case SMESHOp::OpTriangle:
3277 case SMESHOp::OpQuadrangle:
3278 case SMESHOp::OpPolygon:
3279 case SMESHOp::OpTetrahedron:
3280 case SMESHOp::OpHexahedron:
3281 case SMESHOp::OpPentahedron:
3282 case SMESHOp::OpPyramid:
3283 case SMESHOp::OpHexagonalPrism:
3285 if(isStudyLocked()) break;
3287 EmitSignalDeactivateDialog();
3288 SMDSAbs_EntityType type = SMDSEntity_Edge;
3289 switch (theCommandID) {
3290 case SMESHOp::OpElem0D: type = SMDSEntity_0D; break;
3291 case SMESHOp::OpBall: type = SMDSEntity_Ball; break;
3292 case SMESHOp::OpTriangle: type = SMDSEntity_Triangle; break;
3293 case SMESHOp::OpQuadrangle: type = SMDSEntity_Quadrangle; break;
3294 case SMESHOp::OpTetrahedron: type = SMDSEntity_Tetra; break;
3295 case SMESHOp::OpPolygon: type = SMDSEntity_Polygon; break;
3296 case SMESHOp::OpHexahedron: type = SMDSEntity_Hexa; break;
3297 case SMESHOp::OpPentahedron: type = SMDSEntity_Penta; break;
3298 case SMESHOp::OpPyramid: type = SMDSEntity_Pyramid; break;
3299 case SMESHOp::OpHexagonalPrism: type = SMDSEntity_Hexagonal_Prism; break;
3302 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3305 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3309 case SMESHOp::OpPolyhedron:
3311 if(isStudyLocked()) break;
3313 EmitSignalDeactivateDialog();
3314 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3317 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3321 case SMESHOp::OpQuadraticEdge:
3322 case SMESHOp::OpQuadraticTriangle:
3323 case SMESHOp::OpBiQuadraticTriangle:
3324 case SMESHOp::OpQuadraticQuadrangle:
3325 case SMESHOp::OpBiQuadraticQuadrangle:
3326 case SMESHOp::OpQuadraticPolygon:
3327 case SMESHOp::OpQuadraticTetrahedron:
3328 case SMESHOp::OpQuadraticPyramid:
3329 case SMESHOp::OpQuadraticPentahedron:
3330 case SMESHOp::OpBiQuadraticPentahedron:
3331 case SMESHOp::OpQuadraticHexahedron:
3332 case SMESHOp::OpTriQuadraticHexahedron:
3334 if(isStudyLocked()) break;
3336 EmitSignalDeactivateDialog();
3337 SMDSAbs_EntityType type = SMDSEntity_Last;
3339 switch (theCommandID) {
3340 case SMESHOp::OpQuadraticEdge: type = SMDSEntity_Quad_Edge; break;
3341 case SMESHOp::OpQuadraticTriangle: type = SMDSEntity_Quad_Triangle; break;
3342 case SMESHOp::OpBiQuadraticTriangle: type = SMDSEntity_BiQuad_Triangle; break;
3343 case SMESHOp::OpQuadraticQuadrangle: type = SMDSEntity_Quad_Quadrangle; break;
3344 case SMESHOp::OpBiQuadraticQuadrangle: type = SMDSEntity_BiQuad_Quadrangle; break;
3345 case SMESHOp::OpQuadraticPolygon: type = SMDSEntity_Quad_Polygon; break;
3346 case SMESHOp::OpQuadraticTetrahedron: type = SMDSEntity_Quad_Tetra; break;
3347 case SMESHOp::OpQuadraticPyramid: type = SMDSEntity_Quad_Pyramid; break;
3348 case SMESHOp::OpQuadraticPentahedron: type = SMDSEntity_Quad_Penta; break;
3349 case SMESHOp::OpBiQuadraticPentahedron: type = SMDSEntity_BiQuad_Penta; break;
3350 case SMESHOp::OpQuadraticHexahedron: type = SMDSEntity_Quad_Hexa; break;
3351 case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
3354 if ( type != SMDSEntity_Last )
3355 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3358 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3359 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3363 case SMESHOp::OpRemoveNodes:
3365 if(isStudyLocked()) break;
3367 EmitSignalDeactivateDialog();
3368 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3371 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3372 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3376 case SMESHOp::OpRemoveElements: // REMOVES ELEMENTS
3378 if(isStudyLocked()) break;
3380 EmitSignalDeactivateDialog();
3381 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3385 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3386 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3390 case SMESHOp::OpClearMesh: {
3392 if(isStudyLocked()) break;
3394 SALOME_ListIO selected;
3395 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3396 aSel->selectedObjects( selected );
3398 SUIT_OverrideCursor wc;
3399 SALOME_ListIteratorOfListIO It (selected);
3400 for ( ; It.More(); It.Next() )
3402 Handle(SALOME_InteractiveObject) IOS = It.Value();
3403 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3404 if ( aMesh->_is_nil()) continue;
3407 if ( aMesh->NbNodes() == 0 ) // imported mesh is not empty
3408 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3409 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3410 // hide groups and submeshes
3411 _PTR(ChildIterator) anIter =
3412 SMESH::getStudy()->NewChildIterator( aMeshSObj );
3413 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3415 _PTR(SObject) so = anIter->Value();
3416 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3419 catch (const SALOME::SALOME_Exception& S_ex){
3421 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3425 SMESH::UpdateView();
3429 case SMESHOp::OpRemoveOrphanNodes:
3431 if(isStudyLocked()) break;
3432 SALOME_ListIO selected;
3433 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3434 aSel->selectedObjects( selected );
3435 if ( selected.Extent() == 1 ) {
3436 Handle(SALOME_InteractiveObject) anIO = selected.First();
3437 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3438 if ( !aMesh->_is_nil() ) {
3439 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3440 tr( "SMESH_WARNING" ),
3441 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3442 SUIT_MessageBox::Yes |
3443 SUIT_MessageBox::No,
3444 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3447 SUIT_OverrideCursor wc;
3448 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3449 int removed = aMeshEditor->RemoveOrphanNodes();
3450 SUIT_MessageBox::information(SMESHGUI::desktop(),
3451 tr("SMESH_INFORMATION"),
3452 tr("NB_NODES_REMOVED").arg(removed));
3453 if ( removed > 0 ) {
3454 SMESH::UpdateView();
3455 SMESHGUI::Modified();
3458 catch (const SALOME::SALOME_Exception& S_ex) {
3459 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3468 case SMESHOp::OpRenumberingNodes:
3470 if(isStudyLocked()) break;
3472 EmitSignalDeactivateDialog();
3473 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3477 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3478 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3482 case SMESHOp::OpRenumberingElements:
3484 if(isStudyLocked()) break;
3486 EmitSignalDeactivateDialog();
3487 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3491 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3492 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3496 case SMESHOp::OpTranslation:
3498 if(isStudyLocked()) break;
3500 EmitSignalDeactivateDialog();
3501 ( new SMESHGUI_TranslationDlg( this ) )->show();
3504 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3505 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3509 case SMESHOp::OpRotation:
3511 if(isStudyLocked()) break;
3513 EmitSignalDeactivateDialog();
3514 ( new SMESHGUI_RotationDlg( this ) )->show();
3517 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3518 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3522 case SMESHOp::OpSymmetry:
3524 if(isStudyLocked()) break;
3526 EmitSignalDeactivateDialog();
3527 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3530 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3531 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3535 case SMESHOp::OpScale:
3537 if(isStudyLocked()) break;
3539 EmitSignalDeactivateDialog();
3540 ( new SMESHGUI_ScaleDlg( this ) )->show();
3543 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3544 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3549 case SMESHOp::OpOffset:
3551 if(isStudyLocked()) break;
3553 EmitSignalDeactivateDialog();
3554 ( new SMESHGUI_OffsetDlg( this ) )->show();
3557 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3558 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3563 case SMESHOp::OpSewing:
3565 if(isStudyLocked()) break;
3567 EmitSignalDeactivateDialog();
3568 ( new SMESHGUI_SewingDlg( this ) )->show();
3571 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3572 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3576 case SMESHOp::OpMergeNodes:
3578 if(isStudyLocked()) break;
3580 EmitSignalDeactivateDialog();
3581 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3584 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3585 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3589 case SMESHOp::OpMergeElements:
3591 if (isStudyLocked()) break;
3593 EmitSignalDeactivateDialog();
3594 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3596 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3597 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3602 case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
3603 startOperation( SMESHOp::OpMoveNode );
3606 case SMESHOp::OpDuplicateNodes:
3608 if(isStudyLocked()) break;
3610 EmitSignalDeactivateDialog();
3611 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3614 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3615 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3620 case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
3621 startOperation( SMESHOp::OpElem0DOnElemNodes );
3624 case SMESHOp::OpSelectFiltersLibrary: // Library of selection filters
3626 static QList<int> aTypes;
3627 if ( aTypes.isEmpty() )
3629 aTypes.append( SMESH::NODE );
3630 aTypes.append( SMESH::EDGE );
3631 aTypes.append( SMESH::FACE );
3632 aTypes.append( SMESH::VOLUME );
3634 if (!myFilterLibraryDlg)
3635 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3636 else if (myFilterLibraryDlg->isHidden())
3637 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3638 myFilterLibraryDlg->raise();
3642 case SMESHOp::OpFreeNode:
3643 case SMESHOp::OpEqualNode:
3644 case SMESHOp::OpNodeConnectivityNb:
3645 case SMESHOp::OpFreeEdge:
3646 case SMESHOp::OpFreeBorder:
3647 case SMESHOp::OpLength:
3648 case SMESHOp::OpConnection:
3649 case SMESHOp::OpEqualEdge:
3650 case SMESHOp::OpFreeFace:
3651 case SMESHOp::OpBareBorderFace:
3652 case SMESHOp::OpOverConstrainedFace:
3653 case SMESHOp::OpLength2D:
3654 case SMESHOp::OpDeflection2D:
3655 case SMESHOp::OpConnection2D:
3656 case SMESHOp::OpArea:
3657 case SMESHOp::OpTaper:
3658 case SMESHOp::OpAspectRatio:
3659 case SMESHOp::OpMinimumAngle:
3660 case SMESHOp::OpWarpingAngle:
3661 case SMESHOp::OpSkew:
3662 case SMESHOp::OpMaxElementLength2D:
3663 case SMESHOp::OpEqualFace:
3664 case SMESHOp::OpAspectRatio3D:
3665 case SMESHOp::OpVolume:
3666 case SMESHOp::OpMaxElementLength3D:
3667 case SMESHOp::OpBareBorderVolume:
3668 case SMESHOp::OpOverConstrainedVolume:
3669 case SMESHOp::OpEqualVolume:
3672 LightApp_SelectionMgr* mgr = selectionMgr();
3673 SALOME_ListIO selected; mgr->selectedObjects( selected );
3675 if( !selected.IsEmpty() ) {
3676 SUIT_OverrideCursor wc;
3677 ::Control( theCommandID );
3680 SUIT_MessageBox::warning(desktop(),
3681 tr( "SMESH_WRN_WARNING" ),
3682 tr( "SMESH_BAD_SELECTION" ) );
3686 SUIT_MessageBox::warning(desktop(),
3687 tr( "SMESH_WRN_WARNING" ),
3688 tr( "NOT_A_VTK_VIEWER" ) );
3691 case SMESHOp::OpOverallMeshQuality:
3692 OverallMeshQuality();
3694 case SMESHOp::OpNumberingNodes:
3696 SUIT_OverrideCursor wc;
3697 LightApp_SelectionMgr* mgr = selectionMgr();
3698 SALOME_ListIO selected; mgr->selectedObjects( selected );
3700 SALOME_ListIteratorOfListIO it(selected);
3701 for( ; it.More(); it.Next()) {
3702 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3703 if(anIObject->hasEntry()) {
3704 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3705 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3711 case SMESHOp::OpNumberingElements:
3713 SUIT_OverrideCursor wc;
3714 LightApp_SelectionMgr* mgr = selectionMgr();
3715 SALOME_ListIO selected; mgr->selectedObjects( selected );
3717 SALOME_ListIteratorOfListIO it(selected);
3718 for( ; it.More(); it.Next()) {
3719 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3720 if(anIObject->hasEntry())
3721 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3722 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3727 case SMESHOp::OpPropertiesLength:
3728 case SMESHOp::OpPropertiesArea:
3729 case SMESHOp::OpPropertiesVolume:
3730 case SMESHOp::OpMinimumDistance:
3731 case SMESHOp::OpBoundingBox:
3732 case SMESHOp::OpAngle:
3734 int page = SMESHGUI_MeasureDlg::MinDistance;
3735 if ( theCommandID == SMESHOp::OpBoundingBox )
3736 page = SMESHGUI_MeasureDlg::BoundingBox;
3737 else if ( theCommandID == SMESHOp::OpPropertiesLength )
3738 page = SMESHGUI_MeasureDlg::Length;
3739 else if ( theCommandID == SMESHOp::OpPropertiesArea )
3740 page = SMESHGUI_MeasureDlg::Area;
3741 else if ( theCommandID == SMESHOp::OpPropertiesVolume )
3742 page = SMESHGUI_MeasureDlg::Volume;
3743 else if ( theCommandID == SMESHOp::OpAngle )
3744 page = SMESHGUI_MeasureDlg::Angle;
3746 EmitSignalDeactivateDialog();
3747 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3751 case SMESHOp::OpSortChild:
3757 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3758 //updateObjBrowser();
3762 //=============================================================================
3766 //=============================================================================
3767 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3772 //=============================================================================
3776 //=============================================================================
3777 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3782 //=============================================================================
3786 //=============================================================================
3787 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3792 //=============================================================================
3793 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3794 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3796 //=============================================================================
3797 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3798 SUIT_ViewWindow* wnd )
3800 if(theIO->hasEntry()){
3801 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3802 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3806 //=======================================================================
3807 // function : createSMESHAction
3809 //=======================================================================
3810 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3811 const int key, const bool toggle, const QString& shortcutAction )
3814 QWidget* parent = application()->desktop();
3815 SUIT_ResourceMgr* resMgr = resourceMgr();
3817 if ( !icon_id.isEmpty() )
3818 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3820 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3821 if ( !pix.isNull() )
3822 icon = QIcon( pix );
3824 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3825 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3826 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3828 createAction( id, tooltip, icon, menu, status_bar, key, parent,
3829 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3832 //=======================================================================
3833 // function : createPopupItem
3835 //=======================================================================
3836 void SMESHGUI::createPopupItem( const int id,
3837 const QString& clients,
3838 const QString& types,
3839 const QString& theRule,
3842 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3843 popupMgr()->insert( action( id ), pId, 0 );
3845 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3846 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
3847 QString rule = "(%1) and (%2) and (%3)";
3848 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3849 if( clients.isEmpty() )
3850 rule = rule.arg( QString( "true" ) );
3852 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3853 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3856 bool cont = myRules.contains( id );
3858 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3860 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3861 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3864 //=======================================================================
3865 // function : initialize
3867 //=======================================================================
3868 void SMESHGUI::initialize( CAM_Application* app )
3870 SalomeApp_Module::initialize( app );
3872 // SUIT_ResourceMgr* mgr = app->resourceMgr();
3874 /* Automatic Update flag */
3875 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3877 // ----- create actions --------------
3879 //createSMESHAction( SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
3880 createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_I) );
3881 createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
3882 createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL" );
3884 createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
3886 createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
3887 createSMESHAction( SMESHOp::OpImportGMF, "IMPORT_GMF" );
3888 createSMESHAction( SMESHOp::OpPopupImportUNV, "IMPORT_UNV");
3889 createSMESHAction( SMESHOp::OpPopupImportMED, "IMPORT_MED");
3890 createSMESHAction( SMESHOp::OpPopupImportSTL, "IMPORT_STL" );
3892 createSMESHAction( SMESHOp::OpPopupImportCGNS, "IMPORT_CGNS" );
3894 createSMESHAction( SMESHOp::OpPopupImportSAUV, "IMPORT_SAUV" );
3895 createSMESHAction( SMESHOp::OpPopupImportGMF, "IMPORT_GMF" );
3897 createSMESHAction( SMESHOp::OpExportDAT, "DAT" );
3898 createSMESHAction( SMESHOp::OpExportMED, "MED" );
3899 createSMESHAction( SMESHOp::OpExportUNV, "UNV" );
3900 createSMESHAction( SMESHOp::OpExportSTL, "STL" );
3902 createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
3904 createSMESHAction( SMESHOp::OpExportSAUV, "SAUV");
3905 createSMESHAction( SMESHOp::OpExportGMF, "GMF" );
3906 createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
3907 createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
3908 createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
3909 createSMESHAction( SMESHOp::OpPopupExportSTL, "STL" );
3911 createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
3913 createSMESHAction( SMESHOp::OpPopupExportSAUV, "SAUV");
3914 createSMESHAction( SMESHOp::OpPopupExportGMF, "GMF" );
3915 createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
3916 createSMESHAction( SMESHOp::OpDelete, "DELETE", "ICON_DELETE", Qt::Key_Delete );
3917 createSMESHAction( SMESHOp::OpSelectFiltersLibrary, "SEL_FILTER_LIB" );
3918 createSMESHAction( SMESHOp::OpCreateMesh, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
3919 createSMESHAction( SMESHOp::OpCreateSubMesh, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
3920 createSMESHAction( SMESHOp::OpEditMeshOrSubMesh, "EDIT_MESHSUBMESH", "ICON_DLG_EDIT_MESH" );
3921 createSMESHAction( SMESHOp::OpEditMesh, "EDIT_MESH", "ICON_DLG_EDIT_MESH" );
3922 createSMESHAction( SMESHOp::OpEditSubMesh, "EDIT_SUBMESH", "ICON_DLG_EDIT_MESH" );
3923 createSMESHAction( SMESHOp::OpBuildCompoundMesh, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
3924 createSMESHAction( SMESHOp::OpCopyMesh, "COPY_MESH", "ICON_COPY_MESH" );
3925 createSMESHAction( SMESHOp::OpCompute, "COMPUTE", "ICON_COMPUTE" );
3926 createSMESHAction( SMESHOp::OpComputeSubMesh, "COMPUTE_SUBMESH", "ICON_COMPUTE" );
3927 createSMESHAction( SMESHOp::OpPreCompute, "PRECOMPUTE", "ICON_PRECOMPUTE" );
3928 createSMESHAction( SMESHOp::OpEvaluate, "EVALUATE", "ICON_EVALUATE" );
3929 createSMESHAction( SMESHOp::OpMeshOrder, "MESH_ORDER", "ICON_MESH_ORDER");
3930 createSMESHAction( SMESHOp::OpCreateGroup, "CREATE_GROUP", "ICON_CREATE_GROUP" );
3931 createSMESHAction( SMESHOp::OpCreateGeometryGroup, "CREATE_GEO_GROUP", "ICON_CREATE_GEO_GROUP" );
3932 createSMESHAction( SMESHOp::OpConstructGroup, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
3933 createSMESHAction( SMESHOp::OpEditGroup, "EDIT_GROUP", "ICON_EDIT_GROUP" );
3934 createSMESHAction( SMESHOp::OpEditGeomGroupAsGroup, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3935 createSMESHAction( SMESHOp::OpUnionGroups, "UN_GROUP", "ICON_UNION" );
3936 createSMESHAction( SMESHOp::OpIntersectGroups, "INT_GROUP", "ICON_INTERSECT" );
3937 createSMESHAction( SMESHOp::OpCutGroups, "CUT_GROUP", "ICON_CUT" );
3938 createSMESHAction( SMESHOp::OpGroupUnderlyingElem, "UNDERLYING_ELEMS", "ICON_UNDERLYING_ELEMS" );
3939 createSMESHAction( SMESHOp::OpFaceGroupsByEdges, "FACE_GROUPS_BY_EDGES", "ICON_FACE_GROUPS_BY_EDGES" );
3940 createSMESHAction( SMESHOp::OpAddElemGroupPopup, "ADD_TO_GROUP" );
3941 createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE_FROM_GROUP" );
3942 createSMESHAction( SMESHOp::OpDeleteGroup, "DEL_GROUP", "ICON_DEL_GROUP" );
3943 createSMESHAction( SMESHOp::OpMeshInformation , "ADV_INFO", "ICON_ADV_INFO" );
3944 //createSMESHAction( SMESHOp::OpStdInfo, "STD_INFO", "ICON_STD_INFO" );
3945 //createSMESHAction( SMESHOp::OpWhatIs, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3946 createSMESHAction( SMESHOp::OpFindElementByPoint, "FIND_ELEM", "ICON_FIND_ELEM" );
3948 createSMESHAction( SMESHOp::OpFreeNode, "FREE_NODE", "ICON_FREE_NODE", 0, true );
3949 createSMESHAction( SMESHOp::OpEqualNode, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
3950 createSMESHAction( SMESHOp::OpNodeConnectivityNb, "NODE_CONNECTIVITY_NB", "ICON_NODE_CONN_NB", 0, true );
3951 createSMESHAction( SMESHOp::OpFreeEdge, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
3952 createSMESHAction( SMESHOp::OpFreeBorder, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
3953 createSMESHAction( SMESHOp::OpLength, "LENGTH", "ICON_LENGTH", 0, true );
3954 createSMESHAction( SMESHOp::OpConnection, "CONNECTION", "ICON_CONNECTION", 0, true );
3955 createSMESHAction( SMESHOp::OpEqualEdge, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
3956 createSMESHAction( SMESHOp::OpFreeFace, "FREE_FACES", "ICON_FREE_FACES", 0, true );
3957 createSMESHAction( SMESHOp::OpBareBorderFace, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
3958 createSMESHAction( SMESHOp::OpOverConstrainedFace, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
3959 createSMESHAction( SMESHOp::OpLength2D, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
3960 createSMESHAction( SMESHOp::OpDeflection2D, "DEFLECTION_2D", "ICON_DEFLECTION_2D", 0, true );
3961 createSMESHAction( SMESHOp::OpConnection2D, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
3962 createSMESHAction( SMESHOp::OpArea, "AREA", "ICON_AREA", 0, true );
3963 createSMESHAction( SMESHOp::OpTaper, "TAPER", "ICON_TAPER", 0, true );
3964 createSMESHAction( SMESHOp::OpAspectRatio, "ASPECT", "ICON_ASPECT", 0, true );
3965 createSMESHAction( SMESHOp::OpMinimumAngle, "MIN_ANG", "ICON_ANGLE", 0, true );
3966 createSMESHAction( SMESHOp::OpWarpingAngle, "WARP", "ICON_WARP", 0, true );
3967 createSMESHAction( SMESHOp::OpSkew, "SKEW", "ICON_SKEW", 0, true );
3968 createSMESHAction( SMESHOp::OpMaxElementLength2D, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
3969 createSMESHAction( SMESHOp::OpEqualFace, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
3970 createSMESHAction( SMESHOp::OpAspectRatio3D, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
3971 createSMESHAction( SMESHOp::OpVolume, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
3972 createSMESHAction( SMESHOp::OpMaxElementLength3D, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
3973 createSMESHAction( SMESHOp::OpBareBorderVolume, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
3974 createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
3975 createSMESHAction( SMESHOp::OpEqualVolume, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
3976 createSMESHAction( SMESHOp::OpOverallMeshQuality, "OVERALL_MESH_QUALITY", "ICON_OVL_MESH_QUALITY" );
3978 createSMESHAction( SMESHOp::OpNode, "NODE", "ICON_DLG_NODE" );
3979 createSMESHAction( SMESHOp::OpElem0D, "ELEM0D", "ICON_DLG_ELEM0D" );
3980 createSMESHAction( SMESHOp::OpElem0DOnElemNodes, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
3981 createSMESHAction( SMESHOp::OpBall, "BALL", "ICON_DLG_BALL" );
3982 createSMESHAction( SMESHOp::OpEdge, "EDGE", "ICON_DLG_EDGE" );
3983 createSMESHAction( SMESHOp::OpTriangle, "TRIANGLE", "ICON_DLG_TRIANGLE" );
3984 createSMESHAction( SMESHOp::OpQuadrangle, "QUAD", "ICON_DLG_QUADRANGLE" );
3985 createSMESHAction( SMESHOp::OpPolygon, "POLYGON", "ICON_DLG_POLYGON" );
3986 createSMESHAction( SMESHOp::OpTetrahedron, "TETRA", "ICON_DLG_TETRAS" );
3987 createSMESHAction( SMESHOp::OpHexahedron, "HEXA", "ICON_DLG_HEXAS" );
3988 createSMESHAction( SMESHOp::OpPentahedron, "PENTA", "ICON_DLG_PENTA" );
3989 createSMESHAction( SMESHOp::OpPyramid , "PYRAMID", "ICON_DLG_PYRAMID" );
3990 createSMESHAction( SMESHOp::OpHexagonalPrism, "OCTA", "ICON_DLG_OCTA" );
3991 createSMESHAction( SMESHOp::OpPolyhedron, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
3992 createSMESHAction( SMESHOp::OpQuadraticEdge, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
3993 createSMESHAction( SMESHOp::OpQuadraticTriangle, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
3994 createSMESHAction( SMESHOp::OpBiQuadraticTriangle, "BIQUADRATIC_TRIANGLE", "ICON_DLG_BIQUADRATIC_TRIANGLE" );
3995 createSMESHAction( SMESHOp::OpQuadraticQuadrangle, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
3996 createSMESHAction( SMESHOp::OpBiQuadraticQuadrangle, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
3997 createSMESHAction( SMESHOp::OpQuadraticPolygon, "QUADRATIC_POLYGON", "ICON_DLG_QUADRATIC_POLYGON" );
3998 createSMESHAction( SMESHOp::OpQuadraticTetrahedron, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
3999 createSMESHAction( SMESHOp::OpQuadraticPyramid, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
4000 createSMESHAction( SMESHOp::OpQuadraticPentahedron, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
4001 createSMESHAction( SMESHOp::OpBiQuadraticPentahedron, "BIQUADRATIC_PENTAHEDRON", "ICON_DLG_BIQUADRATIC_PENTAHEDRON" );
4002 createSMESHAction( SMESHOp::OpQuadraticHexahedron, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
4003 createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
4005 createSMESHAction( SMESHOp::OpRemoveNodes, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
4006 createSMESHAction( SMESHOp::OpRemoveElements, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
4007 createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
4008 createSMESHAction( SMESHOp::OpClearMesh, "CLEAR_MESH", "ICON_CLEAR_MESH" );
4010 //createSMESHAction( SMESHOp::OpRenumberingNodes, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
4011 //createSMESHAction( SMESHOp::OpRenumberingElements, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
4013 createSMESHAction( SMESHOp::OpTranslation, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
4014 createSMESHAction( SMESHOp::OpRotation, "ROT", "ICON_DLG_MESH_ROTATION" );
4015 createSMESHAction( SMESHOp::OpSymmetry, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
4016 createSMESHAction( SMESHOp::OpScale, "SCALE", "ICON_DLG_MESH_SCALE" );
4017 createSMESHAction( SMESHOp::OpOffset, "OFFSET", "ICON_DLG_MESH_OFFSET" );
4018 createSMESHAction( SMESHOp::OpSewing, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
4019 createSMESHAction( SMESHOp::OpMergeNodes, "MERGE", "ICON_SMESH_MERGE_NODES" );
4020 createSMESHAction( SMESHOp::OpMergeElements, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
4021 createSMESHAction( SMESHOp::OpMoveNode, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
4022 createSMESHAction( SMESHOp::OpDuplicateNodes, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
4023 createSMESHAction( SMESHOp::OpDiagonalInversion, "INV", "ICON_DLG_MESH_DIAGONAL" );
4024 createSMESHAction( SMESHOp::OpUnionOfTwoTriangle, "UNION2", "ICON_UNION2TRI" );
4025 createSMESHAction( SMESHOp::OpOrientation, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
4026 createSMESHAction( SMESHOp::OpReorientFaces, "REORIENT_2D", "ICON_REORIENT_2D" );
4027 createSMESHAction( SMESHOp::OpUnionOfTriangles, "UNION", "ICON_UNIONTRI" );
4028 createSMESHAction( SMESHOp::OpCuttingOfQuadrangles, "CUT", "ICON_CUTQUAD" );
4029 createSMESHAction( SMESHOp::OpSplitVolumes, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
4030 createSMESHAction( SMESHOp::OpSplitBiQuadratic, "SPLIT_BIQUAD", "ICON_SPLIT_BIQUAD" );
4031 createSMESHAction( SMESHOp::OpSmoothing, "SMOOTH", "ICON_DLG_SMOOTHING" );
4032 createSMESHAction( SMESHOp::OpExtrusion, "EXTRUSION", "ICON_EXTRUSION" );
4033 createSMESHAction( SMESHOp::OpExtrusionAlongAPath, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
4034 createSMESHAction( SMESHOp::OpRevolution, "REVOLUTION", "ICON_REVOLUTION" );
4035 createSMESHAction( SMESHOp::OpPatternMapping, "MAP", "ICON_MAP" );
4036 createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
4037 createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D", "ICON_2D_FROM_3D" );
4039 createSMESHAction( SMESHOp::OpReset, "RESET" );
4040 createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
4041 createSMESHAction( SMESHOp::OpShowScalarBar, "SHOW_SCALAR_BAR","",0, true );
4042 createSMESHAction( SMESHOp::OpSaveDistribution, "SAVE_DISTRIBUTION" );
4043 createSMESHAction( SMESHOp::OpShowDistribution, "SHOW_DISTRIBUTION","",0, true );
4044 #ifndef DISABLE_PLOT2DVIEWER
4045 createSMESHAction( SMESHOp::OpPlotDistribution, "PLOT_DISTRIBUTION" );
4047 createSMESHAction( SMESHOp::OpDMWireframe, "WIRE", "ICON_WIRE", 0, true );
4048 createSMESHAction( SMESHOp::OpDMShading, "SHADE", "ICON_SHADE", 0, true );
4049 createSMESHAction( SMESHOp::OpDMNodes, "NODES", "ICON_POINTS", 0, true );
4050 createSMESHAction( SMESHOp::OpDMShrink, "SHRINK", "ICON_SHRINK", 0, true );
4051 createSMESHAction( SMESHOp::OpUpdate, "UPDATE", "ICON_UPDATE" );
4052 createSMESHAction( SMESHOp::OpDE0DElements, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
4053 createSMESHAction( SMESHOp::OpDEEdges, "EDGES", "ICON_DLG_EDGE", 0, true );
4054 createSMESHAction( SMESHOp::OpDEFaces, "FACES", "ICON_DLG_TRIANGLE", 0, true );
4055 createSMESHAction( SMESHOp::OpDEVolumes, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
4056 createSMESHAction( SMESHOp::OpDEBalls, "BALLS", "ICON_DLG_BALL", 0, true );
4057 createSMESHAction( SMESHOp::OpDEChoose, "CHOOSE", "ICON_DLG_CHOOSE", 0, false );
4058 createSMESHAction( SMESHOp::OpDEAllEntity, "ALL", "ICON_DLG_CHOOSE_ALL", 0, false );
4059 createSMESHAction( SMESHOp::OpOrientationOnFaces, "FACE_ORIENTATION", "", 0, true );
4061 createSMESHAction( SMESHOp::OpRepresentationLines, "LINE_REPRESENTATION", "", 0, true );
4062 createSMESHAction( SMESHOp::OpRepresentationArcs, "ARC_REPRESENTATION", "", 0, true );
4064 createSMESHAction( SMESHOp::OpEditHypothesis, "EDIT_HYPO" );
4065 createSMESHAction( SMESHOp::OpUnassign, "UNASSIGN" );
4066 createSMESHAction( SMESHOp::OpNumberingNodes, "NUM_NODES", "", 0, true );
4067 createSMESHAction( SMESHOp::OpNumberingElements, "NUM_ELEMENTS", "", 0, true );
4068 createSMESHAction( SMESHOp::OpProperties, "COLORS" );
4069 createSMESHAction( SMESHOp::OpTransparency, "TRANSP" );
4070 createSMESHAction( SMESHOp::OpClipping, "CLIP" );
4071 createSMESHAction( SMESHOp::OpAutoColor, "AUTO_COLOR" );
4072 createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
4074 createSMESHAction( SMESHOp::OpMinimumDistance, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
4075 createSMESHAction( SMESHOp::OpBoundingBox, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
4076 createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH", "ICON_MEASURE_LENGTH" );
4077 createSMESHAction( SMESHOp::OpPropertiesArea, "MEASURE_AREA", "ICON_MEASURE_AREA" );
4078 createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME", "ICON_MEASURE_VOLUME" );
4079 createSMESHAction( SMESHOp::OpAngle, "MEASURE_ANGLE", "ICON_MEASURE_ANGLE" );
4081 createSMESHAction( SMESHOp::OpHide, "HIDE", "ICON_HIDE" );
4082 createSMESHAction( SMESHOp::OpShow, "SHOW", "ICON_SHOW" );
4083 createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
4085 createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
4087 QList<int> aCtrlActions;
4088 aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode
4089 << SMESHOp::OpNodeConnectivityNb // node controls
4090 << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
4091 << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge // edge controls
4092 << SMESHOp::OpDeflection2D
4093 << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
4094 << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
4095 << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
4096 << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
4097 << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace // face controls
4098 << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
4099 << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
4100 << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume; // volume controls
4101 QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
4102 aCtrlGroup->setExclusive( true );
4103 for( int i = 0; i < aCtrlActions.size(); i++ )
4104 aCtrlGroup->addAction( action( aCtrlActions[i] ) );
4106 // ----- create menu --------------
4107 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
4108 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
4109 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
4110 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
4111 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
4112 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
4113 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
4114 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
4116 createMenu( separator(), fileId );
4118 QMenu* nodeMenu = new QMenu(); QMenu* edgeMenu = new QMenu();
4119 QMenu* faceMenu = new QMenu(); QMenu* volumeMenu = new QMenu();
4120 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
4121 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
4122 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10, -1, nodeMenu ),
4123 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10, -1, edgeMenu ),
4124 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10, -1, faceMenu ),
4125 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10, -1, volumeMenu ),
4126 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
4127 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
4128 //renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
4129 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
4130 basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
4132 //createMenu( SMESHOp::OpImportDAT, importId, -1 );
4133 createMenu( SMESHOp::OpImportUNV, importId, -1 );
4134 createMenu( SMESHOp::OpImportMED, importId, -1 );
4135 createMenu( SMESHOp::OpImportSTL, importId, -1 );
4137 createMenu( SMESHOp::OpImportCGNS, importId, -1 );
4139 createMenu( SMESHOp::OpImportSAUV, importId, -1 );
4140 createMenu( SMESHOp::OpImportGMF, importId, -1 );
4141 createMenu( SMESHOp::OpExportDAT, exportId, -1 );
4142 createMenu( SMESHOp::OpExportMED, exportId, -1 );
4143 createMenu( SMESHOp::OpExportUNV, exportId, -1 );
4144 createMenu( SMESHOp::OpExportSTL, exportId, -1 );
4146 createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
4148 createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
4149 createMenu( SMESHOp::OpExportGMF, exportId, -1 );
4150 createMenu( separator(), fileId, 10 );
4152 createMenu( SMESHOp::OpDelete, editId, -1 );
4154 createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
4156 createMenu( SMESHOp::OpCreateMesh, meshId, -1 ); // "Mesh" menu
4157 createMenu( SMESHOp::OpCreateSubMesh, meshId, -1 );
4158 createMenu( SMESHOp::OpEditMeshOrSubMesh, meshId, -1 );
4159 createMenu( SMESHOp::OpBuildCompoundMesh, meshId, -1 );
4160 createMenu( SMESHOp::OpCopyMesh, meshId, -1 );
4161 createMenu( separator(), meshId, -1 );
4162 createMenu( SMESHOp::OpCompute, meshId, -1 );
4163 createMenu( SMESHOp::OpPreCompute, meshId, -1 );
4164 createMenu( SMESHOp::OpEvaluate, meshId, -1 );
4165 createMenu( SMESHOp::OpMeshOrder, meshId, -1 );
4166 createMenu( separator(), meshId, -1 );
4167 createMenu( SMESHOp::OpCreateGroup, meshId, -1 );
4168 createMenu( SMESHOp::OpCreateGeometryGroup, meshId, -1 );
4169 createMenu( SMESHOp::OpConstructGroup, meshId, -1 );
4170 createMenu( SMESHOp::OpEditGroup, meshId, -1 );
4171 createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4172 createMenu( separator(), meshId, -1 );
4173 createMenu( SMESHOp::OpUnionGroups, meshId, -1 );
4174 createMenu( SMESHOp::OpIntersectGroups, meshId, -1 );
4175 createMenu( SMESHOp::OpCutGroups, meshId, -1 );
4176 createMenu( separator(), meshId, -1 );
4177 createMenu( SMESHOp::OpGroupUnderlyingElem, meshId, -1 );
4178 createMenu( SMESHOp::OpFaceGroupsByEdges, meshId, -1 );
4179 createMenu( separator(), meshId, -1 );
4180 createMenu( SMESHOp::OpMeshInformation, meshId, -1 );
4181 //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4182 //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4183 createMenu( SMESHOp::OpFindElementByPoint, meshId, -1 );
4184 createMenu( separator(), meshId, -1 );
4186 createMenu( SMESHOp::OpFreeNode, nodeId, -1 );
4187 createMenu( SMESHOp::OpEqualNode, nodeId, -1 );
4188 //createMenu( SMESHOp::OpNodeConnectivityNb, nodeId, -1 );
4189 createMenu( SMESHOp::OpFreeBorder, edgeId, -1 );
4190 createMenu( SMESHOp::OpLength, edgeId, -1 );
4191 createMenu( SMESHOp::OpConnection, edgeId, -1 );
4192 createMenu( SMESHOp::OpEqualEdge, edgeId, -1 );
4193 createMenu( SMESHOp::OpFreeEdge, faceId, -1 );
4194 createMenu( SMESHOp::OpFreeFace, faceId, -1 );
4195 createMenu( SMESHOp::OpBareBorderFace, faceId, -1 );
4196 createMenu( SMESHOp::OpOverConstrainedFace, faceId, -1 );
4197 createMenu( SMESHOp::OpLength2D, faceId, -1 );
4198 createMenu( SMESHOp::OpConnection2D, faceId, -1 );
4199 createMenu( SMESHOp::OpArea, faceId, -1 );
4200 createMenu( SMESHOp::OpTaper, faceId, -1 );
4201 createMenu( SMESHOp::OpAspectRatio, faceId, -1 );
4202 createMenu( SMESHOp::OpMinimumAngle, faceId, -1 );
4203 createMenu( SMESHOp::OpWarpingAngle, faceId, -1 );
4204 createMenu( SMESHOp::OpSkew, faceId, -1 );
4205 createMenu( SMESHOp::OpMaxElementLength2D, faceId, -1 );
4206 createMenu( SMESHOp::OpEqualFace, faceId, -1 );
4207 createMenu( SMESHOp::OpDeflection2D, faceId, -1 );
4208 createMenu( SMESHOp::OpAspectRatio3D, volumeId, -1 );
4209 createMenu( SMESHOp::OpVolume, volumeId, -1 );
4210 createMenu( SMESHOp::OpMaxElementLength3D, volumeId, -1 );
4211 createMenu( SMESHOp::OpBareBorderVolume, volumeId, -1 );
4212 createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4213 createMenu( SMESHOp::OpEqualVolume, volumeId, -1 );
4214 createMenu( separator(), ctrlId, -1 );
4215 createMenu( SMESHOp::OpReset, ctrlId, -1 );
4216 createMenu( separator(), ctrlId, -1 );
4217 createMenu( SMESHOp::OpOverallMeshQuality, ctrlId, -1 );
4219 createMenu( SMESHOp::OpNode, addId, -1 );
4220 createMenu( SMESHOp::OpElem0D, addId, -1 );
4221 createMenu( SMESHOp::OpElem0DOnElemNodes, addId, -1 );
4222 createMenu( SMESHOp::OpBall, addId, -1 );
4223 createMenu( SMESHOp::OpEdge, addId, -1 );
4224 createMenu( SMESHOp::OpTriangle, addId, -1 );
4225 createMenu( SMESHOp::OpQuadrangle, addId, -1 );
4226 createMenu( SMESHOp::OpPolygon, addId, -1 );
4227 createMenu( SMESHOp::OpTetrahedron, addId, -1 );
4228 createMenu( SMESHOp::OpHexahedron, addId, -1 );
4229 createMenu( SMESHOp::OpPentahedron, addId, -1 );
4230 createMenu( SMESHOp::OpPyramid, addId, -1 );
4231 createMenu( SMESHOp::OpHexagonalPrism, addId, -1 );
4232 createMenu( SMESHOp::OpPolyhedron, addId, -1 );
4233 createMenu( separator(), addId, -1 );
4234 createMenu( SMESHOp::OpQuadraticEdge, addId, -1 );
4235 createMenu( SMESHOp::OpQuadraticTriangle, addId, -1 );
4236 createMenu( SMESHOp::OpBiQuadraticTriangle , addId, -1 );
4237 createMenu( SMESHOp::OpQuadraticQuadrangle, addId, -1 );
4238 createMenu( SMESHOp::OpBiQuadraticQuadrangle, addId, -1 );
4239 createMenu( SMESHOp::OpQuadraticPolygon, addId, -1 );
4240 createMenu( SMESHOp::OpQuadraticTetrahedron, addId, -1 );
4241 createMenu( SMESHOp::OpQuadraticPyramid, addId, -1 );
4242 createMenu( SMESHOp::OpQuadraticPentahedron, addId, -1 );
4243 createMenu( SMESHOp::OpBiQuadraticPentahedron, addId, -1 );
4244 createMenu( SMESHOp::OpQuadraticHexahedron, addId, -1 );
4245 createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4247 createMenu( SMESHOp::OpRemoveNodes, removeId, -1 );
4248 createMenu( SMESHOp::OpRemoveElements, removeId, -1 );
4249 createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4250 createMenu( separator(), removeId, -1 );
4251 createMenu( SMESHOp::OpDeleteGroup, removeId, -1 );
4252 createMenu( separator(), removeId, -1 );
4253 createMenu( SMESHOp::OpClearMesh, removeId, -1 );
4255 //createMenu( SMESHOp::OpRenumberingNodes, renumId, -1 );
4256 //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4258 createMenu( SMESHOp::OpMergeNodes, transfId, -1 );
4259 createMenu( SMESHOp::OpMergeElements, transfId, -1 );
4260 createMenu( SMESHOp::OpTranslation, transfId, -1 );
4261 createMenu( SMESHOp::OpRotation, transfId, -1 );
4262 createMenu( SMESHOp::OpSymmetry, transfId, -1 );
4263 createMenu( SMESHOp::OpScale, transfId, -1 );
4264 createMenu( SMESHOp::OpOffset, transfId, -1 );
4265 createMenu( SMESHOp::OpSewing, transfId, -1 );
4266 createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4268 createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4269 createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4270 createMenu( SMESHOp::OpExtrusion, modifyId, -1 );
4271 createMenu( SMESHOp::OpExtrusionAlongAPath, modifyId, -1 );
4272 createMenu( SMESHOp::OpRevolution, modifyId, -1 );
4273 createMenu( SMESHOp::OpOrientation, modifyId, -1 );
4274 createMenu( SMESHOp::OpReorientFaces, modifyId, -1 );
4275 createMenu( SMESHOp::OpMoveNode, modifyId, -1 );
4276 createMenu( SMESHOp::OpDiagonalInversion, modifyId, -1 );
4277 createMenu( SMESHOp::OpUnionOfTwoTriangle, modifyId, -1 );
4278 createMenu( SMESHOp::OpUnionOfTriangles, modifyId, -1 );
4279 createMenu( SMESHOp::OpCuttingOfQuadrangles, modifyId, -1 );
4280 createMenu( SMESHOp::OpSplitVolumes, modifyId, -1 );
4281 createMenu( SMESHOp::OpSplitBiQuadratic, modifyId, -1 );
4282 createMenu( SMESHOp::OpSmoothing, modifyId, -1 );
4283 createMenu( SMESHOp::OpPatternMapping, modifyId, -1 );
4285 createMenu( SMESHOp::OpMinimumDistance, measureId, -1 );
4286 createMenu( SMESHOp::OpBoundingBox, measureId, -1 );
4287 createMenu( SMESHOp::OpAngle, measureId, -1 );
4288 createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4289 createMenu( SMESHOp::OpPropertiesArea, basicPropId, -1 );
4290 createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4291 createMenu( SMESHOp::OpUpdate, viewId, -1 );
4293 connect( nodeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4294 connect( edgeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4295 connect( faceMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4296 connect( volumeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4298 // ----- create toolbars --------------
4299 int meshTb = createTool( tr( "TB_MESH" ), QString( "SMESHMeshToolbar" ) ),
4300 info = createTool( tr( "TB_INFO" ), QString( "SMESHInformationToolbar" ) ),
4301 groupTb = createTool( tr( "TB_GROUP" ), QString( "SMESHGroupToolbar" ) ),
4302 ctrl0dTb = createTool( tr( "TB_CTRL0D" ), QString( "SMESHNodeControlsToolbar" ) ),
4303 ctrl1dTb = createTool( tr( "TB_CTRL1D" ), QString( "SMESHEdgeControlsToolbar" ) ),
4304 ctrl2dTb = createTool( tr( "TB_CTRL2D" ), QString( "SMESHFaceControlsToolbar" ) ),
4305 ctrl3dTb = createTool( tr( "TB_CTRL3D" ), QString( "SMESHVolumeControlsToolbar" ) ),
4306 addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ),
4307 addNonElemTb = createTool( tr( "TB_ADDNON" ), QString( "SMESHAddElementToolbar" ) ),
4308 remTb = createTool( tr( "TB_REM" ), QString( "SMESHRemoveToolbar" ) ),
4309 //renumbTb = createTool( tr( "TB_RENUMBER" ), QString( "SMESHRenumberingToolbar" ) ),
4310 transformTb = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ),
4311 modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ),
4312 measuremTb = createTool( tr( "TB_MEASUREM" ), QString( "SMESHMeasurementsToolbar" ) ),
4313 dispModeTb = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4315 createTool( SMESHOp::OpCreateMesh, meshTb );
4316 createTool( SMESHOp::OpCreateSubMesh, meshTb );
4317 createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4318 createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4319 createTool( SMESHOp::OpCopyMesh, meshTb );
4320 createTool( separator(), meshTb );
4321 createTool( SMESHOp::OpCompute, meshTb );
4322 createTool( SMESHOp::OpPreCompute, meshTb );
4323 createTool( SMESHOp::OpEvaluate, meshTb );
4324 createTool( SMESHOp::OpMeshOrder, meshTb );
4326 createTool( SMESHOp::OpCreateGroup, groupTb );
4327 createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4328 createTool( SMESHOp::OpConstructGroup, groupTb );
4329 createTool( SMESHOp::OpEditGroup, groupTb );
4331 createTool( SMESHOp::OpMeshInformation, info );
4332 //createTool( SMESHOp::OpStdInfo, meshTb );
4333 //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4334 createTool( SMESHOp::OpFindElementByPoint, info );
4336 createTool( SMESHOp::OpFreeNode, ctrl0dTb );
4337 createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4338 //createTool( SMESHOp::OpNodeConnectivityNb, ctrl0dTb );
4340 createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4341 createTool( SMESHOp::OpLength, ctrl1dTb );
4342 createTool( SMESHOp::OpConnection, ctrl1dTb );
4343 createTool( SMESHOp::OpEqualEdge, ctrl1dTb );
4345 createTool( SMESHOp::OpFreeEdge, ctrl2dTb );
4346 createTool( SMESHOp::OpFreeFace, ctrl2dTb );
4347 createTool( SMESHOp::OpBareBorderFace, ctrl2dTb );
4348 createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4349 createTool( SMESHOp::OpLength2D, ctrl2dTb );
4350 createTool( SMESHOp::OpConnection2D, ctrl2dTb );
4351 createTool( SMESHOp::OpArea, ctrl2dTb );
4352 createTool( SMESHOp::OpTaper, ctrl2dTb );
4353 createTool( SMESHOp::OpAspectRatio, ctrl2dTb );
4354 createTool( SMESHOp::OpMinimumAngle, ctrl2dTb );
4355 createTool( SMESHOp::OpWarpingAngle, ctrl2dTb );
4356 createTool( SMESHOp::OpSkew, ctrl2dTb );
4357 createTool( SMESHOp::OpMaxElementLength2D, ctrl2dTb );
4358 createTool( SMESHOp::OpEqualFace, ctrl2dTb );
4359 createTool( SMESHOp::OpDeflection2D, ctrl2dTb );
4361 createTool( SMESHOp::OpAspectRatio3D, ctrl3dTb );
4362 createTool( SMESHOp::OpVolume, ctrl3dTb );
4363 createTool( SMESHOp::OpMaxElementLength3D, ctrl3dTb );
4364 createTool( SMESHOp::OpBareBorderVolume, ctrl3dTb );
4365 createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
4366 createTool( SMESHOp::OpEqualVolume, ctrl3dTb );
4368 createTool( SMESHOp::OpNode, addElemTb );
4369 createTool( SMESHOp::OpElem0D, addElemTb );
4370 createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4371 createTool( SMESHOp::OpBall, addElemTb );
4372 createTool( SMESHOp::OpEdge, addElemTb );
4373 createTool( SMESHOp::OpTriangle, addElemTb );
4374 createTool( SMESHOp::OpQuadrangle, addElemTb );
4375 createTool( SMESHOp::OpPolygon, addElemTb );
4376 createTool( SMESHOp::OpTetrahedron, addElemTb );
4377 createTool( SMESHOp::OpHexahedron, addElemTb );
4378 createTool( SMESHOp::OpPentahedron, addElemTb );
4379 createTool( SMESHOp::OpPyramid, addElemTb );
4380 createTool( SMESHOp::OpHexagonalPrism, addElemTb );
4381 createTool( SMESHOp::OpPolyhedron, addElemTb );
4383 createTool( SMESHOp::OpQuadraticEdge, addNonElemTb );
4384 createTool( SMESHOp::OpQuadraticTriangle, addNonElemTb );
4385 createTool( SMESHOp::OpBiQuadraticTriangle, addNonElemTb );
4386 createTool( SMESHOp::OpQuadraticQuadrangle, addNonElemTb );
4387 createTool( SMESHOp::OpBiQuadraticQuadrangle, addNonElemTb );
4388 createTool( SMESHOp::OpQuadraticPolygon, addNonElemTb );
4389 createTool( SMESHOp::OpQuadraticTetrahedron, addNonElemTb );
4390 createTool( SMESHOp::OpQuadraticPyramid, addNonElemTb );
4391 createTool( SMESHOp::OpQuadraticPentahedron, addNonElemTb );
4392 createTool( SMESHOp::OpBiQuadraticPentahedron, addNonElemTb );
4393 createTool( SMESHOp::OpQuadraticHexahedron, addNonElemTb );
4394 createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4396 createTool( SMESHOp::OpRemoveNodes, remTb );
4397 createTool( SMESHOp::OpRemoveElements, remTb );
4398 createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4399 createTool( SMESHOp::OpClearMesh, remTb );
4401 //createTool( SMESHOp::OpRenumberingNodes, renumbTb );
4402 //createTool( SMESHOp::OpRenumberingElements, renumbTb );
4404 createTool( SMESHOp::OpMergeNodes, transformTb );
4405 createTool( SMESHOp::OpMergeElements, transformTb );
4406 createTool( SMESHOp::OpTranslation, transformTb );
4407 createTool( SMESHOp::OpRotation, transformTb );
4408 createTool( SMESHOp::OpSymmetry, transformTb );
4409 createTool( SMESHOp::OpScale, transformTb );
4410 createTool( SMESHOp::OpOffset, transformTb );
4411 createTool( SMESHOp::OpSewing, transformTb );
4412 createTool( SMESHOp::OpDuplicateNodes, transformTb );
4414 createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4415 createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4416 createTool( SMESHOp::OpExtrusion, modifyTb );
4417 createTool( SMESHOp::OpExtrusionAlongAPath, modifyTb );
4418 createTool( SMESHOp::OpRevolution, modifyTb );
4419 createTool( SMESHOp::OpOrientation, modifyTb );
4420 createTool( SMESHOp::OpReorientFaces, modifyTb );
4421 createTool( SMESHOp::OpMoveNode, modifyTb );
4422 createTool( SMESHOp::OpDiagonalInversion, modifyTb );
4423 createTool( SMESHOp::OpUnionOfTwoTriangle, modifyTb );
4424 createTool( SMESHOp::OpUnionOfTriangles, modifyTb );
4425 createTool( SMESHOp::OpCuttingOfQuadrangles, modifyTb );
4426 createTool( SMESHOp::OpSplitVolumes, modifyTb );
4427 createTool( SMESHOp::OpSplitBiQuadratic, modifyTb );
4428 createTool( SMESHOp::OpSmoothing, modifyTb );
4429 createTool( SMESHOp::OpPatternMapping, modifyTb );
4431 createTool( SMESHOp::OpMinimumDistance, measuremTb );
4433 createTool( SMESHOp::OpUpdate, dispModeTb );
4435 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4436 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4440 OB = "'ObjectBrowser'",
4441 View = "'" + SVTK_Viewer::Type() + "'",
4443 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4444 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4445 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4446 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4447 smesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::COMPONENT ) ),
4448 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4449 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4450 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4451 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4452 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4453 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4454 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4456 mesh_part = mesh + " " + subMesh + " " + group,
4457 mesh_group = mesh + " " + group,
4458 mesh_submesh = mesh + " " + subMesh,
4459 hyp_alg = hypo + " " + algo;
4461 // popup for object browser
4463 isInvisible("not( isVisible )"),
4464 isEmpty("numberOfNodes = 0"),
4465 isNotEmpty("numberOfNodes <> 0"),
4467 // has nodes, edges, etc in VISIBLE! actor
4468 hasNodes("(numberOfNodes > 0 ) && hasActor"),
4469 hasElems("(count( elemTypes ) > 0)"),
4470 hasDifferentElems("(count( elemTypes ) > 1)"),
4471 hasDifferentObjElems("(count( objElemTypes ) > 1)"),
4472 hasBalls("({'BallElem'} in elemTypes)"),
4473 hasElems0d("({'Elem0d'} in elemTypes)"),
4474 hasEdges("({'Edge'} in elemTypes)"),
4475 hasFaces("({'Face'} in elemTypes)"),
4476 hasVolumes("({'Volume'} in elemTypes)"),
4477 hasFacesOrVolumes("(({'Face'} in elemTypes) || ({'Volume'} in elemTypes)) ");
4479 createPopupItem( SMESHOp::OpFileInformation, OB, mesh, "&& selcount=1 && isImported" );
4480 createPopupItem( SMESHOp::OpCreateSubMesh, OB, mesh, "&& hasGeomReference");
4481 createPopupItem( SMESHOp::OpEditMesh, OB, mesh, "&& selcount=1" );
4482 createPopupItem( SMESHOp::OpEditSubMesh, OB, subMesh, "&& selcount=1 && hasGeomReference" );
4483 createPopupItem( SMESHOp::OpEditGroup, OB, group );
4484 createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4486 popupMgr()->insert( separator(), -1, 0 );
4487 createPopupItem( SMESHOp::OpCompute, OB, mesh, "&& selcount=1 && isComputable" );
4488 createPopupItem( SMESHOp::OpComputeSubMesh, OB, subMesh, "&& selcount=1 && isComputable" );
4489 createPopupItem( SMESHOp::OpPreCompute, OB, mesh, "&& selcount=1 && isPreComputable" );
4490 createPopupItem( SMESHOp::OpEvaluate, OB, mesh, "&& selcount=1 && isComputable" );
4491 createPopupItem( SMESHOp::OpMeshOrder, OB, mesh, "&& selcount=1 && isComputable && hasGeomReference" );
4492 createPopupItem( SMESHOp::OpUpdate, OB, mesh_part );
4493 createPopupItem( SMESHOp::OpMeshInformation, OB, mesh_part );
4494 createPopupItem( SMESHOp::OpFindElementByPoint,OB, mesh_group, "&& selcount=1" );
4495 createPopupItem( SMESHOp::OpOverallMeshQuality,OB, mesh_part );
4496 popupMgr()->insert( separator(), -1, 0 );
4497 createPopupItem( SMESHOp::OpCreateGroup, OB, mesh, "&& selcount=1" );
4498 createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh, "&& selcount=1 && hasGeomReference" );
4499 createPopupItem( SMESHOp::OpConstructGroup, OB, subMesh );
4500 popupMgr()->insert( separator(), -1, 0 );
4501 createPopupItem( SMESHOp::OpEditHypothesis, OB, hypo, "&& isEditableHyp");
4502 createPopupItem( SMESHOp::OpUnassign, OB, hyp_alg );
4503 popupMgr()->insert( separator(), -1, 0 );
4504 createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh_submesh );
4505 createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh_group, "&& selcount=1 && dim>=2");
4506 popupMgr()->insert( separator(), -1, 0 );
4507 createPopupItem( SMESHOp::OpClearMesh, OB, mesh );
4508 //popupMgr()->insert( separator(), -1, 0 );
4510 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4511 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4512 QString only_one_2D = only_one_non_empty + " && dim>1";
4514 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4515 createPopupItem( SMESHOp::OpPopupExportMED, OB, mesh_group, multiple_non_empty, anId );
4516 createPopupItem( SMESHOp::OpPopupExportUNV, OB, mesh_group, only_one_non_empty, anId );
4517 createPopupItem( SMESHOp::OpPopupExportSTL, OB, mesh_group, only_one_2D, anId );
4519 createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4521 createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, only_one_non_empty, anId );
4522 createPopupItem( SMESHOp::OpPopupExportGMF, OB, mesh_group, only_one_non_empty, anId );
4523 createPopupItem( SMESHOp::OpPopupExportDAT, OB, mesh_group, only_one_non_empty, anId );
4524 createPopupItem( SMESHOp::OpDelete, OB, mesh_part + " " + hyp_alg );
4525 createPopupItem( SMESHOp::OpDeleteGroup, OB, group );
4527 anId = popupMgr()->insert( tr( "MEN_IMPORT" ), -1, -1 ); // IMPORT submenu
4528 createPopupItem( SMESHOp::OpPopupImportMED, OB, smesh, "", anId );
4529 createPopupItem( SMESHOp::OpPopupImportUNV, OB, smesh, "", anId );
4530 createPopupItem( SMESHOp::OpPopupImportSTL, OB, smesh, "", anId );
4532 createPopupItem( SMESHOp::OpPopupImportCGNS, OB, smesh, "", anId );
4534 createPopupItem( SMESHOp::OpPopupImportSAUV, OB, smesh, "", anId );
4535 createPopupItem( SMESHOp::OpPopupImportGMF, OB, smesh, "", anId );
4536 createPopupItem( SMESHOp::OpPopupImportDAT, OB, smesh, "", anId );
4537 popupMgr()->insert( separator(), -1, 0 );
4540 createPopupItem( SMESHOp::OpEditGroup, View, group );
4541 createPopupItem( SMESHOp::OpAddElemGroupPopup, View, elems, "&& guiState = 800" );
4542 createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems, "&& guiState = 800" );
4544 popupMgr()->insert( separator(), -1, 0 );
4545 createPopupItem( SMESHOp::OpUpdate, View, mesh_part );
4546 createPopupItem( SMESHOp::OpMeshInformation, View, mesh_part );
4547 createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4548 createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh );
4549 popupMgr()->insert( separator(), -1, 0 );
4551 createPopupItem( SMESHOp::OpAutoColor, OB + " " + View, mesh, "&& (not isAutoColor)" );
4552 createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4553 popupMgr()->insert( separator(), -1, 0 );
4555 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4556 QString aType = QString( "%1type in {%2}" ).arg( lc );
4557 aType = aType.arg( mesh_part );
4558 QString aMeshInVTK = aClient + "&&" + aType;
4560 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4561 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4562 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4564 //-------------------------------------------------
4566 //-------------------------------------------------
4567 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4569 popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4570 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4571 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4573 popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4574 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4575 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4577 popupMgr()->insert( separator(), -1, -1 );
4579 //-------------------------------------------------
4581 //-------------------------------------------------
4582 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4584 popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4585 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4586 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4588 popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4589 popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4590 popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4592 popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4593 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4594 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4596 popupMgr()->insert( separator(), anId, -1 );
4598 popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4599 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4600 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4602 //-------------------------------------------------
4604 //-------------------------------------------------
4605 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4607 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4609 popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4610 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4611 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4613 popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4614 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4615 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4617 popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4618 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4619 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4621 popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4622 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4623 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4625 popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4626 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4627 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4629 popupMgr()->insert( separator(), anId, -1 );
4631 popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4632 popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&& $type in {" + mesh + "} &&" + hasDifferentObjElems, QtxPopupMgr::VisibleRule );
4634 popupMgr()->insert( separator(), anId, -1 );
4636 popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4637 popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4640 //-------------------------------------------------
4641 // Representation of the 2D Quadratic elements
4642 //-------------------------------------------------
4643 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4644 popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4645 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "&& isVisible && isQuadratic",QtxPopupMgr::VisibleRule );
4646 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4648 popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4649 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "&& isVisible && isQuadratic", QtxPopupMgr::VisibleRule );
4650 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4652 //-------------------------------------------------
4653 // Orientation of faces
4654 //-------------------------------------------------
4655 popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4656 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4657 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4659 //-------------------------------------------------
4661 //-------------------------------------------------
4662 popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4663 popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4665 //-------------------------------------------------
4667 //-------------------------------------------------
4668 popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4669 popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4671 //-------------------------------------------------
4673 //-------------------------------------------------
4675 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4676 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4677 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4678 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4680 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4682 popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4683 popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4685 popupMgr()->insert( separator(), anId, -1 );
4687 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4689 popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4690 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4691 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4693 popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4694 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4695 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4697 // popupMgr()->insert( action( SMESHOp::OpNodeConnectivityNb ), aSubId, -1 );
4698 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4699 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), "controlMode = 'eNodeConnectivityNb'", QtxPopupMgr::ToggleRule );
4701 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4703 popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4704 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVTK + "&&" + hasEdges + "&&" + hasFacesOrVolumes, QtxPopupMgr::VisibleRule );
4705 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4707 popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4708 popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4709 popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4711 popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4712 popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4713 popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4714 popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4715 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4716 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4718 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4720 popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4721 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4722 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4724 popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4725 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4726 QtxPopupMgr::VisibleRule );
4727 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4729 popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4730 popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4731 popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4733 popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4734 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4735 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4737 popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
4738 popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4739 popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4741 popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
4742 popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4743 popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4745 popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
4746 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4747 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4749 popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
4750 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4751 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4753 popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
4754 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4755 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4757 popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
4758 popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4759 popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4761 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
4762 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4763 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4765 popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
4766 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4767 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4769 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
4770 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4771 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4773 popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
4774 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4775 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4777 popupMgr()->insert ( action( SMESHOp::OpDeflection2D ), aSubId, -1 );
4778 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), aMeshInVtkHasFaces + " && hasGeomReference", QtxPopupMgr::VisibleRule );
4779 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), "controlMode = 'eDeflection2D'", QtxPopupMgr::ToggleRule );
4781 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4783 popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D ), aSubId, -1 );
4784 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4785 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4787 popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
4788 popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4789 popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4791 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
4792 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4793 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4795 popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
4796 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4797 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4799 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
4800 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4801 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4803 popupMgr()->insert ( action( SMESHOp::OpEqualVolume ), aSubId, -1 );
4804 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4805 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4807 popupMgr()->insert( separator(), anId, -1 );
4809 popupMgr()->insert( action( SMESHOp::OpShowScalarBar ), anId, -1 );
4810 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4811 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone' && isScalarBarVisible", QtxPopupMgr::ToggleRule );
4812 popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
4813 popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4815 popupMgr()->insert( separator(), anId, -1 );
4817 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4819 popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
4820 popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4822 popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
4823 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4824 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isScalarBarVisible && isDistributionVisible", QtxPopupMgr::ToggleRule);
4826 #ifndef DISABLE_PLOT2DVIEWER
4827 popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
4828 popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4831 //-------------------------------------------------
4833 //-------------------------------------------------
4834 popupMgr()->insert( separator(), -1, -1 );
4835 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4836 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4837 popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
4838 popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4840 popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
4841 popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4843 popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
4844 popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4846 popupMgr()->insert( separator(), -1, -1 );
4848 //-------------------------------------------------
4850 //-------------------------------------------------
4851 popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
4852 popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4854 popupMgr()->insert( separator(), -1, -1 );
4856 popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
4857 popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
4858 popupMgr()->insert( separator(), -1, -1 );
4860 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4861 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4863 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4864 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4867 //================================================================================
4869 * \brief Return true if SMESH or GEOM objects are selected.
4870 * Is called form LightApp_Module::activateModule() which clear selection if
4871 * not isSelectionCompatible()
4873 //================================================================================
4875 bool SMESHGUI::isSelectionCompatible()
4877 bool isCompatible = true;
4878 SALOME_ListIO selected;
4879 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4880 Sel->selectedObjects( selected );
4882 SALOME_ListIteratorOfListIO It( selected );
4883 for ( ; isCompatible && It.More(); It.Next())
4885 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4886 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4888 return isCompatible;
4892 bool SMESHGUI::reusableOperation( const int id )
4894 // compute, evaluate and precompute are not reusable operations
4895 return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate ) ? false : SalomeApp_Module::reusableOperation( id );
4898 bool SMESHGUI::activateModule( SUIT_Study* study )
4900 bool res = SalomeApp_Module::activateModule( study );
4902 setMenuShown( true );
4903 setToolShown( true );
4905 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4906 PyGILState_STATE gstate = PyGILState_Ensure();
4907 PyObject* pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4908 if ( !pluginsmanager ) {
4912 PyObject* result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toUtf8().data(),tr("SMESH_PLUGINS_OTHER").toUtf8().data());
4917 PyGILState_Release(gstate);
4918 // end of SMESH plugins loading
4920 // Reset actions accelerator keys
4921 action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
4923 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4924 GetSMESHGen()->UpdateStudy();
4926 // get all view currently opened in the study and connect their signals to
4927 // the corresponding slots of the class.
4928 SUIT_Desktop* aDesk = study->application()->desktop();
4930 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4931 SUIT_ViewWindow* wnd;
4932 foreach ( wnd, wndList )
4936 Py_XDECREF(pluginsmanager);
4940 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4942 setMenuShown( false );
4943 setToolShown( false );
4945 EmitSignalCloseAllDialogs();
4947 // Unset actions accelerator keys
4948 action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
4950 return SalomeApp_Module::deactivateModule( study );
4953 void SMESHGUI::studyClosed( SUIT_Study* s )
4957 SMESH::RemoveVisuData();
4958 SalomeApp_Module::studyClosed( s );
4961 void SMESHGUI::OnGUIEvent()
4963 const QObject* obj = sender();
4964 if ( !obj || !obj->inherits( "QAction" ) )
4966 int id = actionId((QAction*)obj);
4971 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4973 if ( CORBA::is_nil( myComponentSMESH ) )
4975 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4976 return aGUI.myComponentSMESH;
4978 return myComponentSMESH;
4981 QString SMESHGUI::engineIOR() const
4983 CORBA::ORB_var anORB = getApp()->orb();
4984 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4985 return QString( anIOR.in() );
4988 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4990 SalomeApp_Module::contextMenuPopup( client, menu, title );
4992 selectionMgr()->selectedObjects( lst );
4993 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4994 Handle(SALOME_InteractiveObject) io = lst.First();
4995 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4996 _PTR(Study) study = appStudy->studyDS();
4997 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4999 QString aName = SMESH::fromUtf8( obj->GetName());
5000 while ( !aName.isEmpty() && aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
5001 aName.remove(( aName.length() - 1 ), 1 );
5007 LightApp_Selection* SMESHGUI::createSelection() const
5009 return new SMESHGUI_Selection();
5012 void SMESHGUI::windows( QMap<int, int>& aMap ) const
5014 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
5015 aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
5016 #ifndef DISABLE_PYCONSOLE
5017 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
5021 void SMESHGUI::viewManagers( QStringList& list ) const
5023 list.append( SVTK_Viewer::Type() );
5026 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
5028 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
5029 SMESH::UpdateSelectionProp( this );
5031 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
5032 for(int i = 0; i < aViews.count() ; i++){
5033 SUIT_ViewWindow *sf = aViews[i];
5036 EmitSignalActivatedViewManager();
5040 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
5042 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
5043 myClippingPlaneInfoMap.erase( theViewManager );
5046 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
5048 theActor->AddObserver( SMESH::DeleteActorEvent,
5049 myEventCallbackCommand.GetPointer(),
5053 void SMESHGUI::ProcessEvents( vtkObject* theObject,
5054 unsigned long theEvent,
5055 void* theClientData,
5058 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
5059 if( theObject && (int) theEvent == SMESH::DeleteActorEvent ) {
5060 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
5061 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
5062 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
5063 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
5064 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
5065 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
5066 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
5067 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
5068 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
5069 SMESH::TActorList::iterator anIter3 = anActorList.begin();
5070 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
5071 if( anActor == *anIter3 ) {
5072 anActorList.erase( anIter3 );
5083 void SMESHGUI::createPreferences()
5085 // General tab ------------------------------------------------------------------------
5086 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
5088 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
5089 setPreferenceProperty( autoUpdate, "columns", 2 );
5090 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
5091 setPreferenceProperty( lim, "min", 0 );
5092 setPreferenceProperty( lim, "max", 100000000 );
5093 setPreferenceProperty( lim, "step", 1000 );
5094 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5095 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
5097 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
5098 setPreferenceProperty( dispgroup, "columns", 2 );
5100 addPreference( tr( "PREF_FITALL_ON_DISPLAYONLY" ), dispgroup, LightApp_Preferences::Bool, "SMESH", "fitall_on_displayonly" );
5102 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
5104 modes.append( tr("MEN_WIRE") );
5105 modes.append( tr("MEN_SHADE") );
5106 modes.append( tr("MEN_NODES") );
5107 modes.append( tr("MEN_SHRINK") );
5108 QList<QVariant> indices;
5109 indices.append( 0 );
5110 indices.append( 1 );
5111 indices.append( 2 );
5112 indices.append( 3 );
5113 setPreferenceProperty( dispmode, "strings", modes );
5114 setPreferenceProperty( dispmode, "indexes", indices );
5116 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
5117 setPreferenceProperty( arcgroup, "columns", 2 );
5118 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
5119 QStringList quadraticModes;
5120 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
5121 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
5123 indices.append( 0 );
5124 indices.append( 1 );
5125 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
5126 setPreferenceProperty( quadraticmode, "indexes", indices );
5128 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
5129 "SMESH", "max_angle" );
5130 setPreferenceProperty( maxAngle, "min", 1 );
5131 setPreferenceProperty( maxAngle, "max", 90 );
5133 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
5134 setPreferenceProperty( qaGroup, "columns", 2 );
5135 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
5136 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
5137 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
5138 setPreferenceProperty( prec, "min", 0 );
5139 setPreferenceProperty( prec, "max", 100 );
5140 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
5141 setPreferenceProperty( doubleNodesTol, "precision", 10 );
5142 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
5143 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
5144 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
5147 int cinc = addPreference(tr("PREF_CONTROLS_INCREMENT"), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_increment");
5148 setPreferenceProperty( cinc, "min", 0 );
5149 setPreferenceProperty( cinc, "max", 5 );
5152 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
5153 setPreferenceProperty( exportgroup, "columns", 2 );
5154 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
5155 addPreference( tr( "PREF_SHOW_WARN" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "show_warning" );
5156 int zTol = addPreference( tr( "PREF_ZTOLERANCE" ), exportgroup, LightApp_Preferences::DblSpin, "SMESH", "med_ztolerance" );
5157 setPreferenceProperty( zTol, "precision", 10 );
5158 setPreferenceProperty( zTol, "min", 0.0000000001 );
5159 setPreferenceProperty( zTol, "max", 1000000.0 );
5160 setPreferenceProperty( zTol, "step", 1. );
5161 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
5163 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
5164 setPreferenceProperty( computeGroup, "columns", 2 );
5165 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
5167 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5168 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5169 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5171 indices.append( 0 );
5172 indices.append( 1 );
5173 indices.append( 2 );
5174 setPreferenceProperty( notifyMode, "strings", modes );
5175 setPreferenceProperty( notifyMode, "indexes", indices );
5177 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5178 setPreferenceProperty( infoGroup, "columns", 2 );
5179 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5181 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5182 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5184 indices.append( 0 );
5185 indices.append( 1 );
5186 setPreferenceProperty( elemInfo, "strings", modes );
5187 setPreferenceProperty( elemInfo, "indexes", indices );
5188 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5189 setPreferenceProperty( nodesLim, "min", 0 );
5190 setPreferenceProperty( nodesLim, "max", 10000000 );
5191 setPreferenceProperty( nodesLim, "step", 10000 );
5192 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5193 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5194 setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5195 setPreferenceProperty( ctrlLim, "min", 0 );
5196 setPreferenceProperty( ctrlLim, "max", 10000000 );
5197 setPreferenceProperty( ctrlLim, "step", 1000 );
5198 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5199 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5200 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5201 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5202 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5204 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5205 setPreferenceProperty( segGroup, "columns", 2 );
5206 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5207 "SMESH", "segmentation" );
5208 setPreferenceProperty( segLen, "min", 1 );
5209 setPreferenceProperty( segLen, "max", 10000000 );
5210 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5211 "SMESH", "nb_segments_per_edge" );
5212 setPreferenceProperty( nbSeg, "min", 1 );
5213 setPreferenceProperty( nbSeg, "max", 10000000 );
5214 addPreference( tr( "PREF_USE_MESHGEMS_HYPOSET" ), segGroup, LightApp_Preferences::Bool, "SMESH", "use-meshgems-hypo-sets" );
5216 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5217 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5218 "SMESH", "forget_mesh_on_hyp_modif" );
5221 // Quantities with individual precision settings
5222 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5223 setPreferenceProperty( precGroup, "columns", 2 );
5225 const int nbQuantities = 6;
5226 int precs[nbQuantities], ii = 0;
5227 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5228 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5229 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5230 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5231 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5232 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5233 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5234 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5235 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5236 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5237 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5238 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5240 // Set property for precision value for spinboxes
5241 for ( ii = 0; ii < nbQuantities; ii++ ){
5242 setPreferenceProperty( precs[ii], "min", -14 );
5243 setPreferenceProperty( precs[ii], "max", 14 );
5244 setPreferenceProperty( precs[ii], "precision", 2 );
5247 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5248 setPreferenceProperty( previewGroup, "columns", 2 );
5249 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5250 setPreferenceProperty( chunkSize, "min", 1 );
5251 setPreferenceProperty( chunkSize, "max", 1000 );
5252 setPreferenceProperty( chunkSize, "step", 50 );
5254 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5255 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5257 // Mesh tab ------------------------------------------------------------------------
5258 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5259 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5260 setPreferenceProperty( nodeGroup, "columns", 3 );
5262 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5264 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5266 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5267 QList<QVariant> aMarkerTypeIndicesList;
5268 QList<QVariant> aMarkerTypeIconsList;
5269 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5270 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5271 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5272 aMarkerTypeIndicesList << i;
5273 aMarkerTypeIconsList << pixmap;
5275 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5276 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
5278 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5280 QList<QVariant> aMarkerScaleIndicesList;
5281 QStringList aMarkerScaleValuesList;
5282 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5283 aMarkerScaleIndicesList << i;
5284 //aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5285 aMarkerScaleValuesList << QString::number( i );
5287 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5288 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5290 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5291 //setPreferenceProperty( elemGroup, "columns", 2 );
5293 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5294 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5295 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5296 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5297 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5298 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5299 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5300 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5301 addPreference( tr( "PREF_PREVIEW_COLOR" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5304 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5305 setPreferenceProperty( grpGroup, "columns", 2 );
5307 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5308 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5310 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5311 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5312 /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5313 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5314 double ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5315 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5316 double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5317 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5318 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
5319 LightApp_Preferences::IntSpin, "SMESH", "element_width");
5320 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5321 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5322 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5323 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5325 setPreferenceProperty( size0d, "min", 1 );
5326 setPreferenceProperty( size0d, "max", 10 );
5328 // setPreferenceProperty( ballSize, "min", 1 );
5329 // setPreferenceProperty( ballSize, "max", 10 );
5331 setPreferenceProperty( ballDiameter, "min", 1e-7 );
5332 setPreferenceProperty( ballDiameter, "max", 1e9 );
5333 setPreferenceProperty( ballDiameter, "step", 0.1 );
5335 setPreferenceProperty( ballScale, "min", 1e-2 );
5336 setPreferenceProperty( ballScale, "max", 1e7 );
5337 setPreferenceProperty( ballScale, "step", 0.5 );
5339 setPreferenceProperty( elemW, "min", 1 );
5340 setPreferenceProperty( elemW, "max", 5 );
5342 setPreferenceProperty( outW, "min", 1 );
5343 setPreferenceProperty( outW, "max", 5 );
5345 setPreferenceProperty( shrink, "min", 0 );
5346 setPreferenceProperty( shrink, "max", 100 );
5348 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5349 setPreferenceProperty( numGroup, "columns", 2 );
5351 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5352 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5354 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5355 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5357 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5358 setPreferenceProperty( orientGroup, "columns", 1 );
5360 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5361 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5363 setPreferenceProperty( orientScale, "min", 0.05 );
5364 setPreferenceProperty( orientScale, "max", 0.5 );
5365 setPreferenceProperty( orientScale, "step", 0.05 );
5367 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5369 // Selection tab ------------------------------------------------------------------------
5370 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5372 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5373 setPreferenceProperty( selGroup, "columns", 2 );
5375 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5376 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5378 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5379 setPreferenceProperty( preGroup, "columns", 2 );
5381 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5383 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5384 setPreferenceProperty( precSelGroup, "columns", 2 );
5386 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5387 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5388 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5390 int sinc = addPreference(tr("PREF_SELECTION_INCREMENT"), selTab, LightApp_Preferences::IntSpin, "SMESH", "selection_increment");
5391 setPreferenceProperty( sinc, "min", 0 );
5392 setPreferenceProperty( sinc, "max", 5 );
5394 // Scalar Bar tab ------------------------------------------------------------------------
5395 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5396 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5397 setPreferenceProperty( fontGr, "columns", 2 );
5399 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5400 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5402 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5403 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5405 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5406 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5408 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5409 setPreferenceProperty( numcol, "min", 2 );
5410 setPreferenceProperty( numcol, "max", 256 );
5412 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5413 setPreferenceProperty( numlab, "min", 2 );
5414 setPreferenceProperty( numlab, "max", 65 );
5416 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5417 setPreferenceProperty( orientGr, "columns", 2 );
5418 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5419 QStringList orients;
5420 orients.append( tr( "SMESH_VERTICAL" ) );
5421 orients.append( tr( "SMESH_HORIZONTAL" ) );
5422 indices.clear(); indices.append( 0 ); indices.append( 1 );
5423 setPreferenceProperty( orient, "strings", orients );
5424 setPreferenceProperty( orient, "indexes", indices );
5426 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5427 setPreferenceProperty( posVSizeGr, "columns", 2 );
5428 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5429 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5430 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5431 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5432 setPreferenceProperty( xv, "step", 0.1 );
5433 setPreferenceProperty( xv, "min", 0.0 );
5434 setPreferenceProperty( xv, "max", 1.0 );
5435 setPreferenceProperty( yv, "step", 0.1 );
5436 setPreferenceProperty( yv, "min", 0.0 );
5437 setPreferenceProperty( yv, "max", 1.0 );
5438 setPreferenceProperty( wv, "step", 0.1 );
5439 setPreferenceProperty( wv, "min", 0.0 );
5440 setPreferenceProperty( wv, "max", 1.0 );
5441 setPreferenceProperty( hv, "min", 0.0 );
5442 setPreferenceProperty( hv, "max", 1.0 );
5443 setPreferenceProperty( hv, "step", 0.1 );
5445 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5446 setPreferenceProperty( posHSizeGr, "columns", 2 );
5447 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5448 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5449 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5450 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5451 setPreferenceProperty( xv, "min", 0.0 );
5452 setPreferenceProperty( xv, "max", 1.0 );
5453 setPreferenceProperty( xv, "step", 0.1 );
5454 setPreferenceProperty( xh, "min", 0.0 );
5455 setPreferenceProperty( xh, "max", 1.0 );
5456 setPreferenceProperty( xh, "step", 0.1 );
5457 setPreferenceProperty( yh, "min", 0.0 );
5458 setPreferenceProperty( yh, "max", 1.0 );
5459 setPreferenceProperty( yh, "step", 0.1 );
5460 setPreferenceProperty( wh, "min", 0.0 );
5461 setPreferenceProperty( wh, "max", 1.0 );
5462 setPreferenceProperty( wh, "step", 0.1 );
5463 setPreferenceProperty( hh, "min", 0.0 );
5464 setPreferenceProperty( hh, "max", 1.0 );
5465 setPreferenceProperty( hh, "step", 0.1 );
5467 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5468 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5469 setPreferenceProperty( distributionGr, "columns", 3 );
5471 types.append( tr( "SMESH_MONOCOLOR" ) );
5472 types.append( tr( "SMESH_MULTICOLOR" ) );
5473 indices.clear(); indices.append( 0 ); indices.append( 1 );
5474 setPreferenceProperty( coloringType, "strings", types );
5475 setPreferenceProperty( coloringType, "indexes", indices );
5476 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5480 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5482 if ( sect=="SMESH" ) {
5483 float sbX1 = 0.01, sbY1 = 0.01, sbW = 0.08, sbH = 0.08;
5484 float aTol = 1.00000009999999;
5485 std::string aWarning;
5486 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5488 if ( name == "selection_object_color" ||
5489 name == "selection_element_color" ||
5490 name == "highlight_color" ||
5491 name == "selection_precision_node" ||
5492 name == "selection_precision_element" ||
5493 name == "selection_precision_object" ||
5494 name == "selection_increment")
5496 SMESH::UpdateSelectionProp( this );
5498 else if (name == "scalar_bar_vertical_x" || name == "scalar_bar_vertical_width")
5500 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5501 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5502 if ( sbX1+sbW > aTol ) {
5503 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5506 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5507 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5510 else if (name == "scalar_bar_vertical_y" || name == "scalar_bar_vertical_height" )
5512 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5513 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5514 if ( sbY1 + sbH > aTol ) {
5515 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5516 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5517 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5520 else if (name == "scalar_bar_horizontal_x" || name == "scalar_bar_horizontal_width")
5522 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5523 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5524 if ( sbX1 + sbW > aTol ) {
5525 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5528 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5529 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5532 else if (name == "scalar_bar_horizontal_y" || name == "scalar_bar_horizontal_height")
5534 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5535 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5536 if ( sbY1 + sbH > aTol ) {
5537 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5540 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5541 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5544 else if ( name == "segmentation" )
5546 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5547 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5549 else if ( name == "nb_segments_per_edge" )
5551 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5552 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5554 else if ( name == "historical_python_dump" || name == "forget_mesh_on_hyp_modif" || name == "default_grp_color" )
5556 QString val = aResourceMgr->stringValue( "SMESH", name );
5557 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5559 else if ( name == "numbering_node_color" || name == "numbering_node_font" )
5561 SMESH::UpdateFontProp( this );
5563 else if ( name == "numbering_elem_color" || name == "numbering_elem_font" )
5565 SMESH::UpdateFontProp( this );
5568 if ( aWarning.size() != 0 ) {
5569 aWarning += "The default values are applied instead.";
5570 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5571 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5572 QObject::tr(aWarning.c_str()));
5577 //================================================================================
5579 * \brief Update something in accordance with update flags
5580 * \param theFlags - update flags
5582 * Update viewer or/and object browser etc. in accordance with update flags ( see
5583 * LightApp_UpdateFlags enumeration ).
5585 //================================================================================
5586 void SMESHGUI::update( const int flags )
5588 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5589 SMESH::UpdateView();
5591 SalomeApp_Module::update( flags );
5594 //================================================================================
5596 * \brief Set default selection mode
5598 * SLOT called when operation committed. Sets default selection mode
5600 //================================================================================
5601 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5603 SVTK_ViewWindow* vtkWnd =
5604 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5606 vtkWnd->SetSelectionMode( ActorSelection );
5609 //================================================================================
5611 * \brief Set default selection mode
5613 * SLOT called when operation aborted. Sets default selection mode
5615 //================================================================================
5616 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5618 SVTK_ViewWindow* vtkWnd =
5619 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5621 vtkWnd->SetSelectionMode( ActorSelection );
5624 //================================================================================
5626 * \brief Creates operation with given identifier
5627 * \param id - identifier of operation to be started
5628 * \return Pointer on created operation or NULL if operation is not created
5630 * Virtual method redefined from the base class creates operation with given id.
5631 * It is called called automatically from startOperation method of base class.
5633 //================================================================================
5634 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5636 LightApp_Operation* op = 0;
5637 // to do : create operation here
5640 case SMESHOp::OpSplitBiQuadratic:
5641 op = new SMESHGUI_SplitBiQuadOp();
5643 case SMESHOp::OpConvertMeshToQuadratic:
5644 op = new SMESHGUI_ConvToQuadOp();
5646 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5647 op = new SMESHGUI_Make2DFrom3DOp();
5649 case SMESHOp::OpReorientFaces:
5650 op = new SMESHGUI_ReorientFacesOp();
5652 case SMESHOp::OpCreateMesh:
5653 op = new SMESHGUI_MeshOp( true, true );
5655 case SMESHOp::OpCreateSubMesh:
5656 op = new SMESHGUI_MeshOp( true, false );
5658 case SMESHOp::OpEditMeshOrSubMesh:
5659 case SMESHOp::OpEditMesh:
5660 case SMESHOp::OpEditSubMesh:
5661 op = new SMESHGUI_MeshOp( false );
5663 case SMESHOp::OpCompute:
5664 case SMESHOp::OpComputeSubMesh:
5665 op = new SMESHGUI_ComputeOp();
5667 case SMESHOp::OpPreCompute:
5668 op = new SMESHGUI_PrecomputeOp();
5670 case SMESHOp::OpEvaluate:
5671 op = new SMESHGUI_EvaluateOp();
5673 case SMESHOp::OpMeshOrder:
5674 op = new SMESHGUI_MeshOrderOp();
5676 case SMESHOp::OpCreateGeometryGroup:
5677 op = new SMESHGUI_GroupOnShapeOp();
5679 case SMESHOp::OpFindElementByPoint:
5680 op = new SMESHGUI_FindElemByPointOp();
5682 case SMESHOp::OpMoveNode: // Make mesh pass through point
5683 op = new SMESHGUI_MakeNodeAtPointOp();
5685 case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
5686 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5693 op = SalomeApp_Module::createOperation( id );
5697 //================================================================================
5699 * \brief Stops current operations and starts a given one
5700 * \param id - The id of the operation to start
5702 //================================================================================
5704 void SMESHGUI::switchToOperation(int id)
5706 activeStudy()->abortAllOperations();
5707 startOperation( id );
5710 LightApp_Displayer* SMESHGUI::displayer()
5713 myDisplayer = new SMESHGUI_Displayer( getApp() );
5717 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5720 int aTolerance = 64;
5721 int anIterations = 0;
5727 if( anIterations % aPeriod == 0 )
5730 if( aTolerance < 1 )
5734 aHue = (int)( 360.0 * rand() / RAND_MAX );
5737 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5738 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5739 for( ; it != itEnd; ++it )
5741 SALOMEDS::Color anAutoColor = *it;
5742 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5745 aQColor.getHsv( &h, &s, &v );
5746 if( abs( h - aHue ) < aTolerance )
5758 aColor.setHsv( aHue, 255, 255 );
5760 SALOMEDS::Color aSColor;
5761 aSColor.R = aColor.redF();
5762 aSColor.G = aColor.greenF();
5763 aSColor.B = aColor.blueF();
5768 const char* gSeparator = "_"; // character used to separate parameter names
5769 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5770 const char* gPathSep = "|"; // character used to separate paths
5773 * \brief Store visual parameters
5775 * This method is called just before the study document is saved.
5776 * Store visual parameters in AttributeParameter attribute(s)
5778 void SMESHGUI::storeVisualParameters (int savePoint)
5781 Kernel_Utils::Localizer loc;
5783 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5784 if (!appStudy || !appStudy->studyDS())
5786 _PTR(Study) studyDS = appStudy->studyDS();
5788 // componentName is used for encoding of entries when storing them in IParameters
5789 std::string componentName = myComponentSMESH->ComponentDataType();
5790 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5791 //if (!aSComponent) return;
5794 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5795 componentName.c_str(),
5797 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5799 // store custom markers
5800 if( !myMarkerMap.empty() )
5802 VTK::MarkerMap::const_iterator anIter = myMarkerMap.begin();
5803 for( ; anIter != myMarkerMap.end(); anIter++ )
5805 int anId = anIter->first;
5806 VTK::MarkerData aMarkerData = anIter->second;
5807 std::string aMarkerFileName = aMarkerData.first;
5808 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5809 if( aMarkerTexture.size() < 3 )
5810 continue; // should contain at least width, height and the first value
5812 QString aPropertyName( "texture" );
5813 aPropertyName += gSeparator;
5814 aPropertyName += QString::number( anId );
5816 QString aPropertyValue = aMarkerFileName.c_str();
5817 aPropertyValue += gPathSep;
5819 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5820 ushort aWidth = *aTextureIter++;
5821 ushort aHeight = *aTextureIter++;
5822 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5823 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5824 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5825 aPropertyValue += QString::number( *aTextureIter );
5827 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5831 // viewers counters are used for storing view_numbers in IParameters
5834 // main cycle to store parameters of displayed objects
5835 QList<SUIT_ViewManager*> lst;
5836 QList<SUIT_ViewManager*>::Iterator it;
5837 getApp()->viewManagers(lst);
5838 for (it = lst.begin(); it != lst.end(); it++)
5840 SUIT_ViewManager* vman = *it;
5841 QString vType = vman->getType();
5843 // saving VTK actors properties
5844 if (vType == SVTK_Viewer::Type())
5846 // store the clipping planes attached to the view manager
5847 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5848 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5849 if( anIter != myClippingPlaneInfoMap.end() )
5850 aClippingPlaneInfoList = anIter->second;
5852 if( !aClippingPlaneInfoList.empty() ) {
5853 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5854 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5856 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5857 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5859 QString aPropertyName( "ClippingPlane" );
5860 aPropertyName += gSeparator;
5861 aPropertyName += QString::number( vtkViewers );
5862 aPropertyName += gSeparator;
5863 aPropertyName += QString::number( anId );
5865 QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
5866 aPropertyValue += gDigitsSep;
5867 aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
5868 aPropertyValue += gDigitsSep;
5869 if ( aPlane->PlaneMode == SMESH::Absolute ) {
5870 aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
5871 aPropertyValue += gDigitsSep;
5872 aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
5873 aPropertyValue += gDigitsSep;
5874 aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
5875 aPropertyValue += gDigitsSep;
5876 aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
5877 aPropertyValue += gDigitsSep;
5878 aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
5879 aPropertyValue += gDigitsSep;
5880 aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
5881 aPropertyValue += gDigitsSep;
5882 aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
5884 else if ( aPlane->PlaneMode == SMESH::Relative ) {
5885 aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
5886 aPropertyValue += gDigitsSep;
5887 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5888 aPropertyValue += gDigitsSep;
5889 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5890 aPropertyValue += gDigitsSep;
5891 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5894 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5898 QVector<SUIT_ViewWindow*> views = vman->getViews();
5899 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5901 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5903 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5904 vtkActorCollection* allActors = aCopy.GetActors();
5905 allActors->InitTraversal();
5906 while (vtkActor* actor = allActors->GetNextActor())
5908 if (actor->GetVisibility()) // store only visible actors
5910 SMESH_Actor* aSmeshActor = 0;
5911 if (actor->IsA("SMESH_Actor"))
5912 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5913 if (aSmeshActor && aSmeshActor->hasIO())
5915 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5918 // entry is "encoded" = it does NOT contain component address,
5919 // since it is a subject to change on next component loading
5920 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5922 std::string param, vtkParam = vType.toLatin1().data();
5923 vtkParam += gSeparator;
5924 vtkParam += QString::number(vtkViewers).toLatin1().data();
5925 vtkParam += gSeparator;
5928 param = vtkParam + "Visibility";
5929 ip->setParameter(entry, param, "On");
5932 param = vtkParam + "Representation";
5933 ip->setParameter(entry, param, QString::number
5934 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5937 param = vtkParam + "IsShrunk";
5938 ip->setParameter(entry, param, QString::number
5939 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5941 // Displayed entities
5942 unsigned int aMode = aSmeshActor->GetEntityMode();
5943 bool isE = aMode & SMESH_Actor::eEdges;
5944 bool isF = aMode & SMESH_Actor::eFaces;
5945 bool isV = aMode & SMESH_Actor::eVolumes;
5946 bool is0d = aMode & SMESH_Actor::e0DElements;
5947 bool isB = aMode & SMESH_Actor::eBallElem;
5949 QString modeStr ("e");
5950 modeStr += gDigitsSep; modeStr += QString::number(isE);
5951 modeStr += gDigitsSep; modeStr += "f";
5952 modeStr += gDigitsSep; modeStr += QString::number(isF);
5953 modeStr += gDigitsSep; modeStr += "v";
5954 modeStr += gDigitsSep; modeStr += QString::number(isV);
5955 modeStr += gDigitsSep; modeStr += "0d";
5956 modeStr += gDigitsSep; modeStr += QString::number(is0d);
5957 modeStr += gDigitsSep; modeStr += "b";
5958 modeStr += gDigitsSep; modeStr += QString::number(isB);
5960 param = vtkParam + "Entities";
5961 ip->setParameter(entry, param, modeStr.toLatin1().data());
5967 aSmeshActor->GetSufaceColor(r, g, b, delta);
5968 QStringList colorStr;
5969 colorStr << "surface";
5970 colorStr << QString::number(r);
5971 colorStr << QString::number(g);
5972 colorStr << QString::number(b);
5974 colorStr << "backsurface";
5975 colorStr << QString::number(delta);
5977 aSmeshActor->GetVolumeColor(r, g, b, delta);
5978 colorStr << "volume";
5979 colorStr << QString::number(r);
5980 colorStr << QString::number(g);
5981 colorStr << QString::number(b);
5982 colorStr << QString::number(delta);
5984 aSmeshActor->GetEdgeColor(r, g, b);
5986 colorStr << QString::number(r);
5987 colorStr << QString::number(g);
5988 colorStr << QString::number(b);
5990 aSmeshActor->GetNodeColor(r, g, b);
5992 colorStr << QString::number(r);
5993 colorStr << QString::number(g);
5994 colorStr << QString::number(b);
5996 aSmeshActor->GetOutlineColor(r, g, b);
5997 colorStr << "outline";
5998 colorStr << QString::number(r);
5999 colorStr << QString::number(g);
6000 colorStr << QString::number(b);
6002 aSmeshActor->Get0DColor(r, g, b);
6003 colorStr << "elem0d";
6004 colorStr << QString::number(r);
6005 colorStr << QString::number(g);
6006 colorStr << QString::number(b);
6008 aSmeshActor->GetBallColor(r, g, b);
6010 colorStr << QString::number(r);
6011 colorStr << QString::number(g);
6012 colorStr << QString::number(b);
6014 aSmeshActor->GetFacesOrientationColor(r, g, b);
6015 colorStr << "orientation";
6016 colorStr << QString::number(r);
6017 colorStr << QString::number(g);
6018 colorStr << QString::number(b);
6020 param = vtkParam + "Colors";
6021 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
6024 QStringList sizeStr;
6026 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
6027 sizeStr << "outline";
6028 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
6029 sizeStr << "elem0d";
6030 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
6032 //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
6033 sizeStr << QString::number((double)aSmeshActor->GetBallSize());
6034 sizeStr << QString::number((double)aSmeshActor->GetBallScale());
6035 sizeStr << "shrink";
6036 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
6037 sizeStr << "orientation";
6038 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
6039 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
6041 param = vtkParam + "Sizes";
6042 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
6047 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
6048 if( aMarkerType == VTK::MT_USER ) {
6049 markerStr += "custom";
6050 markerStr += gDigitsSep;
6051 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
6055 markerStr += gDigitsSep;
6056 markerStr += QString::number( (int)aMarkerType );
6057 markerStr += gDigitsSep;
6058 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
6061 param = vtkParam + "PointMarker";
6062 ip->setParameter(entry, param, markerStr.toLatin1().data());
6065 param = vtkParam + "Opacity";
6066 ip->setParameter(entry, param,
6067 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
6070 param = vtkParam + "ClippingPlane";
6072 if( !aClippingPlaneInfoList.empty() ) {
6073 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
6074 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
6076 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
6077 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
6078 SMESH::TActorList::iterator anIter2 = anActorList.begin();
6079 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
6080 if( aSmeshActor == *anIter2 ) {
6081 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
6082 QString::number( anId ).toLatin1().constData() );
6089 ip->setParameter( entry, param, "Off" );
6090 } // if (io->hasEntry())
6091 } // SMESH_Actor && hasIO
6093 } // while.. actors traversal
6097 } // if (SVTK view model)
6098 } // for (viewManagers)
6101 // data structures for clipping planes processing
6105 bool isOpenGLClipping;
6106 vtkIdType RelativeOrientation;
6109 int AbsoluteOrientation;
6110 double X, Y, Z, Dx, Dy, Dz;
6112 typedef std::list<TPlaneData> TPlaneDataList;
6113 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
6115 typedef std::list<vtkActor*> TActorList;
6118 TActorList ActorList;
6119 SUIT_ViewManager* ViewManager;
6121 typedef std::list<TPlaneInfo> TPlaneInfoList;
6122 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
6125 * \brief Restore visual parameters
6127 * This method is called after the study document is opened.
6128 * Restore visual parameters from AttributeParameter attribute(s)
6130 void SMESHGUI::restoreVisualParameters (int savePoint)
6133 Kernel_Utils::Localizer loc;
6135 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6136 if (!appStudy || !appStudy->studyDS())
6138 _PTR(Study) studyDS = appStudy->studyDS();
6140 // componentName is used for encoding of entries when storing them in IParameters
6141 std::string componentName = myComponentSMESH->ComponentDataType();
6142 //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
6143 //if (!aSComponent) return;
6146 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6147 componentName.c_str(),
6149 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6151 // restore custom markers and map of clipping planes
6152 TPlaneDataMap aPlaneDataMap;
6154 std::vector<std::string> properties = ip->getProperties();
6155 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
6157 std::string property = *propIt;
6158 QString aPropertyName( property.c_str() );
6159 QString aPropertyValue( ip->getProperty( property ).c_str() );
6161 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
6162 if( aPropertyNameList.isEmpty() )
6165 QString aPropertyType = aPropertyNameList[0];
6166 if( aPropertyType == "texture" )
6168 if( aPropertyNameList.size() != 2 )
6172 int anId = aPropertyNameList[1].toInt( &ok );
6173 if( !ok || anId < 1 )
6176 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
6177 if( aPropertyValueList.size() != 2 )
6180 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
6181 QString aMarkerTextureString = aPropertyValueList[1];
6182 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
6183 if( aMarkerTextureStringList.size() != 3 )
6187 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6192 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6196 VTK::MarkerTexture aMarkerTexture;
6197 aMarkerTexture.push_back( aWidth );
6198 aMarkerTexture.push_back( aHeight );
6200 QString aMarkerTextureData = aMarkerTextureStringList[2];
6201 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6203 QChar aChar = aMarkerTextureData.at( i );
6204 if( aChar.isDigit() )
6205 aMarkerTexture.push_back( aChar.digitValue() );
6208 myMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6210 else if( aPropertyType == "ClippingPlane" )
6212 if( aPropertyNameList.size() != 3 )
6216 int aViewId = aPropertyNameList[1].toInt( &ok );
6217 if( !ok || aViewId < 0 )
6221 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6222 if( !ok || aClippingPlaneId < 0 )
6225 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6226 if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6229 TPlaneData aPlaneData;
6230 aPlaneData.AbsoluteOrientation = false;
6231 aPlaneData.RelativeOrientation = 0;
6232 aPlaneData.Distance = aPlaneData.Angle[0] = aPlaneData.Angle[1] = 0;
6233 aPlaneData.X = aPlaneData.Y = aPlaneData.Z = 0;
6234 aPlaneData.Dx = aPlaneData.Dy = aPlaneData.Dz = 0;
6236 aPlaneData.Id = aClippingPlaneId;
6239 aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6244 aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6248 if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6251 aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6256 aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6261 aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6266 aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6271 aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6276 aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6281 aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6285 else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6287 aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6292 aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6297 aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6302 aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6307 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6308 aPlaneDataList.push_back( aPlaneData );
6312 TPlaneInfoMap aPlaneInfoMap;
6314 std::vector<std::string> entries = ip->getEntries();
6316 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6318 // entry is a normal entry - it should be "decoded" (setting base address of component)
6319 QString entry (ip->decodeEntry(*entIt).c_str());
6321 // Check that the entry corresponds to a real object in the Study
6322 // as the object may be deleted or modified after the visual state is saved.
6323 _PTR(SObject) so = studyDS->FindObjectID(entry.toUtf8().data());
6324 if (!so) continue; //Skip the not existent entry
6326 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6327 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6329 std::vector<std::string>::iterator namesIt = paramNames.begin();
6330 std::vector<std::string>::iterator valuesIt = paramValues.begin();
6332 // actors are stored in a map after displaying of them for
6333 // quicker access in the future: map < viewID to actor >
6334 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6336 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6338 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6339 // '_' is used as separator and should not be used in viewer type or parameter names.
6340 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6341 if (lst.size() != 3)
6344 QString viewerTypStr = lst[0];
6345 QString viewIndexStr = lst[1];
6346 QString paramNameStr = lst[2];
6349 int viewIndex = viewIndexStr.toUInt(&ok);
6350 if (!ok) // bad conversion of view index to integer
6354 if (viewerTypStr == SVTK_Viewer::Type())
6356 SMESH_Actor* aSmeshActor = 0;
6357 if (vtkActors.IsBound(viewIndex))
6358 aSmeshActor = vtkActors.Find(viewIndex);
6360 QList<SUIT_ViewManager*> lst;
6361 getApp()->viewManagers(viewerTypStr, lst);
6363 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6364 SUIT_ViewManager* vman = NULL;
6365 if (viewIndex >= 0 && viewIndex < lst.count())
6366 vman = lst.at(viewIndex);
6368 if (paramNameStr == "Visibility")
6370 if (!aSmeshActor && displayer() && vman)
6372 SUIT_ViewModel* vmodel = vman->getViewModel();
6373 // SVTK view model can be casted to SALOME_View
6374 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6376 // store displayed actor in a temporary map for quicker
6377 // access later when restoring other parameters
6378 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6379 vtkRenderer* Renderer = vtkView->getRenderer();
6380 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6381 vtkActorCollection* theActors = aCopy.GetActors();
6382 theActors->InitTraversal();
6383 bool isFound = false;
6384 vtkActor *ac = theActors->GetNextActor();
6385 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6386 if (ac->IsA("SMESH_Actor")) {
6387 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6388 if (aGeomAc->hasIO()) {
6389 Handle(SALOME_InteractiveObject) io = aGeomAc->getIO();
6390 if (io->hasEntry() && strcmp(io->getEntry(), entry.toUtf8().data()) == 0) {
6392 vtkActors.Bind(viewIndex, aGeomAc);
6398 } // if (paramNameStr == "Visibility")
6401 // the rest properties "work" with SMESH_Actor
6404 QString val ((*valuesIt).c_str());
6407 if (paramNameStr == "Representation") {
6408 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6411 else if (paramNameStr == "IsShrunk") {
6413 if (!aSmeshActor->IsShrunk())
6414 aSmeshActor->SetShrink();
6417 if (aSmeshActor->IsShrunk())
6418 aSmeshActor->UnShrink();
6421 // Displayed entities
6422 else if (paramNameStr == "Entities") {
6423 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6424 int aEntityMode = SMESH_Actor::eAllEntity;
6425 for ( int i = 0; i < mode.count(); i+=2 ) {
6426 if ( i < mode.count()-1 ) {
6427 QString type = mode[i];
6428 bool val = mode[i+1].toInt();
6429 if ( type == "e" && !val )
6430 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6431 else if ( type == "f" && !val )
6432 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6433 else if ( type == "v" && !val )
6434 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6435 else if ( type == "0d" && !val )
6436 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6437 else if ( type == "b" && !val )
6438 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6441 aSmeshActor->SetEntityMode( aEntityMode );
6444 else if (paramNameStr == "Colors") {
6445 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6452 QColor outlineColor;
6453 QColor orientationColor;
6459 // below lines are required to get default values for delta coefficients
6460 // of backface color for faces and color of reversed volumes
6461 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
6462 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6463 for ( int i = 0; i < colors.count(); i++ ) {
6464 QString type = colors[i];
6465 if ( type == "surface" ) {
6466 // face color is set by 3 values r:g:b, where
6467 // - r,g,b - is rgb color components
6468 if ( i+1 >= colors.count() ) break; // format error
6469 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6470 if ( i+2 >= colors.count() ) break; // format error
6471 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6472 if ( i+3 >= colors.count() ) break; // format error
6473 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6474 faceColor.setRgbF( r, g, b );
6477 else if ( type == "backsurface" ) {
6478 // backface color can be defined in several ways
6479 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6480 // - in latest versions, it is set as delta coefficient
6481 bool rgbOk = false, deltaOk;
6482 if ( i+1 >= colors.count() ) break; // format error
6483 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6484 int delta = colors[i+1].toInt( &deltaOk );
6486 if ( i+1 < colors.count() ) // index is shifted to 1
6487 g = colors[i+1].toDouble( &rgbOk );
6488 if ( rgbOk ) i++; // shift index
6489 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6490 b = colors[i+1].toDouble( &rgbOk );
6492 // - as currently there's no way to set directly backsurface color as it was before,
6493 // we ignore old dump where r,g,b triple was set
6494 // - also we check that delta parameter is set properly
6495 if ( !rgbOk && deltaOk )
6498 else if ( type == "volume" ) {
6499 // volume color is set by 4 values r:g:b:delta, where
6500 // - r,g,b - is a normal volume rgb color components
6501 // - delta - is a reversed volume color delta coefficient
6502 if ( i+1 >= colors.count() ) break; // format error
6503 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6504 if ( i+2 >= colors.count() ) break; // format error
6505 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6506 if ( i+3 >= colors.count() ) break; // format error
6507 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6508 if ( i+4 >= colors.count() ) break; // format error
6509 int delta = colors[i+4].toInt( &bOk );
6510 if ( !bOk ) break; // format error
6511 volumeColor.setRgbF( r, g, b );
6515 else if ( type == "edge" ) {
6516 // edge color is set by 3 values r:g:b, where
6517 // - r,g,b - is rgb color components
6518 if ( i+1 >= colors.count() ) break; // format error
6519 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6520 if ( i+2 >= colors.count() ) break; // format error
6521 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6522 if ( i+3 >= colors.count() ) break; // format error
6523 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6524 edgeColor.setRgbF( r, g, b );
6527 else if ( type == "node" ) {
6528 // node color is set by 3 values r:g:b, where
6529 // - r,g,b - is rgb color components
6530 if ( i+1 >= colors.count() ) break; // format error
6531 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6532 if ( i+2 >= colors.count() ) break; // format error
6533 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6534 if ( i+3 >= colors.count() ) break; // format error
6535 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6536 nodeColor.setRgbF( r, g, b );
6539 else if ( type == "elem0d" ) {
6540 // 0d element color is set by 3 values r:g:b, where
6541 // - r,g,b - is rgb color components
6542 if ( i+1 >= colors.count() ) break; // format error
6543 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6544 if ( i+2 >= colors.count() ) break; // format error
6545 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6546 if ( i+3 >= colors.count() ) break; // format error
6547 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6548 elem0dColor.setRgbF( r, g, b );
6551 else if ( type == "ball" ) {
6552 // ball color is set by 3 values r:g:b, where
6553 // - r,g,b - is rgb color components
6554 if ( i+1 >= colors.count() ) break; // format error
6555 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6556 if ( i+2 >= colors.count() ) break; // format error
6557 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6558 if ( i+3 >= colors.count() ) break; // format error
6559 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6560 ballColor.setRgbF( r, g, b );
6563 else if ( type == "outline" ) {
6564 // outline color is set by 3 values r:g:b, where
6565 // - r,g,b - is rgb color components
6566 if ( i+1 >= colors.count() ) break; // format error
6567 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6568 if ( i+2 >= colors.count() ) break; // format error
6569 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6570 if ( i+3 >= colors.count() ) break; // format error
6571 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6572 outlineColor.setRgbF( r, g, b );
6575 else if ( type == "orientation" ) {
6576 // orientation color is set by 3 values r:g:b, where
6577 // - r,g,b - is rgb color components
6578 if ( i+1 >= colors.count() ) break; // format error
6579 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6580 if ( i+2 >= colors.count() ) break; // format error
6581 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6582 if ( i+3 >= colors.count() ) break; // format error
6583 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6584 orientationColor.setRgbF( r, g, b );
6589 if ( nodeColor.isValid() )
6590 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6592 if ( edgeColor.isValid() )
6593 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6595 if ( faceColor.isValid() )
6596 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6598 if ( volumeColor.isValid() )
6599 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6600 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6601 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6603 if ( elem0dColor.isValid() )
6604 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6606 if ( ballColor.isValid() )
6607 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6609 if ( outlineColor.isValid() )
6610 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6611 // orientation color
6612 if ( orientationColor.isValid() )
6613 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6616 else if (paramNameStr == "Sizes") {
6617 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6620 int outlineWidth = -1;
6621 int elem0dSize = -1;
6622 //int ballSize = -1;
6623 double ballDiameter = -1.0;
6624 double ballScale = -1.0;
6625 double shrinkSize = -1;
6626 double orientationSize = -1;
6627 bool orientation3d = false;
6628 for ( int i = 0; i < sizes.count(); i++ ) {
6629 QString type = sizes[i];
6630 if ( type == "line" ) {
6631 // line (wireframe) width is given as single integer value
6632 if ( i+1 >= sizes.count() ) break; // format error
6633 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6637 if ( type == "outline" ) {
6638 // outline width is given as single integer value
6639 if ( i+1 >= sizes.count() ) break; // format error
6640 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6644 else if ( type == "elem0d" ) {
6645 // 0d element size is given as single integer value
6646 if ( i+1 >= sizes.count() ) break; // format error
6647 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6651 else if ( type == "ball" ) {
6652 // balls are specified by two values: size:scale, where
6653 // - size - is a integer value specifying size
6654 // - scale - is a double value specifying scale factor
6655 if ( i+1 >= sizes.count() ) break; // format error
6656 //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6657 double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6658 if ( i+2 >= sizes.count() ) break; // format error
6659 double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6665 else if ( type == "shrink" ) {
6666 // shrink factor is given as single floating point value
6667 if ( i+1 >= sizes.count() ) break; // format error
6668 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6672 else if ( type == "orientation" ) {
6673 // orientation vectors are specified by two values size:3d, where
6674 // - size - is a floating point value specifying scale factor
6675 // - 3d - is a boolean
6676 if ( i+1 >= sizes.count() ) break; // format error
6677 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6678 if ( i+2 >= sizes.count() ) break; // format error
6679 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6680 orientationSize = v1;
6681 orientation3d = (bool)v2;
6685 // line (wireframe) width
6686 if ( lineWidth > 0 )
6687 aSmeshActor->SetLineWidth( lineWidth );
6689 if ( outlineWidth > 0 )
6690 aSmeshActor->SetOutlineWidth( outlineWidth );
6691 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6692 aSmeshActor->SetOutlineWidth( lineWidth );
6694 if ( elem0dSize > 0 )
6695 aSmeshActor->Set0DSize( elem0dSize );
6697 /*if ( ballSize > 0 )
6698 aSmeshActor->SetBallSize( ballSize );*/
6700 if ( ballDiameter > 0 )
6701 aSmeshActor->SetBallSize( ballDiameter );
6703 if ( ballScale > 0.0 )
6704 aSmeshActor->SetBallScale( ballScale );
6706 if ( shrinkSize > 0 )
6707 aSmeshActor->SetShrinkFactor( shrinkSize );
6708 // orientation vectors
6709 if ( orientationSize > 0 ) {
6710 aSmeshActor->SetFacesOrientationScale( orientationSize );
6711 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6715 else if (paramNameStr == "PointMarker") {
6716 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6717 if( data.count() >= 2 ) {
6719 int aParam1 = data[1].toInt( &ok );
6721 if( data[0] == "std" && data.count() == 3 ) {
6722 int aParam2 = data[2].toInt( &ok );
6723 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6725 else if( data[0] == "custom" ) {
6726 VTK::MarkerMap::const_iterator markerIt = myMarkerMap.find( aParam1 );
6727 if( markerIt != myMarkerMap.end() ) {
6728 VTK::MarkerData aMarkerData = markerIt->second;
6729 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6736 else if (paramNameStr == "Opacity") {
6737 aSmeshActor->SetOpacity(val.toFloat());
6740 else if (paramNameStr.startsWith("ClippingPlane")) {
6741 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6742 // old format - val looks like "Off" or "1:0:0:0.5:0:0"
6743 // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
6744 // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
6745 // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
6746 // new format - val looks like "Off" or "0" (plane id)
6747 // (note: in new format "Off" value is used only for consistency,
6748 // so it is processed together with values in old format)
6749 bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
6750 if( anIsOldFormat ) {
6751 if (paramNameStr == "ClippingPlane1" || val == "Off")
6752 aSmeshActor->RemoveAllClippingPlanes();
6754 QList<SUIT_ViewManager*> lst;
6755 getApp()->viewManagers(viewerTypStr, lst);
6756 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6757 if (viewIndex >= 0 && viewIndex < lst.count()) {
6758 SUIT_ViewManager* vman = lst.at(viewIndex);
6759 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6761 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6763 SMESH::TActorList anActorList;
6764 anActorList.push_back( aSmeshActor );
6765 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
6766 aPlane->myViewWindow = vtkView;
6767 SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
6768 aPlane->PlaneMode = aMode;
6769 bool isOpenGLClipping = ( bool )vals[1].toInt();
6770 aPlane->IsOpenGLClipping = isOpenGLClipping;
6771 if ( aMode == SMESH::Absolute ) {
6772 aPlane->myAbsoluteOrientation = vals[2].toInt();
6773 aPlane->X = vals[3].toFloat();
6774 aPlane->Y = vals[4].toFloat();
6775 aPlane->Z = vals[5].toFloat();
6776 aPlane->Dx = vals[6].toFloat();
6777 aPlane->Dy = vals[7].toFloat();
6778 aPlane->Dz = vals[8].toFloat();
6780 else if ( aMode == SMESH::Relative ) {
6781 aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
6782 aPlane->myDistance = vals[3].toFloat();
6783 aPlane->myAngle[0] = vals[4].toFloat();
6784 aPlane->myAngle[1] = vals[5].toFloat();
6788 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6789 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6790 aClippingPlaneInfo.Plane = aPlane;
6791 aClippingPlaneInfo.ActorList = anActorList;
6792 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6800 int aPlaneId = val.toInt( &ok );
6801 if( ok && aPlaneId >= 0 ) {
6802 bool anIsDefinedPlane = false;
6803 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6804 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6805 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6806 TPlaneInfo& aPlaneInfo = *anIter;
6807 if( aPlaneInfo.PlaneId == aPlaneId ) {
6808 aPlaneInfo.ActorList.push_back( aSmeshActor );
6809 anIsDefinedPlane = true;
6813 if( !anIsDefinedPlane ) {
6814 TPlaneInfo aPlaneInfo;
6815 aPlaneInfo.PlaneId = aPlaneId;
6816 aPlaneInfo.ActorList.push_back( aSmeshActor );
6817 aPlaneInfo.ViewManager = vman;
6819 // to make the list sorted by plane id
6820 anIter = aPlaneInfoList.begin();
6821 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6822 const TPlaneInfo& aPlaneInfoRef = *anIter;
6823 if( aPlaneInfoRef.PlaneId > aPlaneId )
6826 aPlaneInfoList.insert( anIter, aPlaneInfo );
6831 } // if (aSmeshActor)
6832 } // other parameters than Visibility
6834 } // for names/parameters iterator
6835 } // for entries iterator
6837 // take into account planes with empty list of actors referred to them
6838 QList<SUIT_ViewManager*> aVMList;
6839 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6841 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6842 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6843 int aViewId = aPlaneDataIter->first;
6844 if( aViewId >= 0 && aViewId < aVMList.count() ) {
6845 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6847 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6849 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6850 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6851 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6852 const TPlaneData& aPlaneData = *anIter2;
6853 int aPlaneId = aPlaneData.Id;
6855 bool anIsFound = false;
6856 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6857 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6858 const TPlaneInfo& aPlaneInfo = *anIter3;
6859 if( aPlaneInfo.PlaneId == aPlaneId ) {
6866 TPlaneInfo aPlaneInfo; // ActorList field is empty
6867 aPlaneInfo.PlaneId = aPlaneId;
6868 aPlaneInfo.ViewManager = aViewManager;
6870 // to make the list sorted by plane id
6871 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6872 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6873 const TPlaneInfo& aPlaneInfoRef = *anIter4;
6874 if( aPlaneInfoRef.PlaneId > aPlaneId )
6877 aPlaneInfoList.insert( anIter4, aPlaneInfo );
6883 // add clipping planes to actors according to the restored parameters
6884 // and update the clipping plane map
6885 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6886 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6887 int aViewId = anIter1->first;
6888 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6890 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6891 if( anIter2 == aPlaneDataMap.end() )
6893 const TPlaneDataList& aPlaneDataList = anIter2->second;
6895 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6896 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6897 const TPlaneInfo& aPlaneInfo = *anIter3;
6898 int aPlaneId = aPlaneInfo.PlaneId;
6899 const TActorList& anActorList = aPlaneInfo.ActorList;
6900 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6904 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6908 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6910 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6911 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6912 const TPlaneData& aPlaneData = *anIter4;
6913 if( aPlaneData.Id == aPlaneId ) {
6914 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
6915 aPlane->myViewWindow = aViewWindow;
6916 aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
6917 aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
6918 if ( aPlane->PlaneMode == SMESH::Absolute ) {
6919 aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
6920 aPlane->X = aPlaneData.X;
6921 aPlane->Y = aPlaneData.Y;
6922 aPlane->Z = aPlaneData.Z;
6923 aPlane->Dx = aPlaneData.Dx;
6924 aPlane->Dy = aPlaneData.Dy;
6925 aPlane->Dz = aPlaneData.Dz;
6927 else if ( aPlane->PlaneMode == SMESH::Relative ) {
6928 aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
6929 aPlane->myDistance = aPlaneData.Distance;
6930 aPlane->myAngle[0] = aPlaneData.Angle[0];
6931 aPlane->myAngle[1] = aPlaneData.Angle[1];
6934 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6935 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6936 aClippingPlaneInfo.Plane = aPlane;
6937 aClippingPlaneInfo.ActorList = anActorList;
6938 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6949 // update all VTK views
6950 QList<SUIT_ViewManager*> lst;
6951 getApp()->viewManagers(lst);
6952 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6953 SUIT_ViewModel* vmodel = (*it)->getViewModel();
6954 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6955 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6956 // set OpenGL clipping planes
6957 VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
6958 vtkActorCollection* anAllActors = aCopy.GetActors();
6959 anAllActors->InitTraversal();
6960 while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
6961 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
6962 anActor->SetOpenGLClippingPlane();
6964 vtkView->getRenderer()->ResetCameraClippingRange();
6971 \brief Adds preferences for dfont of VTK viewer
6973 \param pIf group identifier
6974 \param param parameter
6975 \return identifier of preferences
6977 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
6979 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6981 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6984 fam.append( tr( "SMESH_FONT_ARIAL" ) );
6985 fam.append( tr( "SMESH_FONT_COURIER" ) );
6986 fam.append( tr( "SMESH_FONT_TIMES" ) );
6988 setPreferenceProperty( tfont, "fonts", fam );
6990 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6991 if ( needSize ) f = f | QtxFontEdit::Size;
6992 setPreferenceProperty( tfont, "features", f );
6998 \brief Actions after hypothesis edition
6999 Updates object browser after hypothesis edition
7001 void SMESHGUI::onHypothesisEdit( int result )
7004 SMESHGUI::Modified();
7005 updateObjBrowser( true );
7009 \brief Actions after choosing menu of control modes
7010 Updates control mode actions according to current selection
7012 void SMESHGUI::onUpdateControlActions()
7014 SALOME_ListIO selected;
7015 if ( LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr() )
7016 aSel->selectedObjects( selected );
7018 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
7019 if ( selected.Extent() ) {
7020 if ( selected.First()->hasEntry() ) {
7021 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( selected.First()->getEntry() )) {
7022 aControl = anActor->GetControlMode();
7023 SALOME_ListIteratorOfListIO it(selected);
7024 for ( it.Next(); it.More(); it.Next() ) {
7025 Handle(SALOME_InteractiveObject) anIO = it.Value();
7026 if ( anIO->hasEntry() ) {
7027 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
7028 if ( aControl != anActor->GetControlMode() ) {
7029 aControl = SMESH_Actor::eNone;
7039 int anAction = ActionToControl( aControl, true );
7041 action( anAction )->setChecked( true );
7043 QMenu* send = (QMenu*)sender();
7044 QList<QAction*> actions = send->actions();
7045 for ( int i = 0; i < actions.size(); i++ )
7046 actions[i]->setChecked( false );
7052 \brief Signal handler closing(SUIT_ViewWindow*) of a view
7053 \param pview view being closed
7055 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
7056 #ifndef DISABLE_PLOT2DVIEWER
7057 //Crear all Plot2d Viewers if need.
7058 SMESH::ClearPlot2Viewers(pview);
7060 EmitSignalCloseView();
7063 void SMESHGUI::message( const QString& msg )
7066 QStringList data = msg.split("/");
7067 if ( data.count() > 0 ) {
7068 if ( data.first() == "mesh_loading" ) {
7070 QString entry = data.count() > 1 ? data[1] : QString();
7071 if ( entry.isEmpty() )
7074 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
7076 _PTR(SObject) obj = study->FindObjectID( entry.toUtf8().constData() );
7079 name = SMESH::fromUtf8(obj->GetName());
7080 if ( name.isEmpty() )
7083 if ( data.last() == "stop" )
7084 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
7086 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
7087 QApplication::processEvents();
7093 \brief Connects or disconnects signals about activating and cloning view on the module slots
7094 \param pview view which is connected/disconnected
7096 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
7100 SUIT_ViewManager* viewMgr = pview->getViewManager();
7102 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7103 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7105 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7106 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7111 \brief Return \c true if object can be renamed
7113 bool SMESHGUI::renameAllowed( const QString& entry) const {
7114 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7118 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7122 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
7127 if(appStudy->isComponent(entry) || obj->isReference())
7130 // check type to prevent renaming of inappropriate objects
7131 int aType = SMESHGUI_Selection::type(qPrintable(entry));
7132 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7133 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7134 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7135 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7136 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
7143 Rename object by entry.
7144 \param entry entry of the object
7145 \param name new name of the object
7146 \brief Return \c true if rename operation finished successfully, \c false otherwise.
7148 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
7150 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7154 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7159 _PTR(Study) aStudy = appStudy->studyDS();
7164 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
7166 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
7171 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
7172 _PTR(GenericAttribute) anAttr;
7173 _PTR(AttributeName) aName;
7175 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
7177 // check type to prevent renaming of inappropriate objects
7178 int aType = SMESHGUI_Selection::type( qPrintable(entry));
7179 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7180 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7181 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7182 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7183 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
7184 if ( !name.isEmpty() ) {
7185 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qUtf8Printable(name) );
7187 // update name of group object and its actor
7188 Handle(SALOME_InteractiveObject) IObject =
7189 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
7191 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
7192 if( !aGroupObject->_is_nil() ) {
7193 aGroupObject->SetName( qUtf8Printable(name) );
7194 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
7195 anActor->setName( qUtf8Printable(name) );
7205 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
7207 static QList<QColor> colors;
7209 if ( colors.isEmpty() ) {
7211 for (int s = 0; s < 2 ; s++)
7213 for (int v = 100; v >= 40; v = v - 20)
7215 for (int h = 0; h < 359 ; h = h + 60)
7217 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
7222 static int currentColor = randomize( colors.size() );
7224 SALOMEDS::Color color;
7225 color.R = (double)colors[currentColor].red() / 255.0;
7226 color.G = (double)colors[currentColor].green() / 255.0;
7227 color.B = (double)colors[currentColor].blue() / 255.0;
7229 currentColor = (currentColor+1) % colors.count();