1 // Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
3 // Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
6 // This library is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU Lesser General Public
8 // License as published by the Free Software Foundation; either
9 // version 2.1 of the License, or (at your option) any later version.
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 // Lesser General Public License for more details.
16 // You should have received a copy of the GNU Lesser General Public
17 // License along with this library; if not, write to the Free Software
18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
22 // File : SMESHGUI.cxx
23 // Author : Nicolas REJNERI, Open CASCADE S.A.S.
25 #include <Standard_math.hxx> // E.A. must be included before Python.h to fix compilation on windows
27 #undef HAVE_FINITE // VSR: avoid compilation warning on Linux : "HAVE_FINITE" redefined
33 #include "SMESHGUI_Add0DElemsOnAllNodesDlg.h"
34 #include "SMESHGUI_AddMeshElementDlg.h"
35 #include "SMESHGUI_AddQuadraticElementDlg.h"
36 #include "SMESHGUI_BuildCompoundDlg.h"
37 #include "SMESHGUI_ClippingDlg.h"
38 #include "SMESHGUI_ComputeDlg.h"
39 #include "SMESHGUI_ConvToQuadOp.h"
40 #include "SMESHGUI_CopyMeshDlg.h"
41 #include "SMESHGUI_CreatePolyhedralVolumeDlg.h"
42 #include "SMESHGUI_DeleteGroupDlg.h"
43 #include "SMESHGUI_Displayer.h"
44 #include "SMESHGUI_DuplicateNodesDlg.h"
45 #include "SMESHGUI_ExtrusionAlongPathDlg.h"
46 #include "SMESHGUI_ExtrusionDlg.h"
47 #include "SMESHGUI_FieldSelectorWdg.h"
48 #include "SMESHGUI_FileInfoDlg.h"
49 #include "SMESHGUI_FileValidator.h"
50 #include "SMESHGUI_FilterDlg.h"
51 #include "SMESHGUI_FilterLibraryDlg.h"
52 #include "SMESHGUI_FindElemByPointDlg.h"
53 #include "SMESHGUI_GroupDlg.h"
54 #include "SMESHGUI_GroupOnShapeDlg.h"
55 #include "SMESHGUI_GroupOpDlg.h"
56 #include "SMESHGUI_Hypotheses.h"
57 #include "SMESHGUI_Make2DFrom3DOp.h"
58 #include "SMESHGUI_MakeNodeAtPointDlg.h"
59 #include "SMESHGUI_Measurements.h"
60 #include "SMESHGUI_MergeDlg.h"
61 #include "SMESHGUI_MeshInfo.h"
62 #include "SMESHGUI_MeshOp.h"
63 #include "SMESHGUI_MeshOrderOp.h"
64 #include "SMESHGUI_MeshPatternDlg.h"
65 #include "SMESHGUI_MultiEditDlg.h"
66 #include "SMESHGUI_NodesDlg.h"
67 #include "SMESHGUI_Operations.h"
68 #include "SMESHGUI_Preferences_ScalarBarDlg.h"
69 #include "SMESHGUI_PropertiesDlg.h"
70 #include "SMESHGUI_RemoveElementsDlg.h"
71 #include "SMESHGUI_RemoveNodesDlg.h"
72 #include "SMESHGUI_RenumberingDlg.h"
73 #include "SMESHGUI_ReorientFacesDlg.h"
74 #include "SMESHGUI_RevolutionDlg.h"
75 #include "SMESHGUI_RotationDlg.h"
76 #include "SMESHGUI_ScaleDlg.h"
77 #include "SMESHGUI_Selection.h"
78 #include "SMESHGUI_SewingDlg.h"
79 #include "SMESHGUI_SingleEditDlg.h"
80 #include "SMESHGUI_SmoothingDlg.h"
81 #include "SMESHGUI_SymmetryDlg.h"
82 #include "SMESHGUI_TranslationDlg.h"
83 #include "SMESHGUI_TransparencyDlg.h"
84 #include "SMESHGUI_DisplayEntitiesDlg.h"
85 #include "SMESHGUI_SplitBiQuad.h"
87 #include "SMESHGUI_FilterUtils.h"
88 #include "SMESHGUI_GEOMGenUtils.h"
89 #include "SMESHGUI_GroupUtils.h"
90 #include "SMESHGUI_HypothesesUtils.h"
91 #include "SMESHGUI_MeshUtils.h"
92 #include "SMESHGUI_PatternUtils.h"
93 #include "SMESHGUI_Utils.h"
94 #include "SMESHGUI_VTKUtils.h"
96 #include "SMESH_version.h"
98 #include "SMESH_ControlsDef.hxx"
99 #include "SMESH_Actor.h"
100 #include "SMESH_ActorUtils.h"
101 #include "SMESH_Client.hxx"
102 #include "SMESH_ScalarBarActor.h"
103 #include "SMESH_TypeFilter.hxx"
105 // SALOME GUI includes
106 #include <SalomeApp_Application.h>
107 #include <SalomeApp_CheckFileDlg.h>
108 #include <SalomeApp_DataObject.h>
109 #include <SalomeApp_Study.h>
110 #include <SalomeApp_Tools.h>
112 #include <LightApp_DataOwner.h>
113 #include <LightApp_NameDlg.h>
114 #include <LightApp_Preferences.h>
115 #include <LightApp_SelectionMgr.h>
116 #include <LightApp_UpdateFlags.h>
118 #include <SVTK_ViewManager.h>
119 #include <SVTK_ViewModel.h>
120 #include <SVTK_ViewWindow.h>
122 #include <VTKViewer_Algorithm.h>
124 #include <SUIT_Desktop.h>
125 #include <SUIT_FileDlg.h>
126 #include <SUIT_MessageBox.h>
127 #include <SUIT_OverrideCursor.h>
128 #include <SUIT_ResourceMgr.h>
129 #include <SUIT_Session.h>
131 #include <QtxPopupMgr.h>
132 #include <QtxFontEdit.h>
134 #include <SALOME_ListIO.hxx>
136 #ifndef DISABLE_PLOT2DVIEWER
137 #include <SPlot2d_ViewModel.h>
138 #include <SPlot2d_Histogram.h>
142 #include <SALOMEconfig.h>
143 #include CORBA_CLIENT_HEADER(SALOMEDS_Attributes)
144 #include CORBA_CLIENT_HEADER(SMESH_MeshEditor)
145 #include CORBA_CLIENT_HEADER(SMESH_Measurements)
148 // #define INCLUDE_MENUITEM_DEF // VSR commented ????????
149 #include <QApplication>
151 #include <QTextStream>
156 #include <boost/shared_ptr.hpp>
159 #include <vtkCallbackCommand.h>
160 #include <vtkCamera.h>
161 #include <vtkLookupTable.h>
162 #include <vtkPlane.h>
163 #include <vtkRenderer.h>
165 // SALOME KERNEL includes
166 #include <SALOMEDSClient_ClientFactory.hxx>
167 #include <SALOMEDSClient_IParameters.hxx>
168 #include <SALOMEDSClient_SComponent.hxx>
169 #include <SALOMEDSClient_StudyBuilder.hxx>
170 #include <SALOMEDS_Study.hxx>
171 #include <SALOMEDS_SObject.hxx>
172 #include "utilities.h"
175 #include <Standard_ErrorHandler.hxx>
176 #include <NCollection_DataMap.hxx>
177 #include <NCollection_DoubleMap.hxx>
179 #include <Basics_Utils.hxx>
181 // Below macro, when uncommented, switches on simplified (more performant) algorithm
182 // of auto-color picking up
183 #define SIMPLE_AUTOCOLOR
188 //=============================================================
189 void ImportMeshesFromFile(SMESH::SMESH_Gen_ptr theComponentMesh,
192 void ExportMeshToFile(int theCommandID);
194 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap);
196 void SetDisplayEntity(int theCommandID);
198 int ActionToControl( int theID, bool theReversed = false );
200 void Control( int theCommandID );
203 //================================================================================
205 * \brief Reads meshes from file
207 //================================================================================
209 void ImportMeshesFromFile( SMESH::SMESH_Gen_ptr theComponentMesh,
213 std::string myExtension;
215 if ( theCommandID == SMESHOp::OpImportMED ) {
216 filter.append( QObject::tr( "MED_FILES_FILTER" ) + " (*.*med)" );
217 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
219 else if ( theCommandID == SMESHOp::OpImportUNV ) {
220 filter.append( QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)" );
222 else if ( theCommandID == SMESHOp::OpImportDAT ) {
223 filter.append( QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)" );
225 else if ( theCommandID == SMESHOp::OpImportSTL ) {
226 filter.append( QObject::tr( "STL_FILES_FILTER" ) + " (*.stl)" );
229 else if ( theCommandID == SMESHOp::OpImportCGNS ) {
230 filter.append( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
233 else if ( theCommandID == SMESHOp::OpImportSAUV ) {
234 filter.append( QObject::tr( "SAUV files (*.sauv*)" ) );
235 filter.append( QObject::tr( "All files (*)" ) );
237 else if ( theCommandID == SMESHOp::OpImportGMF ) {
238 filter.append( QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" );
239 filter.append( QObject::tr( "GMF_BINARY_FILES_FILTER") + " (*.meshb)" );
242 QString anInitialPath = "";
243 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
244 anInitialPath = QDir::currentPath();
246 QStringList filenames;
247 bool toCreateGroups = true;
249 // if ( theCommandID == SMESHOp::OpImportGMF ) { // GMF
250 // SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg
251 // ( SMESHGUI::desktop(), true, QObject::tr("SMESH_REQUIRED_GROUPS"), true, true );
252 // fd->setWindowTitle( QObject::tr( "SMESH_IMPORT_MESH" ) );
253 // fd->setNameFilters( filter );
254 // fd->SetChecked( true );
256 // filenames << fd->selectedFile();
257 // toCreateGroups = fd->IsChecked();
263 filenames = SUIT_FileDlg::getOpenFileNames( SMESHGUI::desktop(),
266 QObject::tr( "SMESH_IMPORT_MESH" ) );
268 if ( filenames.count() > 0 )
270 SUIT_OverrideCursor wc;
271 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
274 QStringList anEntryList;
275 bool isEmpty = false;
276 for ( QStringList::ConstIterator it = filenames.begin(); it != filenames.end(); ++it )
278 QString filename = *it;
279 SMESH::mesh_array_var aMeshes = new SMESH::mesh_array;
281 switch ( theCommandID ) {
282 case SMESHOp::OpImportDAT:
284 // DAT format (currently unsupported)
285 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
286 arg( QObject::tr( "SMESH_ERR_NOT_SUPPORTED_FORMAT" ) ) );
289 case SMESHOp::OpImportUNV:
292 aMeshes->length( 1 );
293 aMeshes[0] = theComponentMesh->CreateMeshesFromUNV( filename.toUtf8().constData() );
294 if ( aMeshes[0]->_is_nil() )
295 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
296 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
299 case SMESHOp::OpImportMED:
302 SMESH::DriverMED_ReadStatus res;
303 aMeshes = theComponentMesh->CreateMeshesFromMED( filename.toUtf8().constData(), res );
304 if ( res != SMESH::DRS_OK ) {
305 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
306 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
310 case SMESHOp::OpImportSTL:
313 aMeshes->length( 1 );
314 aMeshes[0] = theComponentMesh->CreateMeshesFromSTL( filename.toUtf8().constData() );
315 if ( aMeshes[0]->_is_nil() ) {
316 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
317 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
322 case SMESHOp::OpImportCGNS:
325 SMESH::DriverMED_ReadStatus res;
326 aMeshes = theComponentMesh->CreateMeshesFromCGNS( filename.toUtf8().constData(), res );
327 if ( res != SMESH::DRS_OK ) {
328 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
329 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
334 case SMESHOp::OpImportSAUV:
337 SMESH::DriverMED_ReadStatus res;
338 aMeshes = theComponentMesh->CreateMeshesFromSAUV( filename.toUtf8().constData(), res );
339 if ( res != SMESH::DRS_OK ) {
340 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
341 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
345 case SMESHOp::OpImportGMF:
348 SMESH::ComputeError_var res;
349 aMeshes->length( 1 );
350 aMeshes[0] = theComponentMesh->CreateMeshesFromGMF( filename.toUtf8().constData(),
353 if ( res->code != SMESH::DRS_OK ) {
354 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
355 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res->code ).toLatin1().data() ) ) );
356 if ( strlen( res->comment.in() ) > 0 ) {
357 errors.back() += ": ";
358 errors.back() += res->comment.in();
365 catch ( const SALOME::SALOME_Exception& S_ex ) {
366 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
367 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
370 for ( int i = 0, iEnd = aMeshes->length(); i < iEnd; i++ )
372 _PTR(SObject) aMeshSO = SMESH::FindSObject( aMeshes[i] );
374 _PTR(StudyBuilder) aBuilder = aStudy->NewBuilder();
375 _PTR(AttributePixMap) aPixmap = aBuilder->FindOrCreateAttribute( aMeshSO, "AttributePixMap" );
376 aPixmap->SetPixMap( "ICON_SMESH_TREE_MESH_IMPORTED" );
377 if ( theCommandID == SMESHOp::OpImportUNV ) // mesh names aren't taken from the file for UNV import
378 SMESH::SetName( aMeshSO, QFileInfo(filename).fileName() );
380 anEntryList.append( aMeshSO->GetID().c_str() );
388 // update Object browser
389 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
391 // browse to the published meshes
392 if( LightApp_Application* anApp =
393 dynamic_cast<LightApp_Application*>( SUIT_Session::session()->activeApplication() ) )
394 anApp->browseObjects( anEntryList );
396 // show Error message box if there were errors
397 if ( errors.count() > 0 ) {
398 SUIT_MessageBox::critical( SMESHGUI::desktop(),
399 QObject::tr( "SMESH_ERROR" ),
400 QObject::tr( "SMESH_IMPORT_ERRORS" ) + "\n" + errors.join( "\n" ) );
403 // show warning message box, if some imported mesh is empty
405 SUIT_MessageBox::warning( SMESHGUI::desktop(),
406 QObject::tr( "SMESH_WRN_WARNING" ),
407 QObject::tr( "SMESH_DRS_SOME_EMPTY" ) );
412 //================================================================================
414 * \brief Export selected meshes or groups into a file
416 //================================================================================
418 void ExportMeshToFile( int theCommandID )
420 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
421 SALOME_ListIO selected;
423 aSel->selectedObjects( selected );
425 const bool isDAT = ( theCommandID == SMESHOp::OpExportDAT ||
426 theCommandID == SMESHOp::OpPopupExportDAT );
427 const bool isMED = ( theCommandID == SMESHOp::OpExportMED ||
428 theCommandID == SMESHOp::OpPopupExportMED );
429 const bool isUNV = ( theCommandID == SMESHOp::OpExportUNV ||
430 theCommandID == SMESHOp::OpPopupExportUNV );
431 const bool isSTL = ( theCommandID == SMESHOp::OpExportSTL ||
432 theCommandID == SMESHOp::OpPopupExportSTL );
434 const bool isCGNS= ( theCommandID == SMESHOp::OpExportCGNS ||
435 theCommandID == SMESHOp::OpPopupExportCGNS );
437 const bool isCGNS= false;
439 const bool isSAUV= ( theCommandID == SMESHOp::OpExportSAUV ||
440 theCommandID == SMESHOp::OpPopupExportSAUV );
441 const bool isGMF = ( theCommandID == SMESHOp::OpExportGMF ||
442 theCommandID == SMESHOp::OpPopupExportGMF );
444 const bool multiMeshSupported = ( isMED || isCGNS ); // file can hold several meshes
445 if ( selected.Extent() == 0 || ( selected.Extent() > 1 && !multiMeshSupported ))
448 // get mesh object from selection and check duplication of their names
449 bool hasDuplicatedMeshNames = false;
450 QList< QPair< SMESH::SMESH_IDSource_var, QString > > aMeshList;
451 QList< QPair< SMESH::SMESH_IDSource_var, QString > >::iterator aMeshIter;
452 SALOME_ListIteratorOfListIO It( selected );
453 for( ; It.More(); It.Next() )
455 Handle(SALOME_InteractiveObject) anIObject = It.Value();
456 SMESH::SMESH_IDSource_var aMeshItem =
457 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIObject);
458 if ( aMeshItem->_is_nil() ) {
459 SUIT_MessageBox::warning( SMESHGUI::desktop(),
460 QObject::tr( "SMESH_WRN_WARNING" ),
461 QObject::tr( "SMESH_BAD_MESH_SELECTION" ));
465 QString aMeshName = anIObject->getName();
467 // check for name duplications
468 if ( !hasDuplicatedMeshNames )
469 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
470 if( aMeshName == (*aMeshIter).second ) {
471 hasDuplicatedMeshNames = true;
476 aMeshList.append( QPair< SMESH::SMESH_IDSource_var, QString >( aMeshItem, aMeshName ) );
479 if( hasDuplicatedMeshNames && isMED ) {
480 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
481 QObject::tr("SMESH_WRN_WARNING"),
482 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_MESH_NAMES"),
483 QObject::tr("SMESH_BUT_YES"),
484 QObject::tr("SMESH_BUT_NO"), 0, 1);
489 aMeshIter = aMeshList.begin();
490 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
491 SMESH::SMESH_Mesh_var aMesh = aMeshOrGroup->GetMesh();
492 QString aMeshName = (*aMeshIter).second;
494 if ( isMED || isCGNS || isSAUV ) // formats where group names must be unique
496 // check for equal group names within each mesh
497 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
498 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
499 if ( !aMeshItem->_is_nil() && aMeshItem->HasDuplicatedGroupNamesMED()) {
500 int aRet = SUIT_MessageBox::warning
501 (SMESHGUI::desktop(),
502 QObject::tr("SMESH_WRN_WARNING"),
503 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_GRP").arg((*aMeshIter).second),
504 QObject::tr("SMESH_BUT_YES"),
505 QObject::tr("SMESH_BUT_NO"), 0, 1);
512 // Warn the user about presence of not supported elements
514 std::vector< SMESH::EntityType > notSupportedElemTypes, presentNotSupported;
518 notSupportedElemTypes.push_back( SMESH::Entity_0D );
519 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
524 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
525 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
526 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
527 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
528 notSupportedElemTypes.push_back( SMESH::Entity_Pyramid );
529 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
530 notSupportedElemTypes.push_back( SMESH::Entity_0D );
531 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
536 notSupportedElemTypes.push_back( SMESH::Entity_Edge );
537 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Edge );
538 notSupportedElemTypes.push_back( SMESH::Entity_0D );
539 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
544 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
549 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
550 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Triangle );
551 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Quadrangle );
552 notSupportedElemTypes.push_back( SMESH::Entity_TriQuad_Hexa );
553 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
554 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
555 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
556 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
561 notSupportedElemTypes.push_back( SMESH::Entity_0D );
562 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
563 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
564 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Pyramid );
565 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Penta );
566 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
567 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
568 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
569 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
571 if ( ! notSupportedElemTypes.empty() )
573 SMESH::long_array_var nbElems = aMeshOrGroup->GetMeshInfo();
574 for ( size_t iType = 0; iType < notSupportedElemTypes.size(); ++iType )
575 if ( nbElems[ notSupportedElemTypes[ iType ]] > 0 )
576 presentNotSupported.push_back( notSupportedElemTypes[ iType ]);
578 if ( !presentNotSupported.empty() )
581 const char* typeMsg[] = {
582 "SMESH_NODES", "SMESH_ELEMS0D","SMESH_EDGES","SMESH_QUADRATIC_EDGES",
583 "SMESH_TRIANGLES", "SMESH_QUADRATIC_TRIANGLES", "SMESH_BIQUADRATIC_TRIANGLES",
584 "SMESH_QUADRANGLES","SMESH_QUADRATIC_QUADRANGLES", "SMESH_BIQUADRATIC_QUADRANGLES",
585 "SMESH_POLYGONS","SMESH_QUADRATIC_POLYGONS",
586 "SMESH_TETRAHEDRA","SMESH_QUADRATIC_TETRAHEDRONS","SMESH_PYRAMIDS",
587 "SMESH_QUADRATIC_PYRAMIDS","SMESH_HEXAHEDRA","SMESH_QUADRATIC_HEXAHEDRONS",
588 "SMESH_TRIQUADRATIC_HEXAHEDRONS","SMESH_PENTAHEDRA","SMESH_QUADRATIC_PENTAHEDRONS",
589 "SMESH_OCTAHEDRA","SMESH_POLYEDRONS","SMESH_QUADRATIC_POLYEDRONS","SMESH_BALLS"
591 // is typeMsg complete? (compilation failure mains that enum SMDSAbs_EntityType changed)
592 const int nbTypes = sizeof( typeMsg ) / sizeof( const char* );
593 int _assert[( nbTypes == SMESH::Entity_Last ) ? 2 : -1 ]; _assert[0]=_assert[1];
595 QString andStr = " " + QObject::tr("SMESH_AND") + " ", comma(", ");
596 for ( size_t iType = 0; iType < presentNotSupported.size(); ++iType ) {
597 typeNames += QObject::tr( typeMsg[ presentNotSupported[ iType ]]);
598 if ( iType != presentNotSupported.size() - 1 )
599 typeNames += ( iType == presentNotSupported.size() - 2 ) ? andStr : comma;
601 int aRet = SUIT_MessageBox::warning
602 (SMESHGUI::desktop(),
603 QObject::tr("SMESH_WRN_WARNING"),
604 QObject::tr("EXPORT_NOT_SUPPORTED").arg(aMeshName).arg(format).arg(typeNames),
605 QObject::tr("SMESH_BUT_YES"),
606 QObject::tr("SMESH_BUT_NO"), 0, 1);
611 // Get parameters of export operation
614 SMESH::MED_VERSION aFormat = SMESH::MED_V2_2;
615 // Init the parameters with the default values
616 bool aIsASCII_STL = true;
617 bool toCreateGroups = false;
618 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
620 toCreateGroups = resMgr->booleanValue( "SMESH", "auto_groups", false );
621 bool toOverwrite = true;
622 bool toFindOutDim = true;
624 QString aFilter, aTitle = QObject::tr("SMESH_EXPORT_MESH");
625 QString anInitialPath = "";
626 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
627 anInitialPath = QDir::currentPath();
629 QList< QPair< GEOM::ListOfFields_var, QString > > aFieldList;
631 // Get a file name to write in and additional otions
632 if ( isUNV || isDAT || isGMF ) // Export w/o options
635 aFilter = QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)";
637 aFilter = QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)";
639 aFilter = QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" +
640 ";;" + QObject::tr( "GMF_BINARY_FILES_FILTER" ) + " (*.meshb)";
641 if ( anInitialPath.isEmpty() ) anInitialPath = SUIT_FileDlg::getLastVisitedPath();
642 aFilename = SUIT_FileDlg::getFileName(SMESHGUI::desktop(),
643 anInitialPath + QString("/") + aMeshName,
644 aFilter, aTitle, false);
646 else if ( isCGNS )// Export to CGNS
648 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
649 fd->setWindowTitle( aTitle );
650 fd->setNameFilter( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
651 if ( !anInitialPath.isEmpty() )
652 fd->setDirectory( anInitialPath );
653 fd->selectFile(aMeshName);
654 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
655 fd->setValidator( fv );
658 aFilename = fd->selectedFile();
659 toOverwrite = fv->isOverwrite();
663 else if ( isSTL ) // Export to STL
665 QMap<QString, int> aFilterMap;
666 aFilterMap.insert( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)", 1 );
667 aFilterMap.insert( QObject::tr( "STL_BIN_FILES_FILTER" ) + " (*.stl)", 0 );
670 QMap<QString, int>::const_iterator it = aFilterMap.begin();
671 for ( ; it != aFilterMap.end(); ++it )
672 filters.push_back( it.key() );
674 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
675 fd->setWindowTitle( aTitle );
676 fd->setNameFilters( filters );
677 fd->selectNameFilter( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
678 if ( !anInitialPath.isEmpty() )
679 fd->setDirectory( anInitialPath );
680 fd->selectFile(aMeshName);
684 aFilename = fd->selectedFile();
685 aIsASCII_STL = (aFilterMap[fd->selectedNameFilter()]) == 1 ? true: false;
690 else if ( isMED || isSAUV ) // Export to MED or SAUV
692 QMap<QString, SMESH::MED_VERSION> aFilterMap;
693 //QString v21 (aMesh->GetVersionString(SMESH::MED_V2_1, 2));
695 QString v22 (aMesh->GetVersionString(SMESH::MED_V2_2, 2));
696 //aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v21 ) + " (*.med)", SMESH::MED_V2_1 );
697 aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v22 ) + " (*.med)", SMESH::MED_V2_2 );
700 aFilterMap.insert("All files (*)", SMESH::MED_V2_1 );
701 aFilterMap.insert("SAUV files (*.sauv)", SMESH::MED_V2_2 );
702 aFilterMap.insert("SAUV files (*.sauve)", SMESH::MED_V2_1 );
706 QString aDefaultFilter;
707 QMap<QString, SMESH::MED_VERSION>::const_iterator it = aFilterMap.begin();
708 for ( ; it != aFilterMap.end(); ++it ) {
709 filters.push_back( it.key() );
710 if (it.value() == SMESH::MED_V2_2)
711 aDefaultFilter = it.key();
713 QStringList checkBoxes;
714 checkBoxes << QObject::tr("SMESH_AUTO_GROUPS") << QObject::tr("SMESH_AUTO_DIM");
716 SMESHGUI_FieldSelectorWdg* fieldSelWdg = new SMESHGUI_FieldSelectorWdg();
717 QList< QWidget* > wdgList;
718 if ( fieldSelWdg->GetAllFeilds( aMeshList, aFieldList ))
719 wdgList.append( fieldSelWdg );
721 SalomeApp_CheckFileDlg* fd =
722 new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true, wdgList );
723 fd->setWindowTitle( aTitle );
724 fd->setNameFilters( filters );
725 fd->selectNameFilter( aDefaultFilter );
726 fd->SetChecked( toCreateGroups, 0 );
727 fd->SetChecked( toFindOutDim, 1 );
728 if ( !anInitialPath.isEmpty() )
729 fd->setDirectory( anInitialPath );
730 fd->selectFile(aMeshName);
733 QListView *lview = fd->findChild<QListView*>("listView");
735 lview->setMinimumHeight(200);
737 QTreeView *tview = fd->findChild<QTreeView*>("treeView");
739 tview->setMinimumHeight(200);
742 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
743 fd->setValidator( fv );
748 aFilename = fd->selectedFile();
750 aFilename = QString::null;
753 aFormat = aFilterMap[fd->selectedNameFilter()];
754 toOverwrite = fv->isOverwrite();
756 if ( !aFilename.isEmpty() ) {
757 // med-2.1 does not support poly elements
758 if ( aFormat==SMESH::MED_V2_1 )
759 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
760 SMESH::SMESH_IDSource_var aMeshItem = (*aMeshIter).first;
761 SMESH::long_array_var nbElems = aMeshItem->GetMeshInfo();
762 if ( nbElems[ SMESH::Entity_Polygon ] + nbElems[ SMESH::Entity_Quad_Polygon ] +
763 nbElems[ SMESH::Entity_Polyhedra ] + nbElems[ SMESH::Entity_Quad_Polyhedra ])
765 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
766 QObject::tr("SMESH_WRN_WARNING"),
767 QObject::tr("SMESH_EXPORT_MED_V2_1").arg((*aMeshIter).second),
768 QObject::tr("SMESH_BUT_YES"),
769 QObject::tr("SMESH_BUT_NO"), 0, 1);
777 // can't append to an existing using other format
778 SMESH::MED_VERSION aVersion = SMESH::MED_V2_1;
779 bool isVersionOk = SMESHGUI::GetSMESHGen()->GetMEDVersion( aFilename.toUtf8().constData(), aVersion );
780 if( !isVersionOk || aVersion != aFormat ) {
781 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
782 QObject::tr("SMESH_WRN_WARNING"),
783 QObject::tr("SMESH_EXPORT_MED_VERSION_COLLISION").arg(aFilename),
784 QObject::tr("SMESH_BUT_YES"),
785 QObject::tr("SMESH_BUT_NO"), 0, 1);
792 QStringList aMeshNamesCollisionList;
793 SMESH::string_array_var aMeshNames = SMESHGUI::GetSMESHGen()->GetMeshNames( aFilename.toUtf8().constData() );
794 for( int i = 0, n = aMeshNames->length(); i < n; i++ ) {
795 QString anExistingMeshName( aMeshNames[ i ] );
796 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
797 QString anExportMeshName = (*aMeshIter).second;
798 if( anExportMeshName == anExistingMeshName ) {
799 aMeshNamesCollisionList.append( anExportMeshName );
804 if( !aMeshNamesCollisionList.isEmpty() ) {
805 QString aMeshNamesCollisionString = aMeshNamesCollisionList.join( ", " );
806 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
807 QObject::tr("SMESH_WRN_WARNING"),
808 QObject::tr("SMESH_EXPORT_MED_MESH_NAMES_COLLISION").arg(aMeshNamesCollisionString),
809 QObject::tr("SMESH_BUT_YES"),
810 QObject::tr("SMESH_BUT_NO"),
811 QObject::tr("SMESH_BUT_CANCEL"), 0, 2);
820 toCreateGroups = fd->IsChecked(0);
821 toFindOutDim = fd->IsChecked(1);
822 fieldSelWdg->GetSelectedFeilds();
823 if ( !fieldSelWdg->parent() )
834 if ( !aFilename.isEmpty() ) {
835 // Check whether the file already exists and delete it if yes
836 QFile aFile( aFilename );
837 if ( aFile.exists() && toOverwrite )
839 SUIT_OverrideCursor wc;
842 // Renumbering is not needed since SMDS redesign in V6.2.0 (Nov 2010)
843 // bool Renumber = false;
844 // // PAL 14172 : Check of we have to renumber or not from the preferences before export
846 // Renumber= resMgr->booleanValue("renumbering");
848 // SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
849 // aMeshEditor->RenumberNodes();
850 // aMeshEditor->RenumberElements();
851 // if ( SMESHGUI::automaticUpdate() )
852 // SMESH::UpdateView();
856 aMeshIter = aMeshList.begin();
857 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
859 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
860 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
861 const GEOM::ListOfFields& fields = aFieldList[ aMeshIndex ].first.in();
862 const QString& geoAssFields = aFieldList[ aMeshIndex ].second;
863 const bool hasFields = ( fields.length() || !geoAssFields.isEmpty() );
864 if ( !hasFields && aMeshOrGroup->_is_equivalent( aMeshItem ))
865 aMeshItem->ExportToMEDX( aFilename.toUtf8().data(), toCreateGroups,
866 aFormat, toOverwrite && aMeshIndex == 0, toFindOutDim );
868 aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups,
869 aFormat, toOverwrite && aMeshIndex == 0, toFindOutDim,
870 fields, geoAssFields.toLatin1().data() );
875 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ )
877 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
878 if( !aMeshItem->_is_nil() )
879 aMeshItem->ExportSAUV( aFilename.toUtf8().data(), toCreateGroups );
884 if ( aMeshOrGroup->_is_equivalent( aMesh ))
885 aMesh->ExportDAT( aFilename.toUtf8().data() );
887 aMesh->ExportPartToDAT( aMeshOrGroup, aFilename.toUtf8().data() );
891 if ( aMeshOrGroup->_is_equivalent( aMesh ))
892 aMesh->ExportUNV( aFilename.toUtf8().data() );
894 aMesh->ExportPartToUNV( aMeshOrGroup, aFilename.toUtf8().data() );
898 if ( aMeshOrGroup->_is_equivalent( aMesh ))
899 aMesh->ExportSTL( aFilename.toUtf8().data(), aIsASCII_STL );
901 aMesh->ExportPartToSTL( aMeshOrGroup, aFilename.toUtf8().data(), aIsASCII_STL );
905 aMeshIter = aMeshList.begin();
906 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
908 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
909 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
910 aMeshItem->ExportCGNS( aMeshOrGroup,
911 aFilename.toUtf8().data(),
912 toOverwrite && aMeshIndex == 0 );
917 toCreateGroups = true;
918 aMesh->ExportGMF( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups );
921 catch (const SALOME::SALOME_Exception& S_ex){
923 SUIT_MessageBox::warning(SMESHGUI::desktop(),
924 QObject::tr("SMESH_WRN_WARNING"),
925 QObject::tr("SMESH_EXPORT_FAILED"));
931 inline void InverseEntityMode(unsigned int& theOutputMode,
932 unsigned int theMode)
934 bool anIsNotPresent = ~theOutputMode & theMode;
936 theOutputMode |= theMode;
938 theOutputMode &= ~theMode;
941 void SetDisplayEntity(int theCommandID)
943 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
944 SALOME_ListIO selected;
946 aSel->selectedObjects( selected );
948 if ( selected.Extent() >= 1 ) {
949 SALOME_ListIteratorOfListIO It( selected );
950 for( ; It.More(); It.Next()){
951 Handle(SALOME_InteractiveObject) IObject = It.Value();
952 if(IObject->hasEntry()){
953 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
954 unsigned int aMode = anActor->GetEntityMode();
955 switch(theCommandID){
956 case SMESHOp::OpDE0DElements: InverseEntityMode(aMode,SMESH_Actor::e0DElements); break;
957 case SMESHOp::OpDEEdges: InverseEntityMode(aMode,SMESH_Actor::eEdges); break;
958 case SMESHOp::OpDEFaces: InverseEntityMode(aMode,SMESH_Actor::eFaces); break;
959 case SMESHOp::OpDEVolumes: InverseEntityMode(aMode,SMESH_Actor::eVolumes); break;
960 case SMESHOp::OpDEBalls: InverseEntityMode(aMode,SMESH_Actor::eBallElem); break;
961 case SMESHOp::OpDEAllEntity: aMode = SMESH_Actor::eAllEntity; break;
964 anActor->SetEntityMode(aMode);
973 SalomeApp_Application* app =
974 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
978 LightApp_SelectionMgr* aSel = app->selectionMgr();
979 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
980 if ( !aSel || !appStudy )
983 SALOME_ListIO selected;
984 aSel->selectedObjects( selected );
985 if ( selected.IsEmpty() )
988 Handle(SALOME_InteractiveObject) anIObject = selected.First();
990 _PTR(Study) aStudy = appStudy->studyDS();
991 _PTR(SObject) aMainSObject = aStudy->FindObjectID( anIObject->getEntry() );
992 SMESH::SMESH_Mesh_var aMainObject = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
993 if ( aMainObject->_is_nil() )
996 SUIT_OverrideCursor wc;
998 aMainObject->SetAutoColor( true ); // mesh groups are re-colored here
1000 QList<SALOMEDS::Color> aReservedColors;
1002 SMESH::ListOfGroups aListOfGroups = *aMainObject->GetGroups();
1003 for ( int i = 0, n = aListOfGroups.length(); i < n; i++ )
1005 SMESH::SMESH_GroupBase_var aGroupObject = aListOfGroups[i];
1007 #ifdef SIMPLE_AUTOCOLOR // simplified algorithm for auto-colors
1008 SALOMEDS::Color aColor = SMESHGUI::getPredefinedUniqueColor();
1009 #else // old algorithm for auto-colors
1010 SALOMEDS::Color aColor = SMESHGUI::getUniqueColor( aReservedColors );
1011 aReservedColors.append( aColor );
1012 #endif // SIMPLE_AUTOCOLOR
1013 aGroupObject->SetColor( aColor );
1015 _PTR(SObject) aGroupSObject = SMESH::FindSObject(aGroupObject);
1016 if ( aGroupSObject ) {
1019 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry(aGroupSObject->GetID().c_str())) {
1020 switch ( aGroupObject->GetType ()) {
1022 anActor->SetNodeColor( aColor.R, aColor.G, aColor.B ); break;
1024 anActor->SetEdgeColor( aColor.R, aColor.G, aColor.B ); break;
1026 anActor->Set0DColor( aColor.R, aColor.G, aColor.B ); break;
1028 anActor->SetBallColor( aColor.R, aColor.G, aColor.B ); break;
1030 SMESH::GetColor("SMESH", "volume_color", c, delta, "255,0,170|-100");
1031 anActor->SetVolumeColor( aColor.R, aColor.G, aColor.B, delta ); break;
1034 SMESH::GetColor("SMESH", "fill_color", c, delta, "0,170,255|-100");
1035 anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B, delta );
1041 SMESH::RepaintCurrentView();
1044 void OverallMeshQuality()
1046 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1047 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1048 SALOME_ListIO selected;
1050 aSel->selectedObjects( selected );
1052 if ( selected.IsEmpty() ) return;
1053 SALOME_ListIteratorOfListIO It( selected );
1054 for ( ; It.More(); It.Next() ) {
1055 SMESHGUI_CtrlInfoDlg* ctrlDlg = new SMESHGUI_CtrlInfoDlg( SMESHGUI::desktop() );
1056 ctrlDlg->showInfo( It.Value() );
1061 QString functorToString( SMESH::Controls::FunctorPtr f )
1063 QString type = QObject::tr( "UNKNOWN_CONTROL" );
1064 if ( dynamic_cast< SMESH::Controls::Volume* >( f.get() ) )
1065 type = QObject::tr( "VOLUME_3D_ELEMENTS" );
1066 else if ( dynamic_cast< SMESH::Controls::MaxElementLength2D* >( f.get() ) )
1067 type = QObject::tr( "MAX_ELEMENT_LENGTH_2D" );
1068 else if ( dynamic_cast< SMESH::Controls::MaxElementLength3D* >( f.get() ) )
1069 type = QObject::tr( "MAX_ELEMENT_LENGTH_3D" );
1070 else if ( dynamic_cast< SMESH::Controls::MinimumAngle* >( f.get() ) )
1071 type = QObject::tr( "MINIMUMANGLE_ELEMENTS" );
1072 else if ( dynamic_cast< SMESH::Controls::AspectRatio* >( f.get() ) )
1073 type = QObject::tr( "ASPECTRATIO_ELEMENTS" );
1074 else if ( dynamic_cast< SMESH::Controls::AspectRatio3D* >( f.get() ) )
1075 type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" );
1076 else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) )
1077 type = QObject::tr( "WARP_ELEMENTS" );
1078 else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) )
1079 type = QObject::tr( "TAPER_ELEMENTS" );
1080 else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) )
1081 type = QObject::tr( "SKEW_ELEMENTS" );
1082 else if ( dynamic_cast< SMESH::Controls::Area* >( f.get() ) )
1083 type = QObject::tr( "AREA_ELEMENTS" );
1084 else if ( dynamic_cast< SMESH::Controls::Length* >( f.get() ) )
1085 type = QObject::tr( "LENGTH_EDGES" );
1086 else if ( dynamic_cast< SMESH::Controls::Length2D* >( f.get() ) )
1087 type = QObject::tr( "LENGTH2D_EDGES" );
1088 else if ( dynamic_cast< SMESH::Controls::MultiConnection* >( f.get() ) )
1089 type = QObject::tr( "MULTI_BORDERS" );
1090 else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) )
1091 type = QObject::tr( "MULTI2D_BORDERS" );
1092 else if ( dynamic_cast< SMESH::Controls::FreeNodes* >( f.get() ) )
1093 type = QObject::tr( "FREE_NODES" );
1094 else if ( dynamic_cast< SMESH::Controls::FreeEdges* >( f.get() ) )
1095 type = QObject::tr( "FREE_EDGES" );
1096 else if ( dynamic_cast< SMESH::Controls::FreeBorders* >( f.get() ) )
1097 type = QObject::tr( "FREE_BORDERS" );
1098 else if ( dynamic_cast< SMESH::Controls::FreeFaces* >( f.get() ) )
1099 type = QObject::tr( "FREE_FACES" );
1100 else if ( dynamic_cast< SMESH::Controls::BareBorderVolume* >( f.get() ) )
1101 type = QObject::tr( "BARE_BORDER_VOLUME" );
1102 else if ( dynamic_cast< SMESH::Controls::BareBorderFace* >( f.get() ) )
1103 type = QObject::tr( "BARE_BORDER_FACE" );
1104 else if ( dynamic_cast< SMESH::Controls::OverConstrainedVolume* >( f.get() ) )
1105 type = QObject::tr( "OVER_CONSTRAINED_VOLUME" );
1106 else if ( dynamic_cast< SMESH::Controls::OverConstrainedFace* >( f.get() ) )
1107 type = QObject::tr( "OVER_CONSTRAINED_FACE" );
1108 else if ( dynamic_cast< SMESH::Controls::CoincidentNodes* >( f.get() ) )
1109 type = QObject::tr( "EQUAL_NODE" );
1110 else if ( dynamic_cast< SMESH::Controls::CoincidentElements1D* >( f.get() ) )
1111 type = QObject::tr( "EQUAL_EDGE" );
1112 else if ( dynamic_cast< SMESH::Controls::CoincidentElements2D* >( f.get() ) )
1113 type = QObject::tr( "EQUAL_FACE" );
1114 else if ( dynamic_cast< SMESH::Controls::CoincidentElements3D* >( f.get() ) )
1115 type = QObject::tr( "EQUAL_VOLUME" );
1119 void SaveDistribution()
1121 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1122 SALOME_ListIO selected;
1124 aSel->selectedObjects( selected );
1126 if ( selected.Extent() == 1 ) {
1127 Handle(SALOME_InteractiveObject) anIO = selected.First();
1128 if ( anIO->hasEntry() ) {
1129 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1131 anActor->GetScalarBarActor() &&
1132 anActor->GetControlMode() != SMESH_Actor::eNone )
1134 SMESH_ScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor();
1135 SMESH::Controls::FunctorPtr aFunctor = anActor->GetFunctor();
1136 if ( aScalarBarActor && aFunctor ) {
1137 SMESH::Controls::NumericalFunctor* aNumFun =
1138 dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
1140 std::vector<int> elements;
1141 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
1142 if ( mesh->_is_nil() ) {
1143 SMESH::SMESH_IDSource_var idSource =
1144 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
1145 if ( !idSource->_is_nil() )
1147 SMESH::long_array_var ids = idSource->GetIDs();
1148 elements.resize( ids->length() );
1149 for ( unsigned i = 0; i < elements.size(); ++i )
1150 elements[i] = ids[i];
1153 int nbIntervals = aScalarBarActor->GetMaximumNumberOfColors();
1154 vtkLookupTable* lookupTable =
1155 static_cast<vtkLookupTable*>(aScalarBarActor->GetLookupTable());
1156 double * minmax = lookupTable->GetRange();
1157 bool isLogarithmic = lookupTable->GetScale() == VTK_SCALE_LOG10;
1158 std::vector<int> nbEvents;
1159 std::vector<double> funValues;
1160 aNumFun->GetHistogram( nbIntervals, nbEvents, funValues,
1161 elements, minmax, isLogarithmic );
1162 QString anInitialPath = "";
1163 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
1164 anInitialPath = QDir::currentPath();
1165 QString aMeshName = anIO->getName();
1167 filter.append( QObject::tr( "TEXT_FILES_FILTER" ) + " (*.txt)" );
1168 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
1169 QString aFilename = anInitialPath + "/" + aMeshName + "_" +
1170 functorToString( aFunctor ).toLower().simplified().replace( QRegExp( " |-" ), "_" ) + ".txt";
1171 aFilename = SUIT_FileDlg::getFileName( SMESHGUI::desktop(),
1174 QObject::tr( "SMESH_SAVE_DISTRIBUTION" ),
1176 if ( !aFilename.isEmpty() ) {
1177 QFile f( aFilename );
1178 if ( f.open( QFile::WriteOnly | QFile::Truncate ) ) {
1179 QTextStream out( &f );
1180 out << "# Mesh: " << aMeshName << endl;
1181 out << "# Control: " << functorToString( aFunctor ) << endl;
1183 out.setFieldWidth( 10 );
1184 for ( int i = 0; i < (int)qMin( nbEvents.size(), funValues.size()-1 ); i++ )
1185 out << funValues[i] << "\t" << funValues[i+1] << "\t" << nbEvents[i] << endl;
1196 void ShowElement( int theCommandID )
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 if ( theCommandID == SMESHOp::OpShowDistribution ) {
1213 aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility());
1215 else if ( theCommandID == SMESHOp::OpShowScalarBar ) {
1216 aScalarBarActor->SetVisibility( !aScalarBarActor->GetVisibility());
1223 #ifndef DISABLE_PLOT2DVIEWER
1224 void PlotDistribution()
1226 SalomeApp_Application* app =
1227 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1231 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1232 SALOME_ListIO selected;
1234 aSel->selectedObjects( selected );
1236 if ( selected.Extent() == 1 ) {
1237 Handle(SALOME_InteractiveObject) anIO = selected.First();
1238 if ( anIO->hasEntry() ) {
1239 //Find Actor by entry before getting Plot2d viewer,
1240 //because after call getViewManager( Plot2d_Viewer::Type(), true ) active window is Plot2d Viewer
1241 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1243 SUIT_ViewManager* aViewManager =
1244 app->getViewManager( Plot2d_Viewer::Type(), true ); // create if necessary
1248 SPlot2d_Viewer* aView = dynamic_cast<SPlot2d_Viewer*>(aViewManager->getViewModel());
1252 Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
1256 if ( anActor && anActor->GetControlMode() != SMESH_Actor::eNone )
1258 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1259 QString functorName = functorToString( anActor->GetFunctor());
1260 QString aHistogramName("%1 : %2");
1261 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1262 aHistogram->setName(aHistogramName);
1263 aHistogram->setHorTitle(functorName);
1264 aHistogram->setVerTitle(QObject::tr("DISTRIBUTION_NB_ENT"));
1265 aPlot->displayObject(aHistogram, true);
1270 #endif //DISABLE_PLOT2DVIEWER
1272 void DisableAutoColor()
1274 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1275 SALOME_ListIO selected;
1277 aSel->selectedObjects( selected );
1279 if ( selected.Extent() ) {
1280 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1281 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1282 if ( !aMesh->_is_nil() ) {
1283 aMesh->SetAutoColor( false );
1290 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1291 SALOME_ListIO selected;
1293 aSel->selectedObjects( selected );
1294 if ( selected.Extent() )
1296 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1297 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1298 _PTR(SObject) aSObj = aStudy->FindObjectID(anIObject->getEntry());
1300 if ( aStudy->GetUseCaseBuilder()->SortChildren( aSObj, true/*AscendingOrder*/ ) ) {
1301 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1308 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap)
1310 SALOME_ListIO selected;
1311 SalomeApp_Application* app =
1312 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1316 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1317 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1318 if ( !aSel || !appStudy )
1321 if ( theCommandID == SMESHOp::OpClipping ) { // Clipping dialog can be activated without selection
1322 if ( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
1323 aModule->EmitSignalDeactivateDialog();
1324 if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
1325 (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
1330 _PTR(Study) aStudy = appStudy->studyDS();
1332 aSel->selectedObjects( selected );
1334 if ( selected.Extent() >= 1 )
1336 switch ( theCommandID ) {
1337 case SMESHOp::OpTransparency:
1339 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1340 (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
1343 case SMESHOp::OpProperties:
1346 QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
1347 QColor orientationColor, outlineColor, volumeColor;
1348 int deltaF = 0, deltaV = 0;
1351 double ballScale = 1.0;
1353 int outlineWidth = 1;
1354 double shrinkCoef = 0.0;
1355 double orientationScale = 0.0;
1356 bool orientation3d = false;
1357 VTK::MarkerType markerType = VTK::MT_NONE;
1358 VTK::MarkerScale markerScale = VTK::MS_NONE;
1360 bool hasNodes = false;
1361 int presentEntities = 0;
1362 bool firstTime = true;
1364 SALOME_ListIteratorOfListIO It( selected );
1365 for ( ; It.More(); It.Next() ) {
1366 Handle(SALOME_InteractiveObject) IObject = It.Value();
1367 if ( !IObject->hasEntry() ) continue;
1368 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1369 if ( !anActor || !anActor->GetObject() ) continue;
1372 // nodes: color, marker
1373 anActor->GetNodeColor( color[0], color[1], color[2] );
1374 nodeColor.setRgbF( color[0], color[1], color[2] );
1375 markerType = anActor->GetMarkerType();
1376 markerScale = anActor->GetMarkerScale();
1377 markerId = anActor->GetMarkerTexture();
1378 // edges: color, width
1379 anActor->GetEdgeColor( color[0], color[1], color[2] );
1380 edgeColor.setRgbF( color[0], color[1], color[2] );
1381 edgeWidth = qMax( (int)anActor->GetLineWidth(), 1 ); // minimum allowed width is 1
1382 // faces: front color, back color (delta)
1383 anActor->GetSufaceColor( color[0], color[1], color[2], deltaF );
1384 faceColor.setRgbF( color[0], color[1], color[2] );
1385 // faces: front color, back color (delta)
1386 anActor->GetVolumeColor( color[0], color[1], color[2], deltaV );
1387 volumeColor.setRgbF( color[0], color[1], color[2] );
1388 // 0d elements: color, size
1389 anActor->Get0DColor( color[0], color[1], color[2] );
1390 elem0dColor.setRgbF( color[0], color[1], color[2] );
1391 elem0dSize = qMax( (int)anActor->Get0DSize(), 1 ); // minimum allowed size is 1
1392 // balls: color, size
1393 anActor->GetBallColor( color[0], color[1], color[2] );
1394 ballColor.setRgbF( color[0], color[1], color[2] );
1395 //ballSize = qMax( (int)anActor->GetBallSize(), 1 ); // minimum allowed size is 1
1396 ballScale = qMax( (double)anActor->GetBallScale(), 1e-2 ); // minimum allowed scale is 1e-2
1398 anActor->GetOutlineColor( color[0], color[1], color[2] );
1399 outlineColor.setRgbF( color[0], color[1], color[2] );
1400 outlineWidth = qMax( (int)anActor->GetOutlineWidth(), 1 ); // minimum allowed width is 1
1401 // orientation vectors: color, scale, 3d flag
1402 anActor->GetFacesOrientationColor( color[0], color[1], color[2] );
1403 orientationColor.setRgbF( color[0], color[1], color[2] );
1404 orientationScale = anActor->GetFacesOrientationScale();
1405 orientation3d = anActor->GetFacesOrientation3DVectors();
1407 shrinkCoef = anActor->GetShrinkFactor();
1410 firstTime = false; // we only take properties from first object (for performance reasons)
1413 hasNodes = anActor->GetObject()->GetNbEntities( SMDSAbs_Node );
1414 if ( !(presentEntities & SMESH_Actor::eEdges) && anActor->GetObject()->GetNbEntities( SMDSAbs_Edge ) )
1415 presentEntities = presentEntities | SMESH_Actor::eEdges;
1416 if ( !(presentEntities & SMESH_Actor::eFaces) && anActor->GetObject()->GetNbEntities( SMDSAbs_Face ) )
1417 presentEntities = presentEntities | SMESH_Actor::eFaces;
1418 if ( !(presentEntities & SMESH_Actor::eVolumes) && anActor->GetObject()->GetNbEntities( SMDSAbs_Volume ) )
1419 presentEntities = presentEntities | SMESH_Actor::eVolumes;
1420 if ( !(presentEntities & SMESH_Actor::e0DElements) && anActor->GetObject()->GetNbEntities( SMDSAbs_0DElement ) )
1421 presentEntities = presentEntities | SMESH_Actor::e0DElements;
1422 if ( !(presentEntities & SMESH_Actor::eBallElem) && anActor->GetObject()->GetNbEntities( SMDSAbs_Ball ) )
1423 presentEntities = presentEntities | SMESH_Actor::eBallElem;
1425 // as we know that all types of elements are present, we can exit the loop
1426 if ( presentEntities == SMESH_Actor::eAllEntity )
1430 SMESHGUI_PropertiesDlg dlg( theMarkerMap[ aStudy->StudyId() ], SMESHGUI::desktop() );
1431 // nodes: color, marker
1432 dlg.setNodeColor( nodeColor );
1433 if( markerType != VTK::MT_USER )
1434 dlg.setNodeMarker( markerType, markerScale );
1436 dlg.setNodeCustomMarker( markerId );
1437 // edges: color, line width
1438 dlg.setEdgeColor( edgeColor );
1439 dlg.setEdgeWidth( edgeWidth );
1440 // faces: front color, back color
1441 dlg.setFaceColor( faceColor, deltaF );
1442 // volumes: normal color, reversed color
1443 dlg.setVolumeColor( volumeColor, deltaV );
1444 // outlines: color, line width
1445 dlg.setOutlineColor( outlineColor );
1446 dlg.setOutlineWidth( outlineWidth );
1447 // 0d elements: color, size
1448 dlg.setElem0dColor( elem0dColor );
1449 dlg.setElem0dSize( elem0dSize );
1450 // balls: color, size
1451 dlg.setBallColor( ballColor );
1452 //dlg.setBallSize( ballSize );
1453 dlg.setBallScale( ballScale );
1454 // orientation: color, scale, 3d flag
1455 dlg.setOrientationColor( orientationColor );
1456 dlg.setOrientationSize( int( orientationScale * 100. ) );
1457 dlg.setOrientation3d( orientation3d );
1458 // shrink: scale factor
1459 dlg.setShrinkCoef( int( shrinkCoef * 100. ) );
1460 // hide unused controls
1461 dlg.showControls( presentEntities, hasNodes );
1464 nodeColor = dlg.nodeColor();
1465 markerType = dlg.nodeMarkerType();
1466 markerScale = dlg.nodeMarkerScale();
1467 markerId = dlg.nodeMarkerId();
1468 edgeColor = dlg.edgeColor();
1469 edgeWidth = dlg.edgeWidth();
1470 faceColor = dlg.faceColor();
1471 deltaF = dlg.faceColorDelta();
1472 volumeColor = dlg.volumeColor();
1473 deltaV = dlg.volumeColorDelta();
1474 outlineColor = dlg.outlineColor();
1475 outlineWidth = dlg.outlineWidth();
1476 elem0dColor = dlg.elem0dColor();
1477 elem0dSize = dlg.elem0dSize();
1478 ballColor = dlg.ballColor();
1479 // ballSize = dlg.ballSize();
1480 ballScale = dlg.ballScale();
1481 orientationColor = dlg.orientationColor();
1482 orientationScale = dlg.orientationSize() / 100.;
1483 orientation3d = dlg.orientation3d();
1484 shrinkCoef = dlg.shrinkCoef() / 100.;
1486 // store point markers map that might be changed by the user
1487 theMarkerMap[ aStudy->StudyId() ] = dlg.customMarkers();
1489 // set properties from dialog box to the presentations
1490 SALOME_ListIteratorOfListIO It( selected );
1491 for ( ; It.More(); It.Next() ) {
1492 Handle(SALOME_InteractiveObject) IObject = It.Value();
1493 if ( !IObject->hasEntry() ) continue;
1494 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1495 if ( !anActor ) continue;
1497 // nodes: color, marker
1498 anActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
1499 if ( markerType != VTK::MT_USER ) {
1500 anActor->SetMarkerStd( markerType, markerScale );
1503 const VTK::MarkerMap& markerMap = theMarkerMap[ aStudy->StudyId() ];
1504 VTK::MarkerMap::const_iterator iter = markerMap.find( markerId );
1505 if ( iter != markerMap.end() )
1506 anActor->SetMarkerTexture( markerId, iter->second.second );
1508 // volumes: normal color, reversed color (delta)
1509 anActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
1510 // faces: front color, back color (delta)
1511 anActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
1512 // edges: color, width
1513 anActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
1514 anActor->SetLineWidth( edgeWidth );
1516 anActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
1517 anActor->SetOutlineWidth( outlineWidth );
1518 // 0D elements: color, size
1519 anActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
1520 anActor->Set0DSize( elem0dSize );
1521 // balls: color, size
1522 anActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
1523 // anActor->SetBallSize( ballSize );
1524 anActor->SetBallScale( ballScale );
1525 // orientation: color, scale, 3d flag
1526 anActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
1527 anActor->SetFacesOrientationScale( orientationScale );
1528 anActor->SetFacesOrientation3DVectors( orientation3d );
1530 anActor->SetShrinkFactor( shrinkCoef );
1532 // for groups, set also proper color
1533 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1534 if ( !aGroupObject->_is_nil() ) {
1535 SMESH::ElementType anElementType = aGroupObject->GetType();
1537 switch( anElementType ) {
1539 aColor = nodeColor; break;
1541 aColor = edgeColor; break;
1543 aColor = faceColor; break;
1545 aColor = volumeColor; break;
1547 aColor = elem0dColor; break;
1549 aColor = ballColor; break;
1553 if ( aColor.isValid() ) {
1554 SALOMEDS::Color aGroupColor;
1555 aGroupColor.R = aColor.redF();
1556 aGroupColor.G = aColor.greenF();
1557 aGroupColor.B = aColor.blueF();
1558 aGroupObject->SetColor( aGroupColor );
1560 } // if ( !aGroupObject->_is_nil() )
1561 } // for ( ; It.More(); It.Next() )
1562 SMESH::RepaintCurrentView();
1563 } // if ( dlg.exec() )
1565 } // case SMESHOp::OpProperties:
1566 } // switch(theCommandID)
1567 SALOME_ListIteratorOfListIO It( selected );
1568 for( ; It.More(); It.Next()){
1569 Handle(SALOME_InteractiveObject) IObject = It.Value();
1570 if(IObject->hasEntry()){
1571 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1572 switch(theCommandID){
1573 case SMESHOp::OpDMWireframe:
1574 anActor->SetRepresentation(SMESH_Actor::eEdge);
1576 case SMESHOp::OpDMShading:
1577 anActor->SetRepresentation(SMESH_Actor::eSurface);
1579 case SMESHOp::OpDMShrink:
1580 if(anActor->IsShrunk())
1581 anActor->UnShrink();
1583 anActor->SetShrink();
1585 case SMESHOp::OpDMNodes:
1586 anActor->SetRepresentation(SMESH_Actor::ePoint);
1588 case SMESHOp::OpRepresentationLines:
1589 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1590 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1592 case SMESHOp::OpRepresentationArcs:
1593 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1594 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1600 SMESH::RepaintCurrentView();
1604 int ActionToControl( int theID, bool theReversed )
1606 NCollection_DoubleMap<int,int> ActionControl;
1607 ActionControl.Bind( 0, SMESH_Actor::eNone );
1608 ActionControl.Bind( SMESHOp::OpFreeNode, SMESH_Actor::eFreeNodes );
1609 ActionControl.Bind( SMESHOp::OpEqualNode, SMESH_Actor::eCoincidentNodes );
1610 ActionControl.Bind( SMESHOp::OpFreeEdge, SMESH_Actor::eFreeEdges );
1611 ActionControl.Bind( SMESHOp::OpFreeBorder, SMESH_Actor::eFreeBorders );
1612 ActionControl.Bind( SMESHOp::OpLength, SMESH_Actor::eLength );
1613 ActionControl.Bind( SMESHOp::OpConnection, SMESH_Actor::eMultiConnection );
1614 ActionControl.Bind( SMESHOp::OpEqualEdge, SMESH_Actor::eCoincidentElems1D );
1615 ActionControl.Bind( SMESHOp::OpFreeFace, SMESH_Actor::eFreeFaces );
1616 ActionControl.Bind( SMESHOp::OpBareBorderFace, SMESH_Actor::eBareBorderFace );
1617 ActionControl.Bind( SMESHOp::OpOverConstrainedFace, SMESH_Actor::eOverConstrainedFace );
1618 ActionControl.Bind( SMESHOp::OpLength2D, SMESH_Actor::eLength2D );
1619 ActionControl.Bind( SMESHOp::OpConnection2D, SMESH_Actor::eMultiConnection2D );
1620 ActionControl.Bind( SMESHOp::OpArea, SMESH_Actor::eArea );
1621 ActionControl.Bind( SMESHOp::OpTaper, SMESH_Actor::eTaper );
1622 ActionControl.Bind( SMESHOp::OpAspectRatio, SMESH_Actor::eAspectRatio );
1623 ActionControl.Bind( SMESHOp::OpMinimumAngle, SMESH_Actor::eMinimumAngle );
1624 ActionControl.Bind( SMESHOp::OpWarpingAngle, SMESH_Actor::eWarping );
1625 ActionControl.Bind( SMESHOp::OpSkew, SMESH_Actor::eSkew );
1626 ActionControl.Bind( SMESHOp::OpMaxElementLength2D, SMESH_Actor::eMaxElementLength2D );
1627 ActionControl.Bind( SMESHOp::OpEqualFace, SMESH_Actor::eCoincidentElems2D );
1628 ActionControl.Bind( SMESHOp::OpAspectRatio3D, SMESH_Actor::eAspectRatio3D );
1629 ActionControl.Bind( SMESHOp::OpVolume, SMESH_Actor::eVolume3D );
1630 ActionControl.Bind( SMESHOp::OpMaxElementLength3D, SMESH_Actor::eMaxElementLength3D );
1631 ActionControl.Bind( SMESHOp::OpBareBorderVolume, SMESH_Actor::eBareBorderVolume );
1632 ActionControl.Bind( SMESHOp::OpOverConstrainedVolume, SMESH_Actor::eOverConstrainedVolume );
1633 ActionControl.Bind( SMESHOp::OpEqualVolume, SMESH_Actor::eCoincidentElems3D );
1635 return theReversed ? ActionControl.Find2( theID ) : ActionControl.Find1( theID );
1638 void Control( int theCommandID )
1640 SMESH_Actor::eControl aControl = SMESH_Actor::eControl( ActionToControl( theCommandID ));
1641 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1643 SALOME_ListIO selected;
1644 if ( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
1645 aSel->selectedObjects( selected );
1647 if ( !selected.IsEmpty() ) {
1648 SALOME_ListIteratorOfListIO It(selected);
1649 for ( ; It.More(); It.Next())
1651 Handle(SALOME_InteractiveObject) anIO = It.Value();
1652 if ( !anIO.IsNull() ) {
1653 _PTR(SObject) SO = aStudy->FindObjectID( It.Value()->getEntry() );
1655 CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
1656 SMESH::SMESH_IDSource_var anIDSrc = SMESH::SMESH_IDSource::_narrow( aObject );
1657 if ( !anIDSrc->_is_nil() ) {
1658 SMESH_Actor *anActor = SMESH::FindActorByEntry( anIO->getEntry());
1659 if (( !anActor && selected.Extent() == 1 ) &&
1660 ( anActor = SMESH::CreateActor( aStudy, anIO->getEntry() )))
1662 anActor->SetControlMode( aControl );
1663 SMESH::DisplayActor( SMESH::GetCurrentVtkView(), anActor );
1664 SMESH::UpdateView ( SMESH::eDisplay, anIO->getEntry() );
1668 if ( anActor->GetControlMode() != aControl )
1669 anActor->SetControlMode( aControl );
1670 QString functorName = functorToString( anActor->GetFunctor() );
1671 int anEntitiesCount = anActor->GetNumberControlEntities();
1672 if (anEntitiesCount >= 0)
1673 functorName = functorName + ": " + QString::number(anEntitiesCount);
1674 anActor->GetScalarBarActor()->SetTitle( functorName.toLatin1().constData() );
1675 SMESH::RepaintCurrentView();
1676 #ifndef DISABLE_PLOT2DVIEWER
1677 if ( anActor->GetPlot2Histogram() ) {
1678 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1679 QString aHistogramName("%1 : %2");
1680 aHistogramName = aHistogramName.arg( anIO->getName() ).arg( functorName );
1681 aHistogram->setName( aHistogramName );
1682 aHistogram->setHorTitle( functorName );
1683 SMESH::ProcessIn2DViewers( anActor );
1695 bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1696 SMESH::MeshObjectType theType,
1697 const QString theInTypeName,
1698 QString & theOutTypeName)
1700 SMESH_TypeFilter aTypeFilter( theType );
1702 if ( !theIO.IsNull() )
1704 entry = theIO->getEntry();
1705 LightApp_DataOwner owner( entry );
1706 if ( aTypeFilter.isOk( &owner )) {
1707 theOutTypeName = theInTypeName;
1715 QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1717 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1718 _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1720 _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1721 CORBA::String_var anID = aSComp->GetID().c_str();
1722 if ( !strcmp(anID.in(),theIO->getEntry()) )
1728 CheckOIType ( theIO, SMESH::HYPOTHESIS, "Hypothesis", aTypeName ) ||
1729 CheckOIType ( theIO, SMESH::ALGORITHM, "Algorithm", aTypeName ) ||
1730 CheckOIType ( theIO, SMESH::MESH, "Mesh", aTypeName ) ||
1731 CheckOIType ( theIO, SMESH::SUBMESH, "SubMesh", aTypeName ) ||
1732 CheckOIType ( theIO, SMESH::GROUP, "Group", aTypeName )
1740 // QString CheckHomogeneousSelection()
1742 // LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1743 // SALOME_ListIO selected;
1745 // aSel->selectedObjects( selected );
1747 // QString RefType = CheckTypeObject(selected.First());
1748 // SALOME_ListIteratorOfListIO It(selected);
1749 // for ( ; It.More(); It.Next())
1751 // Handle(SALOME_InteractiveObject) IObject = It.Value();
1752 // QString Type = CheckTypeObject(IObject);
1753 // if ( Type.compare(RefType) != 0 )
1754 // return "Heterogeneous Selection";
1760 uint randomize( uint size )
1762 static bool initialized = false;
1763 if ( !initialized ) {
1764 qsrand( QDateTime::currentDateTime().toTime_t() );
1768 v = uint( (double)( v ) / RAND_MAX * size );
1769 v = qMax( uint(0), qMin ( v, size-1 ) );
1775 void SMESHGUI::OnEditDelete()
1777 // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1778 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1779 SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1781 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1782 _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1783 _PTR(GenericAttribute) anAttr;
1784 _PTR(AttributeIOR) anIOR;
1786 int objectCount = 0;
1788 QString aParentComponent = QString::null;
1789 Handle(SALOME_InteractiveObject) anIO;
1790 for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1792 anIO = anIt.Value();
1793 QString cur = anIO->getComponentDataType();
1794 _PTR(SObject) aSO = aStudy->FindObjectID(anIO->getEntry());
1796 // check if object is reference
1797 _PTR(SObject) aRefSObj;
1798 aNameList.append("\n - ");
1799 if ( aSO->ReferencedObject( aRefSObj ) ) {
1800 QString aRefName = QString::fromStdString ( aRefSObj->GetName() );
1801 aNameList.append( aRefName );
1802 cur = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1805 aNameList.append(anIO->getName());
1809 if( aParentComponent.isNull() )
1810 aParentComponent = cur;
1811 else if( !aParentComponent.isEmpty() && aParentComponent!=cur )
1812 aParentComponent = "";
1815 if ( objectCount == 0 )
1816 return; // No Valid Objects Selected
1818 if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
1819 SUIT_MessageBox::warning( SMESHGUI::desktop(),
1820 QObject::tr("ERR_ERROR"),
1821 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
1824 // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
1825 if (SUIT_MessageBox::warning
1826 (SMESHGUI::desktop(),
1827 QObject::tr("SMESH_WRN_WARNING"),
1828 QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
1829 SUIT_MessageBox::Yes | SUIT_MessageBox::No,
1830 SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
1833 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1835 // Put the whole hierarchy of sub-objects of the selected SO's into a list and
1836 // then treat them all starting from the deepest objects (at list back)
1837 std::list< _PTR(SObject) > listSO;
1838 SALOME_ListIteratorOfListIO It(selected);
1839 for( ; It.More(); It.Next()) // loop on selected IO's
1841 Handle(SALOME_InteractiveObject) IObject = It.Value();
1842 if(IObject->hasEntry()) {
1843 _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
1845 // disable removal of "SMESH" component object
1846 if(aSO->FindAttribute(anAttr, "AttributeIOR")){
1848 if ( engineIOR() == anIOR->Value().c_str() )
1851 //Check the referenced object
1852 _PTR(SObject) aRefSObject;
1853 if ( aSO && aSO->ReferencedObject( aRefSObject ) )
1854 aSO = aRefSObject; // Delete main Object instead of reference
1856 listSO.push_back( aSO );
1857 std::list< _PTR(SObject) >::iterator itSO = --listSO.end();
1858 for ( ; itSO != listSO.end(); ++itSO ) {
1859 _PTR(ChildIterator) it = aStudy->NewChildIterator( *itSO );
1860 for (it->InitEx(false); it->More(); it->Next())
1861 listSO.push_back( it->Value() );
1865 // Check if none of objects to delete is referred from outside
1866 std::list< _PTR(SObject) >::reverse_iterator ritSO;
1867 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1869 _PTR(SObject) SO = *ritSO;
1870 if ( !SO ) continue;
1871 std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( *ritSO );
1872 for (size_t i = 0; i < aReferences.size(); i++) {
1873 _PTR(SComponent) aComponent = aReferences[i]->GetFatherComponent();
1874 std::string type = aComponent->ComponentDataType();
1875 if ( type != "SMESH" )
1877 SUIT_MessageBox::warning( anApp->desktop(),
1878 QObject::tr("WRN_WARNING"),
1879 QObject::tr("DEP_OBJECT") );
1880 return; // outside SMESH, there is an object depending on a SMESH object
1885 // Call mesh->Clear() to prevent loading mesh from file caused by hypotheses removal
1886 for( It.Initialize( selected ); It.More(); It.Next()) // loop on selected IO's
1888 Handle(SALOME_InteractiveObject) IObject = It.Value();
1889 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface< SMESH::SMESH_Mesh >( IObject );
1890 if ( !mesh->_is_nil() )
1894 // Treat SO's in the list starting from the back
1895 aStudyBuilder->NewCommand(); // There is a transaction
1896 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1898 _PTR(SObject) SO = *ritSO;
1899 if ( !SO ) continue;
1900 std::string anEntry = SO->GetID();
1902 /** Erase graphical object and remove all its data **/
1903 if(SO->FindAttribute(anAttr, "AttributeIOR")) {
1904 SMESH::RemoveVisualObjectWithActors( anEntry.c_str(), true);
1906 /** Remove an object from data structures **/
1907 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
1908 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
1909 if ( !aGroup->_is_nil() ) { // DELETE GROUP
1910 SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
1911 aMesh->RemoveGroup( aGroup );
1913 else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
1914 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
1915 aMesh->RemoveSubMesh( aSubMesh );
1917 _PTR(SObject) aMeshSO = SMESH::FindSObject(aMesh);
1919 SMESH::ModifiedMesh(aMeshSO, false, aMesh->NbNodes()==0);
1922 Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
1923 ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
1924 QString objType = CheckTypeObject(IObject);
1925 if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
1926 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
1927 aStudyBuilder->RemoveObjectWithChildren( SO );
1929 else {// default action: remove SObject from the study
1930 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
1931 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
1933 aStudyBuilder->RemoveObjectWithChildren( SO );
1937 } /* listSO back loop */
1939 aStudyBuilder->CommitCommand();
1941 /* Clear any previous selection */
1943 aSel->setSelectedObjects( l1 );
1945 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1949 SMESHGUI_EXPORT CAM_Module* createModule()
1951 return new SMESHGUI();
1954 SMESHGUI_EXPORT char* getModuleVersion() {
1955 return (char*)SMESH_VERSION_STR;
1959 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
1961 //=============================================================================
1965 //=============================================================================
1966 SMESHGUI::SMESHGUI() :
1967 SalomeApp_Module( "SMESH" )
1969 if ( CORBA::is_nil( myComponentSMESH ) )
1971 CORBA::Boolean anIsEmbeddedMode;
1972 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
1973 //MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
1975 // 0019923: EDF 765 SMESH : default values of hypothesis
1976 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
1977 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
1978 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
1979 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
1980 myComponentSMESH->SetDefaultNbSegments( nbSeg );
1982 const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif", "default_grp_color" };
1983 for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
1984 if ( aResourceMgr->hasValue( "SMESH", options[i] ))
1986 QString val = aResourceMgr->stringValue( "SMESH", options[i] );
1987 myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
1991 myActiveDialogBox = 0;
1992 myFilterLibraryDlg = 0;
1996 myEventCallbackCommand = vtkCallbackCommand::New();
1997 myEventCallbackCommand->Delete();
1998 myEventCallbackCommand->SetClientData( this );
1999 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
2002 /* load resources for all available meshers */
2003 SMESH::InitAvailableHypotheses();
2006 //=============================================================================
2010 //=============================================================================
2011 SMESHGUI::~SMESHGUI()
2015 //=============================================================================
2019 //=============================================================================
2020 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
2022 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2024 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
2029 //=============================================================================
2033 //=============================================================================
2034 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
2036 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2040 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2041 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2042 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2043 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2044 return autoUpdate && !exceeded;
2047 //=============================================================================
2051 //=============================================================================
2052 bool SMESHGUI::automaticUpdate( SMESH::SMESH_IDSource_ptr theMesh,
2053 int* entities, bool* limitExceeded, int* hidden, long* nbElements )
2055 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2059 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2060 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2061 bool incrementalLimit = resMgr->booleanValue( "SMESH", "incremental_limit", false );
2063 SMESH::long_array_var info = theMesh->GetMeshInfo();
2064 long nbOdElems = info[SMDSEntity_0D];
2065 long nbEdges = info[SMDSEntity_Edge] + info[SMDSEntity_Quad_Edge];
2066 long nbFaces = info[SMDSEntity_Triangle] + info[SMDSEntity_Quad_Triangle] + info[SMDSEntity_BiQuad_Triangle] +
2067 info[SMDSEntity_Quadrangle] + info[SMDSEntity_Quad_Quadrangle] + info[SMDSEntity_BiQuad_Quadrangle] +
2068 info[SMDSEntity_Polygon] + info[SMDSEntity_Quad_Polygon];
2069 long nbVolumes = info[SMDSEntity_Tetra] + info[SMDSEntity_Quad_Tetra] +
2070 info[SMDSEntity_Hexa] + info[SMDSEntity_Quad_Hexa] + info[SMDSEntity_TriQuad_Hexa] +
2071 info[SMDSEntity_Pyramid] + info[SMDSEntity_Quad_Pyramid] +
2072 info[SMDSEntity_Penta] + info[SMDSEntity_Quad_Penta] +
2073 info[SMDSEntity_Polyhedra] +
2074 info[SMDSEntity_Hexagonal_Prism];
2075 long nbBalls = info[SMDSEntity_Ball];
2077 long requestedSize = nbOdElems + nbBalls + nbEdges + nbFaces + nbVolumes;
2078 *nbElements = requestedSize;
2080 *entities = SMESH_Actor::eAllEntity;
2083 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2085 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2087 if ( incrementalLimit ) {
2090 if ( nbOdElems > 0 ) {
2091 if ( total + nbOdElems > updateLimit ) {
2092 *entities = *entities & ~SMESH_Actor::e0DElements;
2093 *hidden = *hidden | SMESH_Actor::e0DElements;
2100 if ( nbEdges > 0 ) {
2101 if ( total + nbEdges > updateLimit ) {
2102 *entities = *entities & ~SMESH_Actor::eEdges;
2103 *hidden = *hidden | SMESH_Actor::eEdges;
2110 if ( nbFaces > 0 ) {
2111 if ( total + nbFaces > updateLimit ) {
2112 *entities = *entities & ~SMESH_Actor::eFaces;
2113 *hidden = *hidden | SMESH_Actor::eFaces;
2120 if ( nbVolumes > 0 ) {
2121 if ( total + nbVolumes > updateLimit ) {
2122 *entities = *entities & ~SMESH_Actor::eVolumes;
2123 *hidden = *hidden | SMESH_Actor::eVolumes;
2130 if ( nbBalls > 0 ) {
2131 if ( total + nbBalls > updateLimit ) {
2132 *entities = *entities & ~SMESH_Actor::eBallElem;
2133 *hidden = *hidden | SMESH_Actor::eBallElem;
2141 return autoUpdate && !exceeded;
2144 //=============================================================================
2148 //=============================================================================
2149 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
2151 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
2154 //=============================================================================
2158 //=============================================================================
2159 SMESHGUI* SMESHGUI::GetSMESHGUI()
2161 SMESHGUI* smeshMod = 0;
2162 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
2165 CAM_Module* module = app->module( "Mesh" );
2166 smeshMod = dynamic_cast<SMESHGUI*>( module );
2169 if ( smeshMod && smeshMod->application() && smeshMod->application()->activeStudy() )
2171 SalomeApp_Study* study = dynamic_cast<SalomeApp_Study*>( smeshMod->application()->activeStudy() );
2174 _PTR(Study) aStudy = study->studyDS();
2176 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
2185 Standard_EXPORT SMESHGUI* GetComponentGUI()
2187 return SMESHGUI::GetSMESHGUI();
2191 //=============================================================================
2195 //=============================================================================
2196 void SMESHGUI::SetState(int aState)
2201 //=============================================================================
2205 //=============================================================================
2206 void SMESHGUI::ResetState()
2211 //=============================================================================
2215 //=============================================================================
2216 void SMESHGUI::EmitSignalDeactivateDialog()
2218 emit SignalDeactivateActiveDialog();
2221 //=============================================================================
2225 //=============================================================================
2226 void SMESHGUI::EmitSignalStudyFrameChanged()
2228 emit SignalStudyFrameChanged();
2231 //=============================================================================
2235 //=============================================================================
2236 void SMESHGUI::EmitSignalCloseAllDialogs()
2238 emit SignalCloseAllDialogs();
2241 //=============================================================================
2245 //=============================================================================
2246 void SMESHGUI::EmitSignalVisibilityChanged()
2248 emit SignalVisibilityChanged();
2251 //=============================================================================
2255 //=============================================================================
2256 void SMESHGUI::EmitSignalCloseView()
2258 emit SignalCloseView();
2261 //=============================================================================
2265 //=============================================================================
2266 void SMESHGUI::EmitSignalActivatedViewManager()
2268 emit SignalActivatedViewManager();
2271 //=============================================================================
2275 //=============================================================================
2276 QDialog *SMESHGUI::GetActiveDialogBox()
2278 return myActiveDialogBox;
2281 //=============================================================================
2285 //=============================================================================
2286 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2288 myActiveDialogBox = (QDialog *) aDlg;
2292 //=============================================================================
2296 //=============================================================================
2297 SUIT_Desktop* SMESHGUI::desktop()
2299 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2301 return app->desktop();
2306 //=============================================================================
2310 //=============================================================================
2311 SalomeApp_Study* SMESHGUI::activeStudy()
2313 SUIT_Application* app = SUIT_Session::session()->activeApplication();
2315 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2320 //=============================================================================
2324 //=============================================================================
2325 void SMESHGUI::Modified( bool theIsUpdateActions )
2327 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2328 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2329 appStudy->Modified();
2330 if( theIsUpdateActions )
2331 app->updateActions();
2336 //=============================================================================
2340 //=============================================================================
2341 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2343 /* Here the position is on the bottom right corner - 10 */
2344 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2346 SUIT_Desktop *PP = desktop();
2347 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2348 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2352 //=============================================================================
2356 //=============================================================================
2357 static int isStudyLocked(_PTR(Study) theStudy){
2358 return theStudy->GetProperties()->IsLocked();
2361 static bool checkLock(_PTR(Study) theStudy) {
2362 if (isStudyLocked(theStudy)) {
2363 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2364 QObject::tr("WRN_WARNING"),
2365 QObject::tr("WRN_STUDY_LOCKED") );
2371 //=======================================================================
2372 //function : CheckActiveStudyLocked
2374 //=======================================================================
2376 bool SMESHGUI::isActiveStudyLocked()
2378 _PTR(Study) aStudy = activeStudy()->studyDS();
2379 return checkLock( aStudy );
2382 //=============================================================================
2386 //=============================================================================
2387 bool SMESHGUI::OnGUIEvent( int theCommandID )
2389 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2393 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
2394 SUIT_ResourceMgr* mgr = resourceMgr();
2398 if (CORBA::is_nil(GetSMESHGen()->GetCurrentStudy())) {
2399 GetSMESHGen()->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
2402 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2403 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2405 //QAction* act = action( theCommandID );
2407 switch (theCommandID) {
2408 case SMESHOp::OpDelete:
2409 if(checkLock(aStudy)) break;
2412 case SMESHOp::OpImportDAT:
2413 case SMESHOp::OpImportUNV:
2414 case SMESHOp::OpImportMED:
2415 case SMESHOp::OpImportSTL:
2417 case SMESHOp::OpImportCGNS:
2419 case SMESHOp::OpImportSAUV:
2420 case SMESHOp::OpImportGMF:
2422 if(checkLock(aStudy)) break;
2423 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2427 case SMESHOp::OpFileInformation:
2429 SALOME_ListIO selected;
2430 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2432 aSel->selectedObjects( selected );
2433 if( selected.Extent() )
2435 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2436 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2437 if ( !aMesh->_is_nil() )
2439 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2445 case SMESHOp::OpExportDAT:
2446 case SMESHOp::OpExportMED:
2447 case SMESHOp::OpExportUNV:
2448 case SMESHOp::OpExportSTL:
2450 case SMESHOp::OpExportCGNS:
2452 case SMESHOp::OpExportSAUV:
2453 case SMESHOp::OpExportGMF:
2454 case SMESHOp::OpPopupExportDAT:
2455 case SMESHOp::OpPopupExportMED:
2456 case SMESHOp::OpPopupExportUNV:
2457 case SMESHOp::OpPopupExportSTL:
2459 case SMESHOp::OpPopupExportCGNS:
2461 case SMESHOp::OpPopupExportSAUV:
2462 case SMESHOp::OpPopupExportGMF:
2464 ::ExportMeshToFile(theCommandID);
2468 case SMESHOp::OpReset: // SCALAR BAR
2470 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2471 SALOME_ListIO selected;
2473 aSel->selectedObjects( selected );
2475 SALOME_ListIteratorOfListIO it(selected);
2476 for( ; it.More(); it.Next()) {
2477 Handle(SALOME_InteractiveObject) anIO = it.Value();
2478 if( anIO->hasEntry() ) {
2479 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2480 anActor->SetControlMode( SMESH_Actor::eNone );
2481 #ifndef DISABLE_PLOT2DVIEWER
2482 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2487 SMESH::UpdateView();
2490 case SMESHOp::OpScalarBarProperties:
2492 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2495 case SMESHOp::OpShowScalarBar:
2497 // show/hide scalar bar
2498 ::ShowElement(theCommandID);
2501 case SMESHOp::OpSaveDistribution:
2503 // dump control distribution data to the text file
2504 ::SaveDistribution();
2508 case SMESHOp::OpShowDistribution:
2510 // show/hide distribution
2511 ::ShowElement(theCommandID);
2515 #ifndef DISABLE_PLOT2DVIEWER
2516 case SMESHOp::OpPlotDistribution:
2518 // plot distribution
2519 ::PlotDistribution();
2525 case SMESHOp::OpAutoColor:
2529 case SMESHOp::OpDisableAutoColor:
2530 ::DisableAutoColor();
2533 case SMESHOp::OpClipping:
2534 case SMESHOp::OpTransparency:
2535 case SMESHOp::OpProperties: // Display preferences (colors, shrink size, line width, ...)
2538 case SMESHOp::OpDMWireframe:
2539 case SMESHOp::OpDMShading:
2540 case SMESHOp::OpDMNodes:
2541 case SMESHOp::OpDMShrink:
2542 ::SetDisplayMode(theCommandID, myMarkerMap);
2545 //2D quadratic representation
2546 case SMESHOp::OpRepresentationLines:
2547 case SMESHOp::OpRepresentationArcs:
2548 ::SetDisplayMode(theCommandID, myMarkerMap);
2552 case SMESHOp::OpDE0DElements:
2553 case SMESHOp::OpDEEdges:
2554 case SMESHOp::OpDEFaces:
2555 case SMESHOp::OpDEVolumes:
2556 case SMESHOp::OpDEBalls:
2557 case SMESHOp::OpDEAllEntity:
2558 ::SetDisplayEntity(theCommandID);
2561 // Choose entities to be displayed
2562 case SMESHOp::OpDEChoose:
2564 ( new SMESHGUI_DisplayEntitiesDlg( SMESHGUI::desktop() ) )->exec();
2568 case SMESHOp::OpOrientationOnFaces:
2570 LightApp_SelectionMgr* mgr = selectionMgr();
2571 SALOME_ListIO selected; mgr->selectedObjects( selected );
2573 SALOME_ListIteratorOfListIO it(selected);
2574 for( ; it.More(); it.Next()) {
2575 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2576 if(anIObject->hasEntry()) {
2577 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2578 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2585 case SMESHOp::OpUpdate:
2587 if(checkLock(aStudy)) break;
2588 SUIT_OverrideCursor wc;
2590 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2593 SMESH::UpdateView();
2595 catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2596 SMESH::OnVisuException();
2598 catch (...) { // PAL16774 (Crash after display of many groups)
2599 SMESH::OnVisuException();
2603 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2604 aSel->selectedObjects( l );
2605 aSel->setSelectedObjects( l );
2609 case SMESHOp::OpHide:
2610 case SMESHOp::OpShow:
2611 case SMESHOp::OpShowOnly:
2613 SUIT_OverrideCursor wc;
2614 SMESH::EDisplaing anAction;
2615 switch (theCommandID) {
2616 case SMESHOp::OpHide: anAction = SMESH::eErase; break;
2617 case SMESHOp::OpShow: anAction = SMESH::eDisplay; break;
2618 case SMESHOp::OpShowOnly: anAction = SMESH::eDisplayOnly; break;
2621 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2622 SALOME_ListIO sel_objects, to_process;
2624 aSel->selectedObjects( sel_objects );
2626 if ( theCommandID==SMESHOp::OpShowOnly )
2628 //MESSAGE("anAction = SMESH::eDisplayOnly");
2629 startOperation( myEraseAll );
2632 extractContainers( sel_objects, to_process );
2635 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2639 SALOME_ListIteratorOfListIO It( to_process );
2640 for ( ; It.More(); It.Next())
2642 Handle(SALOME_InteractiveObject) IOS = It.Value();
2643 if ( IOS->hasEntry() )
2645 if ( !SMESH::UpdateView( anAction, IOS->getEntry() )) {
2646 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2647 break; // PAL16774 (Crash after display of many groups)
2649 if (anAction == SMESH::eDisplayOnly)
2650 anAction = SMESH::eDisplay;
2655 // PAL13338 + PAL15161 -->
2656 if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !checkLock(aStudy)) {
2657 SMESH::UpdateView();
2658 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2660 // PAL13338 + PAL15161 <--
2662 catch (...) { // PAL16774 (Crash after display of many groups)
2663 SMESH::OnVisuException();
2666 if (anAction == SMESH::eErase) {
2668 aSel->setSelectedObjects( l1 );
2671 aSel->setSelectedObjects( to_process );
2676 case SMESHOp::OpNode:
2678 if(checkLock(aStudy)) break;
2681 EmitSignalDeactivateDialog();
2683 ( new SMESHGUI_NodesDlg( this ) )->show();
2686 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"),tr("SMESH_WRN_VIEWER_VTK"));
2691 case SMESHOp::OpCreateMesh:
2692 case SMESHOp::OpCreateSubMesh:
2693 case SMESHOp::OpEditMeshOrSubMesh:
2694 case SMESHOp::OpEditMesh:
2695 case SMESHOp::OpEditSubMesh:
2696 case SMESHOp::OpCompute:
2697 case SMESHOp::OpComputeSubMesh:
2698 case SMESHOp::OpPreCompute:
2699 case SMESHOp::OpEvaluate:
2700 case SMESHOp::OpMeshOrder:
2701 startOperation( theCommandID );
2703 case SMESHOp::OpCopyMesh:
2705 if (checkLock(aStudy)) break;
2706 EmitSignalDeactivateDialog();
2707 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2710 case SMESHOp::OpBuildCompoundMesh:
2712 if (checkLock(aStudy)) break;
2713 EmitSignalDeactivateDialog();
2714 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2718 case SMESHOp::OpDiagonalInversion:
2719 case SMESHOp::OpUnionOfTwoTriangle:
2723 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2727 if ( checkLock( aStudy ) )
2730 /*Standard_Boolean aRes;
2731 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2732 if ( aMesh->_is_nil() )
2734 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2735 tr( "SMESH_BAD_SELECTION" ) );
2739 EmitSignalDeactivateDialog();
2740 if ( theCommandID == SMESHOp::OpDiagonalInversion )
2741 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2743 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2746 case SMESHOp::OpOrientation:
2747 case SMESHOp::OpUnionOfTriangles:
2748 case SMESHOp::OpCuttingOfQuadrangles:
2749 case SMESHOp::OpSplitVolumes:
2753 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2757 if ( checkLock( aStudy ) )
2760 EmitSignalDeactivateDialog();
2761 SMESHGUI_MultiEditDlg* aDlg = NULL;
2762 if ( theCommandID == SMESHOp::OpOrientation )
2763 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2764 else if ( theCommandID == SMESHOp::OpUnionOfTriangles )
2765 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2766 else if ( theCommandID == SMESHOp::OpSplitVolumes )
2767 aDlg = new SMESHGUI_SplitVolumesDlg(this);
2769 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2774 case SMESHOp::OpSmoothing:
2776 if(checkLock(aStudy)) break;
2778 EmitSignalDeactivateDialog();
2779 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2782 SUIT_MessageBox::warning(desktop(), tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2786 case SMESHOp::OpExtrusion:
2788 if (checkLock(aStudy)) break;
2790 EmitSignalDeactivateDialog();
2791 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2793 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2797 case SMESHOp::OpExtrusionAlongAPath:
2799 if (checkLock(aStudy)) break;
2801 EmitSignalDeactivateDialog();
2802 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2804 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2808 case SMESHOp::OpRevolution:
2810 if(checkLock(aStudy)) break;
2812 EmitSignalDeactivateDialog();
2813 ( new SMESHGUI_RevolutionDlg( this ) )->show();
2816 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2820 case SMESHOp::OpPatternMapping:
2822 if ( checkLock( aStudy ) )
2826 EmitSignalDeactivateDialog();
2827 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2830 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2834 case SMESHOp::OpSplitBiQuadratic:
2835 case SMESHOp::OpConvertMeshToQuadratic:
2836 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
2837 case SMESHOp::OpReorientFaces:
2838 case SMESHOp::OpCreateGeometryGroup:
2840 startOperation( theCommandID );
2843 case SMESHOp::OpCreateGroup:
2847 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2851 if(checkLock(aStudy)) break;
2852 EmitSignalDeactivateDialog();
2853 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2855 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2856 SALOME_ListIO selected;
2858 aSel->selectedObjects( selected );
2860 int nbSel = selected.Extent();
2862 // check if mesh is selected
2863 aMesh = SMESH::GetMeshByIO( selected.First() );
2865 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2870 case SMESHOp::OpConstructGroup:
2874 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2878 if(checkLock(aStudy)) break;
2879 EmitSignalDeactivateDialog();
2881 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2882 SALOME_ListIO selected;
2884 aSel->selectedObjects( selected );
2886 int nbSel = selected.Extent();
2888 // check if submesh is selected
2889 Handle(SALOME_InteractiveObject) IObject = selected.First();
2890 if (IObject->hasEntry()) {
2891 _PTR(SObject) aSObj = aStudy->FindObjectID(IObject->getEntry());
2893 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2894 if (!aSubMesh->_is_nil()) {
2896 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2897 // get submesh elements list by types
2898 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2899 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2900 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2901 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2902 // create group for each type o elements
2903 QString aName = IObject->getName();
2904 QStringList anEntryList;
2905 if (aNodes->length() > 0) {
2906 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2907 aGroup->Add(aNodes.inout());
2908 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2909 anEntryList.append( aSObject->GetID().c_str() );
2911 if (aEdges->length() > 0) {
2912 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2913 aGroup->Add(aEdges.inout());
2914 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2915 anEntryList.append( aSObject->GetID().c_str() );
2917 if (aFaces->length() > 0) {
2918 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2919 aGroup->Add(aFaces.inout());
2920 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2921 anEntryList.append( aSObject->GetID().c_str() );
2923 if (aVolumes->length() > 0) {
2924 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2925 aGroup->Add(aVolumes.inout());
2926 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2927 anEntryList.append( aSObject->GetID().c_str() );
2930 anApp->browseObjects( anEntryList );
2932 catch(const SALOME::SALOME_Exception & S_ex){
2933 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2940 SUIT_MessageBox::warning(desktop(),
2941 tr("SMESH_WRN_WARNING"),
2942 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
2947 case SMESHOp::OpEditGroup:
2951 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2955 if(checkLock(aStudy)) break;
2956 EmitSignalDeactivateDialog();
2958 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2959 SALOME_ListIO selected;
2961 aSel->selectedObjects( selected );
2963 SALOME_ListIteratorOfListIO It (selected);
2964 int nbSelectedGroups = 0;
2965 for ( ; It.More(); It.Next() )
2967 SMESH::SMESH_GroupBase_var aGroup =
2968 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
2969 if (!aGroup->_is_nil()) {
2971 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
2975 if (nbSelectedGroups == 0)
2977 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
2983 case SMESHOp::OpAddElemGroupPopup: // Add elements to group
2985 if(checkLock(aStudy)) break;
2986 if (myState == 800) {
2987 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2988 if (aDlg) aDlg->onAdd();
2993 case SMESHOp::OpRemoveElemGroupPopup: // Remove elements from group
2995 if(checkLock(aStudy)) break;
2996 if (myState == 800) {
2997 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2998 if (aDlg) aDlg->onRemove();
3003 case SMESHOp::OpEditGeomGroupAsGroup:
3007 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3011 if(checkLock(aStudy)) break;
3012 EmitSignalDeactivateDialog();
3014 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3015 SALOME_ListIO selected;
3017 aSel->selectedObjects( selected );
3019 SALOME_ListIteratorOfListIO It (selected);
3020 for ( ; It.More(); It.Next() )
3022 SMESH::SMESH_GroupOnGeom_var aGroup =
3023 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
3024 if (!aGroup->_is_nil()) {
3025 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3030 SMESH::SMESH_GroupOnFilter_var aGroup =
3031 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
3032 if (!aGroup->_is_nil()) {
3033 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3041 case SMESHOp::OpUnionGroups:
3042 case SMESHOp::OpIntersectGroups:
3043 case SMESHOp::OpCutGroups:
3047 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3051 if ( checkLock( aStudy ) )
3054 EmitSignalDeactivateDialog();
3056 SMESHGUI_GroupOpDlg* aDlg = 0;
3057 if ( theCommandID == SMESHOp::OpUnionGroups )
3058 aDlg = new SMESHGUI_UnionGroupsDlg( this );
3059 else if ( theCommandID == SMESHOp::OpIntersectGroups )
3060 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3062 aDlg = new SMESHGUI_CutGroupsDlg( this );
3069 case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
3071 if ( checkLock( aStudy ) )
3074 EmitSignalDeactivateDialog();
3075 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3081 case SMESHOp::OpDeleteGroup: // Delete groups with their contents
3085 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3089 if ( checkLock( aStudy ) )
3092 EmitSignalDeactivateDialog();
3094 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3098 case SMESHOp::OpMeshInformation:
3099 case SMESHOp::OpWhatIs:
3101 int page = theCommandID == SMESHOp::OpMeshInformation ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3102 EmitSignalDeactivateDialog();
3103 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3104 SALOME_ListIO selected;
3106 aSel->selectedObjects( selected );
3108 if ( selected.Extent() > 1 ) { // a dlg for each IO
3109 SALOME_ListIteratorOfListIO It( selected );
3110 for ( ; It.More(); It.Next() ) {
3111 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3112 dlg->showInfo( It.Value() );
3117 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3123 case SMESHOp::OpFindElementByPoint:
3125 startOperation( theCommandID );
3129 case SMESHOp::OpEditHypothesis:
3131 if(checkLock(aStudy)) break;
3133 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3134 SALOME_ListIO selected;
3136 aSel->selectedObjects( selected );
3138 int nbSel = selected.Extent();
3141 Handle(SALOME_InteractiveObject) anIObject = selected.First();
3142 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3144 if ( !aHypothesis->_is_nil() )
3146 SMESHGUI_GenericHypothesisCreator* aCreator =
3147 SMESH::GetHypothesisCreator( SMESH::toQStr( aHypothesis->GetName() ));
3150 // set geometry of mesh and sub-mesh to aCreator
3151 aSel->selectedObjects( selected, "", /*convertReferences=*/false);
3152 if ( selected.Extent() == 1 )
3154 QString subGeomID, meshGeomID;
3155 Handle(SALOME_InteractiveObject) hypIO = selected.First();
3156 if ( SMESH::GetGeomEntries( hypIO, subGeomID, meshGeomID ))
3158 if ( subGeomID.isEmpty() ) subGeomID = meshGeomID;
3159 aCreator->setShapeEntry( subGeomID );
3160 aCreator->setMainShapeEntry( meshGeomID );
3164 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3174 case SMESHOp::OpUnassign: // REMOVE HYPOTHESIS / ALGORITHMS
3176 if(checkLock(aStudy)) break;
3177 SUIT_OverrideCursor wc;
3179 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3180 SALOME_ListIO selected;
3182 aSel->selectedObjects( selected, QString::null, false );
3184 SALOME_ListIteratorOfListIO It(selected);
3185 for (int i = 0; It.More(); It.Next(), i++) {
3186 Handle(SALOME_InteractiveObject) IObject = It.Value();
3187 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3190 aSel->setSelectedObjects( l1 );
3195 case SMESHOp::OpElem0D:
3196 case SMESHOp::OpBall:
3197 case SMESHOp::OpEdge:
3198 case SMESHOp::OpTriangle:
3199 case SMESHOp::OpQuadrangle:
3200 case SMESHOp::OpPolygon:
3201 case SMESHOp::OpTetrahedron:
3202 case SMESHOp::OpHexahedron:
3203 case SMESHOp::OpPentahedron:
3204 case SMESHOp::OpPyramid:
3205 case SMESHOp::OpHexagonalPrism:
3207 if(checkLock(aStudy)) break;
3209 EmitSignalDeactivateDialog();
3210 SMDSAbs_EntityType type = SMDSEntity_Edge;
3211 switch (theCommandID) {
3212 case SMESHOp::OpElem0D: type = SMDSEntity_0D; break;
3213 case SMESHOp::OpBall: type = SMDSEntity_Ball; break;
3214 case SMESHOp::OpTriangle: type = SMDSEntity_Triangle; break;
3215 case SMESHOp::OpQuadrangle: type = SMDSEntity_Quadrangle; break;
3216 case SMESHOp::OpTetrahedron: type = SMDSEntity_Tetra; break;
3217 case SMESHOp::OpPolygon: type = SMDSEntity_Polygon; break;
3218 case SMESHOp::OpHexahedron: type = SMDSEntity_Hexa; break;
3219 case SMESHOp::OpPentahedron: type = SMDSEntity_Penta; break;
3220 case SMESHOp::OpPyramid: type = SMDSEntity_Pyramid; break;
3221 case SMESHOp::OpHexagonalPrism: type = SMDSEntity_Hexagonal_Prism; break;
3224 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3227 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3231 case SMESHOp::OpPolyhedron:
3233 if(checkLock(aStudy)) break;
3235 EmitSignalDeactivateDialog();
3236 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3239 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3243 case SMESHOp::OpQuadraticEdge:
3244 case SMESHOp::OpQuadraticTriangle:
3245 case SMESHOp::OpBiQuadraticTriangle:
3246 case SMESHOp::OpQuadraticQuadrangle:
3247 case SMESHOp::OpBiQuadraticQuadrangle:
3248 case SMESHOp::OpQuadraticPolygon:
3249 case SMESHOp::OpQuadraticTetrahedron:
3250 case SMESHOp::OpQuadraticPyramid:
3251 case SMESHOp::OpQuadraticPentahedron:
3252 case SMESHOp::OpQuadraticHexahedron:
3253 case SMESHOp::OpTriQuadraticHexahedron:
3255 if(checkLock(aStudy)) break;
3257 EmitSignalDeactivateDialog();
3258 SMDSAbs_EntityType type = SMDSEntity_Last;
3260 switch (theCommandID) {
3261 case SMESHOp::OpQuadraticEdge: type = SMDSEntity_Quad_Edge; break;
3262 case SMESHOp::OpQuadraticTriangle: type = SMDSEntity_Quad_Triangle; break;
3263 case SMESHOp::OpBiQuadraticTriangle: type = SMDSEntity_BiQuad_Triangle; break;
3264 case SMESHOp::OpQuadraticQuadrangle: type = SMDSEntity_Quad_Quadrangle; break;
3265 case SMESHOp::OpBiQuadraticQuadrangle: type = SMDSEntity_BiQuad_Quadrangle; break;
3266 case SMESHOp::OpQuadraticPolygon: type = SMDSEntity_Quad_Polygon; break;
3267 case SMESHOp::OpQuadraticTetrahedron: type = SMDSEntity_Quad_Tetra; break;
3268 case SMESHOp::OpQuadraticPyramid: type = SMDSEntity_Quad_Pyramid; break;
3269 case SMESHOp::OpQuadraticPentahedron: type = SMDSEntity_Quad_Penta; break;
3270 case SMESHOp::OpQuadraticHexahedron: type = SMDSEntity_Quad_Hexa; break;
3271 case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
3274 if ( type != SMDSEntity_Last )
3275 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3278 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3279 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3283 case SMESHOp::OpRemoveNodes:
3285 if(checkLock(aStudy)) break;
3287 EmitSignalDeactivateDialog();
3288 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3291 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3292 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3296 case SMESHOp::OpRemoveElements: // REMOVES ELEMENTS
3298 if(checkLock(aStudy)) break;
3300 EmitSignalDeactivateDialog();
3301 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3305 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3306 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3310 case SMESHOp::OpClearMesh: {
3312 if(checkLock(aStudy)) break;
3314 SALOME_ListIO selected;
3315 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3316 aSel->selectedObjects( selected );
3318 SUIT_OverrideCursor wc;
3319 SALOME_ListIteratorOfListIO It (selected);
3320 for ( ; It.More(); It.Next() )
3322 Handle(SALOME_InteractiveObject) IOS = It.Value();
3323 SMESH::SMESH_Mesh_var aMesh =
3324 SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3325 if ( aMesh->_is_nil()) continue;
3327 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3329 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3330 SMESH::ModifiedMesh( aMeshSObj, false, true);
3331 // hide groups and submeshes
3332 _PTR(ChildIterator) anIter =
3333 SMESH::GetActiveStudyDocument()->NewChildIterator( aMeshSObj );
3334 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3336 _PTR(SObject) so = anIter->Value();
3337 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3340 catch (const SALOME::SALOME_Exception& S_ex){
3342 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3346 SMESH::UpdateView();
3350 case SMESHOp::OpRemoveOrphanNodes:
3352 if(checkLock(aStudy)) break;
3353 SALOME_ListIO selected;
3354 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3355 aSel->selectedObjects( selected );
3356 if ( selected.Extent() == 1 ) {
3357 Handle(SALOME_InteractiveObject) anIO = selected.First();
3358 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3359 if ( !aMesh->_is_nil() ) {
3360 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3361 tr( "SMESH_WARNING" ),
3362 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3363 SUIT_MessageBox::Yes |
3364 SUIT_MessageBox::No,
3365 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3368 SUIT_OverrideCursor wc;
3369 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3370 int removed = aMeshEditor->RemoveOrphanNodes();
3371 SUIT_MessageBox::information(SMESHGUI::desktop(),
3372 tr("SMESH_INFORMATION"),
3373 tr("NB_NODES_REMOVED").arg(removed));
3374 if ( removed > 0 ) {
3375 SMESH::UpdateView();
3376 SMESHGUI::Modified();
3379 catch (const SALOME::SALOME_Exception& S_ex) {
3380 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3389 case SMESHOp::OpRenumberingNodes:
3391 if(checkLock(aStudy)) break;
3393 EmitSignalDeactivateDialog();
3394 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3398 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3399 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3403 case SMESHOp::OpRenumberingElements:
3405 if(checkLock(aStudy)) break;
3407 EmitSignalDeactivateDialog();
3408 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3412 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3413 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3417 case SMESHOp::OpTranslation:
3419 if(checkLock(aStudy)) break;
3421 EmitSignalDeactivateDialog();
3422 ( new SMESHGUI_TranslationDlg( this ) )->show();
3425 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3426 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3430 case SMESHOp::OpRotation:
3432 if(checkLock(aStudy)) break;
3434 EmitSignalDeactivateDialog();
3435 ( new SMESHGUI_RotationDlg( this ) )->show();
3438 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3439 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3443 case SMESHOp::OpSymmetry:
3445 if(checkLock(aStudy)) break;
3447 EmitSignalDeactivateDialog();
3448 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3451 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3452 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3456 case SMESHOp::OpScale:
3458 if(checkLock(aStudy)) break;
3460 EmitSignalDeactivateDialog();
3461 ( new SMESHGUI_ScaleDlg( this ) )->show();
3464 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3465 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3470 case SMESHOp::OpSewing:
3472 if(checkLock(aStudy)) break;
3474 EmitSignalDeactivateDialog();
3475 ( new SMESHGUI_SewingDlg( this ) )->show();
3478 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3479 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3483 case SMESHOp::OpMergeNodes:
3485 if(checkLock(aStudy)) break;
3487 EmitSignalDeactivateDialog();
3488 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3491 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3492 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3496 case SMESHOp::OpMergeElements:
3498 if (checkLock(aStudy)) break;
3500 EmitSignalDeactivateDialog();
3501 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3503 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3504 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3509 case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
3510 startOperation( SMESHOp::OpMoveNode );
3513 case SMESHOp::OpDuplicateNodes:
3515 if(checkLock(aStudy)) break;
3517 EmitSignalDeactivateDialog();
3518 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3521 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3522 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3527 case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
3528 startOperation( SMESHOp::OpElem0DOnElemNodes );
3531 case SMESHOp::OpSelectFiltersLibrary: // Library of selection filters
3533 static QList<int> aTypes;
3534 if ( aTypes.isEmpty() )
3536 aTypes.append( SMESH::NODE );
3537 aTypes.append( SMESH::EDGE );
3538 aTypes.append( SMESH::FACE );
3539 aTypes.append( SMESH::VOLUME );
3541 if (!myFilterLibraryDlg)
3542 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3543 else if (myFilterLibraryDlg->isHidden())
3544 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3545 myFilterLibraryDlg->raise();
3549 case SMESHOp::OpFreeNode:
3550 case SMESHOp::OpEqualNode:
3551 case SMESHOp::OpFreeEdge:
3552 case SMESHOp::OpFreeBorder:
3553 case SMESHOp::OpLength:
3554 case SMESHOp::OpConnection:
3555 case SMESHOp::OpEqualEdge:
3556 case SMESHOp::OpFreeFace:
3557 case SMESHOp::OpBareBorderFace:
3558 case SMESHOp::OpOverConstrainedFace:
3559 case SMESHOp::OpLength2D:
3560 case SMESHOp::OpConnection2D:
3561 case SMESHOp::OpArea:
3562 case SMESHOp::OpTaper:
3563 case SMESHOp::OpAspectRatio:
3564 case SMESHOp::OpMinimumAngle:
3565 case SMESHOp::OpWarpingAngle:
3566 case SMESHOp::OpSkew:
3567 case SMESHOp::OpMaxElementLength2D:
3568 case SMESHOp::OpEqualFace:
3569 case SMESHOp::OpAspectRatio3D:
3570 case SMESHOp::OpVolume:
3571 case SMESHOp::OpMaxElementLength3D:
3572 case SMESHOp::OpBareBorderVolume:
3573 case SMESHOp::OpOverConstrainedVolume:
3574 case SMESHOp::OpEqualVolume:
3577 LightApp_SelectionMgr* mgr = selectionMgr();
3578 SALOME_ListIO selected; mgr->selectedObjects( selected );
3580 if( !selected.IsEmpty() ) {
3581 SUIT_OverrideCursor wc;
3582 ::Control( theCommandID );
3585 SUIT_MessageBox::warning(desktop(),
3586 tr( "SMESH_WRN_WARNING" ),
3587 tr( "SMESH_BAD_SELECTION" ) );
3591 SUIT_MessageBox::warning(desktop(),
3592 tr( "SMESH_WRN_WARNING" ),
3593 tr( "NOT_A_VTK_VIEWER" ) );
3596 case SMESHOp::OpOverallMeshQuality:
3597 OverallMeshQuality();
3599 case SMESHOp::OpNumberingNodes:
3601 SUIT_OverrideCursor wc;
3602 LightApp_SelectionMgr* mgr = selectionMgr();
3603 SALOME_ListIO selected; mgr->selectedObjects( selected );
3605 SALOME_ListIteratorOfListIO it(selected);
3606 for( ; it.More(); it.Next()) {
3607 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3608 if(anIObject->hasEntry()) {
3609 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3610 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3616 case SMESHOp::OpNumberingElements:
3618 SUIT_OverrideCursor wc;
3619 LightApp_SelectionMgr* mgr = selectionMgr();
3620 SALOME_ListIO selected; mgr->selectedObjects( selected );
3622 SALOME_ListIteratorOfListIO it(selected);
3623 for( ; it.More(); it.Next()) {
3624 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3625 if(anIObject->hasEntry())
3626 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3627 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3632 case SMESHOp::OpPropertiesLength:
3633 case SMESHOp::OpPropertiesArea:
3634 case SMESHOp::OpPropertiesVolume:
3635 case SMESHOp::OpMinimumDistance:
3636 case SMESHOp::OpBoundingBox:
3638 int page = SMESHGUI_MeasureDlg::MinDistance;
3639 if ( theCommandID == SMESHOp::OpBoundingBox )
3640 page = SMESHGUI_MeasureDlg::BoundingBox;
3641 else if ( theCommandID == SMESHOp::OpPropertiesLength )
3642 page = SMESHGUI_MeasureDlg::Length;
3643 else if ( theCommandID == SMESHOp::OpPropertiesArea )
3644 page = SMESHGUI_MeasureDlg::Area;
3645 else if ( theCommandID == SMESHOp::OpPropertiesVolume )
3646 page = SMESHGUI_MeasureDlg::Volume;
3648 EmitSignalDeactivateDialog();
3649 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3653 case SMESHOp::OpSortChild:
3659 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3660 //updateObjBrowser();
3664 //=============================================================================
3668 //=============================================================================
3669 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3674 //=============================================================================
3678 //=============================================================================
3679 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3684 //=============================================================================
3688 //=============================================================================
3689 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3694 //=============================================================================
3695 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3696 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3698 //=============================================================================
3699 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3700 SUIT_ViewWindow* wnd )
3702 if(theIO->hasEntry()){
3703 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3704 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3708 //=======================================================================
3709 // function : createSMESHAction
3711 //=======================================================================
3712 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3713 const int key, const bool toggle, const QString& shortcutAction )
3716 QWidget* parent = application()->desktop();
3717 SUIT_ResourceMgr* resMgr = resourceMgr();
3719 if ( !icon_id.isEmpty() )
3720 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3722 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3723 if ( !pix.isNull() )
3724 icon = QIcon( pix );
3726 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3727 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3728 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3730 createAction( id, tooltip, icon, menu, status_bar, key, parent,
3731 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3734 //=======================================================================
3735 // function : createPopupItem
3737 //=======================================================================
3738 void SMESHGUI::createPopupItem( const int id,
3739 const QString& clients,
3740 const QString& types,
3741 const QString& theRule,
3744 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3745 popupMgr()->insert( action( id ), pId, 0 );
3747 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3748 QString dc = "selcount"; // VSR : insetad of QtxPopupSelection::defSelCountParam()
3749 QString rule = "(%1) and (%2) and (%3)";
3750 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3751 if( clients.isEmpty() )
3752 rule = rule.arg( QString( "true" ) );
3754 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3755 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3758 bool cont = myRules.contains( id );
3760 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3762 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3763 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3766 //=======================================================================
3767 // function : initialize
3769 //=======================================================================
3770 void SMESHGUI::initialize( CAM_Application* app )
3772 SalomeApp_Module::initialize( app );
3774 // SUIT_ResourceMgr* mgr = app->resourceMgr();
3776 /* Automatic Update flag */
3777 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3779 // ----- create actions --------------
3781 //createSMESHAction( SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
3782 createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_I) );
3783 createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
3784 //createSMESHAction( 114, "NUM" );
3785 createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL" );
3787 createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
3789 createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
3790 createSMESHAction( SMESHOp::OpImportGMF, "IMPORT_GMF" );
3791 createSMESHAction( SMESHOp::OpExportDAT, "DAT" );
3792 createSMESHAction( SMESHOp::OpExportMED, "MED" );
3793 createSMESHAction( SMESHOp::OpExportUNV, "UNV" );
3794 createSMESHAction( SMESHOp::OpExportSTL, "STL" );
3796 createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
3798 createSMESHAction( SMESHOp::OpExportSAUV, "SAUV");
3799 createSMESHAction( SMESHOp::OpExportGMF, "GMF" );
3800 createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
3801 createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
3802 createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
3803 createSMESHAction( SMESHOp::OpPopupExportSTL, "STL" );
3805 createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
3807 createSMESHAction( SMESHOp::OpPopupExportSAUV, "SAUV");
3808 createSMESHAction( SMESHOp::OpPopupExportGMF, "GMF" );
3809 createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
3810 createSMESHAction( SMESHOp::OpDelete, "DELETE", "ICON_DELETE", Qt::Key_Delete );
3811 createSMESHAction( SMESHOp::OpSelectFiltersLibrary, "SEL_FILTER_LIB" );
3812 createSMESHAction( SMESHOp::OpCreateMesh, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
3813 createSMESHAction( SMESHOp::OpCreateSubMesh, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
3814 createSMESHAction( SMESHOp::OpEditMeshOrSubMesh, "EDIT_MESHSUBMESH", "ICON_DLG_EDIT_MESH" );
3815 createSMESHAction( SMESHOp::OpEditMesh, "EDIT_MESH", "ICON_DLG_EDIT_MESH" );
3816 createSMESHAction( SMESHOp::OpEditSubMesh, "EDIT_SUBMESH", "ICON_DLG_EDIT_MESH" );
3817 createSMESHAction( SMESHOp::OpBuildCompoundMesh, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
3818 createSMESHAction( SMESHOp::OpCopyMesh, "COPY_MESH", "ICON_COPY_MESH" );
3819 createSMESHAction( SMESHOp::OpCompute, "COMPUTE", "ICON_COMPUTE" );
3820 createSMESHAction( SMESHOp::OpComputeSubMesh, "COMPUTE_SUBMESH", "ICON_COMPUTE" );
3821 createSMESHAction( SMESHOp::OpPreCompute, "PRECOMPUTE", "ICON_PRECOMPUTE" );
3822 createSMESHAction( SMESHOp::OpEvaluate, "EVALUATE", "ICON_EVALUATE" );
3823 createSMESHAction( SMESHOp::OpMeshOrder, "MESH_ORDER", "ICON_MESH_ORDER");
3824 createSMESHAction( SMESHOp::OpCreateGroup, "CREATE_GROUP", "ICON_CREATE_GROUP" );
3825 createSMESHAction( SMESHOp::OpCreateGeometryGroup, "CREATE_GEO_GROUP", "ICON_CREATE_GEO_GROUP" );
3826 createSMESHAction( SMESHOp::OpConstructGroup, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
3827 createSMESHAction( SMESHOp::OpEditGroup, "EDIT_GROUP", "ICON_EDIT_GROUP" );
3828 createSMESHAction( SMESHOp::OpEditGeomGroupAsGroup, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3829 createSMESHAction( SMESHOp::OpUnionGroups, "UN_GROUP", "ICON_UNION" );
3830 createSMESHAction( SMESHOp::OpIntersectGroups, "INT_GROUP", "ICON_INTERSECT" );
3831 createSMESHAction( SMESHOp::OpCutGroups, "CUT_GROUP", "ICON_CUT" );
3832 createSMESHAction( SMESHOp::OpGroupUnderlyingElem, "UNDERLYING_ELEMS", "ICON_UNDERLYING_ELEMS" );
3833 createSMESHAction( SMESHOp::OpAddElemGroupPopup, "ADD" );
3834 createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE" );
3835 createSMESHAction( SMESHOp::OpDeleteGroup, "DEL_GROUP", "ICON_DEL_GROUP" );
3836 createSMESHAction( SMESHOp::OpMeshInformation , "ADV_INFO", "ICON_ADV_INFO" );
3837 //createSMESHAction( SMESHOp::OpStdInfo, "STD_INFO", "ICON_STD_INFO" );
3838 //createSMESHAction( SMESHOp::OpWhatIs, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3839 createSMESHAction( SMESHOp::OpFindElementByPoint, "FIND_ELEM", "ICON_FIND_ELEM" );
3841 createSMESHAction( SMESHOp::OpFreeNode, "FREE_NODE", "ICON_FREE_NODE", 0, true );
3842 createSMESHAction( SMESHOp::OpEqualNode, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
3843 createSMESHAction( SMESHOp::OpFreeEdge, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
3844 createSMESHAction( SMESHOp::OpFreeBorder, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
3845 createSMESHAction( SMESHOp::OpLength, "LENGTH", "ICON_LENGTH", 0, true );
3846 createSMESHAction( SMESHOp::OpConnection, "CONNECTION", "ICON_CONNECTION", 0, true );
3847 createSMESHAction( SMESHOp::OpEqualEdge, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
3848 createSMESHAction( SMESHOp::OpFreeFace, "FREE_FACES", "ICON_FREE_FACES", 0, true );
3849 createSMESHAction( SMESHOp::OpBareBorderFace, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
3850 createSMESHAction( SMESHOp::OpOverConstrainedFace, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
3851 createSMESHAction( SMESHOp::OpLength2D, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
3852 createSMESHAction( SMESHOp::OpConnection2D, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
3853 createSMESHAction( SMESHOp::OpArea, "AREA", "ICON_AREA", 0, true );
3854 createSMESHAction( SMESHOp::OpTaper, "TAPER", "ICON_TAPER", 0, true );
3855 createSMESHAction( SMESHOp::OpAspectRatio, "ASPECT", "ICON_ASPECT", 0, true );
3856 createSMESHAction( SMESHOp::OpMinimumAngle, "MIN_ANG", "ICON_ANGLE", 0, true );
3857 createSMESHAction( SMESHOp::OpWarpingAngle, "WARP", "ICON_WARP", 0, true );
3858 createSMESHAction( SMESHOp::OpSkew, "SKEW", "ICON_SKEW", 0, true );
3859 createSMESHAction( SMESHOp::OpMaxElementLength2D, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
3860 createSMESHAction( SMESHOp::OpEqualFace, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
3861 createSMESHAction( SMESHOp::OpAspectRatio3D, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
3862 createSMESHAction( SMESHOp::OpVolume, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
3863 createSMESHAction( SMESHOp::OpMaxElementLength3D, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
3864 createSMESHAction( SMESHOp::OpBareBorderVolume, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
3865 createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
3866 createSMESHAction( SMESHOp::OpEqualVolume, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
3867 createSMESHAction( SMESHOp::OpOverallMeshQuality, "OVERALL_MESH_QUALITY" );
3869 createSMESHAction( SMESHOp::OpNode, "NODE", "ICON_DLG_NODE" );
3870 createSMESHAction( SMESHOp::OpElem0D, "ELEM0D", "ICON_DLG_ELEM0D" );
3871 createSMESHAction( SMESHOp::OpElem0DOnElemNodes, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
3872 createSMESHAction( SMESHOp::OpBall, "BALL", "ICON_DLG_BALL" );
3873 createSMESHAction( SMESHOp::OpEdge, "EDGE", "ICON_DLG_EDGE" );
3874 createSMESHAction( SMESHOp::OpTriangle, "TRIANGLE", "ICON_DLG_TRIANGLE" );
3875 createSMESHAction( SMESHOp::OpQuadrangle, "QUAD", "ICON_DLG_QUADRANGLE" );
3876 createSMESHAction( SMESHOp::OpPolygon, "POLYGON", "ICON_DLG_POLYGON" );
3877 createSMESHAction( SMESHOp::OpTetrahedron, "TETRA", "ICON_DLG_TETRAS" );
3878 createSMESHAction( SMESHOp::OpHexahedron, "HEXA", "ICON_DLG_HEXAS" );
3879 createSMESHAction( SMESHOp::OpPentahedron, "PENTA", "ICON_DLG_PENTA" );
3880 createSMESHAction( SMESHOp::OpPyramid , "PYRAMID", "ICON_DLG_PYRAMID" );
3881 createSMESHAction( SMESHOp::OpHexagonalPrism, "OCTA", "ICON_DLG_OCTA" );
3882 createSMESHAction( SMESHOp::OpPolyhedron, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
3883 createSMESHAction( SMESHOp::OpQuadraticEdge, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
3884 createSMESHAction( SMESHOp::OpQuadraticTriangle, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
3885 createSMESHAction( SMESHOp::OpBiQuadraticTriangle, "BIQUADRATIC_TRIANGLE", "ICON_DLG_BIQUADRATIC_TRIANGLE" );
3886 createSMESHAction( SMESHOp::OpQuadraticQuadrangle, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
3887 createSMESHAction( SMESHOp::OpBiQuadraticQuadrangle, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
3888 createSMESHAction( SMESHOp::OpQuadraticPolygon, "QUADRATIC_POLYGON", "ICON_DLG_QUADRATIC_POLYGON" );
3889 createSMESHAction( SMESHOp::OpQuadraticTetrahedron, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
3890 createSMESHAction( SMESHOp::OpQuadraticPyramid, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
3891 createSMESHAction( SMESHOp::OpQuadraticPentahedron, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
3892 createSMESHAction( SMESHOp::OpQuadraticHexahedron, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
3893 createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
3895 createSMESHAction( SMESHOp::OpRemoveNodes, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
3896 createSMESHAction( SMESHOp::OpRemoveElements, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
3897 createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
3898 createSMESHAction( SMESHOp::OpClearMesh, "CLEAR_MESH", "ICON_CLEAR_MESH" );
3900 //createSMESHAction( SMESHOp::OpRenumberingNodes, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
3901 //createSMESHAction( SMESHOp::OpRenumberingElements, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
3903 createSMESHAction( SMESHOp::OpTranslation, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
3904 createSMESHAction( SMESHOp::OpRotation, "ROT", "ICON_DLG_MESH_ROTATION" );
3905 createSMESHAction( SMESHOp::OpSymmetry, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
3906 createSMESHAction( SMESHOp::OpScale, "SCALE", "ICON_DLG_MESH_SCALE" );
3907 createSMESHAction( SMESHOp::OpSewing, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
3908 createSMESHAction( SMESHOp::OpMergeNodes, "MERGE", "ICON_SMESH_MERGE_NODES" );
3909 createSMESHAction( SMESHOp::OpMergeElements, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
3910 createSMESHAction( SMESHOp::OpMoveNode, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
3911 createSMESHAction( SMESHOp::OpDuplicateNodes, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
3912 createSMESHAction( SMESHOp::OpDiagonalInversion, "INV", "ICON_DLG_MESH_DIAGONAL" );
3913 createSMESHAction( SMESHOp::OpUnionOfTwoTriangle, "UNION2", "ICON_UNION2TRI" );
3914 createSMESHAction( SMESHOp::OpOrientation, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
3915 createSMESHAction( SMESHOp::OpReorientFaces, "REORIENT_2D", "ICON_REORIENT_2D" );
3916 createSMESHAction( SMESHOp::OpUnionOfTriangles, "UNION", "ICON_UNIONTRI" );
3917 createSMESHAction( SMESHOp::OpCuttingOfQuadrangles, "CUT", "ICON_CUTQUAD" );
3918 createSMESHAction( SMESHOp::OpSplitVolumes, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
3919 createSMESHAction( SMESHOp::OpSplitBiQuadratic, "SPLIT_BIQUAD", "ICON_SPLIT_BIQUAD" );
3920 createSMESHAction( SMESHOp::OpSmoothing, "SMOOTH", "ICON_DLG_SMOOTHING" );
3921 createSMESHAction( SMESHOp::OpExtrusion, "EXTRUSION", "ICON_EXTRUSION" );
3922 createSMESHAction( SMESHOp::OpExtrusionAlongAPath, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
3923 createSMESHAction( SMESHOp::OpRevolution, "REVOLUTION", "ICON_REVOLUTION" );
3924 createSMESHAction( SMESHOp::OpPatternMapping, "MAP", "ICON_MAP" );
3925 createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
3926 createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D", "ICON_2D_FROM_3D" );
3928 createSMESHAction( SMESHOp::OpReset, "RESET" );
3929 createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
3930 createSMESHAction( SMESHOp::OpShowScalarBar, "SHOW_SCALAR_BAR","",0, true );
3931 createSMESHAction( SMESHOp::OpSaveDistribution, "SAVE_DISTRIBUTION" );
3932 createSMESHAction( SMESHOp::OpShowDistribution, "SHOW_DISTRIBUTION","",0, true );
3933 #ifndef DISABLE_PLOT2DVIEWER
3934 createSMESHAction( SMESHOp::OpPlotDistribution, "PLOT_DISTRIBUTION" );
3936 createSMESHAction( SMESHOp::OpDMWireframe, "WIRE", "ICON_WIRE", 0, true );
3937 createSMESHAction( SMESHOp::OpDMShading, "SHADE", "ICON_SHADE", 0, true );
3938 createSMESHAction( SMESHOp::OpDMNodes, "NODES", "ICON_POINTS", 0, true );
3939 createSMESHAction( SMESHOp::OpDMShrink, "SHRINK", "ICON_SHRINK", 0, true );
3940 createSMESHAction( SMESHOp::OpUpdate, "UPDATE", "ICON_UPDATE" );
3941 createSMESHAction( SMESHOp::OpDE0DElements, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
3942 createSMESHAction( SMESHOp::OpDEEdges, "EDGES", "ICON_DLG_EDGE", 0, true );
3943 createSMESHAction( SMESHOp::OpDEFaces, "FACES", "ICON_DLG_TRIANGLE", 0, true );
3944 createSMESHAction( SMESHOp::OpDEVolumes, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
3945 createSMESHAction( SMESHOp::OpDEBalls, "BALLS", "ICON_DLG_BALL", 0, true );
3946 createSMESHAction( SMESHOp::OpDEChoose, "CHOOSE", "ICON_DLG_CHOOSE", 0, false );
3947 createSMESHAction( SMESHOp::OpDEAllEntity, "ALL", "ICON_DLG_CHOOSE_ALL", 0, false );
3948 createSMESHAction( SMESHOp::OpOrientationOnFaces, "FACE_ORIENTATION", "", 0, true );
3950 createSMESHAction( SMESHOp::OpRepresentationLines, "LINE_REPRESENTATION", "", 0, true );
3951 createSMESHAction( SMESHOp::OpRepresentationArcs, "ARC_REPRESENTATION", "", 0, true );
3953 createSMESHAction( SMESHOp::OpEditHypothesis, "EDIT_HYPO" );
3954 createSMESHAction( SMESHOp::OpUnassign, "UNASSIGN" );
3955 createSMESHAction( SMESHOp::OpNumberingNodes, "NUM_NODES", "", 0, true );
3956 createSMESHAction( SMESHOp::OpNumberingElements, "NUM_ELEMENTS", "", 0, true );
3957 createSMESHAction( SMESHOp::OpProperties, "COLORS" );
3958 createSMESHAction( SMESHOp::OpTransparency, "TRANSP" );
3959 createSMESHAction( SMESHOp::OpClipping, "CLIP" );
3960 createSMESHAction( SMESHOp::OpAutoColor, "AUTO_COLOR" );
3961 createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
3963 createSMESHAction( SMESHOp::OpMinimumDistance, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
3964 createSMESHAction( SMESHOp::OpBoundingBox, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
3965 createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH", "ICON_MEASURE_LENGTH" );
3966 createSMESHAction( SMESHOp::OpPropertiesArea, "MEASURE_AREA", "ICON_MEASURE_AREA" );
3967 createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME", "ICON_MEASURE_VOLUME" );
3969 createSMESHAction( SMESHOp::OpHide, "HIDE" );
3970 createSMESHAction( SMESHOp::OpShow, "SHOW" );
3971 createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
3973 createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
3975 QList<int> aCtrlActions;
3976 aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode // node controls
3977 << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
3978 << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge // edge controls
3979 << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
3980 << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
3981 << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
3982 << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
3983 << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace // face controls
3984 << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
3985 << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
3986 << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume; // volume controls
3987 QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
3988 aCtrlGroup->setExclusive( true );
3989 for( int i = 0; i < aCtrlActions.size(); i++ )
3990 aCtrlGroup->addAction( action( aCtrlActions[i] ) );
3992 // ----- create menu --------------
3993 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
3994 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
3995 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
3996 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
3997 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
3998 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
3999 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
4000 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
4002 createMenu( separator(), fileId );
4004 QMenu* nodeMenu = new QMenu(); QMenu* edgeMenu = new QMenu();
4005 QMenu* faceMenu = new QMenu(); QMenu* volumeMenu = new QMenu();
4006 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
4007 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
4008 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10, -1, nodeMenu ),
4009 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10, -1, edgeMenu ),
4010 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10, -1, faceMenu ),
4011 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10, -1, volumeMenu ),
4012 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
4013 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
4014 //renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
4015 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
4016 basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
4018 //createMenu( SMESHOp::OpImportDAT, importId, -1 );
4019 createMenu( SMESHOp::OpImportUNV, importId, -1 );
4020 createMenu( SMESHOp::OpImportMED, importId, -1 );
4021 createMenu( SMESHOp::OpImportSTL, importId, -1 );
4023 createMenu( SMESHOp::OpImportCGNS, importId, -1 );
4025 createMenu( SMESHOp::OpImportSAUV, importId, -1 );
4026 createMenu( SMESHOp::OpImportGMF, importId, -1 );
4027 createMenu( SMESHOp::OpExportDAT, exportId, -1 );
4028 createMenu( SMESHOp::OpExportMED, exportId, -1 );
4029 createMenu( SMESHOp::OpExportUNV, exportId, -1 );
4030 createMenu( SMESHOp::OpExportSTL, exportId, -1 );
4032 createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
4034 createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
4035 createMenu( SMESHOp::OpExportGMF, exportId, -1 );
4036 createMenu( separator(), fileId, 10 );
4038 createMenu( SMESHOp::OpDelete, editId, -1 );
4040 createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
4042 createMenu( SMESHOp::OpCreateMesh, meshId, -1 ); // "Mesh" menu
4043 createMenu( SMESHOp::OpCreateSubMesh, meshId, -1 );
4044 createMenu( SMESHOp::OpEditMeshOrSubMesh, meshId, -1 );
4045 createMenu( SMESHOp::OpBuildCompoundMesh, meshId, -1 );
4046 createMenu( SMESHOp::OpCopyMesh, meshId, -1 );
4047 createMenu( separator(), meshId, -1 );
4048 createMenu( SMESHOp::OpCompute, meshId, -1 );
4049 createMenu( SMESHOp::OpPreCompute, meshId, -1 );
4050 createMenu( SMESHOp::OpEvaluate, meshId, -1 );
4051 createMenu( SMESHOp::OpMeshOrder, meshId, -1 );
4052 createMenu( separator(), meshId, -1 );
4053 createMenu( SMESHOp::OpCreateGroup, meshId, -1 );
4054 createMenu( SMESHOp::OpCreateGeometryGroup, meshId, -1 );
4055 createMenu( SMESHOp::OpConstructGroup, meshId, -1 );
4056 createMenu( SMESHOp::OpEditGroup, meshId, -1 );
4057 createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4058 createMenu( separator(), meshId, -1 );
4059 createMenu( SMESHOp::OpUnionGroups, meshId, -1 );
4060 createMenu( SMESHOp::OpIntersectGroups, meshId, -1 );
4061 createMenu( SMESHOp::OpCutGroups, meshId, -1 );
4062 createMenu( separator(), meshId, -1 );
4063 createMenu( SMESHOp::OpGroupUnderlyingElem, meshId, -1 );
4064 createMenu( separator(), meshId, -1 );
4065 createMenu( SMESHOp::OpMeshInformation, meshId, -1 );
4066 //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4067 //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4068 createMenu( SMESHOp::OpFindElementByPoint, meshId, -1 );
4069 createMenu( separator(), meshId, -1 );
4071 createMenu( SMESHOp::OpFreeNode, nodeId, -1 );
4072 createMenu( SMESHOp::OpEqualNode, nodeId, -1 );
4073 createMenu( SMESHOp::OpFreeBorder, edgeId, -1 );
4074 createMenu( SMESHOp::OpLength, edgeId, -1 );
4075 createMenu( SMESHOp::OpConnection, edgeId, -1 );
4076 createMenu( SMESHOp::OpEqualEdge, edgeId, -1 );
4077 createMenu( SMESHOp::OpFreeEdge, faceId, -1 );
4078 createMenu( SMESHOp::OpFreeFace, faceId, -1 );
4079 createMenu( SMESHOp::OpBareBorderFace, faceId, -1 );
4080 createMenu( SMESHOp::OpOverConstrainedFace, faceId, -1 );
4081 createMenu( SMESHOp::OpLength2D, faceId, -1 );
4082 createMenu( SMESHOp::OpConnection2D, faceId, -1 );
4083 createMenu( SMESHOp::OpArea, faceId, -1 );
4084 createMenu( SMESHOp::OpTaper, faceId, -1 );
4085 createMenu( SMESHOp::OpAspectRatio, faceId, -1 );
4086 createMenu( SMESHOp::OpMinimumAngle, faceId, -1 );
4087 createMenu( SMESHOp::OpWarpingAngle, faceId, -1 );
4088 createMenu( SMESHOp::OpSkew, faceId, -1 );
4089 createMenu( SMESHOp::OpMaxElementLength2D, faceId, -1 );
4090 createMenu( SMESHOp::OpEqualFace, faceId, -1 );
4091 createMenu( SMESHOp::OpAspectRatio3D, volumeId, -1 );
4092 createMenu( SMESHOp::OpVolume, volumeId, -1 );
4093 createMenu( SMESHOp::OpMaxElementLength3D, volumeId, -1 );
4094 createMenu( SMESHOp::OpBareBorderVolume, volumeId, -1 );
4095 createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4096 createMenu( SMESHOp::OpEqualVolume, volumeId, -1 );
4097 createMenu( separator(), ctrlId, -1 );
4098 createMenu( SMESHOp::OpReset, ctrlId, -1 );
4099 createMenu( separator(), ctrlId, -1 );
4100 createMenu( SMESHOp::OpOverallMeshQuality, ctrlId, -1 );
4102 createMenu( SMESHOp::OpNode, addId, -1 );
4103 createMenu( SMESHOp::OpElem0D, addId, -1 );
4104 createMenu( SMESHOp::OpElem0DOnElemNodes, addId, -1 );
4105 createMenu( SMESHOp::OpBall, addId, -1 );
4106 createMenu( SMESHOp::OpEdge, addId, -1 );
4107 createMenu( SMESHOp::OpTriangle, addId, -1 );
4108 createMenu( SMESHOp::OpQuadrangle, addId, -1 );
4109 createMenu( SMESHOp::OpPolygon, addId, -1 );
4110 createMenu( SMESHOp::OpTetrahedron, addId, -1 );
4111 createMenu( SMESHOp::OpHexahedron, addId, -1 );
4112 createMenu( SMESHOp::OpPentahedron, addId, -1 );
4113 createMenu( SMESHOp::OpPyramid, addId, -1 );
4114 createMenu( SMESHOp::OpHexagonalPrism, addId, -1 );
4115 createMenu( SMESHOp::OpPolyhedron, addId, -1 );
4116 createMenu( separator(), addId, -1 );
4117 createMenu( SMESHOp::OpQuadraticEdge, addId, -1 );
4118 createMenu( SMESHOp::OpQuadraticTriangle, addId, -1 );
4119 createMenu( SMESHOp::OpBiQuadraticTriangle , addId, -1 );
4120 createMenu( SMESHOp::OpQuadraticQuadrangle, addId, -1 );
4121 createMenu( SMESHOp::OpBiQuadraticQuadrangle, addId, -1 );
4122 createMenu( SMESHOp::OpQuadraticPolygon, addId, -1 );
4123 createMenu( SMESHOp::OpQuadraticTetrahedron, addId, -1 );
4124 createMenu( SMESHOp::OpQuadraticPyramid, addId, -1 );
4125 createMenu( SMESHOp::OpQuadraticPentahedron, addId, -1 );
4126 createMenu( SMESHOp::OpQuadraticHexahedron, addId, -1 );
4127 createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4129 createMenu( SMESHOp::OpRemoveNodes, removeId, -1 );
4130 createMenu( SMESHOp::OpRemoveElements, removeId, -1 );
4131 createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4132 createMenu( separator(), removeId, -1 );
4133 createMenu( SMESHOp::OpDeleteGroup, removeId, -1 );
4134 createMenu( separator(), removeId, -1 );
4135 createMenu( SMESHOp::OpClearMesh, removeId, -1 );
4137 //createMenu( SMESHOp::OpRenumberingNodes, renumId, -1 );
4138 //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4140 createMenu( SMESHOp::OpTranslation, transfId, -1 );
4141 createMenu( SMESHOp::OpRotation, transfId, -1 );
4142 createMenu( SMESHOp::OpSymmetry, transfId, -1 );
4143 createMenu( SMESHOp::OpScale, transfId, -1 );
4144 createMenu( SMESHOp::OpSewing, transfId, -1 );
4145 createMenu( SMESHOp::OpMergeNodes, transfId, -1 );
4146 createMenu( SMESHOp::OpMergeElements, transfId, -1 );
4147 createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4149 createMenu( SMESHOp::OpMoveNode, modifyId, -1 );
4150 createMenu( SMESHOp::OpDiagonalInversion, modifyId, -1 );
4151 createMenu( SMESHOp::OpUnionOfTwoTriangle, modifyId, -1 );
4152 createMenu( SMESHOp::OpOrientation, modifyId, -1 );
4153 createMenu( SMESHOp::OpReorientFaces, modifyId, -1 );
4154 createMenu( SMESHOp::OpUnionOfTriangles, modifyId, -1 );
4155 createMenu( SMESHOp::OpCuttingOfQuadrangles, modifyId, -1 );
4156 createMenu( SMESHOp::OpSplitVolumes, modifyId, -1 );
4157 createMenu( SMESHOp::OpSplitBiQuadratic, modifyId, -1 );
4158 createMenu( SMESHOp::OpSmoothing, modifyId, -1 );
4159 createMenu( SMESHOp::OpExtrusion, modifyId, -1 );
4160 createMenu( SMESHOp::OpExtrusionAlongAPath , modifyId, -1 );
4161 createMenu( SMESHOp::OpRevolution, modifyId, -1 );
4162 createMenu( SMESHOp::OpPatternMapping, modifyId, -1 );
4163 createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4164 createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4166 createMenu( SMESHOp::OpMinimumDistance, measureId, -1 );
4167 createMenu( SMESHOp::OpBoundingBox, measureId, -1 );
4168 createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4169 createMenu( SMESHOp::OpPropertiesArea, basicPropId, -1 );
4170 createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4171 createMenu( SMESHOp::OpUpdate, viewId, -1 );
4173 connect( nodeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4174 connect( edgeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4175 connect( faceMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4176 connect( volumeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4178 // ----- create toolbars --------------
4179 int meshTb = createTool( tr( "TB_MESH" ), QString( "SMESHMeshToolbar" ) ),
4180 info = createTool( tr( "TB_INFO" ), QString( "SMESHInformationToolbar" ) ),
4181 groupTb = createTool( tr( "TB_GROUP" ), QString( "SMESHGroupToolbar" ) ),
4182 ctrl0dTb = createTool( tr( "TB_CTRL0D" ), QString( "SMESHNodeControlsToolbar" ) ),
4183 ctrl1dTb = createTool( tr( "TB_CTRL1D" ), QString( "SMESHEdgeControlsToolbar" ) ),
4184 ctrl2dTb = createTool( tr( "TB_CTRL2D" ), QString( "SMESHFaceControlsToolbar" ) ),
4185 ctrl3dTb = createTool( tr( "TB_CTRL3D" ), QString( "SMESHVolumeControlsToolbar" ) ),
4186 addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ),
4187 addNonElemTb = createTool( tr( "TB_ADDNON" ), QString( "SMESHAddElementToolbar" ) ),
4188 remTb = createTool( tr( "TB_REM" ), QString( "SMESHRemoveToolbar" ) ),
4189 //renumbTb = createTool( tr( "TB_RENUMBER" ), QString( "SMESHRenumberingToolbar" ) ),
4190 transformTb = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ),
4191 modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ),
4192 measuremTb = createTool( tr( "TB_MEASUREM" ), QString( "SMESHMeasurementsToolbar" ) ),
4193 dispModeTb = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4195 createTool( SMESHOp::OpCreateMesh, meshTb );
4196 createTool( SMESHOp::OpCreateSubMesh, meshTb );
4197 createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4198 createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4199 createTool( SMESHOp::OpCopyMesh, meshTb );
4200 createTool( separator(), meshTb );
4201 createTool( SMESHOp::OpCompute, meshTb );
4202 createTool( SMESHOp::OpPreCompute, meshTb );
4203 createTool( SMESHOp::OpEvaluate, meshTb );
4204 createTool( SMESHOp::OpMeshOrder, meshTb );
4206 createTool( SMESHOp::OpCreateGroup, groupTb );
4207 createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4208 createTool( SMESHOp::OpConstructGroup, groupTb );
4209 createTool( SMESHOp::OpEditGroup, groupTb );
4211 createTool( SMESHOp::OpMeshInformation, info );
4212 //createTool( SMESHOp::OpStdInfo, meshTb );
4213 //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4214 createTool( SMESHOp::OpFindElementByPoint, info );
4216 createTool( SMESHOp::OpFreeNode, ctrl0dTb );
4217 createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4219 createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4220 createTool( SMESHOp::OpLength, ctrl1dTb );
4221 createTool( SMESHOp::OpConnection, ctrl1dTb );
4222 createTool( SMESHOp::OpEqualEdge, ctrl1dTb );
4224 createTool( SMESHOp::OpFreeEdge, ctrl2dTb );
4225 createTool( SMESHOp::OpFreeFace, ctrl2dTb );
4226 createTool( SMESHOp::OpBareBorderFace, ctrl2dTb );
4227 createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4228 createTool( SMESHOp::OpLength2D, ctrl2dTb );
4229 createTool( SMESHOp::OpConnection2D, ctrl2dTb );
4230 createTool( SMESHOp::OpArea, ctrl2dTb );
4231 createTool( SMESHOp::OpTaper, ctrl2dTb );
4232 createTool( SMESHOp::OpAspectRatio, ctrl2dTb );
4233 createTool( SMESHOp::OpMinimumAngle, ctrl2dTb );
4234 createTool( SMESHOp::OpWarpingAngle, ctrl2dTb );
4235 createTool( SMESHOp::OpSkew, ctrl2dTb );
4236 createTool( SMESHOp::OpMaxElementLength2D, ctrl2dTb );
4237 createTool( SMESHOp::OpEqualFace, ctrl2dTb );
4239 createTool( SMESHOp::OpAspectRatio3D, ctrl3dTb );
4240 createTool( SMESHOp::OpVolume, ctrl3dTb );
4241 createTool( SMESHOp::OpMaxElementLength3D, ctrl3dTb );
4242 createTool( SMESHOp::OpBareBorderVolume, ctrl3dTb );
4243 createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
4244 createTool( SMESHOp::OpEqualVolume, ctrl3dTb );
4246 createTool( SMESHOp::OpNode, addElemTb );
4247 createTool( SMESHOp::OpElem0D, addElemTb );
4248 createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4249 createTool( SMESHOp::OpBall, addElemTb );
4250 createTool( SMESHOp::OpEdge, addElemTb );
4251 createTool( SMESHOp::OpTriangle, addElemTb );
4252 createTool( SMESHOp::OpQuadrangle, addElemTb );
4253 createTool( SMESHOp::OpPolygon, addElemTb );
4254 createTool( SMESHOp::OpTetrahedron, addElemTb );
4255 createTool( SMESHOp::OpHexahedron, addElemTb );
4256 createTool( SMESHOp::OpPentahedron, addElemTb );
4257 createTool( SMESHOp::OpPyramid, addElemTb );
4258 createTool( SMESHOp::OpHexagonalPrism, addElemTb );
4259 createTool( SMESHOp::OpPolyhedron, addElemTb );
4261 createTool( SMESHOp::OpQuadraticEdge, addNonElemTb );
4262 createTool( SMESHOp::OpQuadraticTriangle, addNonElemTb );
4263 createTool( SMESHOp::OpBiQuadraticTriangle, addNonElemTb );
4264 createTool( SMESHOp::OpQuadraticQuadrangle, addNonElemTb );
4265 createTool( SMESHOp::OpBiQuadraticQuadrangle, addNonElemTb );
4266 createTool( SMESHOp::OpQuadraticPolygon, addNonElemTb );
4267 createTool( SMESHOp::OpQuadraticTetrahedron, addNonElemTb );
4268 createTool( SMESHOp::OpQuadraticPyramid, addNonElemTb );
4269 createTool( SMESHOp::OpQuadraticPentahedron, addNonElemTb );
4270 createTool( SMESHOp::OpQuadraticHexahedron, addNonElemTb );
4271 createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4273 createTool( SMESHOp::OpRemoveNodes, remTb );
4274 createTool( SMESHOp::OpRemoveElements, remTb );
4275 createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4276 createTool( SMESHOp::OpClearMesh, remTb );
4278 //createTool( SMESHOp::OpRenumberingNodes, renumbTb );
4279 //createTool( SMESHOp::OpRenumberingElements, renumbTb );
4281 createTool( SMESHOp::OpTranslation, transformTb );
4282 createTool( SMESHOp::OpRotation, transformTb );
4283 createTool( SMESHOp::OpSymmetry, transformTb );
4284 createTool( SMESHOp::OpScale, transformTb );
4285 createTool( SMESHOp::OpSewing, transformTb );
4286 createTool( SMESHOp::OpMergeNodes, transformTb );
4287 createTool( SMESHOp::OpMergeElements, transformTb );
4288 createTool( SMESHOp::OpDuplicateNodes, transformTb );
4290 createTool( SMESHOp::OpMoveNode, modifyTb );
4291 createTool( SMESHOp::OpDiagonalInversion, modifyTb );
4292 createTool( SMESHOp::OpUnionOfTwoTriangle, modifyTb );
4293 createTool( SMESHOp::OpOrientation, modifyTb );
4294 createTool( SMESHOp::OpReorientFaces, modifyTb );
4295 createTool( SMESHOp::OpUnionOfTriangles, modifyTb );
4296 createTool( SMESHOp::OpCuttingOfQuadrangles, modifyTb );
4297 createTool( SMESHOp::OpSplitVolumes, modifyTb );
4298 createTool( SMESHOp::OpSplitBiQuadratic, modifyTb );
4299 createTool( SMESHOp::OpSmoothing, modifyTb );
4300 createTool( SMESHOp::OpExtrusion, modifyTb );
4301 createTool( SMESHOp::OpExtrusionAlongAPath, modifyTb );
4302 createTool( SMESHOp::OpRevolution, modifyTb );
4303 createTool( SMESHOp::OpPatternMapping, modifyTb );
4304 createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4305 createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4307 createTool( SMESHOp::OpMinimumDistance, measuremTb );
4309 createTool( SMESHOp::OpUpdate, dispModeTb );
4311 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4312 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4316 OB = "'ObjectBrowser'",
4317 View = "'" + SVTK_Viewer::Type() + "'",
4319 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4320 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4321 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4322 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4323 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4324 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4325 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4326 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4327 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4328 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4329 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4331 mesh_part = mesh + " " + subMesh + " " + group,
4332 mesh_group = mesh + " " + group,
4333 mesh_submesh = mesh + " " + subMesh,
4334 hyp_alg = hypo + " " + algo;
4336 // popup for object browser
4338 isInvisible("not( isVisible )"),
4339 isEmpty("numberOfNodes = 0"),
4340 isNotEmpty("numberOfNodes <> 0"),
4342 // has nodes, edges, etc in VISIBLE! actor
4343 hasNodes("(numberOfNodes > 0 )"),//&& isVisible)"),
4344 hasElems("(count( elemTypes ) > 0)"),
4345 hasDifferentElems("(count( elemTypes ) > 1)"),
4346 hasBalls("({'BallElem'} in elemTypes)"),
4347 hasElems0d("({'Elem0d'} in elemTypes)"),
4348 hasEdges("({'Edge'} in elemTypes)"),
4349 hasFaces("({'Face'} in elemTypes)"),
4350 hasVolumes("({'Volume'} in elemTypes)"),
4351 hasFacesOrVolumes("(({'Face'} in elemTypes) || ({'Volume'} in elemTypes)) ");
4353 createPopupItem( SMESHOp::OpFileInformation, OB, mesh, "&& selcount=1 && isImported" );
4354 createPopupItem( SMESHOp::OpCreateSubMesh, OB, mesh, "&& hasGeomReference");
4355 createPopupItem( SMESHOp::OpEditMesh, OB, mesh, "&& selcount=1" );
4356 createPopupItem( SMESHOp::OpEditSubMesh, OB, subMesh, "&& selcount=1 && hasGeomReference" );
4357 createPopupItem( SMESHOp::OpEditGroup, OB, group );
4358 createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4360 popupMgr()->insert( separator(), -1, 0 );
4361 createPopupItem( SMESHOp::OpCompute, OB, mesh, "&& selcount=1 && isComputable" );
4362 createPopupItem( SMESHOp::OpComputeSubMesh, OB, subMesh, "&& selcount=1 && isComputable" );
4363 createPopupItem( SMESHOp::OpPreCompute, OB, mesh, "&& selcount=1 && isPreComputable" );
4364 createPopupItem( SMESHOp::OpEvaluate, OB, mesh, "&& selcount=1 && isComputable" );
4365 createPopupItem( SMESHOp::OpMeshOrder, OB, mesh, "&& selcount=1 && isComputable && hasGeomReference" );
4366 createPopupItem( SMESHOp::OpUpdate, OB, mesh_part );
4367 createPopupItem( SMESHOp::OpMeshInformation, OB, mesh_part );
4368 createPopupItem( SMESHOp::OpFindElementByPoint,OB, mesh_group, "&& selcount=1" );
4369 createPopupItem( SMESHOp::OpOverallMeshQuality,OB, mesh_part );
4370 popupMgr()->insert( separator(), -1, 0 );
4371 createPopupItem( SMESHOp::OpCreateGroup, OB, mesh, "&& selcount=1" );
4372 createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh, "&& selcount=1 && hasGeomReference" );
4373 createPopupItem( SMESHOp::OpConstructGroup, OB, subMesh );
4374 popupMgr()->insert( separator(), -1, 0 );
4375 createPopupItem( SMESHOp::OpEditHypothesis, OB, hypo, "&& isEditableHyp");
4376 createPopupItem( SMESHOp::OpUnassign, OB, hyp_alg );
4377 popupMgr()->insert( separator(), -1, 0 );
4378 createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh_submesh );
4379 createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh_group, "&& selcount=1 && dim>=2");
4380 popupMgr()->insert( separator(), -1, 0 );
4381 createPopupItem( SMESHOp::OpClearMesh, OB, mesh );
4382 //popupMgr()->insert( separator(), -1, 0 );
4384 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4385 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4386 QString only_one_2D = only_one_non_empty + " && dim>1";
4388 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4389 createPopupItem( SMESHOp::OpPopupExportMED, OB, mesh_group, multiple_non_empty, anId );
4390 createPopupItem( SMESHOp::OpPopupExportUNV, OB, mesh_group, only_one_non_empty, anId );
4391 createPopupItem( SMESHOp::OpPopupExportSTL, OB, mesh_group, only_one_2D, anId );
4393 createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4395 createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, only_one_non_empty, anId );
4396 createPopupItem( SMESHOp::OpPopupExportGMF, OB, mesh_group, only_one_non_empty, anId );
4397 createPopupItem( SMESHOp::OpPopupExportDAT, OB, mesh_group, only_one_non_empty, anId );
4398 createPopupItem( SMESHOp::OpDelete, OB, mesh_part + " " + hyp_alg );
4399 createPopupItem( SMESHOp::OpDeleteGroup, OB, group );
4400 popupMgr()->insert( separator(), -1, 0 );
4403 createPopupItem( SMESHOp::OpEditGroup, View, group );
4404 createPopupItem( SMESHOp::OpAddElemGroupPopup, View, elems );
4405 createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems );
4407 popupMgr()->insert( separator(), -1, 0 );
4408 createPopupItem( SMESHOp::OpUpdate, View, mesh_part );
4409 createPopupItem( SMESHOp::OpMeshInformation, View, mesh_part );
4410 createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4411 createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh );
4412 popupMgr()->insert( separator(), -1, 0 );
4414 createPopupItem( SMESHOp::OpAutoColor, OB + " " + View, mesh, "&& (not isAutoColor)" );
4415 createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4416 popupMgr()->insert( separator(), -1, 0 );
4418 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4419 QString aType = QString( "%1type in {%2}" ).arg( lc );
4420 aType = aType.arg( mesh_part );
4421 QString aMeshInVTK = aClient + "&&" + aType;
4423 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4424 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4425 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4427 //-------------------------------------------------
4429 //-------------------------------------------------
4430 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4432 popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4433 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4434 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4436 popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4437 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4438 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4440 popupMgr()->insert( separator(), -1, -1 );
4442 //-------------------------------------------------
4444 //-------------------------------------------------
4445 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4447 popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4448 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4449 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4451 popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4452 popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4453 popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4455 popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4456 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes, QtxPopupMgr::VisibleRule );
4457 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4459 popupMgr()->insert( separator(), anId, -1 );
4461 popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4462 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4463 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4465 //-------------------------------------------------
4467 //-------------------------------------------------
4468 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4470 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4472 popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4473 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4474 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4476 popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4477 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4478 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4480 popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4481 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4482 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4484 popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4485 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4486 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4488 popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4489 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4490 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4492 popupMgr()->insert( separator(), anId, -1 );
4494 popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4495 popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&&" + aType + "&&" + isNotEmpty, QtxPopupMgr::VisibleRule );
4497 popupMgr()->insert( separator(), anId, -1 );
4499 popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4500 popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4503 //-------------------------------------------------
4504 // Representation of the 2D Quadratic elements
4505 //-------------------------------------------------
4506 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4507 popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4508 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "&& isVisible && isQuadratic",QtxPopupMgr::VisibleRule );
4509 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4511 popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4512 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "&& isVisible && isQuadratic", QtxPopupMgr::VisibleRule );
4513 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4515 //-------------------------------------------------
4516 // Orientation of faces
4517 //-------------------------------------------------
4518 popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4519 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4520 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4522 //-------------------------------------------------
4524 //-------------------------------------------------
4525 popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4526 popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4528 //-------------------------------------------------
4530 //-------------------------------------------------
4531 popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4532 popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4534 //-------------------------------------------------
4536 //-------------------------------------------------
4538 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4539 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4540 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4541 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4543 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4545 popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4546 popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4548 popupMgr()->insert( separator(), anId, -1 );
4550 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4552 popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4553 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4554 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4556 popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4557 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4558 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4560 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4562 popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4563 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVTK + "&&" + hasEdges + "&&" + hasFacesOrVolumes, QtxPopupMgr::VisibleRule );
4564 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4566 popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4567 popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4568 popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4570 popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4571 popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4572 popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4573 popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4574 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4575 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4577 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4579 popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4580 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4581 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4583 popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4584 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4585 QtxPopupMgr::VisibleRule );
4586 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4588 popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4589 popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4590 popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4592 popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4593 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4594 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4596 popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
4597 popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4598 popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4600 popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
4601 popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4602 popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4604 popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
4605 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4606 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4608 popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
4609 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4610 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4612 popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
4613 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4614 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4616 popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
4617 popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4618 popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4620 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
4621 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4622 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4624 popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
4625 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4626 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4628 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
4629 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4630 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4631 popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
4632 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4633 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4635 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4637 popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D ), aSubId, -1 );
4638 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4639 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4641 popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
4642 popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4643 popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4645 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
4646 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4647 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4649 popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
4650 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4651 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4653 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
4654 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4655 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4657 popupMgr()->insert ( action( SMESHOp::OpEqualVolume ), aSubId, -1 );
4658 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4659 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4661 popupMgr()->insert( separator(), anId, -1 );
4663 popupMgr()->insert( action( SMESHOp::OpShowScalarBar ), anId, -1 );
4664 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4665 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone' && isScalarBarVisible", QtxPopupMgr::ToggleRule );
4666 popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
4667 popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4669 popupMgr()->insert( separator(), anId, -1 );
4671 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4673 popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
4674 popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4676 popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
4677 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4678 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isScalarBarVisible && isDistributionVisible", QtxPopupMgr::ToggleRule);
4680 #ifndef DISABLE_PLOT2DVIEWER
4681 popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
4682 popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4685 //-------------------------------------------------
4687 //-------------------------------------------------
4688 popupMgr()->insert( separator(), -1, -1 );
4689 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4690 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4691 popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
4692 popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4694 popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
4695 popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4697 popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
4698 popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4700 popupMgr()->insert( separator(), -1, -1 );
4702 //-------------------------------------------------
4704 //-------------------------------------------------
4705 popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
4706 popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4708 popupMgr()->insert( separator(), -1, -1 );
4710 popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
4711 popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
4712 popupMgr()->insert( separator(), -1, -1 );
4714 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4715 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4717 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4718 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4721 //================================================================================
4723 * \brief Return true if SMESH or GEOM objects are selected.
4724 * Is called form LightApp_Module::activateModule() which clear selection if
4725 * not isSelectionCompatible()
4727 //================================================================================
4729 bool SMESHGUI::isSelectionCompatible()
4731 bool isCompatible = true;
4732 SALOME_ListIO selected;
4733 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4734 Sel->selectedObjects( selected );
4736 SALOME_ListIteratorOfListIO It( selected );
4737 for ( ; isCompatible && It.More(); It.Next())
4739 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4740 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4742 return isCompatible;
4746 bool SMESHGUI::reusableOperation( const int id )
4748 // compute, evaluate and precompute are not reusable operations
4749 return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate ) ? false : SalomeApp_Module::reusableOperation( id );
4752 bool SMESHGUI::activateModule( SUIT_Study* study )
4754 bool res = SalomeApp_Module::activateModule( study );
4756 setMenuShown( true );
4757 setToolShown( true );
4759 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4760 PyGILState_STATE gstate = PyGILState_Ensure();
4761 PyObject* pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4762 if ( !pluginsmanager ) {
4766 PyObject* result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toUtf8().data(),tr("SMESH_PLUGINS_OTHER").toUtf8().data());
4771 PyGILState_Release(gstate);
4772 // end of SMESH plugins loading
4774 // Reset actions accelerator keys
4775 action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
4777 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4778 GetSMESHGen()->SetCurrentStudy(SALOMEDS::Study::_nil());
4779 if ( SalomeApp_Study* s = dynamic_cast<SalomeApp_Study*>( study )) {
4780 if ( _PTR(Study) aStudy = s->studyDS() )
4781 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
4784 // get all view currently opened in the study and connect their signals to
4785 // the corresponding slots of the class.
4786 SUIT_Desktop* aDesk = study->application()->desktop();
4788 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4789 SUIT_ViewWindow* wnd;
4790 foreach ( wnd, wndList )
4794 Py_XDECREF(pluginsmanager);
4798 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4800 setMenuShown( false );
4801 setToolShown( false );
4803 EmitSignalCloseAllDialogs();
4805 // Unset actions accelerator keys
4806 action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
4808 return SalomeApp_Module::deactivateModule( study );
4811 void SMESHGUI::studyClosed( SUIT_Study* s )
4815 SMESH::RemoveVisuData( s->id() );
4816 SalomeApp_Module::studyClosed( s );
4819 void SMESHGUI::OnGUIEvent()
4821 const QObject* obj = sender();
4822 if ( !obj || !obj->inherits( "QAction" ) )
4824 int id = actionId((QAction*)obj);
4829 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4831 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
4832 if ( CORBA::is_nil( myComponentSMESH ) )
4834 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4836 aGUI.myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4837 return aGUI.myComponentSMESH;
4840 myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4841 return myComponentSMESH;
4844 QString SMESHGUI::engineIOR() const
4846 CORBA::ORB_var anORB = getApp()->orb();
4847 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4848 return QString( anIOR.in() );
4851 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4853 SalomeApp_Module::contextMenuPopup( client, menu, title );
4855 selectionMgr()->selectedObjects( lst );
4856 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4857 Handle(SALOME_InteractiveObject) io = lst.First();
4858 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4859 _PTR(Study) study = appStudy->studyDS();
4860 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4862 QString aName = QString( SMESH::fromUtf8(obj->GetName()) );
4863 while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4864 aName.remove( (aName.length() - 1), 1 );
4870 LightApp_Selection* SMESHGUI::createSelection() const
4872 return new SMESHGUI_Selection();
4875 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4877 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4878 aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
4879 #ifndef DISABLE_PYCONSOLE
4880 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4884 void SMESHGUI::viewManagers( QStringList& list ) const
4886 list.append( SVTK_Viewer::Type() );
4889 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4891 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4892 SMESH::UpdateSelectionProp( this );
4894 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
4895 for(int i = 0; i < aViews.count() ; i++){
4896 SUIT_ViewWindow *sf = aViews[i];
4899 EmitSignalActivatedViewManager();
4903 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
4905 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
4906 myClippingPlaneInfoMap.erase( theViewManager );
4909 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
4911 theActor->AddObserver( SMESH::DeleteActorEvent,
4912 myEventCallbackCommand.GetPointer(),
4916 void SMESHGUI::ProcessEvents( vtkObject* theObject,
4917 unsigned long theEvent,
4918 void* theClientData,
4921 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
4922 if( theObject && (int) theEvent == SMESH::DeleteActorEvent ) {
4923 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
4924 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
4925 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
4926 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
4927 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
4928 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
4929 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
4930 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
4931 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
4932 SMESH::TActorList::iterator anIter3 = anActorList.begin();
4933 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
4934 if( anActor == *anIter3 ) {
4935 anActorList.erase( anIter3 );
4946 void SMESHGUI::createPreferences()
4948 // General tab ------------------------------------------------------------------------
4949 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
4951 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
4952 setPreferenceProperty( autoUpdate, "columns", 2 );
4953 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
4954 setPreferenceProperty( lim, "min", 0 );
4955 setPreferenceProperty( lim, "max", 100000000 );
4956 setPreferenceProperty( lim, "step", 1000 );
4957 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4958 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
4960 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
4961 setPreferenceProperty( qaGroup, "columns", 2 );
4962 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
4963 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
4964 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
4965 setPreferenceProperty( prec, "min", 0 );
4966 setPreferenceProperty( prec, "max", 100 );
4967 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
4968 setPreferenceProperty( doubleNodesTol, "precision", 10 );
4969 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
4970 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
4971 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
4973 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
4974 setPreferenceProperty( dispgroup, "columns", 2 );
4975 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
4977 modes.append( tr("MEN_WIRE") );
4978 modes.append( tr("MEN_SHADE") );
4979 modes.append( tr("MEN_NODES") );
4980 modes.append( tr("MEN_SHRINK") );
4981 QList<QVariant> indices;
4982 indices.append( 0 );
4983 indices.append( 1 );
4984 indices.append( 2 );
4985 indices.append( 3 );
4986 setPreferenceProperty( dispmode, "strings", modes );
4987 setPreferenceProperty( dispmode, "indexes", indices );
4989 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
4990 setPreferenceProperty( arcgroup, "columns", 2 );
4991 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
4992 QStringList quadraticModes;
4993 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
4994 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
4996 indices.append( 0 );
4997 indices.append( 1 );
4998 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
4999 setPreferenceProperty( quadraticmode, "indexes", indices );
5001 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
5002 "SMESH", "max_angle" );
5003 setPreferenceProperty( maxAngle, "min", 1 );
5004 setPreferenceProperty( maxAngle, "max", 90 );
5008 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
5009 setPreferenceProperty( exportgroup, "columns", 2 );
5010 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
5011 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
5013 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
5014 setPreferenceProperty( computeGroup, "columns", 2 );
5015 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
5017 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5018 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5019 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5021 indices.append( 0 );
5022 indices.append( 1 );
5023 indices.append( 2 );
5024 setPreferenceProperty( notifyMode, "strings", modes );
5025 setPreferenceProperty( notifyMode, "indexes", indices );
5027 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5028 setPreferenceProperty( infoGroup, "columns", 2 );
5029 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5031 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5032 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5034 indices.append( 0 );
5035 indices.append( 1 );
5036 setPreferenceProperty( elemInfo, "strings", modes );
5037 setPreferenceProperty( elemInfo, "indexes", indices );
5038 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5039 setPreferenceProperty( nodesLim, "min", 0 );
5040 setPreferenceProperty( nodesLim, "max", 10000000 );
5041 setPreferenceProperty( nodesLim, "step", 10000 );
5042 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5043 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5044 setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5045 setPreferenceProperty( ctrlLim, "min", 0 );
5046 setPreferenceProperty( ctrlLim, "max", 10000000 );
5047 setPreferenceProperty( ctrlLim, "step", 1000 );
5048 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5049 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5050 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5051 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5052 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5054 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5055 setPreferenceProperty( segGroup, "columns", 2 );
5056 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5057 "SMESH", "segmentation" );
5058 setPreferenceProperty( segLen, "min", 1 );
5059 setPreferenceProperty( segLen, "max", 10000000 );
5060 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5061 "SMESH", "nb_segments_per_edge" );
5062 setPreferenceProperty( nbSeg, "min", 1 );
5063 setPreferenceProperty( nbSeg, "max", 10000000 );
5065 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5066 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5067 "SMESH", "forget_mesh_on_hyp_modif" );
5070 // Quantities with individual precision settings
5071 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5072 setPreferenceProperty( precGroup, "columns", 2 );
5074 const int nbQuantities = 6;
5075 int precs[nbQuantities], ii = 0;
5076 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5077 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5078 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5079 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5080 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5081 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5082 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5083 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5084 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5085 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5086 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5087 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5089 // Set property for precision value for spinboxes
5090 for ( ii = 0; ii < nbQuantities; ii++ ){
5091 setPreferenceProperty( precs[ii], "min", -14 );
5092 setPreferenceProperty( precs[ii], "max", 14 );
5093 setPreferenceProperty( precs[ii], "precision", 2 );
5096 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5097 setPreferenceProperty( previewGroup, "columns", 2 );
5098 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5099 setPreferenceProperty( chunkSize, "min", 1 );
5100 setPreferenceProperty( chunkSize, "max", 1000 );
5101 setPreferenceProperty( chunkSize, "step", 50 );
5103 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5104 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5106 // Mesh tab ------------------------------------------------------------------------
5107 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5108 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5109 setPreferenceProperty( nodeGroup, "columns", 3 );
5111 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5113 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5115 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5116 QList<QVariant> aMarkerTypeIndicesList;
5117 QList<QVariant> aMarkerTypeIconsList;
5118 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5119 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5120 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5121 aMarkerTypeIndicesList << i;
5122 aMarkerTypeIconsList << pixmap;
5124 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5125 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
5127 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5129 QList<QVariant> aMarkerScaleIndicesList;
5130 QStringList aMarkerScaleValuesList;
5131 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5132 aMarkerScaleIndicesList << i;
5133 //aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5134 aMarkerScaleValuesList << QString::number( i );
5136 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5137 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5139 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5140 //setPreferenceProperty( elemGroup, "columns", 2 );
5142 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5143 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5144 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5145 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5146 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5147 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5148 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5149 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5150 addPreference( tr( "PREF_PREVIEW_COLOR" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5153 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5154 setPreferenceProperty( grpGroup, "columns", 2 );
5156 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5157 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5159 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5160 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5161 /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5162 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5163 double ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5164 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5165 double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5166 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5167 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
5168 LightApp_Preferences::IntSpin, "SMESH", "element_width");
5169 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5170 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5171 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5172 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5174 setPreferenceProperty( size0d, "min", 1 );
5175 setPreferenceProperty( size0d, "max", 10 );
5177 // setPreferenceProperty( ballSize, "min", 1 );
5178 // setPreferenceProperty( ballSize, "max", 10 );
5180 setPreferenceProperty( ballDiameter, "min", 1e-7 );
5181 setPreferenceProperty( ballDiameter, "max", 1e9 );
5182 setPreferenceProperty( ballDiameter, "step", 0.1 );
5184 setPreferenceProperty( ballScale, "min", 1e-2 );
5185 setPreferenceProperty( ballScale, "max", 1e7 );
5186 setPreferenceProperty( ballScale, "step", 0.5 );
5188 setPreferenceProperty( elemW, "min", 1 );
5189 setPreferenceProperty( elemW, "max", 5 );
5191 setPreferenceProperty( outW, "min", 1 );
5192 setPreferenceProperty( outW, "max", 5 );
5194 setPreferenceProperty( shrink, "min", 0 );
5195 setPreferenceProperty( shrink, "max", 100 );
5197 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5198 setPreferenceProperty( numGroup, "columns", 2 );
5200 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5201 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5203 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5204 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5206 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5207 setPreferenceProperty( orientGroup, "columns", 1 );
5209 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5210 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5212 setPreferenceProperty( orientScale, "min", 0.05 );
5213 setPreferenceProperty( orientScale, "max", 0.5 );
5214 setPreferenceProperty( orientScale, "step", 0.05 );
5216 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5218 // Selection tab ------------------------------------------------------------------------
5219 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5221 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5222 setPreferenceProperty( selGroup, "columns", 2 );
5224 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5225 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5227 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5228 setPreferenceProperty( preGroup, "columns", 2 );
5230 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5232 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5233 setPreferenceProperty( precSelGroup, "columns", 2 );
5235 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5236 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5237 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5239 // Scalar Bar tab ------------------------------------------------------------------------
5240 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5241 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5242 setPreferenceProperty( fontGr, "columns", 2 );
5244 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5245 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5247 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5248 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5250 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5251 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5253 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5254 setPreferenceProperty( numcol, "min", 2 );
5255 setPreferenceProperty( numcol, "max", 256 );
5257 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5258 setPreferenceProperty( numlab, "min", 2 );
5259 setPreferenceProperty( numlab, "max", 65 );
5261 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5262 setPreferenceProperty( orientGr, "columns", 2 );
5263 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5264 QStringList orients;
5265 orients.append( tr( "SMESH_VERTICAL" ) );
5266 orients.append( tr( "SMESH_HORIZONTAL" ) );
5267 indices.clear(); indices.append( 0 ); indices.append( 1 );
5268 setPreferenceProperty( orient, "strings", orients );
5269 setPreferenceProperty( orient, "indexes", indices );
5271 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5272 setPreferenceProperty( posVSizeGr, "columns", 2 );
5273 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5274 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5275 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5276 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5277 setPreferenceProperty( xv, "step", 0.1 );
5278 setPreferenceProperty( xv, "min", 0.0 );
5279 setPreferenceProperty( xv, "max", 1.0 );
5280 setPreferenceProperty( yv, "step", 0.1 );
5281 setPreferenceProperty( yv, "min", 0.0 );
5282 setPreferenceProperty( yv, "max", 1.0 );
5283 setPreferenceProperty( wv, "step", 0.1 );
5284 setPreferenceProperty( wv, "min", 0.0 );
5285 setPreferenceProperty( wv, "max", 1.0 );
5286 setPreferenceProperty( hv, "min", 0.0 );
5287 setPreferenceProperty( hv, "max", 1.0 );
5288 setPreferenceProperty( hv, "step", 0.1 );
5290 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5291 setPreferenceProperty( posHSizeGr, "columns", 2 );
5292 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5293 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5294 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5295 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5296 setPreferenceProperty( xv, "min", 0.0 );
5297 setPreferenceProperty( xv, "max", 1.0 );
5298 setPreferenceProperty( xv, "step", 0.1 );
5299 setPreferenceProperty( xh, "min", 0.0 );
5300 setPreferenceProperty( xh, "max", 1.0 );
5301 setPreferenceProperty( xh, "step", 0.1 );
5302 setPreferenceProperty( yh, "min", 0.0 );
5303 setPreferenceProperty( yh, "max", 1.0 );
5304 setPreferenceProperty( yh, "step", 0.1 );
5305 setPreferenceProperty( wh, "min", 0.0 );
5306 setPreferenceProperty( wh, "max", 1.0 );
5307 setPreferenceProperty( wh, "step", 0.1 );
5308 setPreferenceProperty( hh, "min", 0.0 );
5309 setPreferenceProperty( hh, "max", 1.0 );
5310 setPreferenceProperty( hh, "step", 0.1 );
5312 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5313 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5314 setPreferenceProperty( distributionGr, "columns", 3 );
5316 types.append( tr( "SMESH_MONOCOLOR" ) );
5317 types.append( tr( "SMESH_MULTICOLOR" ) );
5318 indices.clear(); indices.append( 0 ); indices.append( 1 );
5319 setPreferenceProperty( coloringType, "strings", types );
5320 setPreferenceProperty( coloringType, "indexes", indices );
5321 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5325 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5327 if ( sect=="SMESH" ) {
5328 float sbX1 = 0.01, sbY1 = 0.01, sbW = 0.08, sbH = 0.08;
5329 float aTol = 1.00000009999999;
5330 std::string aWarning;
5331 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5333 if ( name== "selection_object_color" ||
5334 name=="selection_element_color" ||
5335 name== "highlight_color" ||
5336 name=="selection_precision_node" ||
5337 name=="selection_precision_element" ||
5338 name=="selection_precision_object" )
5340 SMESH::UpdateSelectionProp( this );
5342 else if (name == "scalar_bar_vertical_x" || name == "scalar_bar_vertical_width")
5344 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5345 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5346 if ( sbX1+sbW > aTol ) {
5347 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5350 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5351 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5354 else if (name == "scalar_bar_vertical_y" || name == "scalar_bar_vertical_height" )
5356 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5357 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5358 if ( sbY1 + sbH > aTol ) {
5359 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5360 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5361 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5364 else if (name == "scalar_bar_horizontal_x" || name == "scalar_bar_horizontal_width")
5366 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5367 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5368 if ( sbX1 + sbW > aTol ) {
5369 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5372 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5373 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5376 else if (name == "scalar_bar_horizontal_y" || name == "scalar_bar_horizontal_height")
5378 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5379 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5380 if ( sbY1 + sbH > aTol ) {
5381 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5384 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5385 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5388 else if ( name == "segmentation" )
5390 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5391 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5393 else if ( name == "nb_segments_per_edge" )
5395 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5396 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5398 else if ( name == "historical_python_dump" || name == "forget_mesh_on_hyp_modif" || name == "default_grp_color" )
5400 QString val = aResourceMgr->stringValue( "SMESH", name );
5401 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5403 else if ( name == "numbering_node_color" || name == "numbering_node_font" )
5405 SMESH::UpdateFontProp( this );
5407 else if ( name == "numbering_elem_color" || name == "numbering_elem_font" )
5409 SMESH::UpdateFontProp( this );
5412 if ( aWarning.size() != 0 ) {
5413 aWarning += "The default values are applied instead.";
5414 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5415 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5416 QObject::tr(aWarning.c_str()));
5421 //================================================================================
5423 * \brief Update something in accordance with update flags
5424 * \param theFlags - update flags
5426 * Update viewer or/and object browser etc. in accordance with update flags ( see
5427 * LightApp_UpdateFlags enumeration ).
5429 //================================================================================
5430 void SMESHGUI::update( const int flags )
5432 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5433 SMESH::UpdateView();
5435 SalomeApp_Module::update( flags );
5438 //================================================================================
5440 * \brief Set default selection mode
5442 * SLOT called when operation commited. Sets default selection mode
5444 //================================================================================
5445 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5447 SVTK_ViewWindow* vtkWnd =
5448 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5450 vtkWnd->SetSelectionMode( ActorSelection );
5453 //================================================================================
5455 * \brief Set default selection mode
5457 * SLOT called when operation aborted. Sets default selection mode
5459 //================================================================================
5460 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5462 SVTK_ViewWindow* vtkWnd =
5463 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5465 vtkWnd->SetSelectionMode( ActorSelection );
5468 //================================================================================
5470 * \brief Creates operation with given identifier
5471 * \param id - identifier of operation to be started
5472 * \return Pointer on created operation or NULL if operation is not created
5474 * Virtual method redefined from the base class creates operation with given id.
5475 * It is called called automatically from startOperation method of base class.
5477 //================================================================================
5478 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5480 LightApp_Operation* op = 0;
5481 // to do : create operation here
5484 case SMESHOp::OpSplitBiQuadratic:
5485 op = new SMESHGUI_SplitBiQuadOp();
5487 case SMESHOp::OpConvertMeshToQuadratic:
5488 op = new SMESHGUI_ConvToQuadOp();
5490 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5491 op = new SMESHGUI_Make2DFrom3DOp();
5493 case SMESHOp::OpReorientFaces:
5494 op = new SMESHGUI_ReorientFacesOp();
5496 case SMESHOp::OpCreateMesh:
5497 op = new SMESHGUI_MeshOp( true, true );
5499 case SMESHOp::OpCreateSubMesh:
5500 op = new SMESHGUI_MeshOp( true, false );
5502 case SMESHOp::OpEditMeshOrSubMesh:
5503 case SMESHOp::OpEditMesh:
5504 case SMESHOp::OpEditSubMesh:
5505 op = new SMESHGUI_MeshOp( false );
5507 case SMESHOp::OpCompute:
5508 case SMESHOp::OpComputeSubMesh:
5509 op = new SMESHGUI_ComputeOp();
5511 case SMESHOp::OpPreCompute:
5512 op = new SMESHGUI_PrecomputeOp();
5514 case SMESHOp::OpEvaluate:
5515 op = new SMESHGUI_EvaluateOp();
5517 case SMESHOp::OpMeshOrder:
5518 op = new SMESHGUI_MeshOrderOp();
5520 case SMESHOp::OpCreateGeometryGroup:
5521 op = new SMESHGUI_GroupOnShapeOp();
5523 case SMESHOp::OpFindElementByPoint:
5524 op = new SMESHGUI_FindElemByPointOp();
5526 case SMESHOp::OpMoveNode: // Make mesh pass through point
5527 op = new SMESHGUI_MakeNodeAtPointOp();
5529 case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
5530 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5537 op = SalomeApp_Module::createOperation( id );
5541 //================================================================================
5543 * \brief Stops current operations and starts a given one
5544 * \param id - The id of the operation to start
5546 //================================================================================
5548 void SMESHGUI::switchToOperation(int id)
5550 if ( _PTR(Study) aStudy = SMESH::GetActiveStudyDocument() )
5551 activeStudy()->abortAllOperations();
5552 startOperation( id );
5555 LightApp_Displayer* SMESHGUI::displayer()
5558 myDisplayer = new SMESHGUI_Displayer( getApp() );
5562 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5565 int aTolerance = 64;
5566 int anIterations = 0;
5572 if( anIterations % aPeriod == 0 )
5575 if( aTolerance < 1 )
5579 aHue = (int)( 360.0 * rand() / RAND_MAX );
5582 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5583 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5584 for( ; it != itEnd; ++it )
5586 SALOMEDS::Color anAutoColor = *it;
5587 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5590 aQColor.getHsv( &h, &s, &v );
5591 if( abs( h - aHue ) < aTolerance )
5603 aColor.setHsv( aHue, 255, 255 );
5605 SALOMEDS::Color aSColor;
5606 aSColor.R = aColor.redF();
5607 aSColor.G = aColor.greenF();
5608 aSColor.B = aColor.blueF();
5613 const char* gSeparator = "_"; // character used to separate parameter names
5614 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5615 const char* gPathSep = "|"; // character used to separate paths
5618 * \brief Store visual parameters
5620 * This method is called just before the study document is saved.
5621 * Store visual parameters in AttributeParameter attribue(s)
5623 void SMESHGUI::storeVisualParameters (int savePoint)
5626 Kernel_Utils::Localizer loc;
5628 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5629 if (!appStudy || !appStudy->studyDS())
5631 _PTR(Study) studyDS = appStudy->studyDS();
5633 // componentName is used for encoding of entries when storing them in IParameters
5634 std::string componentName = myComponentSMESH->ComponentDataType();
5635 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5636 //if (!aSComponent) return;
5639 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5640 componentName.c_str(),
5642 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5644 // store map of custom markers
5645 const VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5646 if( !aMarkerMap.empty() )
5648 VTK::MarkerMap::const_iterator anIter = aMarkerMap.begin();
5649 for( ; anIter != aMarkerMap.end(); anIter++ )
5651 int anId = anIter->first;
5652 VTK::MarkerData aMarkerData = anIter->second;
5653 std::string aMarkerFileName = aMarkerData.first;
5654 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5655 if( aMarkerTexture.size() < 3 )
5656 continue; // should contain at least width, height and the first value
5658 QString aPropertyName( "texture" );
5659 aPropertyName += gSeparator;
5660 aPropertyName += QString::number( anId );
5662 QString aPropertyValue = aMarkerFileName.c_str();
5663 aPropertyValue += gPathSep;
5665 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5666 ushort aWidth = *aTextureIter++;
5667 ushort aHeight = *aTextureIter++;
5668 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5669 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5670 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5671 aPropertyValue += QString::number( *aTextureIter );
5673 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5677 // viewers counters are used for storing view_numbers in IParameters
5680 // main cycle to store parameters of displayed objects
5681 QList<SUIT_ViewManager*> lst;
5682 QList<SUIT_ViewManager*>::Iterator it;
5683 getApp()->viewManagers(lst);
5684 for (it = lst.begin(); it != lst.end(); it++)
5686 SUIT_ViewManager* vman = *it;
5687 QString vType = vman->getType();
5689 // saving VTK actors properties
5690 if (vType == SVTK_Viewer::Type())
5692 // store the clipping planes attached to the view manager
5693 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5694 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5695 if( anIter != myClippingPlaneInfoMap.end() )
5696 aClippingPlaneInfoList = anIter->second;
5698 if( !aClippingPlaneInfoList.empty() ) {
5699 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5700 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5702 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5703 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5705 QString aPropertyName( "ClippingPlane" );
5706 aPropertyName += gSeparator;
5707 aPropertyName += QString::number( vtkViewers );
5708 aPropertyName += gSeparator;
5709 aPropertyName += QString::number( anId );
5711 QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
5712 aPropertyValue += gDigitsSep;
5713 aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
5714 aPropertyValue += gDigitsSep;
5715 if ( aPlane->PlaneMode == SMESH::Absolute ) {
5716 aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
5717 aPropertyValue += gDigitsSep;
5718 aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
5719 aPropertyValue += gDigitsSep;
5720 aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
5721 aPropertyValue += gDigitsSep;
5722 aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
5723 aPropertyValue += gDigitsSep;
5724 aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
5725 aPropertyValue += gDigitsSep;
5726 aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
5727 aPropertyValue += gDigitsSep;
5728 aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
5730 else if ( aPlane->PlaneMode == SMESH::Relative ) {
5731 aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
5732 aPropertyValue += gDigitsSep;
5733 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5734 aPropertyValue += gDigitsSep;
5735 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5736 aPropertyValue += gDigitsSep;
5737 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5740 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5744 QVector<SUIT_ViewWindow*> views = vman->getViews();
5745 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5747 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5749 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5750 vtkActorCollection* allActors = aCopy.GetActors();
5751 allActors->InitTraversal();
5752 while (vtkActor* actor = allActors->GetNextActor())
5754 if (actor->GetVisibility()) // store only visible actors
5756 SMESH_Actor* aSmeshActor = 0;
5757 if (actor->IsA("SMESH_Actor"))
5758 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5759 if (aSmeshActor && aSmeshActor->hasIO())
5761 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5764 // entry is "encoded" = it does NOT contain component adress,
5765 // since it is a subject to change on next component loading
5766 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5768 std::string param, vtkParam = vType.toLatin1().data();
5769 vtkParam += gSeparator;
5770 vtkParam += QString::number(vtkViewers).toLatin1().data();
5771 vtkParam += gSeparator;
5774 param = vtkParam + "Visibility";
5775 ip->setParameter(entry, param, "On");
5778 param = vtkParam + "Representation";
5779 ip->setParameter(entry, param, QString::number
5780 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5783 param = vtkParam + "IsShrunk";
5784 ip->setParameter(entry, param, QString::number
5785 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5787 // Displayed entities
5788 unsigned int aMode = aSmeshActor->GetEntityMode();
5789 bool isE = aMode & SMESH_Actor::eEdges;
5790 bool isF = aMode & SMESH_Actor::eFaces;
5791 bool isV = aMode & SMESH_Actor::eVolumes;
5792 bool is0d = aMode & SMESH_Actor::e0DElements;
5793 bool isB = aMode & SMESH_Actor::eBallElem;
5795 QString modeStr ("e");
5796 modeStr += gDigitsSep; modeStr += QString::number(isE);
5797 modeStr += gDigitsSep; modeStr += "f";
5798 modeStr += gDigitsSep; modeStr += QString::number(isF);
5799 modeStr += gDigitsSep; modeStr += "v";
5800 modeStr += gDigitsSep; modeStr += QString::number(isV);
5801 modeStr += gDigitsSep; modeStr += "0d";
5802 modeStr += gDigitsSep; modeStr += QString::number(is0d);
5803 modeStr += gDigitsSep; modeStr += "b";
5804 modeStr += gDigitsSep; modeStr += QString::number(isB);
5806 param = vtkParam + "Entities";
5807 ip->setParameter(entry, param, modeStr.toLatin1().data());
5813 aSmeshActor->GetSufaceColor(r, g, b, delta);
5814 QStringList colorStr;
5815 colorStr << "surface";
5816 colorStr << QString::number(r);
5817 colorStr << QString::number(g);
5818 colorStr << QString::number(b);
5820 colorStr << "backsurface";
5821 colorStr << QString::number(delta);
5823 aSmeshActor->GetVolumeColor(r, g, b, delta);
5824 colorStr << "volume";
5825 colorStr << QString::number(r);
5826 colorStr << QString::number(g);
5827 colorStr << QString::number(b);
5828 colorStr << QString::number(delta);
5830 aSmeshActor->GetEdgeColor(r, g, b);
5832 colorStr << QString::number(r);
5833 colorStr << QString::number(g);
5834 colorStr << QString::number(b);
5836 aSmeshActor->GetNodeColor(r, g, b);
5838 colorStr << QString::number(r);
5839 colorStr << QString::number(g);
5840 colorStr << QString::number(b);
5842 aSmeshActor->GetOutlineColor(r, g, b);
5843 colorStr << "outline";
5844 colorStr << QString::number(r);
5845 colorStr << QString::number(g);
5846 colorStr << QString::number(b);
5848 aSmeshActor->Get0DColor(r, g, b);
5849 colorStr << "elem0d";
5850 colorStr << QString::number(r);
5851 colorStr << QString::number(g);
5852 colorStr << QString::number(b);
5854 aSmeshActor->GetBallColor(r, g, b);
5856 colorStr << QString::number(r);
5857 colorStr << QString::number(g);
5858 colorStr << QString::number(b);
5860 aSmeshActor->GetFacesOrientationColor(r, g, b);
5861 colorStr << "orientation";
5862 colorStr << QString::number(r);
5863 colorStr << QString::number(g);
5864 colorStr << QString::number(b);
5866 param = vtkParam + "Colors";
5867 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
5870 QStringList sizeStr;
5872 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
5873 sizeStr << "outline";
5874 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
5875 sizeStr << "elem0d";
5876 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
5878 //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
5879 sizeStr << QString::number((double)aSmeshActor->GetBallSize());
5880 sizeStr << QString::number((double)aSmeshActor->GetBallScale());
5881 sizeStr << "shrink";
5882 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
5883 sizeStr << "orientation";
5884 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
5885 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
5887 param = vtkParam + "Sizes";
5888 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
5893 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5894 if( aMarkerType == VTK::MT_USER ) {
5895 markerStr += "custom";
5896 markerStr += gDigitsSep;
5897 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
5901 markerStr += gDigitsSep;
5902 markerStr += QString::number( (int)aMarkerType );
5903 markerStr += gDigitsSep;
5904 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
5907 param = vtkParam + "PointMarker";
5908 ip->setParameter(entry, param, markerStr.toLatin1().data());
5911 param = vtkParam + "Opacity";
5912 ip->setParameter(entry, param,
5913 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
5916 param = vtkParam + "ClippingPlane";
5918 if( !aClippingPlaneInfoList.empty() ) {
5919 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
5920 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
5922 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
5923 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
5924 SMESH::TActorList::iterator anIter2 = anActorList.begin();
5925 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
5926 if( aSmeshActor == *anIter2 ) {
5927 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
5928 QString::number( anId ).toLatin1().constData() );
5935 ip->setParameter( entry, param, "Off" );
5936 } // if (io->hasEntry())
5937 } // SMESH_Actor && hasIO
5939 } // while.. actors traversal
5943 } // if (SVTK view model)
5944 } // for (viewManagers)
5947 // data structures for clipping planes processing
5951 bool isOpenGLClipping;
5952 vtkIdType RelativeOrientation;
5955 int AbsoluteOrientation;
5956 double X, Y, Z, Dx, Dy, Dz;
5958 typedef std::list<TPlaneData> TPlaneDataList;
5959 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
5961 typedef std::list<vtkActor*> TActorList;
5964 TActorList ActorList;
5965 SUIT_ViewManager* ViewManager;
5967 typedef std::list<TPlaneInfo> TPlaneInfoList;
5968 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
5971 * \brief Restore visual parameters
5973 * This method is called after the study document is opened.
5974 * Restore visual parameters from AttributeParameter attribue(s)
5976 void SMESHGUI::restoreVisualParameters (int savePoint)
5979 Kernel_Utils::Localizer loc;
5981 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5982 if (!appStudy || !appStudy->studyDS())
5984 _PTR(Study) studyDS = appStudy->studyDS();
5986 // componentName is used for encoding of entries when storing them in IParameters
5987 std::string componentName = myComponentSMESH->ComponentDataType();
5988 //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
5989 //if (!aSComponent) return;
5992 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5993 componentName.c_str(),
5995 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5997 // restore map of custom markers and map of clipping planes
5998 VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5999 TPlaneDataMap aPlaneDataMap;
6001 std::vector<std::string> properties = ip->getProperties();
6002 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
6004 std::string property = *propIt;
6005 QString aPropertyName( property.c_str() );
6006 QString aPropertyValue( ip->getProperty( property ).c_str() );
6008 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
6009 if( aPropertyNameList.isEmpty() )
6012 QString aPropertyType = aPropertyNameList[0];
6013 if( aPropertyType == "texture" )
6015 if( aPropertyNameList.size() != 2 )
6019 int anId = aPropertyNameList[1].toInt( &ok );
6020 if( !ok || anId < 1 )
6023 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
6024 if( aPropertyValueList.size() != 2 )
6027 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
6028 QString aMarkerTextureString = aPropertyValueList[1];
6029 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
6030 if( aMarkerTextureStringList.size() != 3 )
6034 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6039 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6043 VTK::MarkerTexture aMarkerTexture;
6044 aMarkerTexture.push_back( aWidth );
6045 aMarkerTexture.push_back( aHeight );
6047 QString aMarkerTextureData = aMarkerTextureStringList[2];
6048 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6050 QChar aChar = aMarkerTextureData.at( i );
6051 if( aChar.isDigit() )
6052 aMarkerTexture.push_back( aChar.digitValue() );
6055 aMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6057 else if( aPropertyType == "ClippingPlane" )
6059 if( aPropertyNameList.size() != 3 )
6063 int aViewId = aPropertyNameList[1].toInt( &ok );
6064 if( !ok || aViewId < 0 )
6068 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6069 if( !ok || aClippingPlaneId < 0 )
6072 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6073 if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6076 TPlaneData aPlaneData;
6077 aPlaneData.AbsoluteOrientation = false;
6078 aPlaneData.RelativeOrientation = 0;
6079 aPlaneData.Distance = aPlaneData.Angle[0] = aPlaneData.Angle[1] = 0;
6080 aPlaneData.X = aPlaneData.Y = aPlaneData.Z = 0;
6081 aPlaneData.Dx = aPlaneData.Dy = aPlaneData.Dz = 0;
6083 aPlaneData.Id = aClippingPlaneId;
6086 aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6091 aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6095 if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6098 aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6103 aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6108 aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6113 aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6118 aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6123 aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6128 aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6132 else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6134 aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6139 aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6144 aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6149 aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6154 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6155 aPlaneDataList.push_back( aPlaneData );
6159 TPlaneInfoMap aPlaneInfoMap;
6161 std::vector<std::string> entries = ip->getEntries();
6163 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6165 // entry is a normal entry - it should be "decoded" (setting base adress of component)
6166 QString entry (ip->decodeEntry(*entIt).c_str());
6168 // Check that the entry corresponds to a real object in the Study
6169 // as the object may be deleted or modified after the visual state is saved.
6170 _PTR(SObject) so = studyDS->FindObjectID(entry.toLatin1().data());
6171 if (!so) continue; //Skip the not existent entry
6173 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6174 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6176 std::vector<std::string>::iterator namesIt = paramNames.begin();
6177 std::vector<std::string>::iterator valuesIt = paramValues.begin();
6179 // actors are stored in a map after displaying of them for
6180 // quicker access in the future: map < viewID to actor >
6181 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6183 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6185 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6186 // '_' is used as separator and should not be used in viewer type or parameter names.
6187 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6188 if (lst.size() != 3)
6191 QString viewerTypStr = lst[0];
6192 QString viewIndexStr = lst[1];
6193 QString paramNameStr = lst[2];
6196 int viewIndex = viewIndexStr.toUInt(&ok);
6197 if (!ok) // bad conversion of view index to integer
6201 if (viewerTypStr == SVTK_Viewer::Type())
6203 SMESH_Actor* aSmeshActor = 0;
6204 if (vtkActors.IsBound(viewIndex))
6205 aSmeshActor = vtkActors.Find(viewIndex);
6207 QList<SUIT_ViewManager*> lst;
6208 getApp()->viewManagers(viewerTypStr, lst);
6210 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6211 SUIT_ViewManager* vman = NULL;
6212 if (viewIndex >= 0 && viewIndex < lst.count())
6213 vman = lst.at(viewIndex);
6215 if (paramNameStr == "Visibility")
6217 if (!aSmeshActor && displayer() && vman)
6219 SUIT_ViewModel* vmodel = vman->getViewModel();
6220 // SVTK view model can be casted to SALOME_View
6221 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6223 // store displayed actor in a temporary map for quicker
6224 // access later when restoring other parameters
6225 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6226 vtkRenderer* Renderer = vtkView->getRenderer();
6227 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6228 vtkActorCollection* theActors = aCopy.GetActors();
6229 theActors->InitTraversal();
6230 bool isFound = false;
6231 vtkActor *ac = theActors->GetNextActor();
6232 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6233 if (ac->IsA("SMESH_Actor")) {
6234 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6235 if (aGeomAc->hasIO()) {
6236 Handle(SALOME_InteractiveObject) io = aGeomAc->getIO();
6237 if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) {
6239 vtkActors.Bind(viewIndex, aGeomAc);
6245 } // if (paramNameStr == "Visibility")
6248 // the rest properties "work" with SMESH_Actor
6251 QString val ((*valuesIt).c_str());
6254 if (paramNameStr == "Representation") {
6255 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6258 else if (paramNameStr == "IsShrunk") {
6260 if (!aSmeshActor->IsShrunk())
6261 aSmeshActor->SetShrink();
6264 if (aSmeshActor->IsShrunk())
6265 aSmeshActor->UnShrink();
6268 // Displayed entities
6269 else if (paramNameStr == "Entities") {
6270 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6271 int aEntityMode = SMESH_Actor::eAllEntity;
6272 for ( int i = 0; i < mode.count(); i+=2 ) {
6273 if ( i < mode.count()-1 ) {
6274 QString type = mode[i];
6275 bool val = mode[i+1].toInt();
6276 if ( type == "e" && !val )
6277 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6278 else if ( type == "f" && !val )
6279 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6280 else if ( type == "v" && !val )
6281 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6282 else if ( type == "0d" && !val )
6283 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6284 else if ( type == "b" && !val )
6285 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6288 aSmeshActor->SetEntityMode( aEntityMode );
6291 else if (paramNameStr == "Colors") {
6292 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6299 QColor outlineColor;
6300 QColor orientationColor;
6306 // below lines are required to get default values for delta coefficients
6307 // of backface color for faces and color of reversed volumes
6308 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
6309 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6310 for ( int i = 0; i < colors.count(); i++ ) {
6311 QString type = colors[i];
6312 if ( type == "surface" ) {
6313 // face color is set by 3 values r:g:b, where
6314 // - r,g,b - is rgb color components
6315 if ( i+1 >= colors.count() ) break; // format error
6316 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6317 if ( i+2 >= colors.count() ) break; // format error
6318 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6319 if ( i+3 >= colors.count() ) break; // format error
6320 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6321 faceColor.setRgbF( r, g, b );
6324 else if ( type == "backsurface" ) {
6325 // backface color can be defined in several ways
6326 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6327 // - in latest versions, it is set as delta coefficient
6328 bool rgbOk = false, deltaOk;
6329 if ( i+1 >= colors.count() ) break; // format error
6330 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6331 int delta = colors[i+1].toInt( &deltaOk );
6333 if ( i+1 < colors.count() ) // index is shifted to 1
6334 g = colors[i+1].toDouble( &rgbOk );
6335 if ( rgbOk ) i++; // shift index
6336 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6337 b = colors[i+1].toDouble( &rgbOk );
6339 // - as currently there's no way to set directly backsurface color as it was before,
6340 // we ignore old dump where r,g,b triple was set
6341 // - also we check that delta parameter is set properly
6342 if ( !rgbOk && deltaOk )
6345 else if ( type == "volume" ) {
6346 // volume color is set by 4 values r:g:b:delta, where
6347 // - r,g,b - is a normal volume rgb color components
6348 // - delta - is a reversed volume color delta coefficient
6349 if ( i+1 >= colors.count() ) break; // format error
6350 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6351 if ( i+2 >= colors.count() ) break; // format error
6352 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6353 if ( i+3 >= colors.count() ) break; // format error
6354 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6355 if ( i+4 >= colors.count() ) break; // format error
6356 int delta = colors[i+4].toInt( &bOk );
6357 if ( !bOk ) break; // format error
6358 volumeColor.setRgbF( r, g, b );
6362 else if ( type == "edge" ) {
6363 // edge color is set by 3 values r:g:b, where
6364 // - r,g,b - is rgb color components
6365 if ( i+1 >= colors.count() ) break; // format error
6366 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6367 if ( i+2 >= colors.count() ) break; // format error
6368 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6369 if ( i+3 >= colors.count() ) break; // format error
6370 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6371 edgeColor.setRgbF( r, g, b );
6374 else if ( type == "node" ) {
6375 // node color is set by 3 values r:g:b, where
6376 // - r,g,b - is rgb color components
6377 if ( i+1 >= colors.count() ) break; // format error
6378 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6379 if ( i+2 >= colors.count() ) break; // format error
6380 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6381 if ( i+3 >= colors.count() ) break; // format error
6382 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6383 nodeColor.setRgbF( r, g, b );
6386 else if ( type == "elem0d" ) {
6387 // 0d element color is set by 3 values r:g:b, where
6388 // - r,g,b - is rgb color components
6389 if ( i+1 >= colors.count() ) break; // format error
6390 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6391 if ( i+2 >= colors.count() ) break; // format error
6392 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6393 if ( i+3 >= colors.count() ) break; // format error
6394 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6395 elem0dColor.setRgbF( r, g, b );
6398 else if ( type == "ball" ) {
6399 // ball color is set by 3 values r:g:b, where
6400 // - r,g,b - is rgb color components
6401 if ( i+1 >= colors.count() ) break; // format error
6402 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6403 if ( i+2 >= colors.count() ) break; // format error
6404 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6405 if ( i+3 >= colors.count() ) break; // format error
6406 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6407 ballColor.setRgbF( r, g, b );
6410 else if ( type == "outline" ) {
6411 // outline color is set by 3 values r:g:b, where
6412 // - r,g,b - is rgb color components
6413 if ( i+1 >= colors.count() ) break; // format error
6414 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6415 if ( i+2 >= colors.count() ) break; // format error
6416 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6417 if ( i+3 >= colors.count() ) break; // format error
6418 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6419 outlineColor.setRgbF( r, g, b );
6422 else if ( type == "orientation" ) {
6423 // orientation color is set by 3 values r:g:b, where
6424 // - r,g,b - is rgb color components
6425 if ( i+1 >= colors.count() ) break; // format error
6426 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6427 if ( i+2 >= colors.count() ) break; // format error
6428 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6429 if ( i+3 >= colors.count() ) break; // format error
6430 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6431 orientationColor.setRgbF( r, g, b );
6436 if ( nodeColor.isValid() )
6437 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6439 if ( edgeColor.isValid() )
6440 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6442 if ( faceColor.isValid() )
6443 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6445 if ( volumeColor.isValid() )
6446 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6447 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6448 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6450 if ( elem0dColor.isValid() )
6451 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6453 if ( ballColor.isValid() )
6454 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6456 if ( outlineColor.isValid() )
6457 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6458 // orientation color
6459 if ( orientationColor.isValid() )
6460 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6463 else if (paramNameStr == "Sizes") {
6464 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6467 int outlineWidth = -1;
6468 int elem0dSize = -1;
6469 //int ballSize = -1;
6470 double ballDiameter = -1.0;
6471 double ballScale = -1.0;
6472 double shrinkSize = -1;
6473 double orientationSize = -1;
6474 bool orientation3d = false;
6475 for ( int i = 0; i < sizes.count(); i++ ) {
6476 QString type = sizes[i];
6477 if ( type == "line" ) {
6478 // line (wireframe) width is given as single integer value
6479 if ( i+1 >= sizes.count() ) break; // format error
6480 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6484 if ( type == "outline" ) {
6485 // outline width is given as single integer value
6486 if ( i+1 >= sizes.count() ) break; // format error
6487 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6491 else if ( type == "elem0d" ) {
6492 // 0d element size is given as single integer value
6493 if ( i+1 >= sizes.count() ) break; // format error
6494 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6498 else if ( type == "ball" ) {
6499 // balls are specified by two values: size:scale, where
6500 // - size - is a integer value specifying size
6501 // - scale - is a double value specifying scale factor
6502 if ( i+1 >= sizes.count() ) break; // format error
6503 //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6504 double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6505 if ( i+2 >= sizes.count() ) break; // format error
6506 double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6512 else if ( type == "shrink" ) {
6513 // shrink factor is given as single floating point value
6514 if ( i+1 >= sizes.count() ) break; // format error
6515 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6519 else if ( type == "orientation" ) {
6520 // orientation vectors are specified by two values size:3d, where
6521 // - size - is a floating point value specifying scale factor
6522 // - 3d - is a boolean
6523 if ( i+1 >= sizes.count() ) break; // format error
6524 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6525 if ( i+2 >= sizes.count() ) break; // format error
6526 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6527 orientationSize = v1;
6528 orientation3d = (bool)v2;
6532 // line (wireframe) width
6533 if ( lineWidth > 0 )
6534 aSmeshActor->SetLineWidth( lineWidth );
6536 if ( outlineWidth > 0 )
6537 aSmeshActor->SetOutlineWidth( outlineWidth );
6538 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6539 aSmeshActor->SetOutlineWidth( lineWidth );
6541 if ( elem0dSize > 0 )
6542 aSmeshActor->Set0DSize( elem0dSize );
6544 /*if ( ballSize > 0 )
6545 aSmeshActor->SetBallSize( ballSize );*/
6547 if ( ballDiameter > 0 )
6548 aSmeshActor->SetBallSize( ballDiameter );
6550 if ( ballScale > 0.0 )
6551 aSmeshActor->SetBallScale( ballScale );
6553 if ( shrinkSize > 0 )
6554 aSmeshActor->SetShrinkFactor( shrinkSize );
6555 // orientation vectors
6556 if ( orientationSize > 0 ) {
6557 aSmeshActor->SetFacesOrientationScale( orientationSize );
6558 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6562 else if (paramNameStr == "PointMarker") {
6563 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6564 if( data.count() >= 2 ) {
6566 int aParam1 = data[1].toInt( &ok );
6568 if( data[0] == "std" && data.count() == 3 ) {
6569 int aParam2 = data[2].toInt( &ok );
6570 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6572 else if( data[0] == "custom" ) {
6573 VTK::MarkerMap::const_iterator markerIt = aMarkerMap.find( aParam1 );
6574 if( markerIt != aMarkerMap.end() ) {
6575 VTK::MarkerData aMarkerData = markerIt->second;
6576 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6583 else if (paramNameStr == "Opacity") {
6584 aSmeshActor->SetOpacity(val.toFloat());
6587 else if (paramNameStr.startsWith("ClippingPlane")) {
6588 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6589 // old format - val looks like "Off" or "1:0:0:0.5:0:0"
6590 // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
6591 // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
6592 // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
6593 // new format - val looks like "Off" or "0" (plane id)
6594 // (note: in new format "Off" value is used only for consistency,
6595 // so it is processed together with values in old format)
6596 bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
6597 if( anIsOldFormat ) {
6598 if (paramNameStr == "ClippingPlane1" || val == "Off")
6599 aSmeshActor->RemoveAllClippingPlanes();
6601 QList<SUIT_ViewManager*> lst;
6602 getApp()->viewManagers(viewerTypStr, lst);
6603 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6604 if (viewIndex >= 0 && viewIndex < lst.count()) {
6605 SUIT_ViewManager* vman = lst.at(viewIndex);
6606 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6608 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6610 SMESH::TActorList anActorList;
6611 anActorList.push_back( aSmeshActor );
6612 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
6613 aPlane->myViewWindow = vtkView;
6614 SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
6615 aPlane->PlaneMode = aMode;
6616 bool isOpenGLClipping = ( bool )vals[1].toInt();
6617 aPlane->IsOpenGLClipping = isOpenGLClipping;
6618 if ( aMode == SMESH::Absolute ) {
6619 aPlane->myAbsoluteOrientation = vals[2].toInt();
6620 aPlane->X = vals[3].toFloat();
6621 aPlane->Y = vals[4].toFloat();
6622 aPlane->Z = vals[5].toFloat();
6623 aPlane->Dx = vals[6].toFloat();
6624 aPlane->Dy = vals[7].toFloat();
6625 aPlane->Dz = vals[8].toFloat();
6627 else if ( aMode == SMESH::Relative ) {
6628 aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
6629 aPlane->myDistance = vals[3].toFloat();
6630 aPlane->myAngle[0] = vals[4].toFloat();
6631 aPlane->myAngle[1] = vals[5].toFloat();
6635 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6636 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6637 aClippingPlaneInfo.Plane = aPlane;
6638 aClippingPlaneInfo.ActorList = anActorList;
6639 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6647 int aPlaneId = val.toInt( &ok );
6648 if( ok && aPlaneId >= 0 ) {
6649 bool anIsDefinedPlane = false;
6650 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6651 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6652 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6653 TPlaneInfo& aPlaneInfo = *anIter;
6654 if( aPlaneInfo.PlaneId == aPlaneId ) {
6655 aPlaneInfo.ActorList.push_back( aSmeshActor );
6656 anIsDefinedPlane = true;
6660 if( !anIsDefinedPlane ) {
6661 TPlaneInfo aPlaneInfo;
6662 aPlaneInfo.PlaneId = aPlaneId;
6663 aPlaneInfo.ActorList.push_back( aSmeshActor );
6664 aPlaneInfo.ViewManager = vman;
6666 // to make the list sorted by plane id
6667 anIter = aPlaneInfoList.begin();
6668 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6669 const TPlaneInfo& aPlaneInfoRef = *anIter;
6670 if( aPlaneInfoRef.PlaneId > aPlaneId )
6673 aPlaneInfoList.insert( anIter, aPlaneInfo );
6678 } // if (aSmeshActor)
6679 } // other parameters than Visibility
6681 } // for names/parameters iterator
6682 } // for entries iterator
6684 // take into account planes with empty list of actors referred to them
6685 QList<SUIT_ViewManager*> aVMList;
6686 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6688 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6689 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6690 int aViewId = aPlaneDataIter->first;
6691 if( aViewId >= 0 && aViewId < aVMList.count() ) {
6692 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6694 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6696 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6697 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6698 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6699 const TPlaneData& aPlaneData = *anIter2;
6700 int aPlaneId = aPlaneData.Id;
6702 bool anIsFound = false;
6703 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6704 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6705 const TPlaneInfo& aPlaneInfo = *anIter3;
6706 if( aPlaneInfo.PlaneId == aPlaneId ) {
6713 TPlaneInfo aPlaneInfo; // ActorList field is empty
6714 aPlaneInfo.PlaneId = aPlaneId;
6715 aPlaneInfo.ViewManager = aViewManager;
6717 // to make the list sorted by plane id
6718 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6719 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6720 const TPlaneInfo& aPlaneInfoRef = *anIter4;
6721 if( aPlaneInfoRef.PlaneId > aPlaneId )
6724 aPlaneInfoList.insert( anIter4, aPlaneInfo );
6730 // add clipping planes to actors according to the restored parameters
6731 // and update the clipping plane map
6732 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6733 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6734 int aViewId = anIter1->first;
6735 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6737 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6738 if( anIter2 == aPlaneDataMap.end() )
6740 const TPlaneDataList& aPlaneDataList = anIter2->second;
6742 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6743 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6744 const TPlaneInfo& aPlaneInfo = *anIter3;
6745 int aPlaneId = aPlaneInfo.PlaneId;
6746 const TActorList& anActorList = aPlaneInfo.ActorList;
6747 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6751 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6755 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6757 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6758 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6759 const TPlaneData& aPlaneData = *anIter4;
6760 if( aPlaneData.Id == aPlaneId ) {
6761 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
6762 aPlane->myViewWindow = aViewWindow;
6763 aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
6764 aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
6765 if ( aPlane->PlaneMode == SMESH::Absolute ) {
6766 aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
6767 aPlane->X = aPlaneData.X;
6768 aPlane->Y = aPlaneData.Y;
6769 aPlane->Z = aPlaneData.Z;
6770 aPlane->Dx = aPlaneData.Dx;
6771 aPlane->Dy = aPlaneData.Dy;
6772 aPlane->Dz = aPlaneData.Dz;
6774 else if ( aPlane->PlaneMode == SMESH::Relative ) {
6775 aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
6776 aPlane->myDistance = aPlaneData.Distance;
6777 aPlane->myAngle[0] = aPlaneData.Angle[0];
6778 aPlane->myAngle[1] = aPlaneData.Angle[1];
6781 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6782 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6783 aClippingPlaneInfo.Plane = aPlane;
6784 aClippingPlaneInfo.ActorList = anActorList;
6785 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6796 // update all VTK views
6797 QList<SUIT_ViewManager*> lst;
6798 getApp()->viewManagers(lst);
6799 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6800 SUIT_ViewModel* vmodel = (*it)->getViewModel();
6801 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6802 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6803 // set OpenGL clipping planes
6804 VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
6805 vtkActorCollection* anAllActors = aCopy.GetActors();
6806 anAllActors->InitTraversal();
6807 while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
6808 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
6809 anActor->SetOpenGLClippingPlane();
6811 vtkView->getRenderer()->ResetCameraClippingRange();
6818 \brief Adds preferences for dfont of VTK viewer
6820 \param pIf group identifier
6821 \param param parameter
6822 \return identifier of preferences
6824 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
6826 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6828 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6831 fam.append( tr( "SMESH_FONT_ARIAL" ) );
6832 fam.append( tr( "SMESH_FONT_COURIER" ) );
6833 fam.append( tr( "SMESH_FONT_TIMES" ) );
6835 setPreferenceProperty( tfont, "fonts", fam );
6837 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6838 if ( needSize ) f = f | QtxFontEdit::Size;
6839 setPreferenceProperty( tfont, "features", f );
6845 \brief Actions after hypothesis edition
6846 Updates object browser after hypothesis edition
6848 void SMESHGUI::onHypothesisEdit( int result )
6851 SMESHGUI::Modified();
6852 updateObjBrowser( true );
6856 \brief Actions after choosing menu of control modes
6857 Updates control mode actions according to current selection
6859 void SMESHGUI::onUpdateControlActions()
6861 SALOME_ListIO selected;
6862 if ( LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr() )
6863 aSel->selectedObjects( selected );
6865 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
6866 if ( selected.Extent() ) {
6867 if ( selected.First()->hasEntry() ) {
6868 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( selected.First()->getEntry() )) {
6869 aControl = anActor->GetControlMode();
6870 SALOME_ListIteratorOfListIO it(selected);
6871 for ( it.Next(); it.More(); it.Next() ) {
6872 Handle(SALOME_InteractiveObject) anIO = it.Value();
6873 if ( anIO->hasEntry() ) {
6874 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
6875 if ( aControl != anActor->GetControlMode() ) {
6876 aControl = SMESH_Actor::eNone;
6886 int anAction = ActionToControl( aControl, true );
6888 action( anAction )->setChecked( true );
6890 QMenu* send = (QMenu*)sender();
6891 QList<QAction*> actions = send->actions();
6892 for ( int i = 0; i < actions.size(); i++ )
6893 actions[i]->setChecked( false );
6899 \brief Signal handler closing(SUIT_ViewWindow*) of a view
6900 \param pview view being closed
6902 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
6903 #ifndef DISABLE_PLOT2DVIEWER
6904 //Crear all Plot2d Viewers if need.
6905 SMESH::ClearPlot2Viewers(pview);
6907 EmitSignalCloseView();
6910 void SMESHGUI::message( const QString& msg )
6913 QStringList data = msg.split("/");
6914 if ( data.count() > 0 ) {
6915 if ( data.first() == "mesh_loading" ) {
6917 QString entry = data.count() > 1 ? data[1] : QString();
6918 if ( entry.isEmpty() )
6921 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
6923 _PTR(SObject) obj = study->FindObjectID( entry.toLatin1().constData() );
6926 name = SMESH::fromUtf8(obj->GetName());
6927 if ( name.isEmpty() )
6930 if ( data.last() == "stop" )
6931 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
6933 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
6934 QApplication::processEvents();
6940 \brief Connects or disconnects signals about activating and cloning view on the module slots
6941 \param pview view which is connected/disconnected
6943 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
6947 SUIT_ViewManager* viewMgr = pview->getViewManager();
6949 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6950 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6952 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6953 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6958 \brief Return \c true if object can be renamed
6960 bool SMESHGUI::renameAllowed( const QString& entry) const {
6961 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6965 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6969 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
6974 if(appStudy->isComponent(entry) || obj->isReference())
6977 // check type to prevent renaming of inappropriate objects
6978 int aType = SMESHGUI_Selection::type(qPrintable(entry), SMESH::GetActiveStudyDocument());
6979 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6980 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6981 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6982 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6983 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
6990 Rename object by entry.
6991 \param entry entry of the object
6992 \param name new name of the object
6993 \brief Return \c true if rename operation finished successfully, \c false otherwise.
6995 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
6997 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
7001 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
7006 _PTR(Study) aStudy = appStudy->studyDS();
7011 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
7013 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
7018 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
7019 _PTR(GenericAttribute) anAttr;
7020 _PTR(AttributeName) aName;
7022 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
7024 // check type to prevent renaming of inappropriate objects
7025 int aType = SMESHGUI_Selection::type( qPrintable(entry), SMESH::GetActiveStudyDocument() );
7026 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7027 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7028 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7029 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7030 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
7031 if ( !name.isEmpty() ) {
7032 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
7034 // update name of group object and its actor
7035 Handle(SALOME_InteractiveObject) IObject =
7036 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
7038 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
7039 if( !aGroupObject->_is_nil() ) {
7040 aGroupObject->SetName( qPrintable(name) );
7041 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
7042 anActor->setName( qPrintable(name) );
7052 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
7054 static QList<QColor> colors;
7056 if ( colors.isEmpty() ) {
7058 for (int s = 0; s < 2 ; s++)
7060 for (int v = 100; v >= 40; v = v - 20)
7062 for (int h = 0; h < 359 ; h = h + 60)
7064 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
7069 static int currentColor = randomize( colors.size() );
7071 SALOMEDS::Color color;
7072 color.R = (double)colors[currentColor].red() / 255.0;
7073 color.G = (double)colors[currentColor].green() / 255.0;
7074 color.B = (double)colors[currentColor].blue() / 255.0;
7076 currentColor = (currentColor+1) % colors.count();