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 // Break link with Shaper model
1386 void breakShaperLink()
1388 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1389 SALOME_ListIO selected;
1391 aSel->selectedObjects(selected);
1392 if (selected.Extent()) {
1393 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1394 _PTR(Study) aStudy = SMESH::getStudy();
1395 _PTR(SObject) aSObj = aStudy->FindObjectID(anIObject->getEntry());
1397 std::string aName = aSObj->GetName();
1398 QMessageBox::StandardButton aRes = SUIT_MessageBox::warning(SMESHGUI::desktop(),
1399 QObject::tr("SMESH_WRN_WARNING"),
1400 QObject::tr("MSG_BREAK_SHAPER_LINK").arg(aName.c_str()),
1401 SUIT_MessageBox::Yes | SUIT_MessageBox::No, SUIT_MessageBox::No);
1402 if (aRes == SUIT_MessageBox::Yes) {
1410 void SetDisplayMode(int theCommandID, VTK::MarkerMap& theMarkerMap)
1412 SALOME_ListIO selected;
1413 SalomeApp_Application* app =
1414 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1418 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1419 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1420 if ( !aSel || !appStudy )
1423 if ( theCommandID == SMESHOp::OpClipping ) { // Clipping dialog can be activated without selection
1424 if ( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
1425 aModule->EmitSignalDeactivateDialog();
1426 if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
1427 (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
1432 aSel->selectedObjects( selected );
1434 if ( selected.Extent() >= 1 )
1436 switch ( theCommandID ) {
1437 case SMESHOp::OpTransparency:
1439 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1440 (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
1443 case SMESHOp::OpProperties:
1446 QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
1447 QColor orientationColor, outlineColor, volumeColor;
1448 int deltaF = 0, deltaV = 0;
1451 double ballScale = 1.0;
1453 int outlineWidth = 1;
1454 double shrinkCoef = 0.0;
1455 double orientationScale = 0.0;
1456 bool orientation3d = false;
1457 VTK::MarkerType markerType = VTK::MT_NONE;
1458 VTK::MarkerScale markerScale = VTK::MS_NONE;
1460 bool hasNodes = false;
1461 int presentEntities = 0;
1462 bool firstTime = true;
1464 SALOME_ListIteratorOfListIO It( selected );
1465 for ( ; It.More(); It.Next() ) {
1466 Handle(SALOME_InteractiveObject) IObject = It.Value();
1467 if ( !IObject->hasEntry() ) continue;
1468 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1469 if ( !anActor || !anActor->GetObject() ) continue;
1472 // nodes: color, marker
1473 anActor->GetNodeColor( color[0], color[1], color[2] );
1474 nodeColor.setRgbF( color[0], color[1], color[2] );
1475 markerType = anActor->GetMarkerType();
1476 markerScale = anActor->GetMarkerScale();
1477 markerId = anActor->GetMarkerTexture();
1478 // edges: color, width
1479 anActor->GetEdgeColor( color[0], color[1], color[2] );
1480 edgeColor.setRgbF( color[0], color[1], color[2] );
1481 edgeWidth = qMax( (int)anActor->GetLineWidth(), 1 ); // minimum allowed width is 1
1482 // faces: front color, back color (delta)
1483 anActor->GetSufaceColor( color[0], color[1], color[2], deltaF );
1484 faceColor.setRgbF( color[0], color[1], color[2] );
1485 // faces: front color, back color (delta)
1486 anActor->GetVolumeColor( color[0], color[1], color[2], deltaV );
1487 volumeColor.setRgbF( color[0], color[1], color[2] );
1488 // 0d elements: color, size
1489 anActor->Get0DColor( color[0], color[1], color[2] );
1490 elem0dColor.setRgbF( color[0], color[1], color[2] );
1491 elem0dSize = qMax( (int)anActor->Get0DSize(), 1 ); // minimum allowed size is 1
1492 // balls: color, size
1493 anActor->GetBallColor( color[0], color[1], color[2] );
1494 ballColor.setRgbF( color[0], color[1], color[2] );
1495 //ballSize = qMax( (int)anActor->GetBallSize(), 1 ); // minimum allowed size is 1
1496 ballScale = qMax( (double)anActor->GetBallScale(), 1e-2 ); // minimum allowed scale is 1e-2
1498 anActor->GetOutlineColor( color[0], color[1], color[2] );
1499 outlineColor.setRgbF( color[0], color[1], color[2] );
1500 outlineWidth = qMax( (int)anActor->GetOutlineWidth(), 1 ); // minimum allowed width is 1
1501 // orientation vectors: color, scale, 3d flag
1502 anActor->GetFacesOrientationColor( color[0], color[1], color[2] );
1503 orientationColor.setRgbF( color[0], color[1], color[2] );
1504 orientationScale = anActor->GetFacesOrientationScale();
1505 orientation3d = anActor->GetFacesOrientation3DVectors();
1507 shrinkCoef = anActor->GetShrinkFactor();
1510 firstTime = false; // we only take properties from first object (for performance reasons)
1513 hasNodes = anActor->GetObject()->GetNbEntities( SMDSAbs_Node );
1514 if ( !(presentEntities & SMESH_Actor::eEdges) && anActor->GetObject()->GetNbEntities( SMDSAbs_Edge ) )
1515 presentEntities = presentEntities | SMESH_Actor::eEdges;
1516 if ( !(presentEntities & SMESH_Actor::eFaces) && anActor->GetObject()->GetNbEntities( SMDSAbs_Face ) )
1517 presentEntities = presentEntities | SMESH_Actor::eFaces;
1518 if ( !(presentEntities & SMESH_Actor::eVolumes) && anActor->GetObject()->GetNbEntities( SMDSAbs_Volume ) )
1519 presentEntities = presentEntities | SMESH_Actor::eVolumes;
1520 if ( !(presentEntities & SMESH_Actor::e0DElements) && anActor->GetObject()->GetNbEntities( SMDSAbs_0DElement ) )
1521 presentEntities = presentEntities | SMESH_Actor::e0DElements;
1522 if ( !(presentEntities & SMESH_Actor::eBallElem) && anActor->GetObject()->GetNbEntities( SMDSAbs_Ball ) )
1523 presentEntities = presentEntities | SMESH_Actor::eBallElem;
1525 // as we know that all types of elements are present, we can exit the loop
1526 if ( presentEntities == SMESH_Actor::eAllEntity )
1530 SMESHGUI_PropertiesDlg dlg( theMarkerMap, SMESHGUI::desktop() );
1531 // nodes: color, marker
1532 dlg.setNodeColor( nodeColor );
1533 if( markerType != VTK::MT_USER )
1534 dlg.setNodeMarker( markerType, markerScale );
1536 dlg.setNodeCustomMarker( markerId );
1537 // edges: color, line width
1538 dlg.setEdgeColor( edgeColor );
1539 dlg.setEdgeWidth( edgeWidth );
1540 // faces: front color, back color
1541 dlg.setFaceColor( faceColor, deltaF );
1542 // volumes: normal color, reversed color
1543 dlg.setVolumeColor( volumeColor, deltaV );
1544 // outlines: color, line width
1545 dlg.setOutlineColor( outlineColor );
1546 dlg.setOutlineWidth( outlineWidth );
1547 // 0d elements: color, size
1548 dlg.setElem0dColor( elem0dColor );
1549 dlg.setElem0dSize( elem0dSize );
1550 // balls: color, size
1551 dlg.setBallColor( ballColor );
1552 //dlg.setBallSize( ballSize );
1553 dlg.setBallScale( ballScale );
1554 // orientation: color, scale, 3d flag
1555 dlg.setOrientationColor( orientationColor );
1556 dlg.setOrientationSize( int( orientationScale * 100. ) );
1557 dlg.setOrientation3d( orientation3d );
1558 // shrink: scale factor
1559 dlg.setShrinkCoef( int( shrinkCoef * 100. ) );
1560 // hide unused controls
1561 dlg.showControls( presentEntities, hasNodes );
1564 nodeColor = dlg.nodeColor();
1565 markerType = dlg.nodeMarkerType();
1566 markerScale = dlg.nodeMarkerScale();
1567 markerId = dlg.nodeMarkerId();
1568 edgeColor = dlg.edgeColor();
1569 edgeWidth = dlg.edgeWidth();
1570 faceColor = dlg.faceColor();
1571 deltaF = dlg.faceColorDelta();
1572 volumeColor = dlg.volumeColor();
1573 deltaV = dlg.volumeColorDelta();
1574 outlineColor = dlg.outlineColor();
1575 outlineWidth = dlg.outlineWidth();
1576 elem0dColor = dlg.elem0dColor();
1577 elem0dSize = dlg.elem0dSize();
1578 ballColor = dlg.ballColor();
1579 // ballSize = dlg.ballSize();
1580 ballScale = dlg.ballScale();
1581 orientationColor = dlg.orientationColor();
1582 orientationScale = dlg.orientationSize() / 100.;
1583 orientation3d = dlg.orientation3d();
1584 shrinkCoef = dlg.shrinkCoef() / 100.;
1586 // store point markers that might be changed by the user
1587 theMarkerMap = dlg.customMarkers();
1589 // set properties from dialog box to the presentations
1590 SALOME_ListIteratorOfListIO It( selected );
1591 for ( ; It.More(); It.Next() ) {
1592 Handle(SALOME_InteractiveObject) IObject = It.Value();
1593 if ( !IObject->hasEntry() ) continue;
1594 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1595 if ( !anActor ) continue;
1597 // nodes: color, marker
1598 anActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
1599 if ( markerType != VTK::MT_USER ) {
1600 anActor->SetMarkerStd( markerType, markerScale );
1603 VTK::MarkerMap::const_iterator iter = theMarkerMap.find( markerId );
1604 if ( iter != theMarkerMap.end() )
1605 anActor->SetMarkerTexture( markerId, iter->second.second );
1607 // volumes: normal color, reversed color (delta)
1608 anActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
1609 // faces: front color, back color (delta)
1610 anActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
1611 // edges: color, width
1612 anActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
1613 anActor->SetLineWidth( edgeWidth );
1615 anActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
1616 anActor->SetOutlineWidth( outlineWidth );
1617 // 0D elements: color, size
1618 anActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
1619 anActor->Set0DSize( elem0dSize );
1620 // balls: color, size
1621 anActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
1622 // anActor->SetBallSize( ballSize );
1623 anActor->SetBallScale( ballScale );
1624 // orientation: color, scale, 3d flag
1625 anActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
1626 anActor->SetFacesOrientationScale( orientationScale );
1627 anActor->SetFacesOrientation3DVectors( orientation3d );
1629 anActor->SetShrinkFactor( shrinkCoef );
1631 // for groups, set also proper color
1632 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1633 if ( !aGroupObject->_is_nil() ) {
1634 SMESH::ElementType anElementType = aGroupObject->GetType();
1636 switch( anElementType ) {
1638 aColor = nodeColor; break;
1640 aColor = edgeColor; break;
1642 aColor = faceColor; break;
1644 aColor = volumeColor; break;
1646 aColor = elem0dColor; break;
1648 aColor = ballColor; break;
1652 if ( aColor.isValid() ) {
1653 SALOMEDS::Color aGroupColor;
1654 aGroupColor.R = aColor.redF();
1655 aGroupColor.G = aColor.greenF();
1656 aGroupColor.B = aColor.blueF();
1657 aGroupObject->SetColor( aGroupColor );
1659 } // if ( !aGroupObject->_is_nil() )
1660 } // for ( ; It.More(); It.Next() )
1661 SMESH::RepaintCurrentView();
1662 } // if ( dlg.exec() )
1664 } // case SMESHOp::OpProperties:
1665 } // switch(theCommandID)
1666 SUIT_OverrideCursor wc;
1667 SALOME_ListIteratorOfListIO It( selected );
1668 for( ; It.More(); It.Next()){
1669 Handle(SALOME_InteractiveObject) IObject = It.Value();
1670 if(IObject->hasEntry()){
1671 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1672 switch(theCommandID){
1673 case SMESHOp::OpDMWireframe:
1674 anActor->SetRepresentation(SMESH_Actor::eEdge);
1676 case SMESHOp::OpDMShading:
1677 anActor->SetRepresentation(SMESH_Actor::eSurface);
1679 case SMESHOp::OpDMShrink:
1680 if(anActor->IsShrunk())
1681 anActor->UnShrink();
1683 anActor->SetShrink();
1685 case SMESHOp::OpDMNodes:
1686 anActor->SetRepresentation(SMESH_Actor::ePoint);
1688 case SMESHOp::OpRepresentationLines:
1689 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1690 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1692 case SMESHOp::OpRepresentationArcs:
1693 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1694 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1700 SMESH::RepaintCurrentView();
1704 int ActionToControl( int theID, bool theReversed )
1706 NCollection_DoubleMap<int,int> ActionControl;
1707 ActionControl.Bind( 0, SMESH_Actor::eNone );
1708 ActionControl.Bind( SMESHOp::OpFreeNode, SMESH_Actor::eFreeNodes );
1709 ActionControl.Bind( SMESHOp::OpEqualNode, SMESH_Actor::eCoincidentNodes );
1710 ActionControl.Bind( SMESHOp::OpNodeConnectivityNb, SMESH_Actor::eNodeConnectivityNb );
1711 ActionControl.Bind( SMESHOp::OpFreeEdge, SMESH_Actor::eFreeEdges );
1712 ActionControl.Bind( SMESHOp::OpFreeBorder, SMESH_Actor::eFreeBorders );
1713 ActionControl.Bind( SMESHOp::OpLength, SMESH_Actor::eLength );
1714 ActionControl.Bind( SMESHOp::OpConnection, SMESH_Actor::eMultiConnection );
1715 ActionControl.Bind( SMESHOp::OpEqualEdge, SMESH_Actor::eCoincidentElems1D );
1716 ActionControl.Bind( SMESHOp::OpFreeFace, SMESH_Actor::eFreeFaces );
1717 ActionControl.Bind( SMESHOp::OpBareBorderFace, SMESH_Actor::eBareBorderFace );
1718 ActionControl.Bind( SMESHOp::OpOverConstrainedFace, SMESH_Actor::eOverConstrainedFace );
1719 ActionControl.Bind( SMESHOp::OpLength2D, SMESH_Actor::eLength2D );
1720 ActionControl.Bind( SMESHOp::OpDeflection2D, SMESH_Actor::eDeflection2D );
1721 ActionControl.Bind( SMESHOp::OpConnection2D, SMESH_Actor::eMultiConnection2D );
1722 ActionControl.Bind( SMESHOp::OpArea, SMESH_Actor::eArea );
1723 ActionControl.Bind( SMESHOp::OpTaper, SMESH_Actor::eTaper );
1724 ActionControl.Bind( SMESHOp::OpAspectRatio, SMESH_Actor::eAspectRatio );
1725 ActionControl.Bind( SMESHOp::OpMinimumAngle, SMESH_Actor::eMinimumAngle );
1726 ActionControl.Bind( SMESHOp::OpWarpingAngle, SMESH_Actor::eWarping );
1727 ActionControl.Bind( SMESHOp::OpSkew, SMESH_Actor::eSkew );
1728 ActionControl.Bind( SMESHOp::OpMaxElementLength2D, SMESH_Actor::eMaxElementLength2D );
1729 ActionControl.Bind( SMESHOp::OpEqualFace, SMESH_Actor::eCoincidentElems2D );
1730 ActionControl.Bind( SMESHOp::OpAspectRatio3D, SMESH_Actor::eAspectRatio3D );
1731 ActionControl.Bind( SMESHOp::OpVolume, SMESH_Actor::eVolume3D );
1732 ActionControl.Bind( SMESHOp::OpMaxElementLength3D, SMESH_Actor::eMaxElementLength3D );
1733 ActionControl.Bind( SMESHOp::OpBareBorderVolume, SMESH_Actor::eBareBorderVolume );
1734 ActionControl.Bind( SMESHOp::OpOverConstrainedVolume, SMESH_Actor::eOverConstrainedVolume );
1735 ActionControl.Bind( SMESHOp::OpEqualVolume, SMESH_Actor::eCoincidentElems3D );
1738 return ActionControl.IsBound2( theID ) ? ActionControl.Find2( theID ) : 0;
1739 return ActionControl.IsBound1( theID ) ? ActionControl.Find1( theID ) : 0;
1742 void Control( int theCommandID )
1744 SMESH_Actor::eControl aControl = SMESH_Actor::eControl( ActionToControl( theCommandID ));
1745 _PTR(Study) aStudy = SMESH::getStudy();
1747 SALOME_ListIO selected;
1748 if ( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
1749 aSel->selectedObjects( selected );
1751 if ( !selected.IsEmpty() ) {
1752 SALOME_ListIteratorOfListIO It(selected);
1753 for ( ; It.More(); It.Next())
1755 Handle(SALOME_InteractiveObject) anIO = It.Value();
1756 if ( !anIO.IsNull() ) {
1757 _PTR(SObject) SO = aStudy->FindObjectID( It.Value()->getEntry() );
1759 CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
1760 SMESH::SMESH_IDSource_var anIDSrc = SMESH::SMESH_IDSource::_narrow( aObject );
1761 if ( !anIDSrc->_is_nil() ) {
1762 SMESH_Actor *anActor = SMESH::FindActorByEntry( anIO->getEntry());
1763 if (( !anActor && selected.Extent() == 1 ) &&
1764 ( anActor = SMESH::CreateActor( anIO->getEntry() )))
1766 anActor->SetControlMode( aControl );
1767 SMESH::DisplayActor( SMESH::GetCurrentVtkView(), anActor );
1768 SMESH::UpdateView ( SMESH::eDisplay, anIO->getEntry() );
1772 if ( anActor->GetControlMode() != aControl )
1773 anActor->SetControlMode( aControl );
1774 QString functorName = functorToString( anActor->GetFunctor() );
1775 int anEntitiesCount = anActor->GetNumberControlEntities();
1776 if (anEntitiesCount >= 0)
1777 functorName = functorName + ": " + QString::number(anEntitiesCount);
1778 anActor->GetScalarBarActor()->SetTitle( functorName.toUtf8().constData() );
1779 SMESH::RepaintCurrentView();
1780 #ifndef DISABLE_PLOT2DVIEWER
1781 if ( anActor->GetPlot2Histogram() ) {
1782 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1783 QString aHistogramName("%1 : %2");
1784 aHistogramName = aHistogramName.arg( anIO->getName() ).arg( functorName );
1785 aHistogram->setName( aHistogramName );
1786 aHistogram->setHorTitle( functorName );
1787 SMESH::ProcessIn2DViewers( anActor );
1799 bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1800 SMESH::MeshObjectType theType,
1801 const QString theInTypeName,
1802 QString & theOutTypeName)
1804 SMESH_TypeFilter aTypeFilter( theType );
1806 if ( !theIO.IsNull() )
1808 entry = theIO->getEntry();
1809 LightApp_DataOwner owner( entry );
1810 if ( aTypeFilter.isOk( &owner )) {
1811 theOutTypeName = theInTypeName;
1819 QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1821 _PTR(Study) aStudy = SMESH::getStudy();
1822 _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1824 _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1825 CORBA::String_var anID = aSComp->GetID().c_str();
1826 if ( !strcmp(anID.in(),theIO->getEntry()) )
1832 CheckOIType ( theIO, SMESH::HYPOTHESIS, "Hypothesis", aTypeName ) ||
1833 CheckOIType ( theIO, SMESH::ALGORITHM, "Algorithm", aTypeName ) ||
1834 CheckOIType ( theIO, SMESH::MESH, "Mesh", aTypeName ) ||
1835 CheckOIType ( theIO, SMESH::SUBMESH, "SubMesh", aTypeName ) ||
1836 CheckOIType ( theIO, SMESH::GROUP, "Group", aTypeName )
1844 // QString CheckHomogeneousSelection()
1846 // LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1847 // SALOME_ListIO selected;
1849 // aSel->selectedObjects( selected );
1851 // QString RefType = CheckTypeObject(selected.First());
1852 // SALOME_ListIteratorOfListIO It(selected);
1853 // for ( ; It.More(); It.Next())
1855 // Handle(SALOME_InteractiveObject) IObject = It.Value();
1856 // QString Type = CheckTypeObject(IObject);
1857 // if ( Type.compare(RefType) != 0 )
1858 // return "Heterogeneous Selection";
1864 uint randomize( uint size )
1866 static bool initialized = false;
1867 if ( !initialized ) {
1868 qsrand( QDateTime::currentDateTime().toTime_t() );
1872 v = uint( (double)( v ) / RAND_MAX * size );
1873 v = qMax( uint(0), qMin ( v, size-1 ) );
1879 void SMESHGUI::OnEditDelete()
1881 // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1882 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1883 SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1885 _PTR(Study) aStudy = SMESH::getStudy();
1886 _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1887 _PTR(GenericAttribute) anAttr;
1888 _PTR(AttributeIOR) anIOR;
1890 const int objectCountLimit = 30; // PAL23599
1891 int objectCount = 0;
1893 QString aParentComponent = QString::null;
1895 for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1897 Handle(SALOME_InteractiveObject) anIO = anIt.Value();
1898 if ( anIO.IsNull() ) continue;
1900 QString father = "unknown", name;
1902 _PTR(SObject) aSO = aStudy->FindObjectID( anIO->getEntry() );
1904 father = QString::fromStdString( aSO->GetFatherComponent()->ComponentDataType() );
1905 // check if object is reference
1906 _PTR(SObject) aRefSObj;
1907 if ( aSO->ReferencedObject( aRefSObj ) ) {
1908 name = QString::fromStdString ( aRefSObj->GetName() );
1909 father = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1912 name = anIO->getName();
1915 if ( objectCount < objectCountLimit ) { // avoid occupying the whole screen
1916 aNameList.append("\n - ");
1917 aNameList.append( name );
1920 if( aParentComponent.isNull() )
1921 aParentComponent = father;
1922 else if( !aParentComponent.isEmpty() && aParentComponent!=father )
1923 aParentComponent = "";
1925 if ( objectCount >= objectCountLimit )
1926 aNameList.append("\n - ...");
1928 if ( objectCount == 0 )
1929 return; // No Valid Objects Selected
1931 if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
1932 SUIT_MessageBox::warning( SMESHGUI::desktop(),
1933 QObject::tr("ERR_ERROR"),
1934 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
1937 // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
1938 if (SUIT_MessageBox::warning
1939 (SMESHGUI::desktop(),
1940 QObject::tr("SMESH_WRN_WARNING"),
1941 QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
1942 SUIT_MessageBox::Yes | SUIT_MessageBox::No,
1943 SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
1946 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1948 // Put one level of sub-objects of the selected SO's into a list
1949 // in order to get objects inside folders like "Assigned Algorithms"
1950 std::list< _PTR(SObject) > listSO;
1951 SALOME_ListIteratorOfListIO It(selected);
1952 for( ; It.More(); It.Next()) // loop on selected IO's
1954 Handle(SALOME_InteractiveObject) IObject = It.Value();
1955 if(IObject->hasEntry()) {
1956 _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
1958 // disable removal of "SMESH" component object
1959 if(aSO->FindAttribute(anAttr, "AttributeIOR")){
1961 if ( engineIOR() == anIOR->Value().c_str() )
1964 //Check the referenced object
1965 _PTR(SObject) aRefSObject;
1966 if ( aSO && aSO->ReferencedObject( aRefSObject ) )
1967 aSO = aRefSObject; // Delete main Object instead of reference
1969 listSO.push_back( aSO );
1971 _PTR(ChildIterator) it = aStudy->NewChildIterator( aSO );
1972 for (it->InitEx(false); it->More(); it->Next())
1973 listSO.push_back( it->Value() );
1976 // Check if none of objects to delete is referred from outside
1977 std::list< _PTR(SObject) >::reverse_iterator ritSO;
1978 std::vector< _PTR(SObject) > subSO;
1979 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1981 _PTR(SObject) SO = *ritSO;
1982 if ( !SO ) continue;
1984 int nbChildren = SO->GetLastChildTag();
1986 subSO.reserve( 1 + nbChildren );
1987 subSO.push_back( SO );
1988 if ( nbChildren > 0 )
1990 _PTR(ChildIterator) it = aStudy->NewChildIterator( SO );
1991 for ( it->InitEx( true ); it->More(); it->Next() )
1992 subSO.push_back( it->Value() );
1994 for ( size_t i = 0; i < subSO.size(); ++i )
1996 std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( subSO[i] );
1997 for ( size_t j = 0; j < aReferences.size(); j++ ) {
1998 _PTR(SComponent) aComponent = aReferences[j]->GetFatherComponent();
1999 std::string type = aComponent->ComponentDataType();
2000 if ( type != "SMESH" )
2002 SUIT_MessageBox::warning( anApp->desktop(),
2003 QObject::tr("WRN_WARNING"),
2004 QObject::tr("DEP_OBJECT") );
2005 return; // outside SMESH, there is an object depending on a SMESH object
2011 // Treat SO's in the list starting from the back
2012 aStudyBuilder->NewCommand(); // There is a transaction
2013 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
2015 _PTR(SObject) SO = *ritSO;
2016 if ( !SO ) continue;
2017 std::string anEntry = SO->GetID();
2019 /** Erase graphical object and remove all its data **/
2020 if ( SO->FindAttribute( anAttr, "AttributeIOR" )) {
2021 SMESH::RemoveVisualObjectWithActors( anEntry.c_str(), true);
2023 /** Remove an object from data structures **/
2024 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
2025 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
2026 if ( !aGroup->_is_nil() ) { // DELETE GROUP
2027 SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
2028 aMesh->RemoveGroup( aGroup );
2030 else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
2031 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2032 aMesh->RemoveSubMesh( aSubMesh );
2035 Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
2036 ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
2037 QString objType = CheckTypeObject(IObject);
2038 if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
2039 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
2040 aStudyBuilder->RemoveObjectWithChildren( SO );
2042 else {// default action: remove SObject from the study
2043 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
2044 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
2046 aStudyBuilder->RemoveObjectWithChildren( SO );
2050 } /* listSO back loop */
2052 aStudyBuilder->CommitCommand();
2054 /* Clear any previous selection */
2056 aSel->setSelectedObjects( l1 );
2058 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
2062 SMESHGUI_EXPORT CAM_Module* createModule()
2064 return new SMESHGUI();
2067 SMESHGUI_EXPORT char* getModuleVersion() {
2068 return (char*)SMESH_VERSION_STR;
2072 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
2074 //=============================================================================
2078 //=============================================================================
2079 SMESHGUI::SMESHGUI() :
2080 SalomeApp_Module( "SMESH" )
2082 if ( CORBA::is_nil( myComponentSMESH ) )
2084 CORBA::Boolean anIsEmbeddedMode;
2085 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
2086 //MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
2088 // 0019923: EDF 765 SMESH : default values of hypothesis
2089 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
2090 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
2091 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
2092 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
2093 myComponentSMESH->SetDefaultNbSegments( nbSeg );
2095 const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif", "default_grp_color" };
2096 for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
2097 if ( aResourceMgr->hasValue( "SMESH", options[i] ))
2099 QString val = aResourceMgr->stringValue( "SMESH", options[i] );
2100 myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
2104 myActiveDialogBox = 0;
2105 myFilterLibraryDlg = 0;
2109 myEventCallbackCommand = vtkCallbackCommand::New();
2110 myEventCallbackCommand->Delete();
2111 myEventCallbackCommand->SetClientData( this );
2112 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
2115 /* load resources for all available meshers */
2116 SMESH::InitAvailableHypotheses();
2119 //=============================================================================
2123 //=============================================================================
2124 SMESHGUI::~SMESHGUI()
2128 //=============================================================================
2132 //=============================================================================
2133 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
2135 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2137 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
2142 //=============================================================================
2146 //=============================================================================
2147 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
2149 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2153 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2154 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2155 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2156 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2157 return autoUpdate && !exceeded;
2160 //=============================================================================
2164 //=============================================================================
2165 bool SMESHGUI::automaticUpdate( SMESH::SMESH_IDSource_ptr theMesh,
2166 int* entities, bool* limitExceeded, int* hidden, long* nbElements )
2168 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2172 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2173 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2174 bool incrementalLimit = resMgr->booleanValue( "SMESH", "incremental_limit", false );
2176 SMESH::long_array_var info = theMesh->GetMeshInfo();
2177 long nbOdElems = info[SMDSEntity_0D];
2178 long nbEdges = info[SMDSEntity_Edge] + info[SMDSEntity_Quad_Edge];
2179 long nbFaces = info[SMDSEntity_Triangle] + info[SMDSEntity_Quad_Triangle] + info[SMDSEntity_BiQuad_Triangle] +
2180 info[SMDSEntity_Quadrangle] + info[SMDSEntity_Quad_Quadrangle] + info[SMDSEntity_BiQuad_Quadrangle] +
2181 info[SMDSEntity_Polygon] + info[SMDSEntity_Quad_Polygon];
2182 long nbVolumes = info[SMDSEntity_Tetra] + info[SMDSEntity_Quad_Tetra] +
2183 info[SMDSEntity_Hexa] + info[SMDSEntity_Quad_Hexa] + info[SMDSEntity_TriQuad_Hexa] +
2184 info[SMDSEntity_Pyramid] + info[SMDSEntity_Quad_Pyramid] +
2185 info[SMDSEntity_Penta] + info[SMDSEntity_Quad_Penta] + info[SMDSEntity_BiQuad_Penta] +
2186 info[SMDSEntity_Polyhedra] +
2187 info[SMDSEntity_Hexagonal_Prism];
2188 long nbBalls = info[SMDSEntity_Ball];
2190 long requestedSize = nbOdElems + nbBalls + nbEdges + nbFaces + nbVolumes;
2191 *nbElements = requestedSize;
2193 *entities = SMESH_Actor::eAllEntity;
2196 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2198 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2200 if ( incrementalLimit ) {
2203 if ( nbOdElems > 0 ) {
2204 if ( total + nbOdElems > updateLimit ) {
2205 *entities = *entities & ~SMESH_Actor::e0DElements;
2206 *hidden = *hidden | SMESH_Actor::e0DElements;
2213 if ( nbEdges > 0 ) {
2214 if ( total + nbEdges > updateLimit ) {
2215 *entities = *entities & ~SMESH_Actor::eEdges;
2216 *hidden = *hidden | SMESH_Actor::eEdges;
2223 if ( nbFaces > 0 ) {
2224 if ( total + nbFaces > updateLimit ) {
2225 *entities = *entities & ~SMESH_Actor::eFaces;
2226 *hidden = *hidden | SMESH_Actor::eFaces;
2233 if ( nbVolumes > 0 ) {
2234 if ( total + nbVolumes > updateLimit ) {
2235 *entities = *entities & ~SMESH_Actor::eVolumes;
2236 *hidden = *hidden | SMESH_Actor::eVolumes;
2243 if ( nbBalls > 0 ) {
2244 if ( total + nbBalls > updateLimit ) {
2245 *entities = *entities & ~SMESH_Actor::eBallElem;
2246 *hidden = *hidden | SMESH_Actor::eBallElem;
2254 return autoUpdate && !exceeded;
2257 //=============================================================================
2261 //=============================================================================
2262 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
2264 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
2267 //=============================================================================
2271 //=============================================================================
2272 SMESHGUI* SMESHGUI::GetSMESHGUI()
2274 SMESHGUI* smeshMod = 0;
2275 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
2278 CAM_Module* module = app->module( "Mesh" );
2279 smeshMod = dynamic_cast<SMESHGUI*>( module );
2287 Standard_EXPORT SMESHGUI* GetComponentGUI()
2289 return SMESHGUI::GetSMESHGUI();
2293 //=============================================================================
2297 //=============================================================================
2298 void SMESHGUI::SetState(int aState)
2303 //=============================================================================
2307 //=============================================================================
2308 void SMESHGUI::ResetState()
2313 //=============================================================================
2317 //=============================================================================
2318 void SMESHGUI::EmitSignalDeactivateDialog()
2320 emit SignalDeactivateActiveDialog();
2323 //=============================================================================
2327 //=============================================================================
2328 void SMESHGUI::EmitSignalStudyFrameChanged()
2330 emit SignalStudyFrameChanged();
2333 //=============================================================================
2337 //=============================================================================
2338 void SMESHGUI::EmitSignalCloseAllDialogs()
2340 emit SignalCloseAllDialogs();
2343 //=============================================================================
2347 //=============================================================================
2348 void SMESHGUI::EmitSignalVisibilityChanged()
2350 emit SignalVisibilityChanged();
2353 //=============================================================================
2357 //=============================================================================
2358 void SMESHGUI::EmitSignalCloseView()
2360 emit SignalCloseView();
2363 //=============================================================================
2367 //=============================================================================
2368 void SMESHGUI::EmitSignalActivatedViewManager()
2370 emit SignalActivatedViewManager();
2373 //=============================================================================
2377 //=============================================================================
2378 QDialog *SMESHGUI::GetActiveDialogBox()
2380 return myActiveDialogBox;
2383 //=============================================================================
2387 //=============================================================================
2388 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2390 myActiveDialogBox = (QDialog *) aDlg;
2394 //=============================================================================
2398 //=============================================================================
2399 SUIT_Desktop* SMESHGUI::desktop()
2401 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2403 return app->desktop();
2408 //=============================================================================
2412 //=============================================================================
2413 SalomeApp_Study* SMESHGUI::activeStudy()
2415 SUIT_Application* app = SUIT_Session::session()->activeApplication();
2417 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2422 //=============================================================================
2426 //=============================================================================
2427 void SMESHGUI::Modified( bool theIsUpdateActions )
2429 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2430 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2431 appStudy->Modified();
2432 if( theIsUpdateActions )
2433 app->updateActions();
2438 //=============================================================================
2442 //=============================================================================
2443 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2445 /* Here the position is on the bottom right corner - 10 */
2446 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2448 SUIT_Desktop *PP = desktop();
2449 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2450 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2455 * \brief Verifies whether study of operation is locked
2456 * \param theMess - specifies whether message box must be shown if study is locked
2457 * \return State of study.
2459 * Verifies whether study of operation is locked. If second parameter is TRUE and study
2460 * is locked when corresponding message box appears
2462 bool SMESHGUI::isStudyLocked( bool theMessage )
2464 if ( SMESH::getStudy()->GetProperties()->IsLocked() )
2467 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2468 QObject::tr( "WRN_WARNING" ),
2469 QObject::tr( "WRN_STUDY_LOCKED" ) );
2475 //=============================================================================
2479 //=============================================================================
2480 bool SMESHGUI::OnGUIEvent( int theCommandID )
2482 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2486 SUIT_ResourceMgr* mgr = resourceMgr();
2490 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2491 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2493 //QAction* act = action( theCommandID );
2495 switch (theCommandID) {
2496 case SMESHOp::OpDelete:
2497 if(isStudyLocked()) break;
2500 case SMESHOp::OpImportDAT:
2501 case SMESHOp::OpImportUNV:
2502 case SMESHOp::OpImportMED:
2503 case SMESHOp::OpImportSTL:
2504 case SMESHOp::OpImportCGNS:
2505 case SMESHOp::OpImportSAUV:
2506 case SMESHOp::OpImportGMF:
2507 case SMESHOp::OpPopupImportDAT:
2508 case SMESHOp::OpPopupImportUNV:
2509 case SMESHOp::OpPopupImportMED:
2510 case SMESHOp::OpPopupImportSTL:
2511 case SMESHOp::OpPopupImportCGNS:
2512 case SMESHOp::OpPopupImportSAUV:
2513 case SMESHOp::OpPopupImportGMF:
2515 if(isStudyLocked()) break;
2516 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2520 case SMESHOp::OpFileInformation:
2522 SALOME_ListIO selected;
2523 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2525 aSel->selectedObjects( selected );
2526 if( selected.Extent() )
2528 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2529 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2530 if ( !aMesh->_is_nil() )
2532 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2538 case SMESHOp::OpExportDAT:
2539 case SMESHOp::OpExportMED:
2540 case SMESHOp::OpExportUNV:
2541 case SMESHOp::OpExportSTL:
2542 case SMESHOp::OpExportCGNS:
2543 case SMESHOp::OpExportSAUV:
2544 case SMESHOp::OpExportGMF:
2545 case SMESHOp::OpPopupExportDAT:
2546 case SMESHOp::OpPopupExportMED:
2547 case SMESHOp::OpPopupExportUNV:
2548 case SMESHOp::OpPopupExportSTL:
2549 case SMESHOp::OpPopupExportCGNS:
2550 case SMESHOp::OpPopupExportSAUV:
2551 case SMESHOp::OpPopupExportGMF:
2553 ::ExportMeshToFile(theCommandID);
2557 case SMESHOp::OpReset: // SCALAR BAR
2559 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2560 SALOME_ListIO selected;
2562 aSel->selectedObjects( selected );
2564 SALOME_ListIteratorOfListIO it(selected);
2565 for( ; it.More(); it.Next()) {
2566 Handle(SALOME_InteractiveObject) anIO = it.Value();
2567 if( anIO->hasEntry() ) {
2568 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2569 anActor->SetControlMode( SMESH_Actor::eNone );
2570 #ifndef DISABLE_PLOT2DVIEWER
2571 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2573 anActor->UpdateFilter();
2577 SMESH::UpdateView();
2580 case SMESHOp::OpScalarBarProperties:
2582 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2585 case SMESHOp::OpShowScalarBar:
2587 // show/hide scalar bar
2588 ::ShowElement(theCommandID);
2591 case SMESHOp::OpSaveDistribution:
2593 // dump control distribution data to the text file
2594 ::SaveDistribution();
2598 case SMESHOp::OpShowDistribution:
2600 // show/hide distribution
2601 ::ShowElement(theCommandID);
2605 #ifndef DISABLE_PLOT2DVIEWER
2606 case SMESHOp::OpPlotDistribution:
2608 // plot distribution
2609 ::PlotDistribution();
2615 case SMESHOp::OpAutoColor:
2619 case SMESHOp::OpDisableAutoColor:
2620 ::DisableAutoColor();
2623 case SMESHOp::OpClipping:
2624 case SMESHOp::OpTransparency:
2625 case SMESHOp::OpProperties: // Display preferences (colors, shrink size, line width, ...)
2628 case SMESHOp::OpDMWireframe:
2629 case SMESHOp::OpDMShading:
2630 case SMESHOp::OpDMNodes:
2631 case SMESHOp::OpDMShrink:
2632 ::SetDisplayMode(theCommandID, myMarkerMap);
2635 //2D quadratic representation
2636 case SMESHOp::OpRepresentationLines:
2637 case SMESHOp::OpRepresentationArcs:
2638 ::SetDisplayMode(theCommandID, myMarkerMap);
2642 case SMESHOp::OpDE0DElements:
2643 case SMESHOp::OpDEEdges:
2644 case SMESHOp::OpDEFaces:
2645 case SMESHOp::OpDEVolumes:
2646 case SMESHOp::OpDEBalls:
2647 case SMESHOp::OpDEAllEntity:
2648 ::SetDisplayEntity(theCommandID);
2651 // Choose entities to be displayed
2652 case SMESHOp::OpDEChoose:
2654 ( new SMESHGUI_DisplayEntitiesDlg( SMESHGUI::desktop() ) )->exec();
2658 case SMESHOp::OpOrientationOnFaces:
2660 SUIT_OverrideCursor wc;
2661 LightApp_SelectionMgr* mgr = selectionMgr();
2662 SALOME_ListIO selected; mgr->selectedObjects( selected );
2664 SALOME_ListIteratorOfListIO it(selected);
2665 for( ; it.More(); it.Next()) {
2666 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2667 if(anIObject->hasEntry()) {
2668 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2669 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2676 case SMESHOp::OpUpdate:
2678 if(isStudyLocked()) break;
2679 SUIT_OverrideCursor wc;
2682 SMESH::UpdateView();
2684 catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2685 SMESH::OnVisuException();
2687 catch (...) { // PAL16774 (Crash after display of many groups)
2688 SMESH::OnVisuException();
2692 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2693 aSel->selectedObjects( l );
2694 aSel->setSelectedObjects( l );
2698 case SMESHOp::OpHide:
2699 case SMESHOp::OpShow:
2700 case SMESHOp::OpShowOnly:
2702 SUIT_OverrideCursor wc;
2703 SMESH::EDisplaing anAction;
2704 switch (theCommandID) {
2705 case SMESHOp::OpHide: anAction = SMESH::eErase; break;
2706 case SMESHOp::OpShow: anAction = SMESH::eDisplay; break;
2707 case SMESHOp::OpShowOnly: anAction = SMESH::eDisplayOnly; break;
2710 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2711 SALOME_ListIO sel_objects, to_process;
2713 aSel->selectedObjects( sel_objects );
2715 if ( theCommandID==SMESHOp::OpShowOnly )
2717 //MESSAGE("anAction = SMESH::eDisplayOnly");
2718 startOperation( myEraseAll );
2721 extractContainers( sel_objects, to_process );
2726 SALOME_ListIteratorOfListIO It( to_process );
2727 for ( ; It.More(); It.Next())
2729 Handle(SALOME_InteractiveObject) IOS = It.Value();
2730 if ( IOS->hasEntry() )
2732 if ( !SMESH::UpdateView( anAction, IOS->getEntry() )) {
2733 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2734 break; // PAL16774 (Crash after display of many groups)
2736 if (anAction == SMESH::eDisplayOnly)
2737 anAction = SMESH::eDisplay;
2742 // PAL13338 + PAL15161 -->
2743 if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !isStudyLocked()) {
2744 SMESH::UpdateView();
2745 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2747 // PAL13338 + PAL15161 <--
2749 catch (...) { // PAL16774 (Crash after display of many groups)
2750 SMESH::OnVisuException();
2753 if (anAction == SMESH::eErase) {
2755 aSel->setSelectedObjects( l1 );
2758 aSel->setSelectedObjects( to_process );
2760 if ( vtkwnd && vtkwnd->GetRenderer() && !isStudyLocked() &&
2761 ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) )
2762 vtkwnd->GetRenderer()->AdjustActors();
2767 case SMESHOp::OpNode:
2769 if(isStudyLocked()) break;
2772 EmitSignalDeactivateDialog();
2774 ( new SMESHGUI_NodesDlg( this ) )->show();
2777 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"),tr("SMESH_WRN_VIEWER_VTK"));
2782 case SMESHOp::OpCreateMesh:
2783 case SMESHOp::OpCreateSubMesh:
2784 case SMESHOp::OpEditMeshOrSubMesh:
2785 case SMESHOp::OpEditMesh:
2786 case SMESHOp::OpEditSubMesh:
2787 case SMESHOp::OpCompute:
2788 case SMESHOp::OpComputeSubMesh:
2789 case SMESHOp::OpPreCompute:
2790 case SMESHOp::OpEvaluate:
2791 case SMESHOp::OpMeshOrder:
2792 startOperation( theCommandID );
2794 case SMESHOp::OpCopyMesh:
2796 if (isStudyLocked()) break;
2797 EmitSignalDeactivateDialog();
2798 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2801 case SMESHOp::OpBuildCompoundMesh:
2803 if (isStudyLocked()) break;
2804 EmitSignalDeactivateDialog();
2805 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2809 case SMESHOp::OpDiagonalInversion:
2810 case SMESHOp::OpUnionOfTwoTriangle:
2814 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2818 if ( isStudyLocked() )
2821 /*Standard_Boolean aRes;
2822 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2823 if ( aMesh->_is_nil() )
2825 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2826 tr( "SMESH_BAD_SELECTION" ) );
2830 EmitSignalDeactivateDialog();
2831 if ( theCommandID == SMESHOp::OpDiagonalInversion )
2832 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2834 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2837 case SMESHOp::OpOrientation:
2838 case SMESHOp::OpUnionOfTriangles:
2839 case SMESHOp::OpCuttingOfQuadrangles:
2840 case SMESHOp::OpSplitVolumes:
2844 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2848 if ( isStudyLocked() )
2851 EmitSignalDeactivateDialog();
2852 SMESHGUI_MultiEditDlg* aDlg = NULL;
2853 if ( theCommandID == SMESHOp::OpOrientation )
2854 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2855 else if ( theCommandID == SMESHOp::OpUnionOfTriangles )
2856 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2857 else if ( theCommandID == SMESHOp::OpSplitVolumes )
2858 aDlg = new SMESHGUI_SplitVolumesDlg(this);
2860 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2865 case SMESHOp::OpSmoothing:
2867 if(isStudyLocked()) break;
2869 EmitSignalDeactivateDialog();
2870 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2873 SUIT_MessageBox::warning(desktop(), tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2877 case SMESHOp::OpExtrusion:
2879 if (isStudyLocked()) break;
2881 EmitSignalDeactivateDialog();
2882 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2884 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2888 case SMESHOp::OpExtrusionAlongAPath:
2890 if (isStudyLocked()) break;
2892 EmitSignalDeactivateDialog();
2893 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2895 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2899 case SMESHOp::OpRevolution:
2901 if(isStudyLocked()) break;
2903 EmitSignalDeactivateDialog();
2904 ( new SMESHGUI_RevolutionDlg( this ) )->show();
2907 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2911 case SMESHOp::OpPatternMapping:
2913 if ( isStudyLocked() )
2917 EmitSignalDeactivateDialog();
2918 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2921 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2925 case SMESHOp::OpSplitBiQuadratic:
2926 case SMESHOp::OpConvertMeshToQuadratic:
2927 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
2928 case SMESHOp::OpReorientFaces:
2929 case SMESHOp::OpCreateGeometryGroup:
2931 startOperation( theCommandID );
2934 case SMESHOp::OpCreateGroup:
2938 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2942 if(isStudyLocked()) break;
2943 EmitSignalDeactivateDialog();
2944 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2946 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2947 SALOME_ListIO selected;
2949 aSel->selectedObjects( selected );
2951 int nbSel = selected.Extent();
2953 // check if mesh is selected
2954 aMesh = SMESH::GetMeshByIO( selected.First() );
2956 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2961 case SMESHOp::OpConstructGroup:
2965 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2969 if(isStudyLocked()) break;
2970 EmitSignalDeactivateDialog();
2972 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2973 SALOME_ListIO selected;
2975 aSel->selectedObjects( selected );
2977 int nbSel = selected.Extent();
2979 // check if submesh is selected
2980 Handle(SALOME_InteractiveObject) IObject = selected.First();
2981 if (IObject->hasEntry()) {
2982 _PTR(SObject) aSObj = SMESH::getStudy()->FindObjectID(IObject->getEntry());
2984 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2985 if (!aSubMesh->_is_nil()) {
2987 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2988 // get submesh elements list by types
2989 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2990 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2991 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2992 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2993 // create group for each type o elements
2994 QString aName = IObject->getName();
2995 QStringList anEntryList;
2996 if (aNodes->length() > 0) {
2997 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2998 aGroup->Add(aNodes.inout());
2999 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3000 anEntryList.append( aSObject->GetID().c_str() );
3002 if (aEdges->length() > 0) {
3003 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
3004 aGroup->Add(aEdges.inout());
3005 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3006 anEntryList.append( aSObject->GetID().c_str() );
3008 if (aFaces->length() > 0) {
3009 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
3010 aGroup->Add(aFaces.inout());
3011 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3012 anEntryList.append( aSObject->GetID().c_str() );
3014 if (aVolumes->length() > 0) {
3015 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
3016 aGroup->Add(aVolumes.inout());
3017 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
3018 anEntryList.append( aSObject->GetID().c_str() );
3021 anApp->browseObjects( anEntryList );
3023 catch(const SALOME::SALOME_Exception & S_ex){
3024 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3031 SUIT_MessageBox::warning(desktop(),
3032 tr("SMESH_WRN_WARNING"),
3033 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
3038 case SMESHOp::OpEditGroup:
3042 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3046 if(isStudyLocked()) break;
3047 EmitSignalDeactivateDialog();
3049 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3050 SALOME_ListIO selected;
3052 aSel->selectedObjects( selected );
3054 SALOME_ListIteratorOfListIO It (selected);
3055 int nbSelectedGroups = 0;
3056 for ( ; It.More(); It.Next() )
3058 SMESH::SMESH_GroupBase_var aGroup =
3059 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
3060 if (!aGroup->_is_nil()) {
3062 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
3066 if (nbSelectedGroups == 0)
3068 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
3074 case SMESHOp::OpAddElemGroupPopup: // Add elements to group
3076 if(isStudyLocked()) break;
3077 if (myState == 800) {
3078 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3079 if (aDlg) aDlg->onAdd();
3084 case SMESHOp::OpRemoveElemGroupPopup: // Remove elements from group
3086 if(isStudyLocked()) break;
3087 if (myState == 800) {
3088 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3089 if (aDlg) aDlg->onRemove();
3094 case SMESHOp::OpEditGeomGroupAsGroup:
3098 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3102 if(isStudyLocked()) break;
3103 EmitSignalDeactivateDialog();
3105 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3106 SALOME_ListIO selected;
3108 aSel->selectedObjects( selected );
3110 SALOME_ListIteratorOfListIO It (selected);
3111 for ( ; It.More(); It.Next() )
3113 SMESH::SMESH_GroupOnGeom_var aGroup =
3114 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
3115 if (!aGroup->_is_nil()) {
3116 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3121 SMESH::SMESH_GroupOnFilter_var aGroup =
3122 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
3123 if (!aGroup->_is_nil()) {
3124 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3132 case SMESHOp::OpUnionGroups:
3133 case SMESHOp::OpIntersectGroups:
3134 case SMESHOp::OpCutGroups:
3138 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3142 if ( isStudyLocked() )
3145 EmitSignalDeactivateDialog();
3147 SMESHGUI_GroupOpDlg* aDlg = 0;
3148 if ( theCommandID == SMESHOp::OpUnionGroups )
3149 aDlg = new SMESHGUI_UnionGroupsDlg( this );
3150 else if ( theCommandID == SMESHOp::OpIntersectGroups )
3151 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3153 aDlg = new SMESHGUI_CutGroupsDlg( this );
3160 case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
3162 if ( isStudyLocked() )
3165 EmitSignalDeactivateDialog();
3166 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3172 case SMESHOp::OpFaceGroupsByEdges: // Create face groups separated by sharp edges
3174 if ( isStudyLocked() )
3177 EmitSignalDeactivateDialog();
3178 SMESHGUI_FaceGroupsSeparatedByEdgesDlg* aDlg = new SMESHGUI_FaceGroupsSeparatedByEdgesDlg( this );
3184 case SMESHOp::OpDeleteGroup: // Delete groups with their contents
3188 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3192 if ( isStudyLocked() )
3195 EmitSignalDeactivateDialog();
3197 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3201 case SMESHOp::OpMeshInformation:
3202 case SMESHOp::OpWhatIs:
3204 int page = theCommandID == SMESHOp::OpMeshInformation ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3205 EmitSignalDeactivateDialog();
3206 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3207 SALOME_ListIO selected;
3209 aSel->selectedObjects( selected );
3211 if ( selected.Extent() > 1 ) { // a dlg for each IO
3212 SALOME_ListIteratorOfListIO It( selected );
3213 for ( ; It.More(); It.Next() ) {
3214 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3215 dlg->showInfo( It.Value() );
3220 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3226 case SMESHOp::OpFindElementByPoint:
3228 startOperation( theCommandID );
3232 case SMESHOp::OpEditHypothesis:
3234 if(isStudyLocked()) break;
3236 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3237 SALOME_ListIO selected;
3239 aSel->selectedObjects( selected );
3241 int nbSel = selected.Extent();
3244 Handle(SALOME_InteractiveObject) anIObject = selected.First();
3245 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3247 if ( !aHypothesis->_is_nil() )
3249 SMESHGUI_GenericHypothesisCreator* aCreator =
3250 SMESH::GetHypothesisCreator( SMESH::toQStr( aHypothesis->GetName() ));
3253 // set geometry of mesh and sub-mesh to aCreator
3254 aSel->selectedObjects( selected, "", /*convertReferences=*/false);
3255 if ( selected.Extent() == 1 )
3257 QString subGeomID, meshGeomID;
3258 Handle(SALOME_InteractiveObject) hypIO = selected.First();
3259 if ( SMESH::GetGeomEntries( hypIO, subGeomID, meshGeomID ))
3261 if ( subGeomID.isEmpty() ) subGeomID = meshGeomID;
3262 aCreator->setShapeEntry( subGeomID );
3263 aCreator->setMainShapeEntry( meshGeomID );
3267 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3277 case SMESHOp::OpUnassign: // REMOVE HYPOTHESIS / ALGORITHMS
3279 if(isStudyLocked()) break;
3280 SUIT_OverrideCursor wc;
3282 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3283 SALOME_ListIO selected;
3285 aSel->selectedObjects( selected, QString::null, false );
3287 SALOME_ListIteratorOfListIO It(selected);
3288 for (int i = 0; It.More(); It.Next(), i++) {
3289 Handle(SALOME_InteractiveObject) IObject = It.Value();
3290 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3293 aSel->setSelectedObjects( l1 );
3298 case SMESHOp::OpElem0D:
3299 case SMESHOp::OpBall:
3300 case SMESHOp::OpEdge:
3301 case SMESHOp::OpTriangle:
3302 case SMESHOp::OpQuadrangle:
3303 case SMESHOp::OpPolygon:
3304 case SMESHOp::OpTetrahedron:
3305 case SMESHOp::OpHexahedron:
3306 case SMESHOp::OpPentahedron:
3307 case SMESHOp::OpPyramid:
3308 case SMESHOp::OpHexagonalPrism:
3310 if(isStudyLocked()) break;
3312 EmitSignalDeactivateDialog();
3313 SMDSAbs_EntityType type = SMDSEntity_Edge;
3314 switch (theCommandID) {
3315 case SMESHOp::OpElem0D: type = SMDSEntity_0D; break;
3316 case SMESHOp::OpBall: type = SMDSEntity_Ball; break;
3317 case SMESHOp::OpTriangle: type = SMDSEntity_Triangle; break;
3318 case SMESHOp::OpQuadrangle: type = SMDSEntity_Quadrangle; break;
3319 case SMESHOp::OpTetrahedron: type = SMDSEntity_Tetra; break;
3320 case SMESHOp::OpPolygon: type = SMDSEntity_Polygon; break;
3321 case SMESHOp::OpHexahedron: type = SMDSEntity_Hexa; break;
3322 case SMESHOp::OpPentahedron: type = SMDSEntity_Penta; break;
3323 case SMESHOp::OpPyramid: type = SMDSEntity_Pyramid; break;
3324 case SMESHOp::OpHexagonalPrism: type = SMDSEntity_Hexagonal_Prism; break;
3327 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3330 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3334 case SMESHOp::OpPolyhedron:
3336 if(isStudyLocked()) break;
3338 EmitSignalDeactivateDialog();
3339 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3342 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3346 case SMESHOp::OpQuadraticEdge:
3347 case SMESHOp::OpQuadraticTriangle:
3348 case SMESHOp::OpBiQuadraticTriangle:
3349 case SMESHOp::OpQuadraticQuadrangle:
3350 case SMESHOp::OpBiQuadraticQuadrangle:
3351 case SMESHOp::OpQuadraticPolygon:
3352 case SMESHOp::OpQuadraticTetrahedron:
3353 case SMESHOp::OpQuadraticPyramid:
3354 case SMESHOp::OpQuadraticPentahedron:
3355 case SMESHOp::OpBiQuadraticPentahedron:
3356 case SMESHOp::OpQuadraticHexahedron:
3357 case SMESHOp::OpTriQuadraticHexahedron:
3359 if(isStudyLocked()) break;
3361 EmitSignalDeactivateDialog();
3362 SMDSAbs_EntityType type = SMDSEntity_Last;
3364 switch (theCommandID) {
3365 case SMESHOp::OpQuadraticEdge: type = SMDSEntity_Quad_Edge; break;
3366 case SMESHOp::OpQuadraticTriangle: type = SMDSEntity_Quad_Triangle; break;
3367 case SMESHOp::OpBiQuadraticTriangle: type = SMDSEntity_BiQuad_Triangle; break;
3368 case SMESHOp::OpQuadraticQuadrangle: type = SMDSEntity_Quad_Quadrangle; break;
3369 case SMESHOp::OpBiQuadraticQuadrangle: type = SMDSEntity_BiQuad_Quadrangle; break;
3370 case SMESHOp::OpQuadraticPolygon: type = SMDSEntity_Quad_Polygon; break;
3371 case SMESHOp::OpQuadraticTetrahedron: type = SMDSEntity_Quad_Tetra; break;
3372 case SMESHOp::OpQuadraticPyramid: type = SMDSEntity_Quad_Pyramid; break;
3373 case SMESHOp::OpQuadraticPentahedron: type = SMDSEntity_Quad_Penta; break;
3374 case SMESHOp::OpBiQuadraticPentahedron: type = SMDSEntity_BiQuad_Penta; break;
3375 case SMESHOp::OpQuadraticHexahedron: type = SMDSEntity_Quad_Hexa; break;
3376 case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
3379 if ( type != SMDSEntity_Last )
3380 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3383 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3384 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3388 case SMESHOp::OpRemoveNodes:
3390 if(isStudyLocked()) break;
3392 EmitSignalDeactivateDialog();
3393 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3396 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3397 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3401 case SMESHOp::OpRemoveElements: // REMOVES ELEMENTS
3403 if(isStudyLocked()) break;
3405 EmitSignalDeactivateDialog();
3406 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3410 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3411 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3415 case SMESHOp::OpClearMesh: {
3417 if(isStudyLocked()) break;
3419 SALOME_ListIO selected;
3420 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3421 aSel->selectedObjects( selected );
3423 SUIT_OverrideCursor wc;
3424 SALOME_ListIteratorOfListIO It (selected);
3425 for ( ; It.More(); It.Next() )
3427 Handle(SALOME_InteractiveObject) IOS = It.Value();
3428 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3429 if ( aMesh->_is_nil()) continue;
3432 if ( aMesh->NbNodes() == 0 ) // imported mesh is not empty
3433 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3434 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3435 // hide groups and submeshes
3436 _PTR(ChildIterator) anIter =
3437 SMESH::getStudy()->NewChildIterator( aMeshSObj );
3438 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3440 _PTR(SObject) so = anIter->Value();
3441 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3444 catch (const SALOME::SALOME_Exception& S_ex){
3446 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3450 SMESH::UpdateView();
3454 case SMESHOp::OpRemoveOrphanNodes:
3456 if(isStudyLocked()) break;
3457 SALOME_ListIO selected;
3458 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3459 aSel->selectedObjects( selected );
3460 if ( selected.Extent() == 1 ) {
3461 Handle(SALOME_InteractiveObject) anIO = selected.First();
3462 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3463 if ( !aMesh->_is_nil() ) {
3464 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3465 tr( "SMESH_WARNING" ),
3466 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3467 SUIT_MessageBox::Yes |
3468 SUIT_MessageBox::No,
3469 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3472 SUIT_OverrideCursor wc;
3473 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3474 int removed = aMeshEditor->RemoveOrphanNodes();
3475 SUIT_MessageBox::information(SMESHGUI::desktop(),
3476 tr("SMESH_INFORMATION"),
3477 tr("NB_NODES_REMOVED").arg(removed));
3478 if ( removed > 0 ) {
3479 SMESH::UpdateView();
3480 SMESHGUI::Modified();
3483 catch (const SALOME::SALOME_Exception& S_ex) {
3484 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3493 case SMESHOp::OpRenumberingNodes:
3495 if(isStudyLocked()) break;
3497 EmitSignalDeactivateDialog();
3498 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3502 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3503 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3507 case SMESHOp::OpRenumberingElements:
3509 if(isStudyLocked()) break;
3511 EmitSignalDeactivateDialog();
3512 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3516 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3517 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3521 case SMESHOp::OpTranslation:
3523 if(isStudyLocked()) break;
3525 EmitSignalDeactivateDialog();
3526 ( new SMESHGUI_TranslationDlg( this ) )->show();
3529 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3530 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3534 case SMESHOp::OpRotation:
3536 if(isStudyLocked()) break;
3538 EmitSignalDeactivateDialog();
3539 ( new SMESHGUI_RotationDlg( this ) )->show();
3542 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3543 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3547 case SMESHOp::OpSymmetry:
3549 if(isStudyLocked()) break;
3551 EmitSignalDeactivateDialog();
3552 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3555 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3556 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3560 case SMESHOp::OpScale:
3562 if(isStudyLocked()) break;
3564 EmitSignalDeactivateDialog();
3565 ( new SMESHGUI_ScaleDlg( this ) )->show();
3568 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3569 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3574 case SMESHOp::OpOffset:
3576 if(isStudyLocked()) break;
3578 EmitSignalDeactivateDialog();
3579 ( new SMESHGUI_OffsetDlg( this ) )->show();
3582 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3583 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3588 case SMESHOp::OpSewing:
3590 if(isStudyLocked()) break;
3592 EmitSignalDeactivateDialog();
3593 ( new SMESHGUI_SewingDlg( this ) )->show();
3596 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3597 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3601 case SMESHOp::OpMergeNodes:
3603 if(isStudyLocked()) break;
3605 EmitSignalDeactivateDialog();
3606 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3609 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3610 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3614 case SMESHOp::OpMergeElements:
3616 if (isStudyLocked()) break;
3618 EmitSignalDeactivateDialog();
3619 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3621 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3622 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3627 case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
3628 startOperation( SMESHOp::OpMoveNode );
3631 case SMESHOp::OpDuplicateNodes:
3633 if(isStudyLocked()) break;
3635 EmitSignalDeactivateDialog();
3636 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3639 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3640 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3645 case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
3646 startOperation( SMESHOp::OpElem0DOnElemNodes );
3649 case SMESHOp::OpSelectFiltersLibrary: // Library of selection filters
3651 static QList<int> aTypes;
3652 if ( aTypes.isEmpty() )
3654 aTypes.append( SMESH::NODE );
3655 aTypes.append( SMESH::EDGE );
3656 aTypes.append( SMESH::FACE );
3657 aTypes.append( SMESH::VOLUME );
3659 if (!myFilterLibraryDlg)
3660 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3661 else if (myFilterLibraryDlg->isHidden())
3662 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3663 myFilterLibraryDlg->raise();
3667 case SMESHOp::OpFreeNode:
3668 case SMESHOp::OpEqualNode:
3669 case SMESHOp::OpNodeConnectivityNb:
3670 case SMESHOp::OpFreeEdge:
3671 case SMESHOp::OpFreeBorder:
3672 case SMESHOp::OpLength:
3673 case SMESHOp::OpConnection:
3674 case SMESHOp::OpEqualEdge:
3675 case SMESHOp::OpFreeFace:
3676 case SMESHOp::OpBareBorderFace:
3677 case SMESHOp::OpOverConstrainedFace:
3678 case SMESHOp::OpLength2D:
3679 case SMESHOp::OpDeflection2D:
3680 case SMESHOp::OpConnection2D:
3681 case SMESHOp::OpArea:
3682 case SMESHOp::OpTaper:
3683 case SMESHOp::OpAspectRatio:
3684 case SMESHOp::OpMinimumAngle:
3685 case SMESHOp::OpWarpingAngle:
3686 case SMESHOp::OpSkew:
3687 case SMESHOp::OpMaxElementLength2D:
3688 case SMESHOp::OpEqualFace:
3689 case SMESHOp::OpAspectRatio3D:
3690 case SMESHOp::OpVolume:
3691 case SMESHOp::OpMaxElementLength3D:
3692 case SMESHOp::OpBareBorderVolume:
3693 case SMESHOp::OpOverConstrainedVolume:
3694 case SMESHOp::OpEqualVolume:
3697 LightApp_SelectionMgr* mgr = selectionMgr();
3698 SALOME_ListIO selected; mgr->selectedObjects( selected );
3700 if( !selected.IsEmpty() ) {
3701 SUIT_OverrideCursor wc;
3702 ::Control( theCommandID );
3705 SUIT_MessageBox::warning(desktop(),
3706 tr( "SMESH_WRN_WARNING" ),
3707 tr( "SMESH_BAD_SELECTION" ) );
3711 SUIT_MessageBox::warning(desktop(),
3712 tr( "SMESH_WRN_WARNING" ),
3713 tr( "NOT_A_VTK_VIEWER" ) );
3716 case SMESHOp::OpOverallMeshQuality:
3717 OverallMeshQuality();
3719 case SMESHOp::OpNumberingNodes:
3721 SUIT_OverrideCursor wc;
3722 LightApp_SelectionMgr* mgr = selectionMgr();
3723 SALOME_ListIO selected; mgr->selectedObjects( selected );
3725 SALOME_ListIteratorOfListIO it(selected);
3726 for( ; it.More(); it.Next()) {
3727 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3728 if(anIObject->hasEntry()) {
3729 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3730 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3736 case SMESHOp::OpNumberingElements:
3738 SUIT_OverrideCursor wc;
3739 LightApp_SelectionMgr* mgr = selectionMgr();
3740 SALOME_ListIO selected; mgr->selectedObjects( selected );
3742 SALOME_ListIteratorOfListIO it(selected);
3743 for( ; it.More(); it.Next()) {
3744 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3745 if(anIObject->hasEntry())
3746 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3747 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3752 case SMESHOp::OpPropertiesLength:
3753 case SMESHOp::OpPropertiesArea:
3754 case SMESHOp::OpPropertiesVolume:
3755 case SMESHOp::OpMinimumDistance:
3756 case SMESHOp::OpBoundingBox:
3757 case SMESHOp::OpAngle:
3759 int page = SMESHGUI_MeasureDlg::MinDistance;
3760 if ( theCommandID == SMESHOp::OpBoundingBox )
3761 page = SMESHGUI_MeasureDlg::BoundingBox;
3762 else if ( theCommandID == SMESHOp::OpPropertiesLength )
3763 page = SMESHGUI_MeasureDlg::Length;
3764 else if ( theCommandID == SMESHOp::OpPropertiesArea )
3765 page = SMESHGUI_MeasureDlg::Area;
3766 else if ( theCommandID == SMESHOp::OpPropertiesVolume )
3767 page = SMESHGUI_MeasureDlg::Volume;
3768 else if ( theCommandID == SMESHOp::OpAngle )
3769 page = SMESHGUI_MeasureDlg::Angle;
3771 EmitSignalDeactivateDialog();
3772 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3776 case SMESHOp::OpSortChild:
3779 case SMESHOp::OpBreakLink:
3780 ::breakShaperLink();
3785 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3786 //updateObjBrowser();
3790 //=============================================================================
3794 //=============================================================================
3795 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3800 //=============================================================================
3804 //=============================================================================
3805 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3810 //=============================================================================
3814 //=============================================================================
3815 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3820 //=============================================================================
3821 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3822 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3824 //=============================================================================
3825 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3826 SUIT_ViewWindow* wnd )
3828 if(theIO->hasEntry()){
3829 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3830 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3834 //=======================================================================
3835 // function : createSMESHAction
3837 //=======================================================================
3838 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3839 const int key, const bool toggle, const QString& shortcutAction )
3842 QWidget* parent = application()->desktop();
3843 SUIT_ResourceMgr* resMgr = resourceMgr();
3845 if ( !icon_id.isEmpty() )
3846 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3848 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3849 if ( !pix.isNull() )
3850 icon = QIcon( pix );
3852 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3853 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3854 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3856 createAction( id, tooltip, icon, menu, status_bar, key, parent,
3857 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3860 //=======================================================================
3861 // function : createPopupItem
3863 //=======================================================================
3864 void SMESHGUI::createPopupItem( const int id,
3865 const QString& clients,
3866 const QString& types,
3867 const QString& theRule,
3870 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3871 popupMgr()->insert( action( id ), pId, 0 );
3873 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3874 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
3875 QString rule = "(%1) and (%2) and (%3)";
3876 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3877 if( clients.isEmpty() )
3878 rule = rule.arg( QString( "true" ) );
3880 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3881 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3884 bool cont = myRules.contains( id );
3886 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3888 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3889 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3892 //=======================================================================
3893 // function : initialize
3895 //=======================================================================
3896 void SMESHGUI::initialize( CAM_Application* app )
3898 SalomeApp_Module::initialize( app );
3900 // SUIT_ResourceMgr* mgr = app->resourceMgr();
3902 /* Automatic Update flag */
3903 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3905 // ----- create actions --------------
3907 //createSMESHAction( SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
3908 createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_I) );
3909 createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
3910 createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL" );
3912 createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
3914 createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
3915 createSMESHAction( SMESHOp::OpImportGMF, "IMPORT_GMF" );
3916 createSMESHAction( SMESHOp::OpPopupImportUNV, "IMPORT_UNV");
3917 createSMESHAction( SMESHOp::OpPopupImportMED, "IMPORT_MED");
3918 createSMESHAction( SMESHOp::OpPopupImportSTL, "IMPORT_STL" );
3920 createSMESHAction( SMESHOp::OpPopupImportCGNS, "IMPORT_CGNS" );
3922 createSMESHAction( SMESHOp::OpPopupImportSAUV, "IMPORT_SAUV" );
3923 createSMESHAction( SMESHOp::OpPopupImportGMF, "IMPORT_GMF" );
3925 createSMESHAction( SMESHOp::OpExportDAT, "DAT" );
3926 createSMESHAction( SMESHOp::OpExportMED, "MED" );
3927 createSMESHAction( SMESHOp::OpExportUNV, "UNV" );
3928 createSMESHAction( SMESHOp::OpExportSTL, "STL" );
3930 createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
3932 createSMESHAction( SMESHOp::OpExportSAUV, "SAUV");
3933 createSMESHAction( SMESHOp::OpExportGMF, "GMF" );
3934 createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
3935 createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
3936 createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
3937 createSMESHAction( SMESHOp::OpPopupExportSTL, "STL" );
3939 createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
3941 createSMESHAction( SMESHOp::OpPopupExportSAUV, "SAUV");
3942 createSMESHAction( SMESHOp::OpPopupExportGMF, "GMF" );
3943 createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
3944 createSMESHAction( SMESHOp::OpDelete, "DELETE", "ICON_DELETE", Qt::Key_Delete );
3945 createSMESHAction( SMESHOp::OpSelectFiltersLibrary, "SEL_FILTER_LIB" );
3946 createSMESHAction( SMESHOp::OpCreateMesh, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
3947 createSMESHAction( SMESHOp::OpCreateSubMesh, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
3948 createSMESHAction( SMESHOp::OpEditMeshOrSubMesh, "EDIT_MESHSUBMESH", "ICON_DLG_EDIT_MESH" );
3949 createSMESHAction( SMESHOp::OpEditMesh, "EDIT_MESH", "ICON_DLG_EDIT_MESH" );
3950 createSMESHAction( SMESHOp::OpEditSubMesh, "EDIT_SUBMESH", "ICON_DLG_EDIT_MESH" );
3951 createSMESHAction( SMESHOp::OpBuildCompoundMesh, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
3952 createSMESHAction( SMESHOp::OpCopyMesh, "COPY_MESH", "ICON_COPY_MESH" );
3953 createSMESHAction( SMESHOp::OpCompute, "COMPUTE", "ICON_COMPUTE" );
3954 createSMESHAction( SMESHOp::OpComputeSubMesh, "COMPUTE_SUBMESH", "ICON_COMPUTE" );
3955 createSMESHAction( SMESHOp::OpPreCompute, "PRECOMPUTE", "ICON_PRECOMPUTE" );
3956 createSMESHAction( SMESHOp::OpEvaluate, "EVALUATE", "ICON_EVALUATE" );
3957 createSMESHAction( SMESHOp::OpMeshOrder, "MESH_ORDER", "ICON_MESH_ORDER");
3958 createSMESHAction( SMESHOp::OpCreateGroup, "CREATE_GROUP", "ICON_CREATE_GROUP" );
3959 createSMESHAction( SMESHOp::OpCreateGeometryGroup, "CREATE_GEO_GROUP", "ICON_CREATE_GEO_GROUP" );
3960 createSMESHAction( SMESHOp::OpConstructGroup, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
3961 createSMESHAction( SMESHOp::OpEditGroup, "EDIT_GROUP", "ICON_EDIT_GROUP" );
3962 createSMESHAction( SMESHOp::OpEditGeomGroupAsGroup, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3963 createSMESHAction( SMESHOp::OpUnionGroups, "UN_GROUP", "ICON_UNION" );
3964 createSMESHAction( SMESHOp::OpIntersectGroups, "INT_GROUP", "ICON_INTERSECT" );
3965 createSMESHAction( SMESHOp::OpCutGroups, "CUT_GROUP", "ICON_CUT" );
3966 createSMESHAction( SMESHOp::OpGroupUnderlyingElem, "UNDERLYING_ELEMS", "ICON_UNDERLYING_ELEMS" );
3967 createSMESHAction( SMESHOp::OpFaceGroupsByEdges, "FACE_GROUPS_BY_EDGES", "ICON_FACE_GROUPS_BY_EDGES" );
3968 createSMESHAction( SMESHOp::OpAddElemGroupPopup, "ADD_TO_GROUP" );
3969 createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE_FROM_GROUP" );
3970 createSMESHAction( SMESHOp::OpDeleteGroup, "DEL_GROUP", "ICON_DEL_GROUP" );
3971 createSMESHAction( SMESHOp::OpMeshInformation , "ADV_INFO", "ICON_ADV_INFO" );
3972 //createSMESHAction( SMESHOp::OpStdInfo, "STD_INFO", "ICON_STD_INFO" );
3973 //createSMESHAction( SMESHOp::OpWhatIs, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3974 createSMESHAction( SMESHOp::OpFindElementByPoint, "FIND_ELEM", "ICON_FIND_ELEM" );
3976 createSMESHAction( SMESHOp::OpFreeNode, "FREE_NODE", "ICON_FREE_NODE", 0, true );
3977 createSMESHAction( SMESHOp::OpEqualNode, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
3978 createSMESHAction( SMESHOp::OpNodeConnectivityNb, "NODE_CONNECTIVITY_NB", "ICON_NODE_CONN_NB", 0, true );
3979 createSMESHAction( SMESHOp::OpFreeEdge, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
3980 createSMESHAction( SMESHOp::OpFreeBorder, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
3981 createSMESHAction( SMESHOp::OpLength, "LENGTH", "ICON_LENGTH", 0, true );
3982 createSMESHAction( SMESHOp::OpConnection, "CONNECTION", "ICON_CONNECTION", 0, true );
3983 createSMESHAction( SMESHOp::OpEqualEdge, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
3984 createSMESHAction( SMESHOp::OpFreeFace, "FREE_FACES", "ICON_FREE_FACES", 0, true );
3985 createSMESHAction( SMESHOp::OpBareBorderFace, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
3986 createSMESHAction( SMESHOp::OpOverConstrainedFace, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
3987 createSMESHAction( SMESHOp::OpLength2D, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
3988 createSMESHAction( SMESHOp::OpDeflection2D, "DEFLECTION_2D", "ICON_DEFLECTION_2D", 0, true );
3989 createSMESHAction( SMESHOp::OpConnection2D, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
3990 createSMESHAction( SMESHOp::OpArea, "AREA", "ICON_AREA", 0, true );
3991 createSMESHAction( SMESHOp::OpTaper, "TAPER", "ICON_TAPER", 0, true );
3992 createSMESHAction( SMESHOp::OpAspectRatio, "ASPECT", "ICON_ASPECT", 0, true );
3993 createSMESHAction( SMESHOp::OpMinimumAngle, "MIN_ANG", "ICON_ANGLE", 0, true );
3994 createSMESHAction( SMESHOp::OpWarpingAngle, "WARP", "ICON_WARP", 0, true );
3995 createSMESHAction( SMESHOp::OpSkew, "SKEW", "ICON_SKEW", 0, true );
3996 createSMESHAction( SMESHOp::OpMaxElementLength2D, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
3997 createSMESHAction( SMESHOp::OpEqualFace, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
3998 createSMESHAction( SMESHOp::OpAspectRatio3D, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
3999 createSMESHAction( SMESHOp::OpVolume, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
4000 createSMESHAction( SMESHOp::OpMaxElementLength3D, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
4001 createSMESHAction( SMESHOp::OpBareBorderVolume, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
4002 createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
4003 createSMESHAction( SMESHOp::OpEqualVolume, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
4004 createSMESHAction( SMESHOp::OpOverallMeshQuality, "OVERALL_MESH_QUALITY", "ICON_OVL_MESH_QUALITY" );
4006 createSMESHAction( SMESHOp::OpNode, "NODE", "ICON_DLG_NODE" );
4007 createSMESHAction( SMESHOp::OpElem0D, "ELEM0D", "ICON_DLG_ELEM0D" );
4008 createSMESHAction( SMESHOp::OpElem0DOnElemNodes, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
4009 createSMESHAction( SMESHOp::OpBall, "BALL", "ICON_DLG_BALL" );
4010 createSMESHAction( SMESHOp::OpEdge, "EDGE", "ICON_DLG_EDGE" );
4011 createSMESHAction( SMESHOp::OpTriangle, "TRIANGLE", "ICON_DLG_TRIANGLE" );
4012 createSMESHAction( SMESHOp::OpQuadrangle, "QUAD", "ICON_DLG_QUADRANGLE" );
4013 createSMESHAction( SMESHOp::OpPolygon, "POLYGON", "ICON_DLG_POLYGON" );
4014 createSMESHAction( SMESHOp::OpTetrahedron, "TETRA", "ICON_DLG_TETRAS" );
4015 createSMESHAction( SMESHOp::OpHexahedron, "HEXA", "ICON_DLG_HEXAS" );
4016 createSMESHAction( SMESHOp::OpPentahedron, "PENTA", "ICON_DLG_PENTA" );
4017 createSMESHAction( SMESHOp::OpPyramid , "PYRAMID", "ICON_DLG_PYRAMID" );
4018 createSMESHAction( SMESHOp::OpHexagonalPrism, "OCTA", "ICON_DLG_OCTA" );
4019 createSMESHAction( SMESHOp::OpPolyhedron, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
4020 createSMESHAction( SMESHOp::OpQuadraticEdge, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
4021 createSMESHAction( SMESHOp::OpQuadraticTriangle, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
4022 createSMESHAction( SMESHOp::OpBiQuadraticTriangle, "BIQUADRATIC_TRIANGLE", "ICON_DLG_BIQUADRATIC_TRIANGLE" );
4023 createSMESHAction( SMESHOp::OpQuadraticQuadrangle, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
4024 createSMESHAction( SMESHOp::OpBiQuadraticQuadrangle, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
4025 createSMESHAction( SMESHOp::OpQuadraticPolygon, "QUADRATIC_POLYGON", "ICON_DLG_QUADRATIC_POLYGON" );
4026 createSMESHAction( SMESHOp::OpQuadraticTetrahedron, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
4027 createSMESHAction( SMESHOp::OpQuadraticPyramid, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
4028 createSMESHAction( SMESHOp::OpQuadraticPentahedron, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
4029 createSMESHAction( SMESHOp::OpBiQuadraticPentahedron, "BIQUADRATIC_PENTAHEDRON", "ICON_DLG_BIQUADRATIC_PENTAHEDRON" );
4030 createSMESHAction( SMESHOp::OpQuadraticHexahedron, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
4031 createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
4033 createSMESHAction( SMESHOp::OpRemoveNodes, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
4034 createSMESHAction( SMESHOp::OpRemoveElements, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
4035 createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
4036 createSMESHAction( SMESHOp::OpClearMesh, "CLEAR_MESH", "ICON_CLEAR_MESH" );
4038 //createSMESHAction( SMESHOp::OpRenumberingNodes, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
4039 //createSMESHAction( SMESHOp::OpRenumberingElements, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
4041 createSMESHAction( SMESHOp::OpTranslation, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
4042 createSMESHAction( SMESHOp::OpRotation, "ROT", "ICON_DLG_MESH_ROTATION" );
4043 createSMESHAction( SMESHOp::OpSymmetry, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
4044 createSMESHAction( SMESHOp::OpScale, "SCALE", "ICON_DLG_MESH_SCALE" );
4045 createSMESHAction( SMESHOp::OpOffset, "OFFSET", "ICON_DLG_MESH_OFFSET" );
4046 createSMESHAction( SMESHOp::OpSewing, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
4047 createSMESHAction( SMESHOp::OpMergeNodes, "MERGE", "ICON_SMESH_MERGE_NODES" );
4048 createSMESHAction( SMESHOp::OpMergeElements, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
4049 createSMESHAction( SMESHOp::OpMoveNode, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
4050 createSMESHAction( SMESHOp::OpDuplicateNodes, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
4051 createSMESHAction( SMESHOp::OpDiagonalInversion, "INV", "ICON_DLG_MESH_DIAGONAL" );
4052 createSMESHAction( SMESHOp::OpUnionOfTwoTriangle, "UNION2", "ICON_UNION2TRI" );
4053 createSMESHAction( SMESHOp::OpOrientation, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
4054 createSMESHAction( SMESHOp::OpReorientFaces, "REORIENT_2D", "ICON_REORIENT_2D" );
4055 createSMESHAction( SMESHOp::OpUnionOfTriangles, "UNION", "ICON_UNIONTRI" );
4056 createSMESHAction( SMESHOp::OpCuttingOfQuadrangles, "CUT", "ICON_CUTQUAD" );
4057 createSMESHAction( SMESHOp::OpSplitVolumes, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
4058 createSMESHAction( SMESHOp::OpSplitBiQuadratic, "SPLIT_BIQUAD", "ICON_SPLIT_BIQUAD" );
4059 createSMESHAction( SMESHOp::OpSmoothing, "SMOOTH", "ICON_DLG_SMOOTHING" );
4060 createSMESHAction( SMESHOp::OpExtrusion, "EXTRUSION", "ICON_EXTRUSION" );
4061 createSMESHAction( SMESHOp::OpExtrusionAlongAPath, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
4062 createSMESHAction( SMESHOp::OpRevolution, "REVOLUTION", "ICON_REVOLUTION" );
4063 createSMESHAction( SMESHOp::OpPatternMapping, "MAP", "ICON_MAP" );
4064 createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
4065 createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D", "ICON_2D_FROM_3D" );
4067 createSMESHAction( SMESHOp::OpReset, "RESET" );
4068 createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
4069 createSMESHAction( SMESHOp::OpShowScalarBar, "SHOW_SCALAR_BAR","",0, true );
4070 createSMESHAction( SMESHOp::OpSaveDistribution, "SAVE_DISTRIBUTION" );
4071 createSMESHAction( SMESHOp::OpShowDistribution, "SHOW_DISTRIBUTION","",0, true );
4072 #ifndef DISABLE_PLOT2DVIEWER
4073 createSMESHAction( SMESHOp::OpPlotDistribution, "PLOT_DISTRIBUTION" );
4075 createSMESHAction( SMESHOp::OpDMWireframe, "WIRE", "ICON_WIRE", 0, true );
4076 createSMESHAction( SMESHOp::OpDMShading, "SHADE", "ICON_SHADE", 0, true );
4077 createSMESHAction( SMESHOp::OpDMNodes, "NODES", "ICON_POINTS", 0, true );
4078 createSMESHAction( SMESHOp::OpDMShrink, "SHRINK", "ICON_SHRINK", 0, true );
4079 createSMESHAction( SMESHOp::OpUpdate, "UPDATE", "ICON_UPDATE" );
4080 createSMESHAction( SMESHOp::OpDE0DElements, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
4081 createSMESHAction( SMESHOp::OpDEEdges, "EDGES", "ICON_DLG_EDGE", 0, true );
4082 createSMESHAction( SMESHOp::OpDEFaces, "FACES", "ICON_DLG_TRIANGLE", 0, true );
4083 createSMESHAction( SMESHOp::OpDEVolumes, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
4084 createSMESHAction( SMESHOp::OpDEBalls, "BALLS", "ICON_DLG_BALL", 0, true );
4085 createSMESHAction( SMESHOp::OpDEChoose, "CHOOSE", "ICON_DLG_CHOOSE", 0, false );
4086 createSMESHAction( SMESHOp::OpDEAllEntity, "ALL", "ICON_DLG_CHOOSE_ALL", 0, false );
4087 createSMESHAction( SMESHOp::OpOrientationOnFaces, "FACE_ORIENTATION", "", 0, true );
4089 createSMESHAction( SMESHOp::OpRepresentationLines, "LINE_REPRESENTATION", "", 0, true );
4090 createSMESHAction( SMESHOp::OpRepresentationArcs, "ARC_REPRESENTATION", "", 0, true );
4092 createSMESHAction( SMESHOp::OpEditHypothesis, "EDIT_HYPO" );
4093 createSMESHAction( SMESHOp::OpUnassign, "UNASSIGN" );
4094 createSMESHAction( SMESHOp::OpNumberingNodes, "NUM_NODES", "", 0, true );
4095 createSMESHAction( SMESHOp::OpNumberingElements, "NUM_ELEMENTS", "", 0, true );
4096 createSMESHAction( SMESHOp::OpProperties, "COLORS" );
4097 createSMESHAction( SMESHOp::OpTransparency, "TRANSP" );
4098 createSMESHAction( SMESHOp::OpClipping, "CLIP" );
4099 createSMESHAction( SMESHOp::OpAutoColor, "AUTO_COLOR" );
4100 createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
4102 createSMESHAction( SMESHOp::OpMinimumDistance, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
4103 createSMESHAction( SMESHOp::OpBoundingBox, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
4104 createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH", "ICON_MEASURE_LENGTH" );
4105 createSMESHAction( SMESHOp::OpPropertiesArea, "MEASURE_AREA", "ICON_MEASURE_AREA" );
4106 createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME", "ICON_MEASURE_VOLUME" );
4107 createSMESHAction( SMESHOp::OpAngle, "MEASURE_ANGLE", "ICON_MEASURE_ANGLE" );
4109 createSMESHAction( SMESHOp::OpHide, "HIDE", "ICON_HIDE" );
4110 createSMESHAction( SMESHOp::OpShow, "SHOW", "ICON_SHOW" );
4111 createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
4113 createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
4115 createSMESHAction( SMESHOp::OpBreakLink, "BREAK_SHAPER_LINK" );
4117 QList<int> aCtrlActions;
4118 aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode
4119 << SMESHOp::OpNodeConnectivityNb // node controls
4120 << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
4121 << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge // edge controls
4122 << SMESHOp::OpDeflection2D
4123 << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
4124 << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
4125 << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
4126 << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
4127 << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace // face controls
4128 << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
4129 << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
4130 << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume; // volume controls
4131 QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
4132 aCtrlGroup->setExclusive( true );
4133 for( int i = 0; i < aCtrlActions.size(); i++ )
4134 aCtrlGroup->addAction( action( aCtrlActions[i] ) );
4136 // ----- create menu --------------
4137 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
4138 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
4139 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
4140 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
4141 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
4142 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
4143 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
4144 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
4146 createMenu( separator(), fileId );
4148 QMenu* nodeMenu = new QMenu(); QMenu* edgeMenu = new QMenu();
4149 QMenu* faceMenu = new QMenu(); QMenu* volumeMenu = new QMenu();
4150 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
4151 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
4152 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10, -1, nodeMenu ),
4153 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10, -1, edgeMenu ),
4154 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10, -1, faceMenu ),
4155 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10, -1, volumeMenu ),
4156 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
4157 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
4158 //renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
4159 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
4160 basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
4162 //createMenu( SMESHOp::OpImportDAT, importId, -1 );
4163 createMenu( SMESHOp::OpImportUNV, importId, -1 );
4164 createMenu( SMESHOp::OpImportMED, importId, -1 );
4165 createMenu( SMESHOp::OpImportSTL, importId, -1 );
4167 createMenu( SMESHOp::OpImportCGNS, importId, -1 );
4169 createMenu( SMESHOp::OpImportSAUV, importId, -1 );
4170 createMenu( SMESHOp::OpImportGMF, importId, -1 );
4171 createMenu( SMESHOp::OpExportDAT, exportId, -1 );
4172 createMenu( SMESHOp::OpExportMED, exportId, -1 );
4173 createMenu( SMESHOp::OpExportUNV, exportId, -1 );
4174 createMenu( SMESHOp::OpExportSTL, exportId, -1 );
4176 createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
4178 createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
4179 createMenu( SMESHOp::OpExportGMF, exportId, -1 );
4180 createMenu( separator(), fileId, 10 );
4182 createMenu( SMESHOp::OpDelete, editId, -1 );
4184 createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
4186 createMenu( SMESHOp::OpCreateMesh, meshId, -1 ); // "Mesh" menu
4187 createMenu( SMESHOp::OpCreateSubMesh, meshId, -1 );
4188 createMenu( SMESHOp::OpEditMeshOrSubMesh, meshId, -1 );
4189 createMenu( SMESHOp::OpBuildCompoundMesh, meshId, -1 );
4190 createMenu( SMESHOp::OpCopyMesh, meshId, -1 );
4191 createMenu( separator(), meshId, -1 );
4192 createMenu( SMESHOp::OpCompute, meshId, -1 );
4193 createMenu( SMESHOp::OpPreCompute, meshId, -1 );
4194 createMenu( SMESHOp::OpEvaluate, meshId, -1 );
4195 createMenu( SMESHOp::OpMeshOrder, meshId, -1 );
4196 createMenu( separator(), meshId, -1 );
4197 createMenu( SMESHOp::OpCreateGroup, meshId, -1 );
4198 createMenu( SMESHOp::OpCreateGeometryGroup, meshId, -1 );
4199 createMenu( SMESHOp::OpConstructGroup, meshId, -1 );
4200 createMenu( SMESHOp::OpEditGroup, meshId, -1 );
4201 createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4202 createMenu( separator(), meshId, -1 );
4203 createMenu( SMESHOp::OpUnionGroups, meshId, -1 );
4204 createMenu( SMESHOp::OpIntersectGroups, meshId, -1 );
4205 createMenu( SMESHOp::OpCutGroups, meshId, -1 );
4206 createMenu( separator(), meshId, -1 );
4207 createMenu( SMESHOp::OpGroupUnderlyingElem, meshId, -1 );
4208 createMenu( SMESHOp::OpFaceGroupsByEdges, meshId, -1 );
4209 createMenu( separator(), meshId, -1 );
4210 createMenu( SMESHOp::OpMeshInformation, meshId, -1 );
4211 //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4212 //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4213 createMenu( SMESHOp::OpFindElementByPoint, meshId, -1 );
4214 createMenu( separator(), meshId, -1 );
4216 createMenu( SMESHOp::OpFreeNode, nodeId, -1 );
4217 createMenu( SMESHOp::OpEqualNode, nodeId, -1 );
4218 //createMenu( SMESHOp::OpNodeConnectivityNb, nodeId, -1 );
4219 createMenu( SMESHOp::OpFreeBorder, edgeId, -1 );
4220 createMenu( SMESHOp::OpLength, edgeId, -1 );
4221 createMenu( SMESHOp::OpConnection, edgeId, -1 );
4222 createMenu( SMESHOp::OpEqualEdge, edgeId, -1 );
4223 createMenu( SMESHOp::OpFreeEdge, faceId, -1 );
4224 createMenu( SMESHOp::OpFreeFace, faceId, -1 );
4225 createMenu( SMESHOp::OpBareBorderFace, faceId, -1 );
4226 createMenu( SMESHOp::OpOverConstrainedFace, faceId, -1 );
4227 createMenu( SMESHOp::OpLength2D, faceId, -1 );
4228 createMenu( SMESHOp::OpConnection2D, faceId, -1 );
4229 createMenu( SMESHOp::OpArea, faceId, -1 );
4230 createMenu( SMESHOp::OpTaper, faceId, -1 );
4231 createMenu( SMESHOp::OpAspectRatio, faceId, -1 );
4232 createMenu( SMESHOp::OpMinimumAngle, faceId, -1 );
4233 createMenu( SMESHOp::OpWarpingAngle, faceId, -1 );
4234 createMenu( SMESHOp::OpSkew, faceId, -1 );
4235 createMenu( SMESHOp::OpMaxElementLength2D, faceId, -1 );
4236 createMenu( SMESHOp::OpEqualFace, faceId, -1 );
4237 createMenu( SMESHOp::OpDeflection2D, faceId, -1 );
4238 createMenu( SMESHOp::OpAspectRatio3D, volumeId, -1 );
4239 createMenu( SMESHOp::OpVolume, volumeId, -1 );
4240 createMenu( SMESHOp::OpMaxElementLength3D, volumeId, -1 );
4241 createMenu( SMESHOp::OpBareBorderVolume, volumeId, -1 );
4242 createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4243 createMenu( SMESHOp::OpEqualVolume, volumeId, -1 );
4244 createMenu( separator(), ctrlId, -1 );
4245 createMenu( SMESHOp::OpReset, ctrlId, -1 );
4246 createMenu( separator(), ctrlId, -1 );
4247 createMenu( SMESHOp::OpOverallMeshQuality, ctrlId, -1 );
4249 createMenu( SMESHOp::OpNode, addId, -1 );
4250 createMenu( SMESHOp::OpElem0D, addId, -1 );
4251 createMenu( SMESHOp::OpElem0DOnElemNodes, addId, -1 );
4252 createMenu( SMESHOp::OpBall, addId, -1 );
4253 createMenu( SMESHOp::OpEdge, addId, -1 );
4254 createMenu( SMESHOp::OpTriangle, addId, -1 );
4255 createMenu( SMESHOp::OpQuadrangle, addId, -1 );
4256 createMenu( SMESHOp::OpPolygon, addId, -1 );
4257 createMenu( SMESHOp::OpTetrahedron, addId, -1 );
4258 createMenu( SMESHOp::OpHexahedron, addId, -1 );
4259 createMenu( SMESHOp::OpPentahedron, addId, -1 );
4260 createMenu( SMESHOp::OpPyramid, addId, -1 );
4261 createMenu( SMESHOp::OpHexagonalPrism, addId, -1 );
4262 createMenu( SMESHOp::OpPolyhedron, addId, -1 );
4263 createMenu( separator(), addId, -1 );
4264 createMenu( SMESHOp::OpQuadraticEdge, addId, -1 );
4265 createMenu( SMESHOp::OpQuadraticTriangle, addId, -1 );
4266 createMenu( SMESHOp::OpBiQuadraticTriangle , addId, -1 );
4267 createMenu( SMESHOp::OpQuadraticQuadrangle, addId, -1 );
4268 createMenu( SMESHOp::OpBiQuadraticQuadrangle, addId, -1 );
4269 createMenu( SMESHOp::OpQuadraticPolygon, addId, -1 );
4270 createMenu( SMESHOp::OpQuadraticTetrahedron, addId, -1 );
4271 createMenu( SMESHOp::OpQuadraticPyramid, addId, -1 );
4272 createMenu( SMESHOp::OpQuadraticPentahedron, addId, -1 );
4273 createMenu( SMESHOp::OpBiQuadraticPentahedron, addId, -1 );
4274 createMenu( SMESHOp::OpQuadraticHexahedron, addId, -1 );
4275 createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4277 createMenu( SMESHOp::OpRemoveNodes, removeId, -1 );
4278 createMenu( SMESHOp::OpRemoveElements, removeId, -1 );
4279 createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4280 createMenu( separator(), removeId, -1 );
4281 createMenu( SMESHOp::OpDeleteGroup, removeId, -1 );
4282 createMenu( separator(), removeId, -1 );
4283 createMenu( SMESHOp::OpClearMesh, removeId, -1 );
4285 //createMenu( SMESHOp::OpRenumberingNodes, renumId, -1 );
4286 //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4288 createMenu( SMESHOp::OpMergeNodes, transfId, -1 );
4289 createMenu( SMESHOp::OpMergeElements, transfId, -1 );
4290 createMenu( SMESHOp::OpTranslation, transfId, -1 );
4291 createMenu( SMESHOp::OpRotation, transfId, -1 );
4292 createMenu( SMESHOp::OpSymmetry, transfId, -1 );
4293 createMenu( SMESHOp::OpScale, transfId, -1 );
4294 createMenu( SMESHOp::OpOffset, transfId, -1 );
4295 createMenu( SMESHOp::OpSewing, transfId, -1 );
4296 createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4298 createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4299 createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4300 createMenu( SMESHOp::OpExtrusion, modifyId, -1 );
4301 createMenu( SMESHOp::OpExtrusionAlongAPath, modifyId, -1 );
4302 createMenu( SMESHOp::OpRevolution, modifyId, -1 );
4303 createMenu( SMESHOp::OpOrientation, modifyId, -1 );
4304 createMenu( SMESHOp::OpReorientFaces, modifyId, -1 );
4305 createMenu( SMESHOp::OpMoveNode, modifyId, -1 );
4306 createMenu( SMESHOp::OpDiagonalInversion, modifyId, -1 );
4307 createMenu( SMESHOp::OpUnionOfTwoTriangle, modifyId, -1 );
4308 createMenu( SMESHOp::OpUnionOfTriangles, modifyId, -1 );
4309 createMenu( SMESHOp::OpCuttingOfQuadrangles, modifyId, -1 );
4310 createMenu( SMESHOp::OpSplitVolumes, modifyId, -1 );
4311 createMenu( SMESHOp::OpSplitBiQuadratic, modifyId, -1 );
4312 createMenu( SMESHOp::OpSmoothing, modifyId, -1 );
4313 createMenu( SMESHOp::OpPatternMapping, modifyId, -1 );
4315 createMenu( SMESHOp::OpMinimumDistance, measureId, -1 );
4316 createMenu( SMESHOp::OpBoundingBox, measureId, -1 );
4317 createMenu( SMESHOp::OpAngle, measureId, -1 );
4318 createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4319 createMenu( SMESHOp::OpPropertiesArea, basicPropId, -1 );
4320 createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4321 createMenu( SMESHOp::OpUpdate, viewId, -1 );
4323 connect( nodeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4324 connect( edgeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4325 connect( faceMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4326 connect( volumeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4328 // ----- create toolbars --------------
4329 int meshTb = createTool( tr( "TB_MESH" ), QString( "SMESHMeshToolbar" ) ),
4330 info = createTool( tr( "TB_INFO" ), QString( "SMESHInformationToolbar" ) ),
4331 groupTb = createTool( tr( "TB_GROUP" ), QString( "SMESHGroupToolbar" ) ),
4332 ctrl0dTb = createTool( tr( "TB_CTRL0D" ), QString( "SMESHNodeControlsToolbar" ) ),
4333 ctrl1dTb = createTool( tr( "TB_CTRL1D" ), QString( "SMESHEdgeControlsToolbar" ) ),
4334 ctrl2dTb = createTool( tr( "TB_CTRL2D" ), QString( "SMESHFaceControlsToolbar" ) ),
4335 ctrl3dTb = createTool( tr( "TB_CTRL3D" ), QString( "SMESHVolumeControlsToolbar" ) ),
4336 addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ),
4337 addNonElemTb = createTool( tr( "TB_ADDNON" ), QString( "SMESHAddElementToolbar" ) ),
4338 remTb = createTool( tr( "TB_REM" ), QString( "SMESHRemoveToolbar" ) ),
4339 //renumbTb = createTool( tr( "TB_RENUMBER" ), QString( "SMESHRenumberingToolbar" ) ),
4340 transformTb = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ),
4341 modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ),
4342 measuremTb = createTool( tr( "TB_MEASUREM" ), QString( "SMESHMeasurementsToolbar" ) ),
4343 dispModeTb = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4345 createTool( SMESHOp::OpCreateMesh, meshTb );
4346 createTool( SMESHOp::OpCreateSubMesh, meshTb );
4347 createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4348 createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4349 createTool( SMESHOp::OpCopyMesh, meshTb );
4350 createTool( separator(), meshTb );
4351 createTool( SMESHOp::OpCompute, meshTb );
4352 createTool( SMESHOp::OpPreCompute, meshTb );
4353 createTool( SMESHOp::OpEvaluate, meshTb );
4354 createTool( SMESHOp::OpMeshOrder, meshTb );
4356 createTool( SMESHOp::OpCreateGroup, groupTb );
4357 createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4358 createTool( SMESHOp::OpConstructGroup, groupTb );
4359 createTool( SMESHOp::OpEditGroup, groupTb );
4361 createTool( SMESHOp::OpMeshInformation, info );
4362 //createTool( SMESHOp::OpStdInfo, meshTb );
4363 //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4364 createTool( SMESHOp::OpFindElementByPoint, info );
4366 createTool( SMESHOp::OpFreeNode, ctrl0dTb );
4367 createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4368 //createTool( SMESHOp::OpNodeConnectivityNb, ctrl0dTb );
4370 createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4371 createTool( SMESHOp::OpLength, ctrl1dTb );
4372 createTool( SMESHOp::OpConnection, ctrl1dTb );
4373 createTool( SMESHOp::OpEqualEdge, ctrl1dTb );
4375 createTool( SMESHOp::OpFreeEdge, ctrl2dTb );
4376 createTool( SMESHOp::OpFreeFace, ctrl2dTb );
4377 createTool( SMESHOp::OpBareBorderFace, ctrl2dTb );
4378 createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4379 createTool( SMESHOp::OpLength2D, ctrl2dTb );
4380 createTool( SMESHOp::OpConnection2D, ctrl2dTb );
4381 createTool( SMESHOp::OpArea, ctrl2dTb );
4382 createTool( SMESHOp::OpTaper, ctrl2dTb );
4383 createTool( SMESHOp::OpAspectRatio, ctrl2dTb );
4384 createTool( SMESHOp::OpMinimumAngle, ctrl2dTb );
4385 createTool( SMESHOp::OpWarpingAngle, ctrl2dTb );
4386 createTool( SMESHOp::OpSkew, ctrl2dTb );
4387 createTool( SMESHOp::OpMaxElementLength2D, ctrl2dTb );
4388 createTool( SMESHOp::OpEqualFace, ctrl2dTb );
4389 createTool( SMESHOp::OpDeflection2D, ctrl2dTb );
4391 createTool( SMESHOp::OpAspectRatio3D, ctrl3dTb );
4392 createTool( SMESHOp::OpVolume, ctrl3dTb );
4393 createTool( SMESHOp::OpMaxElementLength3D, ctrl3dTb );
4394 createTool( SMESHOp::OpBareBorderVolume, ctrl3dTb );
4395 createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
4396 createTool( SMESHOp::OpEqualVolume, ctrl3dTb );
4398 createTool( SMESHOp::OpNode, addElemTb );
4399 createTool( SMESHOp::OpElem0D, addElemTb );
4400 createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4401 createTool( SMESHOp::OpBall, addElemTb );
4402 createTool( SMESHOp::OpEdge, addElemTb );
4403 createTool( SMESHOp::OpTriangle, addElemTb );
4404 createTool( SMESHOp::OpQuadrangle, addElemTb );
4405 createTool( SMESHOp::OpPolygon, addElemTb );
4406 createTool( SMESHOp::OpTetrahedron, addElemTb );
4407 createTool( SMESHOp::OpHexahedron, addElemTb );
4408 createTool( SMESHOp::OpPentahedron, addElemTb );
4409 createTool( SMESHOp::OpPyramid, addElemTb );
4410 createTool( SMESHOp::OpHexagonalPrism, addElemTb );
4411 createTool( SMESHOp::OpPolyhedron, addElemTb );
4413 createTool( SMESHOp::OpQuadraticEdge, addNonElemTb );
4414 createTool( SMESHOp::OpQuadraticTriangle, addNonElemTb );
4415 createTool( SMESHOp::OpBiQuadraticTriangle, addNonElemTb );
4416 createTool( SMESHOp::OpQuadraticQuadrangle, addNonElemTb );
4417 createTool( SMESHOp::OpBiQuadraticQuadrangle, addNonElemTb );
4418 createTool( SMESHOp::OpQuadraticPolygon, addNonElemTb );
4419 createTool( SMESHOp::OpQuadraticTetrahedron, addNonElemTb );
4420 createTool( SMESHOp::OpQuadraticPyramid, addNonElemTb );
4421 createTool( SMESHOp::OpQuadraticPentahedron, addNonElemTb );
4422 createTool( SMESHOp::OpBiQuadraticPentahedron, addNonElemTb );
4423 createTool( SMESHOp::OpQuadraticHexahedron, addNonElemTb );
4424 createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4426 createTool( SMESHOp::OpRemoveNodes, remTb );
4427 createTool( SMESHOp::OpRemoveElements, remTb );
4428 createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4429 createTool( SMESHOp::OpClearMesh, remTb );
4431 //createTool( SMESHOp::OpRenumberingNodes, renumbTb );
4432 //createTool( SMESHOp::OpRenumberingElements, renumbTb );
4434 createTool( SMESHOp::OpMergeNodes, transformTb );
4435 createTool( SMESHOp::OpMergeElements, transformTb );
4436 createTool( SMESHOp::OpTranslation, transformTb );
4437 createTool( SMESHOp::OpRotation, transformTb );
4438 createTool( SMESHOp::OpSymmetry, transformTb );
4439 createTool( SMESHOp::OpScale, transformTb );
4440 createTool( SMESHOp::OpOffset, transformTb );
4441 createTool( SMESHOp::OpSewing, transformTb );
4442 createTool( SMESHOp::OpDuplicateNodes, transformTb );
4444 createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4445 createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4446 createTool( SMESHOp::OpExtrusion, modifyTb );
4447 createTool( SMESHOp::OpExtrusionAlongAPath, modifyTb );
4448 createTool( SMESHOp::OpRevolution, modifyTb );
4449 createTool( SMESHOp::OpOrientation, modifyTb );
4450 createTool( SMESHOp::OpReorientFaces, modifyTb );
4451 createTool( SMESHOp::OpMoveNode, modifyTb );
4452 createTool( SMESHOp::OpDiagonalInversion, modifyTb );
4453 createTool( SMESHOp::OpUnionOfTwoTriangle, modifyTb );
4454 createTool( SMESHOp::OpUnionOfTriangles, modifyTb );
4455 createTool( SMESHOp::OpCuttingOfQuadrangles, modifyTb );
4456 createTool( SMESHOp::OpSplitVolumes, modifyTb );
4457 createTool( SMESHOp::OpSplitBiQuadratic, modifyTb );
4458 createTool( SMESHOp::OpSmoothing, modifyTb );
4459 createTool( SMESHOp::OpPatternMapping, modifyTb );
4461 createTool( SMESHOp::OpMinimumDistance, measuremTb );
4463 createTool( SMESHOp::OpUpdate, dispModeTb );
4465 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4466 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4470 OB = "'ObjectBrowser'",
4471 View = "'" + SVTK_Viewer::Type() + "'",
4473 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4474 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4475 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4476 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4477 smesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::COMPONENT ) ),
4478 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4479 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4480 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4481 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4482 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4483 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4484 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4486 mesh_part = mesh + " " + subMesh + " " + group,
4487 mesh_group = mesh + " " + group,
4488 mesh_submesh = mesh + " " + subMesh,
4489 hyp_alg = hypo + " " + algo;
4491 // popup for object browser
4493 isInvisible("not( isVisible )"),
4494 isEmpty("numberOfNodes = 0"),
4495 isNotEmpty("numberOfNodes <> 0"),
4497 // has nodes, edges, etc in VISIBLE! actor
4498 hasNodes("(numberOfNodes > 0 ) && hasActor"),
4499 hasElems("(count( elemTypes ) > 0)"),
4500 hasDifferentElems("(count( elemTypes ) > 1)"),
4501 hasDifferentObjElems("(count( objElemTypes ) > 1)"),
4502 hasBalls("({'BallElem'} in elemTypes)"),
4503 hasElems0d("({'Elem0d'} in elemTypes)"),
4504 hasEdges("({'Edge'} in elemTypes)"),
4505 hasFaces("({'Face'} in elemTypes)"),
4506 hasVolumes("({'Volume'} in elemTypes)"),
4507 hasFacesOrVolumes("(({'Face'} in elemTypes) || ({'Volume'} in elemTypes)) ");
4509 createPopupItem( SMESHOp::OpFileInformation, OB, mesh, "&& selcount=1 && isImported" );
4510 createPopupItem( SMESHOp::OpCreateSubMesh, OB, mesh, "&& hasGeomReference");
4511 createPopupItem( SMESHOp::OpEditMesh, OB, mesh, "&& selcount=1" );
4512 createPopupItem( SMESHOp::OpEditSubMesh, OB, subMesh, "&& selcount=1 && hasGeomReference" );
4513 createPopupItem( SMESHOp::OpEditGroup, OB, group );
4514 createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4516 popupMgr()->insert( separator(), -1, 0 );
4517 createPopupItem( SMESHOp::OpCompute, OB, mesh, "&& selcount=1 && isComputable" );
4518 createPopupItem( SMESHOp::OpComputeSubMesh, OB, subMesh, "&& selcount=1 && isComputable" );
4519 createPopupItem( SMESHOp::OpPreCompute, OB, mesh, "&& selcount=1 && isPreComputable" );
4520 createPopupItem( SMESHOp::OpEvaluate, OB, mesh, "&& selcount=1 && isComputable" );
4521 createPopupItem( SMESHOp::OpMeshOrder, OB, mesh, "&& selcount=1 && isComputable && hasGeomReference" );
4522 createPopupItem( SMESHOp::OpUpdate, OB, mesh_part );
4523 createPopupItem( SMESHOp::OpMeshInformation, OB, mesh_part );
4524 createPopupItem( SMESHOp::OpFindElementByPoint,OB, mesh_group, "&& selcount=1" );
4525 createPopupItem( SMESHOp::OpOverallMeshQuality,OB, mesh_part );
4526 popupMgr()->insert( separator(), -1, 0 );
4527 createPopupItem( SMESHOp::OpCreateGroup, OB, mesh, "&& selcount=1" );
4528 createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh, "&& selcount=1 && hasGeomReference" );
4529 createPopupItem( SMESHOp::OpConstructGroup, OB, subMesh );
4530 popupMgr()->insert( separator(), -1, 0 );
4531 createPopupItem( SMESHOp::OpEditHypothesis, OB, hypo, "&& isEditableHyp");
4532 createPopupItem( SMESHOp::OpUnassign, OB, hyp_alg );
4533 popupMgr()->insert( separator(), -1, 0 );
4534 createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh_submesh );
4535 createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh_group, "&& selcount=1 && dim>=2");
4536 popupMgr()->insert( separator(), -1, 0 );
4537 createPopupItem( SMESHOp::OpClearMesh, OB, mesh );
4538 //popupMgr()->insert( separator(), -1, 0 );
4540 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4541 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4542 QString only_one_2D = only_one_non_empty + " && dim>1";
4544 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4545 createPopupItem( SMESHOp::OpPopupExportMED, OB, mesh_group, multiple_non_empty, anId );
4546 createPopupItem( SMESHOp::OpPopupExportUNV, OB, mesh_group, only_one_non_empty, anId );
4547 createPopupItem( SMESHOp::OpPopupExportSTL, OB, mesh_group, only_one_2D, anId );
4549 createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4551 createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, only_one_non_empty, anId );
4552 createPopupItem( SMESHOp::OpPopupExportGMF, OB, mesh_group, only_one_non_empty, anId );
4553 createPopupItem( SMESHOp::OpPopupExportDAT, OB, mesh_group, only_one_non_empty, anId );
4554 createPopupItem( SMESHOp::OpDelete, OB, mesh_part + " " + hyp_alg );
4555 createPopupItem( SMESHOp::OpDeleteGroup, OB, group );
4557 anId = popupMgr()->insert( tr( "MEN_IMPORT" ), -1, -1 ); // IMPORT submenu
4558 createPopupItem( SMESHOp::OpPopupImportMED, OB, smesh, "", anId );
4559 createPopupItem( SMESHOp::OpPopupImportUNV, OB, smesh, "", anId );
4560 createPopupItem( SMESHOp::OpPopupImportSTL, OB, smesh, "", anId );
4562 createPopupItem( SMESHOp::OpPopupImportCGNS, OB, smesh, "", anId );
4564 createPopupItem( SMESHOp::OpPopupImportSAUV, OB, smesh, "", anId );
4565 createPopupItem( SMESHOp::OpPopupImportGMF, OB, smesh, "", anId );
4566 createPopupItem( SMESHOp::OpPopupImportDAT, OB, smesh, "", anId );
4567 popupMgr()->insert( separator(), -1, 0 );
4570 createPopupItem( SMESHOp::OpEditGroup, View, group );
4571 createPopupItem( SMESHOp::OpAddElemGroupPopup, View, elems, "&& guiState = 800" );
4572 createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems, "&& guiState = 800" );
4574 popupMgr()->insert( separator(), -1, 0 );
4575 createPopupItem( SMESHOp::OpUpdate, View, mesh_part );
4576 createPopupItem( SMESHOp::OpMeshInformation, View, mesh_part );
4577 createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4578 createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh );
4579 popupMgr()->insert( separator(), -1, 0 );
4581 createPopupItem( SMESHOp::OpAutoColor, OB + " " + View, mesh, "&& (not isAutoColor)" );
4582 createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4583 popupMgr()->insert( separator(), -1, 0 );
4585 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4586 QString aType = QString( "%1type in {%2}" ).arg( lc );
4587 aType = aType.arg( mesh_part );
4588 QString aMeshInVTK = aClient + "&&" + aType;
4590 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4591 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4592 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4594 //-------------------------------------------------
4596 //-------------------------------------------------
4597 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4599 popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4600 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4601 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4603 popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4604 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4605 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4607 popupMgr()->insert( separator(), -1, -1 );
4609 //-------------------------------------------------
4611 //-------------------------------------------------
4612 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4614 popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4615 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4616 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4618 popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4619 popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4620 popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4622 popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4623 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4624 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4626 popupMgr()->insert( separator(), anId, -1 );
4628 popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4629 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4630 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4632 //-------------------------------------------------
4634 //-------------------------------------------------
4635 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4637 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4639 popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4640 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4641 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4643 popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4644 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4645 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4647 popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4648 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4649 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4651 popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4652 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4653 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4655 popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4656 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4657 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4659 popupMgr()->insert( separator(), anId, -1 );
4661 popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4662 popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&& $type in {" + mesh + "} &&" + hasDifferentObjElems, QtxPopupMgr::VisibleRule );
4664 popupMgr()->insert( separator(), anId, -1 );
4666 popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4667 popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4670 //-------------------------------------------------
4671 // Representation of the 2D Quadratic elements
4672 //-------------------------------------------------
4673 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4674 popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4675 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "&& isVisible && isQuadratic",QtxPopupMgr::VisibleRule );
4676 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4678 popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4679 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "&& isVisible && isQuadratic", QtxPopupMgr::VisibleRule );
4680 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4682 //-------------------------------------------------
4683 // Orientation of faces
4684 //-------------------------------------------------
4685 popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4686 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4687 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4689 //-------------------------------------------------
4691 //-------------------------------------------------
4692 popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4693 popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4695 //-------------------------------------------------
4697 //-------------------------------------------------
4698 popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4699 popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4701 //-------------------------------------------------
4703 //-------------------------------------------------
4705 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4706 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4707 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4708 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4710 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4712 popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4713 popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4715 popupMgr()->insert( separator(), anId, -1 );
4717 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4719 popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4720 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4721 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4723 popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4724 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4725 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4727 // popupMgr()->insert( action( SMESHOp::OpNodeConnectivityNb ), aSubId, -1 );
4728 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4729 // popupMgr()->setRule( action( SMESHOp::OpNodeConnectivityNb ), "controlMode = 'eNodeConnectivityNb'", QtxPopupMgr::ToggleRule );
4731 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4733 popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4734 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVTK + "&&" + hasEdges + "&&" + hasFacesOrVolumes, QtxPopupMgr::VisibleRule );
4735 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4737 popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4738 popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4739 popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4741 popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4742 popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4743 popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4744 popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4745 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4746 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4748 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4750 popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4751 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4752 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4754 popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4755 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4756 QtxPopupMgr::VisibleRule );
4757 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4759 popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4760 popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4761 popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4763 popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4764 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4765 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4767 popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
4768 popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4769 popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4771 popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
4772 popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4773 popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4775 popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
4776 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4777 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4779 popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
4780 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4781 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4783 popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
4784 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4785 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4787 popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
4788 popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4789 popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4791 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
4792 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4793 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4795 popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
4796 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4797 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4799 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
4800 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4801 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4803 popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
4804 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4805 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4807 popupMgr()->insert ( action( SMESHOp::OpDeflection2D ), aSubId, -1 );
4808 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), aMeshInVtkHasFaces + " && hasGeomReference", QtxPopupMgr::VisibleRule );
4809 popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), "controlMode = 'eDeflection2D'", QtxPopupMgr::ToggleRule );
4811 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4813 popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D ), aSubId, -1 );
4814 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4815 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4817 popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
4818 popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4819 popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4821 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
4822 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4823 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4825 popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
4826 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4827 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4829 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
4830 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4831 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4833 popupMgr()->insert ( action( SMESHOp::OpEqualVolume ), aSubId, -1 );
4834 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4835 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4837 popupMgr()->insert( separator(), anId, -1 );
4839 popupMgr()->insert( action( SMESHOp::OpShowScalarBar ), anId, -1 );
4840 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4841 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone' && isScalarBarVisible", QtxPopupMgr::ToggleRule );
4842 popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
4843 popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4845 popupMgr()->insert( separator(), anId, -1 );
4847 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4849 popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
4850 popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4852 popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
4853 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4854 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isScalarBarVisible && isDistributionVisible", QtxPopupMgr::ToggleRule);
4856 #ifndef DISABLE_PLOT2DVIEWER
4857 popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
4858 popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4861 //-------------------------------------------------
4863 //-------------------------------------------------
4864 popupMgr()->insert( separator(), -1, -1 );
4865 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4866 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4867 popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
4868 popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4870 popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
4871 popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4873 popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
4874 popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4876 popupMgr()->insert( separator(), -1, -1 );
4878 //-------------------------------------------------
4880 //-------------------------------------------------
4881 popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
4882 popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4884 popupMgr()->insert( separator(), -1, -1 );
4886 popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
4887 popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
4888 popupMgr()->insert( separator(), -1, -1 );
4890 popupMgr()->insert( action( SMESHOp::OpBreakLink), -1, -1 );
4891 popupMgr()->setRule( action( SMESHOp::OpBreakLink), "$component={'SHAPERSTUDY'} and client='ObjectBrowser' and canBreakLink", QtxPopupMgr::VisibleRule );
4893 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4894 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4896 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4897 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4900 //================================================================================
4902 * \brief Return true if SMESH or GEOM objects are selected.
4903 * Is called form LightApp_Module::activateModule() which clear selection if
4904 * not isSelectionCompatible()
4906 //================================================================================
4908 bool SMESHGUI::isSelectionCompatible()
4910 bool isCompatible = true;
4911 SALOME_ListIO selected;
4912 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4913 Sel->selectedObjects( selected );
4915 SALOME_ListIteratorOfListIO It( selected );
4916 for ( ; isCompatible && It.More(); It.Next())
4918 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4919 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4921 return isCompatible;
4925 bool SMESHGUI::reusableOperation( const int id )
4927 // compute, evaluate and precompute are not reusable operations
4928 return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate ) ? false : SalomeApp_Module::reusableOperation( id );
4931 bool SMESHGUI::activateModule( SUIT_Study* study )
4933 bool res = SalomeApp_Module::activateModule( study );
4935 setMenuShown( true );
4936 setToolShown( true );
4938 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4939 PyGILState_STATE gstate = PyGILState_Ensure();
4940 PyObject* pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4941 if ( !pluginsmanager ) {
4945 PyObject* result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toUtf8().data(),tr("SMESH_PLUGINS_OTHER").toUtf8().data());
4950 PyGILState_Release(gstate);
4951 // end of SMESH plugins loading
4953 // Reset actions accelerator keys
4954 action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
4956 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4957 GetSMESHGen()->UpdateStudy();
4959 // get all view currently opened in the study and connect their signals to
4960 // the corresponding slots of the class.
4961 SUIT_Desktop* aDesk = study->application()->desktop();
4963 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4964 SUIT_ViewWindow* wnd;
4965 foreach ( wnd, wndList )
4969 Py_XDECREF(pluginsmanager);
4973 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4975 setMenuShown( false );
4976 setToolShown( false );
4978 EmitSignalCloseAllDialogs();
4980 // Unset actions accelerator keys
4981 action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
4983 return SalomeApp_Module::deactivateModule( study );
4986 void SMESHGUI::studyClosed( SUIT_Study* s )
4990 SMESH::RemoveVisuData();
4991 SalomeApp_Module::studyClosed( s );
4994 void SMESHGUI::OnGUIEvent()
4996 const QObject* obj = sender();
4997 if ( !obj || !obj->inherits( "QAction" ) )
4999 int id = actionId((QAction*)obj);
5004 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
5006 if ( CORBA::is_nil( myComponentSMESH ) )
5008 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
5009 return aGUI.myComponentSMESH;
5011 return myComponentSMESH;
5014 QString SMESHGUI::engineIOR() const
5016 CORBA::ORB_var anORB = getApp()->orb();
5017 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
5018 return QString( anIOR.in() );
5021 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
5023 SalomeApp_Module::contextMenuPopup( client, menu, title );
5025 selectionMgr()->selectedObjects( lst );
5026 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
5027 Handle(SALOME_InteractiveObject) io = lst.First();
5028 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
5029 _PTR(Study) study = appStudy->studyDS();
5030 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
5032 QString aName = SMESH::fromUtf8( obj->GetName());
5033 while ( !aName.isEmpty() && aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
5034 aName.remove(( aName.length() - 1 ), 1 );
5040 LightApp_Selection* SMESHGUI::createSelection() const
5042 return new SMESHGUI_Selection();
5045 void SMESHGUI::windows( QMap<int, int>& aMap ) const
5047 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
5048 aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
5049 #ifndef DISABLE_PYCONSOLE
5050 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
5054 void SMESHGUI::viewManagers( QStringList& list ) const
5056 list.append( SVTK_Viewer::Type() );
5059 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
5061 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
5062 SMESH::UpdateSelectionProp( this );
5064 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
5065 for(int i = 0; i < aViews.count() ; i++){
5066 SUIT_ViewWindow *sf = aViews[i];
5069 EmitSignalActivatedViewManager();
5073 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
5075 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
5076 myClippingPlaneInfoMap.erase( theViewManager );
5079 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
5081 theActor->AddObserver( SMESH::DeleteActorEvent,
5082 myEventCallbackCommand.GetPointer(),
5086 void SMESHGUI::ProcessEvents( vtkObject* theObject,
5087 unsigned long theEvent,
5088 void* theClientData,
5091 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
5092 if( theObject && (int) theEvent == SMESH::DeleteActorEvent ) {
5093 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
5094 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
5095 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
5096 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
5097 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
5098 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
5099 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
5100 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
5101 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
5102 SMESH::TActorList::iterator anIter3 = anActorList.begin();
5103 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
5104 if( anActor == *anIter3 ) {
5105 anActorList.erase( anIter3 );
5116 void SMESHGUI::createPreferences()
5118 // General tab ------------------------------------------------------------------------
5119 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
5121 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
5122 setPreferenceProperty( autoUpdate, "columns", 2 );
5123 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
5124 setPreferenceProperty( lim, "min", 0 );
5125 setPreferenceProperty( lim, "max", 100000000 );
5126 setPreferenceProperty( lim, "step", 1000 );
5127 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5128 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
5130 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
5131 setPreferenceProperty( dispgroup, "columns", 2 );
5133 addPreference( tr( "PREF_FITALL_ON_DISPLAYONLY" ), dispgroup, LightApp_Preferences::Bool, "SMESH", "fitall_on_displayonly" );
5135 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
5137 modes.append( tr("MEN_WIRE") );
5138 modes.append( tr("MEN_SHADE") );
5139 modes.append( tr("MEN_NODES") );
5140 modes.append( tr("MEN_SHRINK") );
5141 QList<QVariant> indices;
5142 indices.append( 0 );
5143 indices.append( 1 );
5144 indices.append( 2 );
5145 indices.append( 3 );
5146 setPreferenceProperty( dispmode, "strings", modes );
5147 setPreferenceProperty( dispmode, "indexes", indices );
5149 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
5150 setPreferenceProperty( arcgroup, "columns", 2 );
5151 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
5152 QStringList quadraticModes;
5153 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
5154 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
5156 indices.append( 0 );
5157 indices.append( 1 );
5158 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
5159 setPreferenceProperty( quadraticmode, "indexes", indices );
5161 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
5162 "SMESH", "max_angle" );
5163 setPreferenceProperty( maxAngle, "min", 1 );
5164 setPreferenceProperty( maxAngle, "max", 90 );
5166 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
5167 setPreferenceProperty( qaGroup, "columns", 2 );
5168 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
5169 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
5170 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
5171 setPreferenceProperty( prec, "min", 0 );
5172 setPreferenceProperty( prec, "max", 100 );
5173 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
5174 setPreferenceProperty( doubleNodesTol, "precision", 10 );
5175 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
5176 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
5177 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
5180 int cinc = addPreference(tr("PREF_CONTROLS_INCREMENT"), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_increment");
5181 setPreferenceProperty( cinc, "min", 0 );
5182 setPreferenceProperty( cinc, "max", 5 );
5185 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
5186 setPreferenceProperty( exportgroup, "columns", 2 );
5187 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
5188 addPreference( tr( "PREF_SHOW_WARN" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "show_warning" );
5189 int zTol = addPreference( tr( "PREF_ZTOLERANCE" ), exportgroup, LightApp_Preferences::DblSpin, "SMESH", "med_ztolerance" );
5190 setPreferenceProperty( zTol, "precision", 10 );
5191 setPreferenceProperty( zTol, "min", 0.0000000001 );
5192 setPreferenceProperty( zTol, "max", 1000000.0 );
5193 setPreferenceProperty( zTol, "step", 1. );
5194 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
5196 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
5197 setPreferenceProperty( computeGroup, "columns", 2 );
5198 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
5200 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5201 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5202 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5204 indices.append( 0 );
5205 indices.append( 1 );
5206 indices.append( 2 );
5207 setPreferenceProperty( notifyMode, "strings", modes );
5208 setPreferenceProperty( notifyMode, "indexes", indices );
5210 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5211 setPreferenceProperty( infoGroup, "columns", 2 );
5212 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5214 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5215 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5217 indices.append( 0 );
5218 indices.append( 1 );
5219 setPreferenceProperty( elemInfo, "strings", modes );
5220 setPreferenceProperty( elemInfo, "indexes", indices );
5221 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5222 setPreferenceProperty( nodesLim, "min", 0 );
5223 setPreferenceProperty( nodesLim, "max", 10000000 );
5224 setPreferenceProperty( nodesLim, "step", 10000 );
5225 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5226 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5227 setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5228 setPreferenceProperty( ctrlLim, "min", 0 );
5229 setPreferenceProperty( ctrlLim, "max", 10000000 );
5230 setPreferenceProperty( ctrlLim, "step", 1000 );
5231 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5232 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5233 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5234 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5235 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5237 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5238 setPreferenceProperty( segGroup, "columns", 2 );
5239 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5240 "SMESH", "segmentation" );
5241 setPreferenceProperty( segLen, "min", 1 );
5242 setPreferenceProperty( segLen, "max", 10000000 );
5243 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5244 "SMESH", "nb_segments_per_edge" );
5245 setPreferenceProperty( nbSeg, "min", 1 );
5246 setPreferenceProperty( nbSeg, "max", 10000000 );
5248 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5249 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5250 "SMESH", "forget_mesh_on_hyp_modif" );
5253 // Quantities with individual precision settings
5254 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5255 setPreferenceProperty( precGroup, "columns", 2 );
5257 const int nbQuantities = 6;
5258 int precs[nbQuantities], ii = 0;
5259 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5260 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5261 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5262 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5263 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5264 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5265 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5266 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5267 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5268 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5269 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5270 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5272 // Set property for precision value for spinboxes
5273 for ( ii = 0; ii < nbQuantities; ii++ ){
5274 setPreferenceProperty( precs[ii], "min", -14 );
5275 setPreferenceProperty( precs[ii], "max", 14 );
5276 setPreferenceProperty( precs[ii], "precision", 2 );
5279 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5280 setPreferenceProperty( previewGroup, "columns", 2 );
5281 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5282 setPreferenceProperty( chunkSize, "min", 1 );
5283 setPreferenceProperty( chunkSize, "max", 1000 );
5284 setPreferenceProperty( chunkSize, "step", 50 );
5286 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5287 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5289 // Mesh tab ------------------------------------------------------------------------
5290 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5291 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5292 setPreferenceProperty( nodeGroup, "columns", 3 );
5294 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5296 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5298 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5299 QList<QVariant> aMarkerTypeIndicesList;
5300 QList<QVariant> aMarkerTypeIconsList;
5301 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5302 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5303 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5304 aMarkerTypeIndicesList << i;
5305 aMarkerTypeIconsList << pixmap;
5307 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5308 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
5310 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5312 QList<QVariant> aMarkerScaleIndicesList;
5313 QStringList aMarkerScaleValuesList;
5314 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5315 aMarkerScaleIndicesList << i;
5316 //aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5317 aMarkerScaleValuesList << QString::number( i );
5319 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5320 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5322 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5323 //setPreferenceProperty( elemGroup, "columns", 2 );
5325 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5326 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5327 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5328 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5329 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5330 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5331 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5332 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5333 addPreference( tr( "PREF_PREVIEW_COLOR" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5336 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5337 setPreferenceProperty( grpGroup, "columns", 2 );
5339 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5340 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5342 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5343 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5344 /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5345 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5346 double ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5347 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5348 double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5349 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5350 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
5351 LightApp_Preferences::IntSpin, "SMESH", "element_width");
5352 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5353 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5354 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5355 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5357 setPreferenceProperty( size0d, "min", 1 );
5358 setPreferenceProperty( size0d, "max", 10 );
5360 // setPreferenceProperty( ballSize, "min", 1 );
5361 // setPreferenceProperty( ballSize, "max", 10 );
5363 setPreferenceProperty( ballDiameter, "min", 1e-7 );
5364 setPreferenceProperty( ballDiameter, "max", 1e9 );
5365 setPreferenceProperty( ballDiameter, "step", 0.1 );
5367 setPreferenceProperty( ballScale, "min", 1e-2 );
5368 setPreferenceProperty( ballScale, "max", 1e7 );
5369 setPreferenceProperty( ballScale, "step", 0.5 );
5371 setPreferenceProperty( elemW, "min", 1 );
5372 setPreferenceProperty( elemW, "max", 5 );
5374 setPreferenceProperty( outW, "min", 1 );
5375 setPreferenceProperty( outW, "max", 5 );
5377 setPreferenceProperty( shrink, "min", 0 );
5378 setPreferenceProperty( shrink, "max", 100 );
5380 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5381 setPreferenceProperty( numGroup, "columns", 2 );
5383 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5384 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5386 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5387 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5389 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5390 setPreferenceProperty( orientGroup, "columns", 1 );
5392 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5393 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5395 setPreferenceProperty( orientScale, "min", 0.05 );
5396 setPreferenceProperty( orientScale, "max", 0.5 );
5397 setPreferenceProperty( orientScale, "step", 0.05 );
5399 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5401 // Selection tab ------------------------------------------------------------------------
5402 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5404 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5405 setPreferenceProperty( selGroup, "columns", 2 );
5407 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5408 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5410 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5411 setPreferenceProperty( preGroup, "columns", 2 );
5413 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5415 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5416 setPreferenceProperty( precSelGroup, "columns", 2 );
5418 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5419 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5420 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5422 int sinc = addPreference(tr("PREF_SELECTION_INCREMENT"), selTab, LightApp_Preferences::IntSpin, "SMESH", "selection_increment");
5423 setPreferenceProperty( sinc, "min", 0 );
5424 setPreferenceProperty( sinc, "max", 5 );
5426 // Scalar Bar tab ------------------------------------------------------------------------
5427 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5428 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5429 setPreferenceProperty( fontGr, "columns", 2 );
5431 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5432 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5434 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5435 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5437 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5438 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5440 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5441 setPreferenceProperty( numcol, "min", 2 );
5442 setPreferenceProperty( numcol, "max", 256 );
5444 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5445 setPreferenceProperty( numlab, "min", 2 );
5446 setPreferenceProperty( numlab, "max", 65 );
5448 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5449 setPreferenceProperty( orientGr, "columns", 2 );
5450 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5451 QStringList orients;
5452 orients.append( tr( "SMESH_VERTICAL" ) );
5453 orients.append( tr( "SMESH_HORIZONTAL" ) );
5454 indices.clear(); indices.append( 0 ); indices.append( 1 );
5455 setPreferenceProperty( orient, "strings", orients );
5456 setPreferenceProperty( orient, "indexes", indices );
5458 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5459 setPreferenceProperty( posVSizeGr, "columns", 2 );
5460 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5461 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5462 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5463 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5464 setPreferenceProperty( xv, "step", 0.1 );
5465 setPreferenceProperty( xv, "min", 0.0 );
5466 setPreferenceProperty( xv, "max", 1.0 );
5467 setPreferenceProperty( yv, "step", 0.1 );
5468 setPreferenceProperty( yv, "min", 0.0 );
5469 setPreferenceProperty( yv, "max", 1.0 );
5470 setPreferenceProperty( wv, "step", 0.1 );
5471 setPreferenceProperty( wv, "min", 0.0 );
5472 setPreferenceProperty( wv, "max", 1.0 );
5473 setPreferenceProperty( hv, "min", 0.0 );
5474 setPreferenceProperty( hv, "max", 1.0 );
5475 setPreferenceProperty( hv, "step", 0.1 );
5477 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5478 setPreferenceProperty( posHSizeGr, "columns", 2 );
5479 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5480 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5481 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5482 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5483 setPreferenceProperty( xv, "min", 0.0 );
5484 setPreferenceProperty( xv, "max", 1.0 );
5485 setPreferenceProperty( xv, "step", 0.1 );
5486 setPreferenceProperty( xh, "min", 0.0 );
5487 setPreferenceProperty( xh, "max", 1.0 );
5488 setPreferenceProperty( xh, "step", 0.1 );
5489 setPreferenceProperty( yh, "min", 0.0 );
5490 setPreferenceProperty( yh, "max", 1.0 );
5491 setPreferenceProperty( yh, "step", 0.1 );
5492 setPreferenceProperty( wh, "min", 0.0 );
5493 setPreferenceProperty( wh, "max", 1.0 );
5494 setPreferenceProperty( wh, "step", 0.1 );
5495 setPreferenceProperty( hh, "min", 0.0 );
5496 setPreferenceProperty( hh, "max", 1.0 );
5497 setPreferenceProperty( hh, "step", 0.1 );
5499 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5500 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5501 setPreferenceProperty( distributionGr, "columns", 3 );
5503 types.append( tr( "SMESH_MONOCOLOR" ) );
5504 types.append( tr( "SMESH_MULTICOLOR" ) );
5505 indices.clear(); indices.append( 0 ); indices.append( 1 );
5506 setPreferenceProperty( coloringType, "strings", types );
5507 setPreferenceProperty( coloringType, "indexes", indices );
5508 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5512 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5514 if ( sect=="SMESH" ) {
5515 float sbX1 = 0.01, sbY1 = 0.01, sbW = 0.08, sbH = 0.08;
5516 float aTol = 1.00000009999999;
5517 std::string aWarning;
5518 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5520 if ( name == "selection_object_color" ||
5521 name == "selection_element_color" ||
5522 name == "highlight_color" ||
5523 name == "selection_precision_node" ||
5524 name == "selection_precision_element" ||
5525 name == "selection_precision_object" ||
5526 name == "selection_increment")
5528 SMESH::UpdateSelectionProp( this );
5530 else if (name == "scalar_bar_vertical_x" || name == "scalar_bar_vertical_width")
5532 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5533 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5534 if ( sbX1+sbW > aTol ) {
5535 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5538 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5539 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5542 else if (name == "scalar_bar_vertical_y" || name == "scalar_bar_vertical_height" )
5544 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5545 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5546 if ( sbY1 + sbH > aTol ) {
5547 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5548 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5549 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5552 else if (name == "scalar_bar_horizontal_x" || name == "scalar_bar_horizontal_width")
5554 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5555 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5556 if ( sbX1 + sbW > aTol ) {
5557 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5560 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5561 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5564 else if (name == "scalar_bar_horizontal_y" || name == "scalar_bar_horizontal_height")
5566 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5567 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5568 if ( sbY1 + sbH > aTol ) {
5569 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5572 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5573 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5576 else if ( name == "segmentation" )
5578 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5579 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5581 else if ( name == "nb_segments_per_edge" )
5583 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5584 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5586 else if ( name == "historical_python_dump" || name == "forget_mesh_on_hyp_modif" || name == "default_grp_color" )
5588 QString val = aResourceMgr->stringValue( "SMESH", name );
5589 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5591 else if ( name == "numbering_node_color" || name == "numbering_node_font" )
5593 SMESH::UpdateFontProp( this );
5595 else if ( name == "numbering_elem_color" || name == "numbering_elem_font" )
5597 SMESH::UpdateFontProp( this );
5600 if ( aWarning.size() != 0 ) {
5601 aWarning += "The default values are applied instead.";
5602 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5603 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5604 QObject::tr(aWarning.c_str()));
5609 //================================================================================
5611 * \brief Update something in accordance with update flags
5612 * \param theFlags - update flags
5614 * Update viewer or/and object browser etc. in accordance with update flags ( see
5615 * LightApp_UpdateFlags enumeration ).
5617 //================================================================================
5618 void SMESHGUI::update( const int flags )
5620 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5621 SMESH::UpdateView();
5623 SalomeApp_Module::update( flags );
5626 //================================================================================
5628 * \brief Set default selection mode
5630 * SLOT called when operation committed. Sets default selection mode
5632 //================================================================================
5633 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5635 SVTK_ViewWindow* vtkWnd =
5636 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5638 vtkWnd->SetSelectionMode( ActorSelection );
5641 //================================================================================
5643 * \brief Set default selection mode
5645 * SLOT called when operation aborted. Sets default selection mode
5647 //================================================================================
5648 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5650 SVTK_ViewWindow* vtkWnd =
5651 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5653 vtkWnd->SetSelectionMode( ActorSelection );
5656 //================================================================================
5658 * \brief Creates operation with given identifier
5659 * \param id - identifier of operation to be started
5660 * \return Pointer on created operation or NULL if operation is not created
5662 * Virtual method redefined from the base class creates operation with given id.
5663 * It is called called automatically from startOperation method of base class.
5665 //================================================================================
5666 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5668 LightApp_Operation* op = 0;
5669 // to do : create operation here
5672 case SMESHOp::OpSplitBiQuadratic:
5673 op = new SMESHGUI_SplitBiQuadOp();
5675 case SMESHOp::OpConvertMeshToQuadratic:
5676 op = new SMESHGUI_ConvToQuadOp();
5678 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5679 op = new SMESHGUI_Make2DFrom3DOp();
5681 case SMESHOp::OpReorientFaces:
5682 op = new SMESHGUI_ReorientFacesOp();
5684 case SMESHOp::OpCreateMesh:
5685 op = new SMESHGUI_MeshOp( true, true );
5687 case SMESHOp::OpCreateSubMesh:
5688 op = new SMESHGUI_MeshOp( true, false );
5690 case SMESHOp::OpEditMeshOrSubMesh:
5691 case SMESHOp::OpEditMesh:
5692 case SMESHOp::OpEditSubMesh:
5693 op = new SMESHGUI_MeshOp( false );
5695 case SMESHOp::OpCompute:
5696 case SMESHOp::OpComputeSubMesh:
5697 op = new SMESHGUI_ComputeOp();
5699 case SMESHOp::OpPreCompute:
5700 op = new SMESHGUI_PrecomputeOp();
5702 case SMESHOp::OpEvaluate:
5703 op = new SMESHGUI_EvaluateOp();
5705 case SMESHOp::OpMeshOrder:
5706 op = new SMESHGUI_MeshOrderOp();
5708 case SMESHOp::OpCreateGeometryGroup:
5709 op = new SMESHGUI_GroupOnShapeOp();
5711 case SMESHOp::OpFindElementByPoint:
5712 op = new SMESHGUI_FindElemByPointOp();
5714 case SMESHOp::OpMoveNode: // Make mesh pass through point
5715 op = new SMESHGUI_MakeNodeAtPointOp();
5717 case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
5718 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5725 op = SalomeApp_Module::createOperation( id );
5729 //================================================================================
5731 * \brief Stops current operations and starts a given one
5732 * \param id - The id of the operation to start
5734 //================================================================================
5736 void SMESHGUI::switchToOperation(int id)
5738 activeStudy()->abortAllOperations();
5739 startOperation( id );
5742 LightApp_Displayer* SMESHGUI::displayer()
5745 myDisplayer = new SMESHGUI_Displayer( getApp() );
5749 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5752 int aTolerance = 64;
5753 int anIterations = 0;
5759 if( anIterations % aPeriod == 0 )
5762 if( aTolerance < 1 )
5766 aHue = (int)( 360.0 * rand() / RAND_MAX );
5769 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5770 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5771 for( ; it != itEnd; ++it )
5773 SALOMEDS::Color anAutoColor = *it;
5774 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5777 aQColor.getHsv( &h, &s, &v );
5778 if( abs( h - aHue ) < aTolerance )
5790 aColor.setHsv( aHue, 255, 255 );
5792 SALOMEDS::Color aSColor;
5793 aSColor.R = aColor.redF();
5794 aSColor.G = aColor.greenF();
5795 aSColor.B = aColor.blueF();
5800 const char* gSeparator = "_"; // character used to separate parameter names
5801 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5802 const char* gPathSep = "|"; // character used to separate paths
5805 * \brief Store visual parameters
5807 * This method is called just before the study document is saved.
5808 * Store visual parameters in AttributeParameter attribute(s)
5810 void SMESHGUI::storeVisualParameters (int savePoint)
5813 Kernel_Utils::Localizer loc;
5815 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5816 if (!appStudy || !appStudy->studyDS())
5818 _PTR(Study) studyDS = appStudy->studyDS();
5820 // componentName is used for encoding of entries when storing them in IParameters
5821 std::string componentName = myComponentSMESH->ComponentDataType();
5822 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5823 //if (!aSComponent) return;
5826 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5827 componentName.c_str(),
5829 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5831 // store custom markers
5832 if( !myMarkerMap.empty() )
5834 VTK::MarkerMap::const_iterator anIter = myMarkerMap.begin();
5835 for( ; anIter != myMarkerMap.end(); anIter++ )
5837 int anId = anIter->first;
5838 VTK::MarkerData aMarkerData = anIter->second;
5839 std::string aMarkerFileName = aMarkerData.first;
5840 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5841 if( aMarkerTexture.size() < 3 )
5842 continue; // should contain at least width, height and the first value
5844 QString aPropertyName( "texture" );
5845 aPropertyName += gSeparator;
5846 aPropertyName += QString::number( anId );
5848 QString aPropertyValue = aMarkerFileName.c_str();
5849 aPropertyValue += gPathSep;
5851 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5852 ushort aWidth = *aTextureIter++;
5853 ushort aHeight = *aTextureIter++;
5854 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5855 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5856 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5857 aPropertyValue += QString::number( *aTextureIter );
5859 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5863 // viewers counters are used for storing view_numbers in IParameters
5866 // main cycle to store parameters of displayed objects
5867 QList<SUIT_ViewManager*> lst;
5868 QList<SUIT_ViewManager*>::Iterator it;
5869 getApp()->viewManagers(lst);
5870 for (it = lst.begin(); it != lst.end(); it++)
5872 SUIT_ViewManager* vman = *it;
5873 QString vType = vman->getType();
5875 // saving VTK actors properties
5876 if (vType == SVTK_Viewer::Type())
5878 // store the clipping planes attached to the view manager
5879 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5880 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5881 if( anIter != myClippingPlaneInfoMap.end() )
5882 aClippingPlaneInfoList = anIter->second;
5884 if( !aClippingPlaneInfoList.empty() ) {
5885 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5886 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5888 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5889 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5891 QString aPropertyName( "ClippingPlane" );
5892 aPropertyName += gSeparator;
5893 aPropertyName += QString::number( vtkViewers );
5894 aPropertyName += gSeparator;
5895 aPropertyName += QString::number( anId );
5897 QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
5898 aPropertyValue += gDigitsSep;
5899 aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
5900 aPropertyValue += gDigitsSep;
5901 if ( aPlane->PlaneMode == SMESH::Absolute ) {
5902 aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
5903 aPropertyValue += gDigitsSep;
5904 aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
5905 aPropertyValue += gDigitsSep;
5906 aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
5907 aPropertyValue += gDigitsSep;
5908 aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
5909 aPropertyValue += gDigitsSep;
5910 aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
5911 aPropertyValue += gDigitsSep;
5912 aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
5913 aPropertyValue += gDigitsSep;
5914 aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
5916 else if ( aPlane->PlaneMode == SMESH::Relative ) {
5917 aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
5918 aPropertyValue += gDigitsSep;
5919 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5920 aPropertyValue += gDigitsSep;
5921 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5922 aPropertyValue += gDigitsSep;
5923 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5926 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5930 QVector<SUIT_ViewWindow*> views = vman->getViews();
5931 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5933 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5935 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5936 vtkActorCollection* allActors = aCopy.GetActors();
5937 allActors->InitTraversal();
5938 while (vtkActor* actor = allActors->GetNextActor())
5940 if (actor->GetVisibility()) // store only visible actors
5942 SMESH_Actor* aSmeshActor = 0;
5943 if (actor->IsA("SMESH_Actor"))
5944 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5945 if (aSmeshActor && aSmeshActor->hasIO())
5947 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5950 // entry is "encoded" = it does NOT contain component address,
5951 // since it is a subject to change on next component loading
5952 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5954 std::string param, vtkParam = vType.toLatin1().data();
5955 vtkParam += gSeparator;
5956 vtkParam += QString::number(vtkViewers).toLatin1().data();
5957 vtkParam += gSeparator;
5960 param = vtkParam + "Visibility";
5961 ip->setParameter(entry, param, "On");
5964 param = vtkParam + "Representation";
5965 ip->setParameter(entry, param, QString::number
5966 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5969 param = vtkParam + "IsShrunk";
5970 ip->setParameter(entry, param, QString::number
5971 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5973 // Displayed entities
5974 unsigned int aMode = aSmeshActor->GetEntityMode();
5975 bool isE = aMode & SMESH_Actor::eEdges;
5976 bool isF = aMode & SMESH_Actor::eFaces;
5977 bool isV = aMode & SMESH_Actor::eVolumes;
5978 bool is0d = aMode & SMESH_Actor::e0DElements;
5979 bool isB = aMode & SMESH_Actor::eBallElem;
5981 QString modeStr ("e");
5982 modeStr += gDigitsSep; modeStr += QString::number(isE);
5983 modeStr += gDigitsSep; modeStr += "f";
5984 modeStr += gDigitsSep; modeStr += QString::number(isF);
5985 modeStr += gDigitsSep; modeStr += "v";
5986 modeStr += gDigitsSep; modeStr += QString::number(isV);
5987 modeStr += gDigitsSep; modeStr += "0d";
5988 modeStr += gDigitsSep; modeStr += QString::number(is0d);
5989 modeStr += gDigitsSep; modeStr += "b";
5990 modeStr += gDigitsSep; modeStr += QString::number(isB);
5992 param = vtkParam + "Entities";
5993 ip->setParameter(entry, param, modeStr.toLatin1().data());
5999 aSmeshActor->GetSufaceColor(r, g, b, delta);
6000 QStringList colorStr;
6001 colorStr << "surface";
6002 colorStr << QString::number(r);
6003 colorStr << QString::number(g);
6004 colorStr << QString::number(b);
6006 colorStr << "backsurface";
6007 colorStr << QString::number(delta);
6009 aSmeshActor->GetVolumeColor(r, g, b, delta);
6010 colorStr << "volume";
6011 colorStr << QString::number(r);
6012 colorStr << QString::number(g);
6013 colorStr << QString::number(b);
6014 colorStr << QString::number(delta);
6016 aSmeshActor->GetEdgeColor(r, g, b);
6018 colorStr << QString::number(r);
6019 colorStr << QString::number(g);
6020 colorStr << QString::number(b);
6022 aSmeshActor->GetNodeColor(r, g, b);
6024 colorStr << QString::number(r);
6025 colorStr << QString::number(g);
6026 colorStr << QString::number(b);
6028 aSmeshActor->GetOutlineColor(r, g, b);
6029 colorStr << "outline";
6030 colorStr << QString::number(r);
6031 colorStr << QString::number(g);
6032 colorStr << QString::number(b);
6034 aSmeshActor->Get0DColor(r, g, b);
6035 colorStr << "elem0d";
6036 colorStr << QString::number(r);
6037 colorStr << QString::number(g);
6038 colorStr << QString::number(b);
6040 aSmeshActor->GetBallColor(r, g, b);
6042 colorStr << QString::number(r);
6043 colorStr << QString::number(g);
6044 colorStr << QString::number(b);
6046 aSmeshActor->GetFacesOrientationColor(r, g, b);
6047 colorStr << "orientation";
6048 colorStr << QString::number(r);
6049 colorStr << QString::number(g);
6050 colorStr << QString::number(b);
6052 param = vtkParam + "Colors";
6053 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
6056 QStringList sizeStr;
6058 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
6059 sizeStr << "outline";
6060 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
6061 sizeStr << "elem0d";
6062 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
6064 //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
6065 sizeStr << QString::number((double)aSmeshActor->GetBallSize());
6066 sizeStr << QString::number((double)aSmeshActor->GetBallScale());
6067 sizeStr << "shrink";
6068 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
6069 sizeStr << "orientation";
6070 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
6071 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
6073 param = vtkParam + "Sizes";
6074 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
6079 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
6080 if( aMarkerType == VTK::MT_USER ) {
6081 markerStr += "custom";
6082 markerStr += gDigitsSep;
6083 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
6087 markerStr += gDigitsSep;
6088 markerStr += QString::number( (int)aMarkerType );
6089 markerStr += gDigitsSep;
6090 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
6093 param = vtkParam + "PointMarker";
6094 ip->setParameter(entry, param, markerStr.toLatin1().data());
6097 param = vtkParam + "Opacity";
6098 ip->setParameter(entry, param,
6099 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
6102 param = vtkParam + "ClippingPlane";
6104 if( !aClippingPlaneInfoList.empty() ) {
6105 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
6106 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
6108 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
6109 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
6110 SMESH::TActorList::iterator anIter2 = anActorList.begin();
6111 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
6112 if( aSmeshActor == *anIter2 ) {
6113 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
6114 QString::number( anId ).toLatin1().constData() );
6121 ip->setParameter( entry, param, "Off" );
6122 } // if (io->hasEntry())
6123 } // SMESH_Actor && hasIO
6125 } // while.. actors traversal
6129 } // if (SVTK view model)
6130 } // for (viewManagers)
6133 // data structures for clipping planes processing
6137 bool isOpenGLClipping;
6138 vtkIdType RelativeOrientation;
6141 int AbsoluteOrientation;
6142 double X, Y, Z, Dx, Dy, Dz;
6144 typedef std::list<TPlaneData> TPlaneDataList;
6145 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
6147 typedef std::list<vtkActor*> TActorList;
6150 TActorList ActorList;
6151 SUIT_ViewManager* ViewManager;
6153 typedef std::list<TPlaneInfo> TPlaneInfoList;
6154 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
6157 * \brief Restore visual parameters
6159 * This method is called after the study document is opened.
6160 * Restore visual parameters from AttributeParameter attribute(s)
6162 void SMESHGUI::restoreVisualParameters (int savePoint)
6165 Kernel_Utils::Localizer loc;
6167 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
6168 if (!appStudy || !appStudy->studyDS())
6170 _PTR(Study) studyDS = appStudy->studyDS();
6172 // componentName is used for encoding of entries when storing them in IParameters
6173 std::string componentName = myComponentSMESH->ComponentDataType();
6174 //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
6175 //if (!aSComponent) return;
6178 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
6179 componentName.c_str(),
6181 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
6183 // restore custom markers and map of clipping planes
6184 TPlaneDataMap aPlaneDataMap;
6186 std::vector<std::string> properties = ip->getProperties();
6187 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
6189 std::string property = *propIt;
6190 QString aPropertyName( property.c_str() );
6191 QString aPropertyValue( ip->getProperty( property ).c_str() );
6193 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
6194 if( aPropertyNameList.isEmpty() )
6197 QString aPropertyType = aPropertyNameList[0];
6198 if( aPropertyType == "texture" )
6200 if( aPropertyNameList.size() != 2 )
6204 int anId = aPropertyNameList[1].toInt( &ok );
6205 if( !ok || anId < 1 )
6208 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
6209 if( aPropertyValueList.size() != 2 )
6212 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
6213 QString aMarkerTextureString = aPropertyValueList[1];
6214 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
6215 if( aMarkerTextureStringList.size() != 3 )
6219 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6224 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6228 VTK::MarkerTexture aMarkerTexture;
6229 aMarkerTexture.push_back( aWidth );
6230 aMarkerTexture.push_back( aHeight );
6232 QString aMarkerTextureData = aMarkerTextureStringList[2];
6233 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6235 QChar aChar = aMarkerTextureData.at( i );
6236 if( aChar.isDigit() )
6237 aMarkerTexture.push_back( aChar.digitValue() );
6240 myMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6242 else if( aPropertyType == "ClippingPlane" )
6244 if( aPropertyNameList.size() != 3 )
6248 int aViewId = aPropertyNameList[1].toInt( &ok );
6249 if( !ok || aViewId < 0 )
6253 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6254 if( !ok || aClippingPlaneId < 0 )
6257 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6258 if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6261 TPlaneData aPlaneData;
6262 aPlaneData.AbsoluteOrientation = false;
6263 aPlaneData.RelativeOrientation = 0;
6264 aPlaneData.Distance = aPlaneData.Angle[0] = aPlaneData.Angle[1] = 0;
6265 aPlaneData.X = aPlaneData.Y = aPlaneData.Z = 0;
6266 aPlaneData.Dx = aPlaneData.Dy = aPlaneData.Dz = 0;
6268 aPlaneData.Id = aClippingPlaneId;
6271 aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6276 aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6280 if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6283 aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6288 aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6293 aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6298 aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6303 aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6308 aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6313 aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6317 else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6319 aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6324 aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6329 aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6334 aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6339 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6340 aPlaneDataList.push_back( aPlaneData );
6344 TPlaneInfoMap aPlaneInfoMap;
6346 std::vector<std::string> entries = ip->getEntries();
6348 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6350 // entry is a normal entry - it should be "decoded" (setting base address of component)
6351 QString entry (ip->decodeEntry(*entIt).c_str());
6353 // Check that the entry corresponds to a real object in the Study
6354 // as the object may be deleted or modified after the visual state is saved.
6355 _PTR(SObject) so = studyDS->FindObjectID(entry.toUtf8().data());
6356 if (!so) continue; //Skip the not existent entry
6358 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6359 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6361 std::vector<std::string>::iterator namesIt = paramNames.begin();
6362 std::vector<std::string>::iterator valuesIt = paramValues.begin();
6364 // actors are stored in a map after displaying of them for
6365 // quicker access in the future: map < viewID to actor >
6366 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6368 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6370 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6371 // '_' is used as separator and should not be used in viewer type or parameter names.
6372 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6373 if (lst.size() != 3)
6376 QString viewerTypStr = lst[0];
6377 QString viewIndexStr = lst[1];
6378 QString paramNameStr = lst[2];
6381 int viewIndex = viewIndexStr.toUInt(&ok);
6382 if (!ok) // bad conversion of view index to integer
6386 if (viewerTypStr == SVTK_Viewer::Type())
6388 SMESH_Actor* aSmeshActor = 0;
6389 if (vtkActors.IsBound(viewIndex))
6390 aSmeshActor = vtkActors.Find(viewIndex);
6392 QList<SUIT_ViewManager*> lst;
6393 getApp()->viewManagers(viewerTypStr, lst);
6395 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6396 SUIT_ViewManager* vman = NULL;
6397 if (viewIndex >= 0 && viewIndex < lst.count())
6398 vman = lst.at(viewIndex);
6400 if (paramNameStr == "Visibility")
6402 if (!aSmeshActor && displayer() && vman)
6404 SUIT_ViewModel* vmodel = vman->getViewModel();
6405 // SVTK view model can be casted to SALOME_View
6406 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6408 // store displayed actor in a temporary map for quicker
6409 // access later when restoring other parameters
6410 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6411 vtkRenderer* Renderer = vtkView->getRenderer();
6412 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6413 vtkActorCollection* theActors = aCopy.GetActors();
6414 theActors->InitTraversal();
6415 bool isFound = false;
6416 vtkActor *ac = theActors->GetNextActor();
6417 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6418 if (ac->IsA("SMESH_Actor")) {
6419 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6420 if (aGeomAc->hasIO()) {
6421 Handle(SALOME_InteractiveObject) io = aGeomAc->getIO();
6422 if (io->hasEntry() && strcmp(io->getEntry(), entry.toUtf8().data()) == 0) {
6424 vtkActors.Bind(viewIndex, aGeomAc);
6430 } // if (paramNameStr == "Visibility")
6433 // the rest properties "work" with SMESH_Actor
6436 QString val ((*valuesIt).c_str());
6439 if (paramNameStr == "Representation") {
6440 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6443 else if (paramNameStr == "IsShrunk") {
6445 if (!aSmeshActor->IsShrunk())
6446 aSmeshActor->SetShrink();
6449 if (aSmeshActor->IsShrunk())
6450 aSmeshActor->UnShrink();
6453 // Displayed entities
6454 else if (paramNameStr == "Entities") {
6455 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6456 int aEntityMode = SMESH_Actor::eAllEntity;
6457 for ( int i = 0; i < mode.count(); i+=2 ) {
6458 if ( i < mode.count()-1 ) {
6459 QString type = mode[i];
6460 bool val = mode[i+1].toInt();
6461 if ( type == "e" && !val )
6462 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6463 else if ( type == "f" && !val )
6464 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6465 else if ( type == "v" && !val )
6466 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6467 else if ( type == "0d" && !val )
6468 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6469 else if ( type == "b" && !val )
6470 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6473 aSmeshActor->SetEntityMode( aEntityMode );
6476 else if (paramNameStr == "Colors") {
6477 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6484 QColor outlineColor;
6485 QColor orientationColor;
6491 // below lines are required to get default values for delta coefficients
6492 // of backface color for faces and color of reversed volumes
6493 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
6494 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6495 for ( int i = 0; i < colors.count(); i++ ) {
6496 QString type = colors[i];
6497 if ( type == "surface" ) {
6498 // face color is set by 3 values r:g:b, where
6499 // - r,g,b - is rgb color components
6500 if ( i+1 >= colors.count() ) break; // format error
6501 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6502 if ( i+2 >= colors.count() ) break; // format error
6503 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6504 if ( i+3 >= colors.count() ) break; // format error
6505 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6506 faceColor.setRgbF( r, g, b );
6509 else if ( type == "backsurface" ) {
6510 // backface color can be defined in several ways
6511 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6512 // - in latest versions, it is set as delta coefficient
6513 bool rgbOk = false, deltaOk;
6514 if ( i+1 >= colors.count() ) break; // format error
6515 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6516 int delta = colors[i+1].toInt( &deltaOk );
6518 if ( i+1 < colors.count() ) // index is shifted to 1
6519 g = colors[i+1].toDouble( &rgbOk );
6520 if ( rgbOk ) i++; // shift index
6521 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6522 b = colors[i+1].toDouble( &rgbOk );
6524 // - as currently there's no way to set directly backsurface color as it was before,
6525 // we ignore old dump where r,g,b triple was set
6526 // - also we check that delta parameter is set properly
6527 if ( !rgbOk && deltaOk )
6530 else if ( type == "volume" ) {
6531 // volume color is set by 4 values r:g:b:delta, where
6532 // - r,g,b - is a normal volume rgb color components
6533 // - delta - is a reversed volume color delta coefficient
6534 if ( i+1 >= colors.count() ) break; // format error
6535 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6536 if ( i+2 >= colors.count() ) break; // format error
6537 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6538 if ( i+3 >= colors.count() ) break; // format error
6539 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6540 if ( i+4 >= colors.count() ) break; // format error
6541 int delta = colors[i+4].toInt( &bOk );
6542 if ( !bOk ) break; // format error
6543 volumeColor.setRgbF( r, g, b );
6547 else if ( type == "edge" ) {
6548 // edge color is set by 3 values r:g:b, where
6549 // - r,g,b - is rgb color components
6550 if ( i+1 >= colors.count() ) break; // format error
6551 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6552 if ( i+2 >= colors.count() ) break; // format error
6553 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6554 if ( i+3 >= colors.count() ) break; // format error
6555 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6556 edgeColor.setRgbF( r, g, b );
6559 else if ( type == "node" ) {
6560 // node color is set by 3 values r:g:b, where
6561 // - r,g,b - is rgb color components
6562 if ( i+1 >= colors.count() ) break; // format error
6563 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6564 if ( i+2 >= colors.count() ) break; // format error
6565 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6566 if ( i+3 >= colors.count() ) break; // format error
6567 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6568 nodeColor.setRgbF( r, g, b );
6571 else if ( type == "elem0d" ) {
6572 // 0d element color is set by 3 values r:g:b, where
6573 // - r,g,b - is rgb color components
6574 if ( i+1 >= colors.count() ) break; // format error
6575 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6576 if ( i+2 >= colors.count() ) break; // format error
6577 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6578 if ( i+3 >= colors.count() ) break; // format error
6579 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6580 elem0dColor.setRgbF( r, g, b );
6583 else if ( type == "ball" ) {
6584 // ball color is set by 3 values r:g:b, where
6585 // - r,g,b - is rgb color components
6586 if ( i+1 >= colors.count() ) break; // format error
6587 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6588 if ( i+2 >= colors.count() ) break; // format error
6589 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6590 if ( i+3 >= colors.count() ) break; // format error
6591 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6592 ballColor.setRgbF( r, g, b );
6595 else if ( type == "outline" ) {
6596 // outline color is set by 3 values r:g:b, where
6597 // - r,g,b - is rgb color components
6598 if ( i+1 >= colors.count() ) break; // format error
6599 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6600 if ( i+2 >= colors.count() ) break; // format error
6601 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6602 if ( i+3 >= colors.count() ) break; // format error
6603 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6604 outlineColor.setRgbF( r, g, b );
6607 else if ( type == "orientation" ) {
6608 // orientation color is set by 3 values r:g:b, where
6609 // - r,g,b - is rgb color components
6610 if ( i+1 >= colors.count() ) break; // format error
6611 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6612 if ( i+2 >= colors.count() ) break; // format error
6613 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6614 if ( i+3 >= colors.count() ) break; // format error
6615 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6616 orientationColor.setRgbF( r, g, b );
6621 if ( nodeColor.isValid() )
6622 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6624 if ( edgeColor.isValid() )
6625 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6627 if ( faceColor.isValid() )
6628 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6630 if ( volumeColor.isValid() )
6631 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6632 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6633 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6635 if ( elem0dColor.isValid() )
6636 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6638 if ( ballColor.isValid() )
6639 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6641 if ( outlineColor.isValid() )
6642 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6643 // orientation color
6644 if ( orientationColor.isValid() )
6645 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6648 else if (paramNameStr == "Sizes") {
6649 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6652 int outlineWidth = -1;
6653 int elem0dSize = -1;
6654 //int ballSize = -1;
6655 double ballDiameter = -1.0;
6656 double ballScale = -1.0;
6657 double shrinkSize = -1;
6658 double orientationSize = -1;
6659 bool orientation3d = false;
6660 for ( int i = 0; i < sizes.count(); i++ ) {
6661 QString type = sizes[i];
6662 if ( type == "line" ) {
6663 // line (wireframe) width is given as single integer value
6664 if ( i+1 >= sizes.count() ) break; // format error
6665 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6669 if ( type == "outline" ) {
6670 // outline width is given as single integer value
6671 if ( i+1 >= sizes.count() ) break; // format error
6672 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6676 else if ( type == "elem0d" ) {
6677 // 0d element size is given as single integer value
6678 if ( i+1 >= sizes.count() ) break; // format error
6679 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6683 else if ( type == "ball" ) {
6684 // balls are specified by two values: size:scale, where
6685 // - size - is a integer value specifying size
6686 // - scale - is a double value specifying scale factor
6687 if ( i+1 >= sizes.count() ) break; // format error
6688 //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6689 double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6690 if ( i+2 >= sizes.count() ) break; // format error
6691 double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6697 else if ( type == "shrink" ) {
6698 // shrink factor is given as single floating point value
6699 if ( i+1 >= sizes.count() ) break; // format error
6700 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6704 else if ( type == "orientation" ) {
6705 // orientation vectors are specified by two values size:3d, where
6706 // - size - is a floating point value specifying scale factor
6707 // - 3d - is a boolean
6708 if ( i+1 >= sizes.count() ) break; // format error
6709 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6710 if ( i+2 >= sizes.count() ) break; // format error
6711 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6712 orientationSize = v1;
6713 orientation3d = (bool)v2;
6717 // line (wireframe) width
6718 if ( lineWidth > 0 )
6719 aSmeshActor->SetLineWidth( lineWidth );
6721 if ( outlineWidth > 0 )
6722 aSmeshActor->SetOutlineWidth( outlineWidth );
6723 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6724 aSmeshActor->SetOutlineWidth( lineWidth );
6726 if ( elem0dSize > 0 )
6727 aSmeshActor->Set0DSize( elem0dSize );
6729 /*if ( ballSize > 0 )
6730 aSmeshActor->SetBallSize( ballSize );*/
6732 if ( ballDiameter > 0 )
6733 aSmeshActor->SetBallSize( ballDiameter );
6735 if ( ballScale > 0.0 )
6736 aSmeshActor->SetBallScale( ballScale );
6738 if ( shrinkSize > 0 )
6739 aSmeshActor->SetShrinkFactor( shrinkSize );
6740 // orientation vectors
6741 if ( orientationSize > 0 ) {
6742 aSmeshActor->SetFacesOrientationScale( orientationSize );
6743 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6747 else if (paramNameStr == "PointMarker") {
6748 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6749 if( data.count() >= 2 ) {
6751 int aParam1 = data[1].toInt( &ok );
6753 if( data[0] == "std" && data.count() == 3 ) {
6754 int aParam2 = data[2].toInt( &ok );
6755 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6757 else if( data[0] == "custom" ) {
6758 VTK::MarkerMap::const_iterator markerIt = myMarkerMap.find( aParam1 );
6759 if( markerIt != myMarkerMap.end() ) {
6760 VTK::MarkerData aMarkerData = markerIt->second;
6761 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6768 else if (paramNameStr == "Opacity") {
6769 aSmeshActor->SetOpacity(val.toFloat());
6772 else if (paramNameStr.startsWith("ClippingPlane")) {
6773 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6774 // old format - val looks like "Off" or "1:0:0:0.5:0:0"
6775 // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
6776 // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
6777 // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
6778 // new format - val looks like "Off" or "0" (plane id)
6779 // (note: in new format "Off" value is used only for consistency,
6780 // so it is processed together with values in old format)
6781 bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
6782 if( anIsOldFormat ) {
6783 if (paramNameStr == "ClippingPlane1" || val == "Off")
6784 aSmeshActor->RemoveAllClippingPlanes();
6786 QList<SUIT_ViewManager*> lst;
6787 getApp()->viewManagers(viewerTypStr, lst);
6788 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6789 if (viewIndex >= 0 && viewIndex < lst.count()) {
6790 SUIT_ViewManager* vman = lst.at(viewIndex);
6791 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6793 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6795 SMESH::TActorList anActorList;
6796 anActorList.push_back( aSmeshActor );
6797 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
6798 aPlane->myViewWindow = vtkView;
6799 SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
6800 aPlane->PlaneMode = aMode;
6801 bool isOpenGLClipping = ( bool )vals[1].toInt();
6802 aPlane->IsOpenGLClipping = isOpenGLClipping;
6803 if ( aMode == SMESH::Absolute ) {
6804 aPlane->myAbsoluteOrientation = vals[2].toInt();
6805 aPlane->X = vals[3].toFloat();
6806 aPlane->Y = vals[4].toFloat();
6807 aPlane->Z = vals[5].toFloat();
6808 aPlane->Dx = vals[6].toFloat();
6809 aPlane->Dy = vals[7].toFloat();
6810 aPlane->Dz = vals[8].toFloat();
6812 else if ( aMode == SMESH::Relative ) {
6813 aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
6814 aPlane->myDistance = vals[3].toFloat();
6815 aPlane->myAngle[0] = vals[4].toFloat();
6816 aPlane->myAngle[1] = vals[5].toFloat();
6820 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6821 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6822 aClippingPlaneInfo.Plane = aPlane;
6823 aClippingPlaneInfo.ActorList = anActorList;
6824 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6832 int aPlaneId = val.toInt( &ok );
6833 if( ok && aPlaneId >= 0 ) {
6834 bool anIsDefinedPlane = false;
6835 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6836 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6837 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6838 TPlaneInfo& aPlaneInfo = *anIter;
6839 if( aPlaneInfo.PlaneId == aPlaneId ) {
6840 aPlaneInfo.ActorList.push_back( aSmeshActor );
6841 anIsDefinedPlane = true;
6845 if( !anIsDefinedPlane ) {
6846 TPlaneInfo aPlaneInfo;
6847 aPlaneInfo.PlaneId = aPlaneId;
6848 aPlaneInfo.ActorList.push_back( aSmeshActor );
6849 aPlaneInfo.ViewManager = vman;
6851 // to make the list sorted by plane id
6852 anIter = aPlaneInfoList.begin();
6853 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6854 const TPlaneInfo& aPlaneInfoRef = *anIter;
6855 if( aPlaneInfoRef.PlaneId > aPlaneId )
6858 aPlaneInfoList.insert( anIter, aPlaneInfo );
6863 } // if (aSmeshActor)
6864 } // other parameters than Visibility
6866 } // for names/parameters iterator
6867 } // for entries iterator
6869 // take into account planes with empty list of actors referred to them
6870 QList<SUIT_ViewManager*> aVMList;
6871 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6873 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6874 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6875 int aViewId = aPlaneDataIter->first;
6876 if( aViewId >= 0 && aViewId < aVMList.count() ) {
6877 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6879 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6881 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6882 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6883 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6884 const TPlaneData& aPlaneData = *anIter2;
6885 int aPlaneId = aPlaneData.Id;
6887 bool anIsFound = false;
6888 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6889 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6890 const TPlaneInfo& aPlaneInfo = *anIter3;
6891 if( aPlaneInfo.PlaneId == aPlaneId ) {
6898 TPlaneInfo aPlaneInfo; // ActorList field is empty
6899 aPlaneInfo.PlaneId = aPlaneId;
6900 aPlaneInfo.ViewManager = aViewManager;
6902 // to make the list sorted by plane id
6903 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6904 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6905 const TPlaneInfo& aPlaneInfoRef = *anIter4;
6906 if( aPlaneInfoRef.PlaneId > aPlaneId )
6909 aPlaneInfoList.insert( anIter4, aPlaneInfo );
6915 // add clipping planes to actors according to the restored parameters
6916 // and update the clipping plane map
6917 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6918 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6919 int aViewId = anIter1->first;
6920 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6922 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6923 if( anIter2 == aPlaneDataMap.end() )
6925 const TPlaneDataList& aPlaneDataList = anIter2->second;
6927 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6928 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6929 const TPlaneInfo& aPlaneInfo = *anIter3;
6930 int aPlaneId = aPlaneInfo.PlaneId;
6931 const TActorList& anActorList = aPlaneInfo.ActorList;
6932 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6936 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6940 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6942 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6943 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6944 const TPlaneData& aPlaneData = *anIter4;
6945 if( aPlaneData.Id == aPlaneId ) {
6946 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
6947 aPlane->myViewWindow = aViewWindow;
6948 aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
6949 aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
6950 if ( aPlane->PlaneMode == SMESH::Absolute ) {
6951 aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
6952 aPlane->X = aPlaneData.X;
6953 aPlane->Y = aPlaneData.Y;
6954 aPlane->Z = aPlaneData.Z;
6955 aPlane->Dx = aPlaneData.Dx;
6956 aPlane->Dy = aPlaneData.Dy;
6957 aPlane->Dz = aPlaneData.Dz;
6959 else if ( aPlane->PlaneMode == SMESH::Relative ) {
6960 aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
6961 aPlane->myDistance = aPlaneData.Distance;
6962 aPlane->myAngle[0] = aPlaneData.Angle[0];
6963 aPlane->myAngle[1] = aPlaneData.Angle[1];
6966 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6967 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6968 aClippingPlaneInfo.Plane = aPlane;
6969 aClippingPlaneInfo.ActorList = anActorList;
6970 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6981 // update all VTK views
6982 QList<SUIT_ViewManager*> lst;
6983 getApp()->viewManagers(lst);
6984 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6985 SUIT_ViewModel* vmodel = (*it)->getViewModel();
6986 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6987 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6988 // set OpenGL clipping planes
6989 VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
6990 vtkActorCollection* anAllActors = aCopy.GetActors();
6991 anAllActors->InitTraversal();
6992 while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
6993 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
6994 anActor->SetOpenGLClippingPlane();
6996 vtkView->getRenderer()->ResetCameraClippingRange();
7003 \brief Adds preferences for dfont of VTK viewer
7005 \param pIf group identifier
7006 \param param parameter
7007 \return identifier of preferences
7009 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
7011 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
7013 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
7016 fam.append( tr( "SMESH_FONT_ARIAL" ) );
7017 fam.append( tr( "SMESH_FONT_COURIER" ) );
7018 fam.append( tr( "SMESH_FONT_TIMES" ) );
7020 setPreferenceProperty( tfont, "fonts", fam );
7022 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
7023 if ( needSize ) f = f | QtxFontEdit::Size;
7024 setPreferenceProperty( tfont, "features", f );
7030 \brief Actions after hypothesis edition
7031 Updates object browser after hypothesis edition
7033 void SMESHGUI::onHypothesisEdit( int result )
7036 SMESHGUI::Modified();
7037 updateObjBrowser( true );
7041 \brief Actions after choosing menu of control modes
7042 Updates control mode actions according to current selection
7044 void SMESHGUI::onUpdateControlActions()
7046 SALOME_ListIO selected;
7047 if ( LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr() )
7048 aSel->selectedObjects( selected );
7050 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
7051 if ( selected.Extent() ) {
7052 if ( selected.First()->hasEntry() ) {
7053 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( selected.First()->getEntry() )) {
7054 aControl = anActor->GetControlMode();
7055 SALOME_ListIteratorOfListIO it(selected);
7056 for ( it.Next(); it.More(); it.Next() ) {
7057 Handle(SALOME_InteractiveObject) anIO = it.Value();
7058 if ( anIO->hasEntry() ) {
7059 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
7060 if ( aControl != anActor->GetControlMode() ) {
7061 aControl = SMESH_Actor::eNone;
7071 int anAction = ActionToControl( aControl, true );
7073 action( anAction )->setChecked( true );
7075 QMenu* send = (QMenu*)sender();
7076 QList<QAction*> actions = send->actions();
7077 for ( int i = 0; i < actions.size(); i++ )
7078 actions[i]->setChecked( false );
7084 \brief Signal handler closing(SUIT_ViewWindow*) of a view
7085 \param pview view being closed
7087 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
7088 #ifndef DISABLE_PLOT2DVIEWER
7089 //Crear all Plot2d Viewers if need.
7090 SMESH::ClearPlot2Viewers(pview);
7092 EmitSignalCloseView();
7095 void SMESHGUI::message( const QString& msg )
7098 QStringList data = msg.split("/");
7099 if ( data.count() > 0 ) {
7100 if ( data.first() == "mesh_loading" ) {
7102 QString entry = data.count() > 1 ? data[1] : QString();
7103 if ( entry.isEmpty() )
7106 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
7108 _PTR(SObject) obj = study->FindObjectID( entry.toUtf8().constData() );
7111 name = SMESH::fromUtf8(obj->GetName());
7112 if ( name.isEmpty() )
7115 if ( data.last() == "stop" )
7116 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
7118 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
7119 QApplication::processEvents();
7125 \brief Connects or disconnects signals about activating and cloning view on the module slots
7126 \param pview view which is connected/disconnected
7128 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
7132 SUIT_ViewManager* viewMgr = pview->getViewManager();
7134 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7135 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7137 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
7138 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
7143 \brief Return \c true if object can be renamed
7145 bool SMESHGUI::renameAllowed( const QString& entry) const {
7146 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7150 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7154 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
7159 if(appStudy->isComponent(entry) || obj->isReference())
7162 // check type to prevent renaming of inappropriate objects
7163 int aType = SMESHGUI_Selection::type(qPrintable(entry));
7164 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7165 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7166 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7167 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7168 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
7175 Rename object by entry.
7176 \param entry entry of the object
7177 \param name new name of the object
7178 \brief Return \c true if rename operation finished successfully, \c false otherwise.
7180 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
7182 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7186 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7191 _PTR(Study) aStudy = appStudy->studyDS();
7196 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
7198 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
7203 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
7204 _PTR(GenericAttribute) anAttr;
7205 _PTR(AttributeName) aName;
7207 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
7209 // check type to prevent renaming of inappropriate objects
7210 int aType = SMESHGUI_Selection::type( qPrintable(entry));
7211 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7212 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7213 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7214 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7215 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
7216 if ( !name.isEmpty() ) {
7217 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qUtf8Printable(name) );
7219 // update name of group object and its actor
7220 Handle(SALOME_InteractiveObject) IObject =
7221 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
7223 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
7224 if( !aGroupObject->_is_nil() ) {
7225 aGroupObject->SetName( qUtf8Printable(name) );
7226 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
7227 anActor->setName( qUtf8Printable(name) );
7237 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
7239 static QList<QColor> colors;
7241 if ( colors.isEmpty() ) {
7243 for (int s = 0; s < 2 ; s++)
7245 for (int v = 100; v >= 40; v = v - 20)
7247 for (int h = 0; h < 359 ; h = h + 60)
7249 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
7254 static int currentColor = randomize( colors.size() );
7256 SALOMEDS::Color color;
7257 color.R = (double)colors[currentColor].red() / 255.0;
7258 color.G = (double)colors[currentColor].green() / 255.0;
7259 color.B = (double)colors[currentColor].blue() / 255.0;
7261 currentColor = (currentColor+1) % colors.count();