1 // Copyright (C) 2007-2015 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>
178 #include <Basics_Utils.hxx>
180 //To disable automatic genericobj management, the following line should be commented.
181 //Otherwise, it should be uncommented.
182 //Refer to KERNEL_SRC/src/SALOMEDSImpl/SALOMEDSImpl_AttributeIOR.cxx
183 #define WITHGENERICOBJ
185 // Below macro, when uncommented, switches on simplified (more performant) algorithm
186 // of auto-color picking up
187 #define SIMPLE_AUTOCOLOR
192 //=============================================================
193 void ImportMeshesFromFile(SMESH::SMESH_Gen_ptr theComponentMesh,
196 void ExportMeshToFile(int theCommandID);
198 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap);
200 void SetDisplayEntity(int theCommandID);
202 void Control( int theCommandID );
205 //================================================================================
207 * \brief Reads meshes from file
209 //================================================================================
211 void ImportMeshesFromFile( SMESH::SMESH_Gen_ptr theComponentMesh,
215 std::string myExtension;
217 if ( theCommandID == SMESHOp::OpImportMED ) {
218 filter.append( QObject::tr( "MED_FILES_FILTER" ) + " (*.*med)" );
219 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
221 else if ( theCommandID == SMESHOp::OpImportUNV ) {
222 filter.append( QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)" );
224 else if ( theCommandID == SMESHOp::OpImportDAT ) {
225 filter.append( QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)" );
227 else if ( theCommandID == SMESHOp::OpImportSTL ) {
228 filter.append( QObject::tr( "STL_FILES_FILTER" ) + " (*.stl)" );
231 else if ( theCommandID == SMESHOp::OpImportCGNS ) {
232 filter.append( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
235 else if ( theCommandID == SMESHOp::OpImportSAUV ) {
236 filter.append( QObject::tr( "SAUV files (*.sauv*)" ) );
237 filter.append( QObject::tr( "All files (*)" ) );
239 else if ( theCommandID == SMESHOp::OpImportGMF ) {
240 filter.append( QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" );
241 filter.append( QObject::tr( "GMF_BINARY_FILES_FILTER") + " (*.meshb)" );
244 QString anInitialPath = "";
245 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
246 anInitialPath = QDir::currentPath();
248 QStringList filenames;
249 bool toCreateGroups = true;
251 // if ( theCommandID == SMESHOp::OpImportGMF ) { // GMF
252 // SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg
253 // ( SMESHGUI::desktop(), true, QObject::tr("SMESH_REQUIRED_GROUPS"), true, true );
254 // fd->setWindowTitle( QObject::tr( "SMESH_IMPORT_MESH" ) );
255 // fd->setNameFilters( filter );
256 // fd->SetChecked( true );
258 // filenames << fd->selectedFile();
259 // toCreateGroups = fd->IsChecked();
265 filenames = SUIT_FileDlg::getOpenFileNames( SMESHGUI::desktop(),
268 QObject::tr( "SMESH_IMPORT_MESH" ) );
270 if ( filenames.count() > 0 ) {
271 SUIT_OverrideCursor wc;
272 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
275 QStringList anEntryList;
276 bool isEmpty = false;
277 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++ ) {
371 _PTR(SObject) aMeshSO = SMESH::FindSObject( aMeshes[i] );
373 _PTR(StudyBuilder) aBuilder = aStudy->NewBuilder();
374 _PTR(AttributePixMap) aPixmap = aBuilder->FindOrCreateAttribute( aMeshSO, "AttributePixMap" );
375 aPixmap->SetPixMap( "ICON_SMESH_TREE_MESH_IMPORTED" );
376 if ( theCommandID == SMESHOp::OpImportUNV ) // mesh names aren't taken from the file for UNV import
377 SMESH::SetName( aMeshSO, QFileInfo(filename).fileName() );
379 anEntryList.append( aMeshSO->GetID().c_str() );
387 // update Object browser
388 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
390 // browse to the published meshes
391 if( LightApp_Application* anApp =
392 dynamic_cast<LightApp_Application*>( SUIT_Session::session()->activeApplication() ) )
393 anApp->browseObjects( anEntryList );
395 // show Error message box if there were errors
396 if ( errors.count() > 0 ) {
397 SUIT_MessageBox::critical( SMESHGUI::desktop(),
398 QObject::tr( "SMESH_ERROR" ),
399 QObject::tr( "SMESH_IMPORT_ERRORS" ) + "\n" + errors.join( "\n" ) );
402 // show warning message box, if some imported mesh is empty
404 SUIT_MessageBox::warning( SMESHGUI::desktop(),
405 QObject::tr( "SMESH_WRN_WARNING" ),
406 QObject::tr( "SMESH_DRS_SOME_EMPTY" ) );
411 //================================================================================
413 * \brief Export selected meshes or groups into a file
415 //================================================================================
417 void ExportMeshToFile( int theCommandID )
419 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
420 SALOME_ListIO selected;
422 aSel->selectedObjects( selected );
424 const bool isDAT = ( theCommandID == SMESHOp::OpExportDAT || theCommandID == SMESHOp::OpPopupExportDAT );
425 const bool isMED = ( theCommandID == SMESHOp::OpExportMED || theCommandID == SMESHOp::OpPopupExportMED );
426 const bool isUNV = ( theCommandID == SMESHOp::OpExportUNV || theCommandID == SMESHOp::OpPopupExportUNV );
427 const bool isSTL = ( theCommandID == SMESHOp::OpExportSTL || theCommandID == SMESHOp::OpPopupExportSTL );
429 const bool isCGNS= ( theCommandID == SMESHOp::OpExportCGNS || theCommandID == SMESHOp::OpPopupExportCGNS );
431 const bool isCGNS= false;
433 const bool isSAUV= ( theCommandID == SMESHOp::OpExportSAUV || theCommandID == SMESHOp::OpPopupExportSAUV );
434 const bool isGMF = ( theCommandID == SMESHOp::OpExportGMF || theCommandID == SMESHOp::OpPopupExportGMF );
436 const bool multiMeshSupported = ( isMED || isCGNS ); // file can hold several meshes
437 if ( selected.Extent() == 0 || ( selected.Extent() > 1 && !multiMeshSupported ))
440 // get mesh object from selection and check duplication of their names
441 bool hasDuplicatedMeshNames = false;
442 QList< QPair< SMESH::SMESH_IDSource_var, QString > > aMeshList;
443 QList< QPair< SMESH::SMESH_IDSource_var, QString > >::iterator aMeshIter;
444 SALOME_ListIteratorOfListIO It( selected );
445 for( ; It.More(); It.Next() )
447 Handle(SALOME_InteractiveObject) anIObject = It.Value();
448 SMESH::SMESH_IDSource_var aMeshItem = SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIObject);
449 if ( aMeshItem->_is_nil() ) {
450 SUIT_MessageBox::warning( SMESHGUI::desktop(),
451 QObject::tr( "SMESH_WRN_WARNING" ),
452 QObject::tr( "SMESH_BAD_MESH_SELECTION" ));
456 QString aMeshName = anIObject->getName();
458 // check for name duplications
459 if ( !hasDuplicatedMeshNames )
460 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
461 if( aMeshName == (*aMeshIter).second ) {
462 hasDuplicatedMeshNames = true;
467 aMeshList.append( QPair< SMESH::SMESH_IDSource_var, QString >( aMeshItem, aMeshName ) );
470 if( hasDuplicatedMeshNames && isMED ) {
471 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
472 QObject::tr("SMESH_WRN_WARNING"),
473 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_MESH_NAMES"),
474 QObject::tr("SMESH_BUT_YES"),
475 QObject::tr("SMESH_BUT_NO"), 0, 1);
480 aMeshIter = aMeshList.begin();
481 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
482 SMESH::SMESH_Mesh_var aMesh = aMeshOrGroup->GetMesh();
483 QString aMeshName = (*aMeshIter).second;
485 if ( isMED || isCGNS || isSAUV ) // formats where group names must be unique
487 // check for equal group names within each mesh
488 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
489 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
490 if ( !aMeshItem->_is_nil() && aMeshItem->HasDuplicatedGroupNamesMED()) {
491 int aRet = SUIT_MessageBox::warning
492 (SMESHGUI::desktop(),
493 QObject::tr("SMESH_WRN_WARNING"),
494 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_GRP").arg((*aMeshIter).second),
495 QObject::tr("SMESH_BUT_YES"),
496 QObject::tr("SMESH_BUT_NO"), 0, 1);
503 // Warn the user about presence of not supported elements
505 std::vector< SMESH::EntityType > notSupportedElemTypes, presentNotSupported;
509 notSupportedElemTypes.push_back( SMESH::Entity_0D );
510 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
515 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
516 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
517 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
518 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
519 notSupportedElemTypes.push_back( SMESH::Entity_Pyramid );
520 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
521 notSupportedElemTypes.push_back( SMESH::Entity_0D );
522 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
527 notSupportedElemTypes.push_back( SMESH::Entity_Edge );
528 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Edge );
529 notSupportedElemTypes.push_back( SMESH::Entity_0D );
530 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
535 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
540 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
541 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Triangle );
542 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Quadrangle );
543 notSupportedElemTypes.push_back( SMESH::Entity_TriQuad_Hexa );
544 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
545 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
546 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
547 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
552 notSupportedElemTypes.push_back( SMESH::Entity_0D );
553 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
554 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
555 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Pyramid );
556 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Penta );
557 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
558 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
559 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
560 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
562 if ( ! notSupportedElemTypes.empty() )
564 SMESH::long_array_var nbElems = aMeshOrGroup->GetMeshInfo();
565 for ( size_t iType = 0; iType < notSupportedElemTypes.size(); ++iType )
566 if ( nbElems[ notSupportedElemTypes[ iType ]] > 0 )
567 presentNotSupported.push_back( notSupportedElemTypes[ iType ]);
569 if ( !presentNotSupported.empty() )
572 const char* typeMsg[SMESH::Entity_Last] = {
573 "SMESH_NODES", "SMESH_ELEMS0D","SMESH_EDGES","SMESH_QUADRATIC_EDGES",
574 "SMESH_TRIANGLES", "SMESH_QUADRATIC_TRIANGLES", "SMESH_BIQUADRATIC_TRIANGLES",
575 "SMESH_QUADRANGLES","SMESH_QUADRATIC_QUADRANGLES", "SMESH_BIQUADRATIC_QUADRANGLES",
576 "SMESH_POLYGONS","SMESH_QUADRATIC_POLYGONS",
577 "SMESH_TETRAHEDRA","SMESH_QUADRATIC_TETRAHEDRONS","SMESH_PYRAMIDS",
578 "SMESH_QUADRATIC_PYRAMIDS","SMESH_HEXAHEDRA","SMESH_QUADRATIC_HEXAHEDRONS",
579 "SMESH_TRIQUADRATIC_HEXAHEDRONS","SMESH_PENTAHEDRA","SMESH_QUADRATIC_PENTAHEDRONS",
580 "SMESH_OCTAHEDRA","SMESH_POLYEDRONS","SMESH_QUADRATIC_POLYEDRONS","SMESH_BALLS"
582 QString andStr = " " + QObject::tr("SMESH_AND") + " ", comma(", ");
583 for ( size_t iType = 0; iType < presentNotSupported.size(); ++iType ) {
584 typeNames += QObject::tr( typeMsg[ presentNotSupported[ iType ]]);
585 if ( iType != presentNotSupported.size() - 1 )
586 typeNames += ( iType == presentNotSupported.size() - 2 ) ? andStr : comma;
588 int aRet = SUIT_MessageBox::warning
589 (SMESHGUI::desktop(),
590 QObject::tr("SMESH_WRN_WARNING"),
591 QObject::tr("EXPORT_NOT_SUPPORTED").arg(aMeshName).arg(format).arg(typeNames),
592 QObject::tr("SMESH_BUT_YES"),
593 QObject::tr("SMESH_BUT_NO"), 0, 1);
598 // Get parameters of export operation
601 SMESH::MED_VERSION aFormat;
602 // Init the parameters with the default values
603 bool aIsASCII_STL = true;
604 bool toCreateGroups = false;
605 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
607 toCreateGroups = resMgr->booleanValue( "SMESH", "auto_groups", false );
608 bool toOverwrite = true;
609 bool toFindOutDim = true;
611 QString aFilter, aTitle = QObject::tr("SMESH_EXPORT_MESH");
612 QString anInitialPath = "";
613 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
614 anInitialPath = QDir::currentPath();
616 QList< QPair< GEOM::ListOfFields_var, QString > > aFieldList;
618 // Get a file name to write in and additional otions
619 if ( isUNV || isDAT || isGMF ) // Export w/o options
622 aFilter = QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)";
624 aFilter = QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)";
626 aFilter = QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" +
627 ";;" + QObject::tr( "GMF_BINARY_FILES_FILTER" ) + " (*.meshb)";
628 if ( anInitialPath.isEmpty() ) anInitialPath = SUIT_FileDlg::getLastVisitedPath();
629 aFilename = SUIT_FileDlg::getFileName(SMESHGUI::desktop(),
630 anInitialPath + QString("/") + aMeshName,
631 aFilter, aTitle, false);
633 else if ( isCGNS )// Export to CGNS
635 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
636 fd->setWindowTitle( aTitle );
637 fd->setNameFilter( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
638 if ( !anInitialPath.isEmpty() )
639 fd->setDirectory( anInitialPath );
640 fd->selectFile(aMeshName);
641 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
642 fd->setValidator( fv );
645 aFilename = fd->selectedFile();
646 toOverwrite = fv->isOverwrite();
650 else if ( isSTL ) // Export to STL
652 QMap<QString, int> aFilterMap;
653 aFilterMap.insert( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)", 1 );
654 aFilterMap.insert( QObject::tr( "STL_BIN_FILES_FILTER" ) + " (*.stl)", 0 );
657 QMap<QString, int>::const_iterator it = aFilterMap.begin();
658 for ( ; it != aFilterMap.end(); ++it )
659 filters.push_back( it.key() );
661 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
662 fd->setWindowTitle( aTitle );
663 fd->setNameFilters( filters );
664 fd->selectNameFilter( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
665 if ( !anInitialPath.isEmpty() )
666 fd->setDirectory( anInitialPath );
667 fd->selectFile(aMeshName);
671 aFilename = fd->selectedFile();
672 aIsASCII_STL = (aFilterMap[fd->selectedNameFilter()]) == 1 ? true: false;
677 else if ( isMED || isSAUV ) // Export to MED or SAUV
679 QMap<QString, SMESH::MED_VERSION> aFilterMap;
680 //QString v21 (aMesh->GetVersionString(SMESH::MED_V2_1, 2));
682 QString v22 (aMesh->GetVersionString(SMESH::MED_V2_2, 2));
683 //aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v21 ) + " (*.med)", SMESH::MED_V2_1 );
684 aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v22 ) + " (*.med)", SMESH::MED_V2_2 );
687 aFilterMap.insert("All files (*)", SMESH::MED_V2_1 );
688 aFilterMap.insert("SAUV files (*.sauv)", SMESH::MED_V2_2 );
689 aFilterMap.insert("SAUV files (*.sauve)", SMESH::MED_V2_1 );
693 QString aDefaultFilter;
694 QMap<QString, SMESH::MED_VERSION>::const_iterator it = aFilterMap.begin();
695 for ( ; it != aFilterMap.end(); ++it ) {
696 filters.push_back( it.key() );
697 if (it.value() == SMESH::MED_V2_2)
698 aDefaultFilter = it.key();
700 QStringList checkBoxes;
701 checkBoxes << QObject::tr("SMESH_AUTO_GROUPS") << QObject::tr("SMESH_AUTO_DIM");
703 SMESHGUI_FieldSelectorWdg* fieldSelWdg = new SMESHGUI_FieldSelectorWdg();
704 QList< QWidget* > wdgList;
705 if ( fieldSelWdg->GetAllFeilds( aMeshList, aFieldList ))
706 wdgList.append( fieldSelWdg );
708 SalomeApp_CheckFileDlg* fd =
709 new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true, wdgList );
710 fd->setWindowTitle( aTitle );
711 fd->setNameFilters( filters );
712 fd->selectNameFilter( aDefaultFilter );
713 fd->SetChecked( toCreateGroups, 0 );
714 fd->SetChecked( toFindOutDim, 1 );
715 if ( !anInitialPath.isEmpty() )
716 fd->setDirectory( anInitialPath );
717 fd->selectFile(aMeshName);
720 QListView *lview = fd->findChild<QListView*>("listView");
722 lview->setMinimumHeight(200);
724 QTreeView *tview = fd->findChild<QTreeView*>("treeView");
726 tview->setMinimumHeight(200);
729 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
730 fd->setValidator( fv );
735 aFilename = fd->selectedFile();
737 aFilename = QString::null;
740 aFormat = aFilterMap[fd->selectedNameFilter()];
741 toOverwrite = fv->isOverwrite();
743 if ( !aFilename.isEmpty() ) {
744 // med-2.1 does not support poly elements
745 if ( aFormat==SMESH::MED_V2_1 )
746 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
747 SMESH::SMESH_IDSource_var aMeshItem = (*aMeshIter).first;
748 SMESH::long_array_var nbElems = aMeshItem->GetMeshInfo();
749 if ( nbElems[ SMESH::Entity_Polygon ] + nbElems[ SMESH::Entity_Quad_Polygon ] +
750 nbElems[ SMESH::Entity_Polyhedra ] + nbElems[ SMESH::Entity_Quad_Polyhedra ])
752 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
753 QObject::tr("SMESH_WRN_WARNING"),
754 QObject::tr("SMESH_EXPORT_MED_V2_1").arg((*aMeshIter).second),
755 QObject::tr("SMESH_BUT_YES"),
756 QObject::tr("SMESH_BUT_NO"), 0, 1);
764 // can't append to an existing using other format
765 SMESH::MED_VERSION aVersion = SMESH::MED_V2_1;
766 bool isVersionOk = SMESHGUI::GetSMESHGen()->GetMEDVersion( aFilename.toUtf8().constData(), aVersion );
767 if( !isVersionOk || aVersion != aFormat ) {
768 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
769 QObject::tr("SMESH_WRN_WARNING"),
770 QObject::tr("SMESH_EXPORT_MED_VERSION_COLLISION").arg(aFilename),
771 QObject::tr("SMESH_BUT_YES"),
772 QObject::tr("SMESH_BUT_NO"), 0, 1);
779 QStringList aMeshNamesCollisionList;
780 SMESH::string_array_var aMeshNames = SMESHGUI::GetSMESHGen()->GetMeshNames( aFilename.toUtf8().constData() );
781 for( int i = 0, n = aMeshNames->length(); i < n; i++ ) {
782 QString anExistingMeshName( aMeshNames[ i ] );
783 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
784 QString anExportMeshName = (*aMeshIter).second;
785 if( anExportMeshName == anExistingMeshName ) {
786 aMeshNamesCollisionList.append( anExportMeshName );
791 if( !aMeshNamesCollisionList.isEmpty() ) {
792 QString aMeshNamesCollisionString = aMeshNamesCollisionList.join( ", " );
793 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
794 QObject::tr("SMESH_WRN_WARNING"),
795 QObject::tr("SMESH_EXPORT_MED_MESH_NAMES_COLLISION").arg(aMeshNamesCollisionString),
796 QObject::tr("SMESH_BUT_YES"),
797 QObject::tr("SMESH_BUT_NO"),
798 QObject::tr("SMESH_BUT_CANCEL"), 0, 2);
807 toCreateGroups = fd->IsChecked(0);
808 toFindOutDim = fd->IsChecked(1);
809 fieldSelWdg->GetSelectedFeilds();
810 if ( !fieldSelWdg->parent() )
821 if ( !aFilename.isEmpty() ) {
822 // Check whether the file already exists and delete it if yes
823 QFile aFile( aFilename );
824 if ( aFile.exists() && toOverwrite )
826 SUIT_OverrideCursor wc;
829 // Renumbering is not needed since SMDS redesign in V6.2.0 (Nov 2010)
830 // bool Renumber = false;
831 // // PAL 14172 : Check of we have to renumber or not from the preferences before export
833 // Renumber= resMgr->booleanValue("renumbering");
835 // SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
836 // aMeshEditor->RenumberNodes();
837 // aMeshEditor->RenumberElements();
838 // if ( SMESHGUI::automaticUpdate() )
839 // SMESH::UpdateView();
843 aMeshIter = aMeshList.begin();
844 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
846 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
847 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
848 const GEOM::ListOfFields& fields = aFieldList[ aMeshIndex ].first.in();
849 const QString& geoAssFields = aFieldList[ aMeshIndex ].second;
850 const bool hasFields = ( fields.length() || !geoAssFields.isEmpty() );
851 if ( !hasFields && aMeshOrGroup->_is_equivalent( aMeshItem ))
852 aMeshItem->ExportToMEDX( aFilename.toUtf8().data(), toCreateGroups,
853 aFormat, toOverwrite && aMeshIndex == 0, toFindOutDim );
855 aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups,
856 aFormat, toOverwrite && aMeshIndex == 0, toFindOutDim,
857 fields, geoAssFields.toLatin1().data() );
862 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ )
864 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
865 if( !aMeshItem->_is_nil() )
866 aMeshItem->ExportSAUV( aFilename.toUtf8().data(), toCreateGroups );
871 if ( aMeshOrGroup->_is_equivalent( aMesh ))
872 aMesh->ExportDAT( aFilename.toUtf8().data() );
874 aMesh->ExportPartToDAT( aMeshOrGroup, aFilename.toUtf8().data() );
878 if ( aMeshOrGroup->_is_equivalent( aMesh ))
879 aMesh->ExportUNV( aFilename.toUtf8().data() );
881 aMesh->ExportPartToUNV( aMeshOrGroup, aFilename.toUtf8().data() );
885 if ( aMeshOrGroup->_is_equivalent( aMesh ))
886 aMesh->ExportSTL( aFilename.toUtf8().data(), aIsASCII_STL );
888 aMesh->ExportPartToSTL( aMeshOrGroup, aFilename.toUtf8().data(), aIsASCII_STL );
892 aMeshIter = aMeshList.begin();
893 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
895 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
896 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
897 aMeshItem->ExportCGNS( aMeshOrGroup,
898 aFilename.toUtf8().data(),
899 toOverwrite && aMeshIndex == 0 );
904 toCreateGroups = true;
905 aMesh->ExportGMF( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups );
908 catch (const SALOME::SALOME_Exception& S_ex){
910 SUIT_MessageBox::warning(SMESHGUI::desktop(),
911 QObject::tr("SMESH_WRN_WARNING"),
912 QObject::tr("SMESH_EXPORT_FAILED"));
918 inline void InverseEntityMode(unsigned int& theOutputMode,
919 unsigned int theMode)
921 bool anIsNotPresent = ~theOutputMode & theMode;
923 theOutputMode |= theMode;
925 theOutputMode &= ~theMode;
928 void SetDisplayEntity(int theCommandID){
929 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
930 SALOME_ListIO selected;
932 aSel->selectedObjects( selected );
934 if(selected.Extent() >= 1){
935 SALOME_ListIteratorOfListIO It( selected );
936 for( ; It.More(); It.Next()){
937 Handle(SALOME_InteractiveObject) IObject = It.Value();
938 if(IObject->hasEntry()){
939 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
940 unsigned int aMode = anActor->GetEntityMode();
941 switch(theCommandID){
942 case SMESHOp::OpDE0DElements:
943 InverseEntityMode(aMode,SMESH_Actor::e0DElements);
945 case SMESHOp::OpDEEdges:
946 InverseEntityMode(aMode,SMESH_Actor::eEdges);
948 case SMESHOp::OpDEFaces:
949 InverseEntityMode(aMode,SMESH_Actor::eFaces);
951 case SMESHOp::OpDEVolumes:
952 InverseEntityMode(aMode,SMESH_Actor::eVolumes);
954 case SMESHOp::OpDEBalls:
955 InverseEntityMode(aMode,SMESH_Actor::eBallElem);
957 case SMESHOp::OpDEAllEntity:
958 aMode = SMESH_Actor::eAllEntity;
962 anActor->SetEntityMode(aMode);
971 SALOME_ListIO selected;
972 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
976 LightApp_SelectionMgr* aSel = app->selectionMgr();
977 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
978 if( !aSel || !appStudy )
981 aSel->selectedObjects( selected );
982 if( selected.IsEmpty() )
985 Handle(SALOME_InteractiveObject) anIObject = selected.First();
987 _PTR(Study) aStudy = appStudy->studyDS();
988 _PTR(SObject) aMainSObject( aStudy->FindObjectID( anIObject->getEntry() ) );
989 SMESH::SMESH_Mesh_var aMainObject = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
990 if( aMainObject->_is_nil() )
993 SUIT_OverrideCursor wc;
995 aMainObject->SetAutoColor( true ); // mesh groups are re-colored here
997 QList<SALOMEDS::Color> aReservedColors;
999 SMESH::ListOfGroups aListOfGroups = *aMainObject->GetGroups();
1000 for( int i = 0, n = aListOfGroups.length(); i < n; i++ )
1002 SMESH::SMESH_GroupBase_var aGroupObject = aListOfGroups[i];
1003 //SALOMEDS::Color aColor = aGroupObject->GetColor();
1005 #ifdef SIMPLE_AUTOCOLOR // simplified algorithm for auto-colors
1006 SALOMEDS::Color aColor = SMESHGUI::getPredefinedUniqueColor();
1007 #else // old algorithm for auto-colors
1008 SALOMEDS::Color aColor = SMESHGUI::getUniqueColor( aReservedColors );
1009 aReservedColors.append( aColor );
1010 #endif // SIMPLE_AUTOCOLOR
1011 aGroupObject->SetColor( aColor );
1013 _PTR(SObject) aGroupSObject = SMESH::FindSObject(aGroupObject);
1014 if (aGroupSObject) {
1017 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(aGroupSObject->GetID().c_str())) {
1018 switch ( aGroupObject->GetType ()) {
1020 anActor->SetNodeColor( aColor.R, aColor.G, aColor.B ); break;
1022 anActor->SetEdgeColor( aColor.R, aColor.G, aColor.B ); break;
1024 anActor->Set0DColor( aColor.R, aColor.G, aColor.B ); break;
1026 anActor->SetBallColor( aColor.R, aColor.G, aColor.B ); break;
1028 SMESH::GetColor("SMESH", "volume_color", c, delta, "255,0,170|-100");
1029 anActor->SetVolumeColor( aColor.R, aColor.G, aColor.B, delta ); break;
1032 SMESH::GetColor("SMESH", "fill_color", c, delta, "0,170,255|-100");
1033 anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B, delta );
1039 SMESH::RepaintCurrentView();
1042 void OverallMeshQuality() {
1043 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1044 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1045 SALOME_ListIO selected;
1047 aSel->selectedObjects( selected );
1049 if ( selected.IsEmpty() ) return;
1050 SALOME_ListIteratorOfListIO It( selected );
1051 for ( ; It.More(); It.Next() ) {
1052 SMESHGUI_CtrlInfoDlg* ctrlDlg = new SMESHGUI_CtrlInfoDlg( SMESHGUI::desktop() );
1053 ctrlDlg->showInfo( It.Value() );
1058 QString functorToString( SMESH::Controls::FunctorPtr f )
1060 QString type = QObject::tr( "UNKNOWN_CONTROL" );
1061 if ( dynamic_cast< SMESH::Controls::Volume* >( f.get() ) )
1062 type = QObject::tr( "VOLUME_3D_ELEMENTS" );
1063 else if ( dynamic_cast< SMESH::Controls::MaxElementLength2D* >( f.get() ) )
1064 type = QObject::tr( "MAX_ELEMENT_LENGTH_2D" );
1065 else if ( dynamic_cast< SMESH::Controls::MaxElementLength3D* >( f.get() ) )
1066 type = QObject::tr( "MAX_ELEMENT_LENGTH_3D" );
1067 else if ( dynamic_cast< SMESH::Controls::MinimumAngle* >( f.get() ) )
1068 type = QObject::tr( "MINIMUMANGLE_ELEMENTS" );
1069 else if ( dynamic_cast< SMESH::Controls::AspectRatio* >( f.get() ) )
1070 type = QObject::tr( "ASPECTRATIO_ELEMENTS" );
1071 else if ( dynamic_cast< SMESH::Controls::AspectRatio3D* >( f.get() ) )
1072 type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" );
1073 else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) )
1074 type = QObject::tr( "WARP_ELEMENTS" );
1075 else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) )
1076 type = QObject::tr( "TAPER_ELEMENTS" );
1077 else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) )
1078 type = QObject::tr( "SKEW_ELEMENTS" );
1079 else if ( dynamic_cast< SMESH::Controls::Area* >( f.get() ) )
1080 type = QObject::tr( "AREA_ELEMENTS" );
1081 else if ( dynamic_cast< SMESH::Controls::Length* >( f.get() ) )
1082 type = QObject::tr( "LENGTH_EDGES" );
1083 else if ( dynamic_cast< SMESH::Controls::Length2D* >( f.get() ) )
1084 type = QObject::tr( "LENGTH2D_EDGES" );
1085 else if ( dynamic_cast< SMESH::Controls::MultiConnection* >( f.get() ) )
1086 type = QObject::tr( "MULTI_BORDERS" );
1087 else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) )
1088 type = QObject::tr( "MULTI2D_BORDERS" );
1089 else if ( dynamic_cast< SMESH::Controls::FreeNodes* >( f.get() ) )
1090 type = QObject::tr( "FREE_NODES" );
1091 else if ( dynamic_cast< SMESH::Controls::FreeEdges* >( f.get() ) )
1092 type = QObject::tr( "FREE_EDGES" );
1093 else if ( dynamic_cast< SMESH::Controls::FreeBorders* >( f.get() ) )
1094 type = QObject::tr( "FREE_BORDERS" );
1095 else if ( dynamic_cast< SMESH::Controls::FreeFaces* >( f.get() ) )
1096 type = QObject::tr( "FREE_FACES" );
1097 else if ( dynamic_cast< SMESH::Controls::BareBorderVolume* >( f.get() ) )
1098 type = QObject::tr( "BARE_BORDER_VOLUME" );
1099 else if ( dynamic_cast< SMESH::Controls::BareBorderFace* >( f.get() ) )
1100 type = QObject::tr( "BARE_BORDER_FACE" );
1101 else if ( dynamic_cast< SMESH::Controls::OverConstrainedVolume* >( f.get() ) )
1102 type = QObject::tr( "OVER_CONSTRAINED_VOLUME" );
1103 else if ( dynamic_cast< SMESH::Controls::OverConstrainedFace* >( f.get() ) )
1104 type = QObject::tr( "OVER_CONSTRAINED_FACE" );
1105 else if ( dynamic_cast< SMESH::Controls::CoincidentNodes* >( f.get() ) )
1106 type = QObject::tr( "EQUAL_NODE" );
1107 else if ( dynamic_cast< SMESH::Controls::CoincidentElements1D* >( f.get() ) )
1108 type = QObject::tr( "EQUAL_EDGE" );
1109 else if ( dynamic_cast< SMESH::Controls::CoincidentElements2D* >( f.get() ) )
1110 type = QObject::tr( "EQUAL_FACE" );
1111 else if ( dynamic_cast< SMESH::Controls::CoincidentElements3D* >( f.get() ) )
1112 type = QObject::tr( "EQUAL_VOLUME" );
1116 void SaveDistribution()
1118 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1119 SALOME_ListIO selected;
1121 aSel->selectedObjects( selected );
1123 if ( selected.Extent() == 1 ) {
1124 Handle(SALOME_InteractiveObject) anIO = selected.First();
1125 if ( anIO->hasEntry() ) {
1126 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1127 if ( anActor && anActor->GetScalarBarActor() && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1128 SMESH_ScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor();
1129 SMESH::Controls::FunctorPtr aFunctor = anActor->GetFunctor();
1130 if ( aScalarBarActor && aFunctor ) {
1131 SMESH::Controls::NumericalFunctor* aNumFun = dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
1133 std::vector<int> elements;
1134 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
1135 if ( mesh->_is_nil() ) {
1136 SMESH::SMESH_IDSource_var idSource =
1137 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
1138 if ( !idSource->_is_nil() )
1140 SMESH::long_array_var ids = idSource->GetIDs();
1141 elements.resize( ids->length() );
1142 for ( unsigned i = 0; i < elements.size(); ++i )
1143 elements[i] = ids[i];
1146 int nbIntervals = aScalarBarActor->GetMaximumNumberOfColors();
1147 vtkLookupTable* lookupTable =
1148 static_cast<vtkLookupTable*>(aScalarBarActor->GetLookupTable());
1149 double * minmax = lookupTable->GetRange();
1150 bool isLogarithmic = lookupTable->GetScale() == VTK_SCALE_LOG10;
1151 std::vector<int> nbEvents;
1152 std::vector<double> funValues;
1153 aNumFun->GetHistogram( nbIntervals, nbEvents, funValues, elements, minmax, isLogarithmic );
1154 QString anInitialPath = "";
1155 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
1156 anInitialPath = QDir::currentPath();
1157 QString aMeshName = anIO->getName();
1159 filter.append( QObject::tr( "TEXT_FILES_FILTER" ) + " (*.txt)" );
1160 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
1161 QString aFilename = anInitialPath + "/" + aMeshName + "_" +
1162 functorToString( aFunctor ).toLower().simplified().replace( QRegExp( " |-" ), "_" ) + ".txt";
1163 aFilename = SUIT_FileDlg::getFileName( SMESHGUI::desktop(),
1166 QObject::tr( "SMESH_SAVE_DISTRIBUTION" ),
1168 if ( !aFilename.isEmpty() ) {
1169 QFile f( aFilename );
1170 if ( f.open( QFile::WriteOnly | QFile::Truncate ) ) {
1171 QTextStream out( &f );
1172 out << "# Mesh: " << aMeshName << endl;
1173 out << "# Control: " << functorToString( aFunctor ) << endl;
1175 out.setFieldWidth( 10 );
1176 for ( int i = 0; i < qMin( nbEvents.size(), funValues.size()-1 ); i++ )
1177 out << funValues[i] << "\t" << funValues[i+1] << "\t" << nbEvents[i] << endl;
1188 void ShowElement(int theCommandID ) {
1189 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1190 SALOME_ListIO selected;
1192 aSel->selectedObjects( selected );
1194 if ( selected.Extent() == 1 ) {
1195 Handle(SALOME_InteractiveObject) anIO = selected.First();
1196 if ( anIO->hasEntry() ) {
1197 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1198 if ( anActor && anActor->GetScalarBarActor() && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1199 SMESH_ScalarBarActor *aScalarBarActor = anActor->GetScalarBarActor();
1200 if ( theCommandID == SMESHOp::OpShowDistribution ) {
1201 aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility());
1203 else if ( theCommandID == SMESHOp::OpShowScalarBar ) {
1204 aScalarBarActor->SetVisibility( !aScalarBarActor->GetVisibility());
1211 #ifndef DISABLE_PLOT2DVIEWER
1212 void PlotDistribution() {
1213 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1217 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1218 SALOME_ListIO selected;
1220 aSel->selectedObjects( selected );
1222 if ( selected.Extent() == 1 ) {
1223 Handle(SALOME_InteractiveObject) anIO = selected.First();
1224 if ( anIO->hasEntry() ) {
1225 //Find Actor by entry before getting Plot2d viewer,
1226 //because after call getViewManager( Plot2d_Viewer::Type(), true ) active window is Plot2d Viewer
1227 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1229 SUIT_ViewManager* aViewManager = app->getViewManager( Plot2d_Viewer::Type(), true ); // create if necessary
1234 SPlot2d_Viewer* aView = dynamic_cast<SPlot2d_Viewer*>(aViewManager->getViewModel());
1238 Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
1242 if ( anActor && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1243 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1244 QString functorName = functorToString( anActor->GetFunctor());
1245 QString aHistogramName("%1 : %2");
1246 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1247 aHistogram->setName(aHistogramName);
1248 aHistogram->setHorTitle(functorName);
1249 aHistogram->setVerTitle(QObject::tr("DISTRIBUTION_NB_ENT"));
1250 aPlot->displayObject(aHistogram, true);
1255 #endif //DISABLE_PLOT2DVIEWER
1257 void DisableAutoColor(){
1258 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1259 SALOME_ListIO selected;
1261 aSel->selectedObjects( selected );
1263 if(selected.Extent()){
1264 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1265 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1266 if ( !aMesh->_is_nil() ) {
1267 aMesh->SetAutoColor( false );
1272 void sortChildren(){
1273 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1274 SALOME_ListIO selected;
1276 aSel->selectedObjects( selected );
1278 if(selected.Extent()){
1279 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1280 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1281 _PTR(SObject) aSObj = aStudy->FindObjectID(anIObject->getEntry());
1283 if ( aStudy->GetUseCaseBuilder()->SortChildren( aSObj, true/*AscendingOrder*/ ) ) {
1284 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1291 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap)
1293 SALOME_ListIO selected;
1294 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1298 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1299 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1300 if( !aSel || !appStudy )
1303 if( theCommandID == SMESHOp::OpClipping ) { // Clipping dialog can be activated without selection
1304 if( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
1305 aModule->EmitSignalDeactivateDialog();
1306 if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
1307 (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
1312 _PTR(Study) aStudy = appStudy->studyDS();
1314 aSel->selectedObjects( selected );
1316 if(selected.Extent() >= 1){
1317 switch(theCommandID){
1318 case SMESHOp::OpTransparency:{
1319 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1320 (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
1323 case SMESHOp::OpProperties: {
1325 QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
1326 QColor orientationColor, outlineColor, volumeColor;
1327 int deltaF = 0, deltaV = 0;
1330 double ballScale = 1.0;
1332 int outlineWidth = 1;
1333 double shrinkCoef = 0.0;
1334 double orientationScale = 0.0;
1335 bool orientation3d = false;
1336 VTK::MarkerType markerType = VTK::MT_NONE;
1337 VTK::MarkerScale markerScale = VTK::MS_NONE;
1339 bool hasNodes = false;
1340 int presentEntities = 0;
1341 bool firstTime = true;
1343 SALOME_ListIteratorOfListIO It( selected );
1344 for ( ; It.More(); It.Next() ) {
1345 Handle(SALOME_InteractiveObject) IObject = It.Value();
1346 if ( !IObject->hasEntry() ) continue;
1347 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1348 if ( !anActor || !anActor->GetObject() ) continue;
1351 // nodes: color, marker
1352 anActor->GetNodeColor( color[0], color[1], color[2] );
1353 nodeColor.setRgbF( color[0], color[1], color[2] );
1354 markerType = anActor->GetMarkerType();
1355 markerScale = anActor->GetMarkerScale();
1356 markerId = anActor->GetMarkerTexture();
1357 // edges: color, width
1358 anActor->GetEdgeColor( color[0], color[1], color[2] );
1359 edgeColor.setRgbF( color[0], color[1], color[2] );
1360 edgeWidth = qMax( (int)anActor->GetLineWidth(), 1 ); // minimum allowed width is 1
1361 // faces: front color, back color (delta)
1362 anActor->GetSufaceColor( color[0], color[1], color[2], deltaF );
1363 faceColor.setRgbF( color[0], color[1], color[2] );
1364 // faces: front color, back color (delta)
1365 anActor->GetVolumeColor( color[0], color[1], color[2], deltaV );
1366 volumeColor.setRgbF( color[0], color[1], color[2] );
1367 // 0d elements: color, size
1368 anActor->Get0DColor( color[0], color[1], color[2] );
1369 elem0dColor.setRgbF( color[0], color[1], color[2] );
1370 elem0dSize = qMax( (int)anActor->Get0DSize(), 1 ); // minimum allowed size is 1
1371 // balls: color, size
1372 anActor->GetBallColor( color[0], color[1], color[2] );
1373 ballColor.setRgbF( color[0], color[1], color[2] );
1374 //ballSize = qMax( (int)anActor->GetBallSize(), 1 ); // minimum allowed size is 1
1375 ballScale = qMax( (double)anActor->GetBallScale(), 1e-2 ); // minimum allowed scale is 1e-2
1377 anActor->GetOutlineColor( color[0], color[1], color[2] );
1378 outlineColor.setRgbF( color[0], color[1], color[2] );
1379 outlineWidth = qMax( (int)anActor->GetOutlineWidth(), 1 ); // minimum allowed width is 1
1380 // orientation vectors: color, scale, 3d flag
1381 anActor->GetFacesOrientationColor( color[0], color[1], color[2] );
1382 orientationColor.setRgbF( color[0], color[1], color[2] );
1383 orientationScale = anActor->GetFacesOrientationScale();
1384 orientation3d = anActor->GetFacesOrientation3DVectors();
1386 shrinkCoef = anActor->GetShrinkFactor();
1389 firstTime = false; // we only take properties from first object (for performance reasons)
1392 hasNodes = anActor->GetObject()->GetNbEntities( SMDSAbs_Node );
1393 if ( !(presentEntities & SMESH_Actor::eEdges) && anActor->GetObject()->GetNbEntities( SMDSAbs_Edge ) )
1394 presentEntities = presentEntities | SMESH_Actor::eEdges;
1395 if ( !(presentEntities & SMESH_Actor::eFaces) && anActor->GetObject()->GetNbEntities( SMDSAbs_Face ) )
1396 presentEntities = presentEntities | SMESH_Actor::eFaces;
1397 if ( !(presentEntities & SMESH_Actor::eVolumes) && anActor->GetObject()->GetNbEntities( SMDSAbs_Volume ) )
1398 presentEntities = presentEntities | SMESH_Actor::eVolumes;
1399 if ( !(presentEntities & SMESH_Actor::e0DElements) && anActor->GetObject()->GetNbEntities( SMDSAbs_0DElement ) )
1400 presentEntities = presentEntities | SMESH_Actor::e0DElements;
1401 if ( !(presentEntities & SMESH_Actor::eBallElem) && anActor->GetObject()->GetNbEntities( SMDSAbs_Ball ) )
1402 presentEntities = presentEntities | SMESH_Actor::eBallElem;
1404 // as we know that all types of elements are present, we can exit the loop
1405 if ( presentEntities == SMESH_Actor::eAllEntity )
1409 SMESHGUI_PropertiesDlg dlg( theMarkerMap[ aStudy->StudyId() ], SMESHGUI::desktop() );
1410 // nodes: color, marker
1411 dlg.setNodeColor( nodeColor );
1412 if( markerType != VTK::MT_USER )
1413 dlg.setNodeMarker( markerType, markerScale );
1415 dlg.setNodeCustomMarker( markerId );
1416 // edges: color, line width
1417 dlg.setEdgeColor( edgeColor );
1418 dlg.setEdgeWidth( edgeWidth );
1419 // faces: front color, back color
1420 dlg.setFaceColor( faceColor, deltaF );
1421 // volumes: normal color, reversed color
1422 dlg.setVolumeColor( volumeColor, deltaV );
1423 // outlines: color, line width
1424 dlg.setOutlineColor( outlineColor );
1425 dlg.setOutlineWidth( outlineWidth );
1426 // 0d elements: color, size
1427 dlg.setElem0dColor( elem0dColor );
1428 dlg.setElem0dSize( elem0dSize );
1429 // balls: color, size
1430 dlg.setBallColor( ballColor );
1431 //dlg.setBallSize( ballSize );
1432 dlg.setBallScale( ballScale );
1433 // orientation: color, scale, 3d flag
1434 dlg.setOrientationColor( orientationColor );
1435 dlg.setOrientationSize( int( orientationScale * 100. ) );
1436 dlg.setOrientation3d( orientation3d );
1437 // shrink: scale factor
1438 dlg.setShrinkCoef( int( shrinkCoef * 100. ) );
1439 // hide unused controls
1440 dlg.showControls( presentEntities, hasNodes );
1443 nodeColor = dlg.nodeColor();
1444 markerType = dlg.nodeMarkerType();
1445 markerScale = dlg.nodeMarkerScale();
1446 markerId = dlg.nodeMarkerId();
1447 edgeColor = dlg.edgeColor();
1448 edgeWidth = dlg.edgeWidth();
1449 faceColor = dlg.faceColor();
1450 deltaF = dlg.faceColorDelta();
1451 volumeColor = dlg.volumeColor();
1452 deltaV = dlg.volumeColorDelta();
1453 outlineColor = dlg.outlineColor();
1454 outlineWidth = dlg.outlineWidth();
1455 elem0dColor = dlg.elem0dColor();
1456 elem0dSize = dlg.elem0dSize();
1457 ballColor = dlg.ballColor();
1458 // ballSize = dlg.ballSize();
1459 ballScale = dlg.ballScale();
1460 orientationColor = dlg.orientationColor();
1461 orientationScale = dlg.orientationSize() / 100.;
1462 orientation3d = dlg.orientation3d();
1463 shrinkCoef = dlg.shrinkCoef() / 100.;
1465 // store point markers map that might be changed by the user
1466 theMarkerMap[ aStudy->StudyId() ] = dlg.customMarkers();
1468 // set properties from dialog box to the presentations
1469 SALOME_ListIteratorOfListIO It( selected );
1470 for ( ; It.More(); It.Next() ) {
1471 Handle(SALOME_InteractiveObject) IObject = It.Value();
1472 if ( !IObject->hasEntry() ) continue;
1473 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1474 if ( !anActor ) continue;
1476 // nodes: color, marker
1477 anActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
1478 if ( markerType != VTK::MT_USER ) {
1479 anActor->SetMarkerStd( markerType, markerScale );
1482 const VTK::MarkerMap& markerMap = theMarkerMap[ aStudy->StudyId() ];
1483 VTK::MarkerMap::const_iterator iter = markerMap.find( markerId );
1484 if ( iter != markerMap.end() )
1485 anActor->SetMarkerTexture( markerId, iter->second.second );
1487 // volumes: normal color, reversed color (delta)
1488 anActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
1489 // faces: front color, back color (delta)
1490 anActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
1491 // edges: color, width
1492 anActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
1493 anActor->SetLineWidth( edgeWidth );
1495 anActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
1496 anActor->SetOutlineWidth( outlineWidth );
1497 // 0D elements: color, size
1498 anActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
1499 anActor->Set0DSize( elem0dSize );
1500 // balls: color, size
1501 anActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
1502 // anActor->SetBallSize( ballSize );
1503 anActor->SetBallScale( ballScale );
1504 // orientation: color, scale, 3d flag
1505 anActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
1506 anActor->SetFacesOrientationScale( orientationScale );
1507 anActor->SetFacesOrientation3DVectors( orientation3d );
1509 anActor->SetShrinkFactor( shrinkCoef );
1511 // for groups, set also proper color
1512 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1513 if ( !aGroupObject->_is_nil() ) {
1514 SMESH::ElementType anElementType = aGroupObject->GetType();
1516 switch( anElementType ) {
1518 aColor = nodeColor; break;
1520 aColor = edgeColor; break;
1522 aColor = faceColor; break;
1524 aColor = volumeColor; break;
1526 aColor = elem0dColor; break;
1528 aColor = ballColor; break;
1532 if ( aColor.isValid() ) {
1533 SALOMEDS::Color aGroupColor;
1534 aGroupColor.R = aColor.redF();
1535 aGroupColor.G = aColor.greenF();
1536 aGroupColor.B = aColor.blueF();
1537 aGroupObject->SetColor( aGroupColor );
1539 } // if ( !aGroupObject->_is_nil() )
1540 } // for ( ; It.More(); It.Next() )
1541 SMESH::RepaintCurrentView();
1542 } // if ( dlg.exec() )
1544 } // case SMESHOp::OpProperties:
1545 } // switch(theCommandID)
1546 SALOME_ListIteratorOfListIO It( selected );
1547 for( ; It.More(); It.Next()){
1548 Handle(SALOME_InteractiveObject) IObject = It.Value();
1549 if(IObject->hasEntry()){
1550 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1551 switch(theCommandID){
1552 case SMESHOp::OpDMWireframe:
1553 anActor->SetRepresentation(SMESH_Actor::eEdge);
1555 case SMESHOp::OpDMShading:
1556 anActor->SetRepresentation(SMESH_Actor::eSurface);
1558 case SMESHOp::OpDMShrink:
1559 if(anActor->IsShrunk())
1560 anActor->UnShrink();
1562 anActor->SetShrink();
1564 case SMESHOp::OpDMNodes:
1565 anActor->SetRepresentation(SMESH_Actor::ePoint);
1567 case SMESHOp::OpRepresentationLines:
1568 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1569 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1571 case SMESHOp::OpRepresentationArcs:
1572 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1573 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1579 SMESH::RepaintCurrentView();
1583 void Control( int theCommandID )
1585 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
1586 switch ( theCommandID ){
1587 case SMESHOp::OpFreeNode:
1588 aControl = SMESH_Actor::eFreeNodes;
1590 case SMESHOp::OpEqualNode:
1591 aControl = SMESH_Actor::eCoincidentNodes;
1593 case SMESHOp::OpFreeEdge:
1594 aControl = SMESH_Actor::eFreeEdges;
1596 case SMESHOp::OpFreeBorder:
1597 aControl = SMESH_Actor::eFreeBorders;
1599 case SMESHOp::OpLength:
1600 aControl = SMESH_Actor::eLength;
1602 case SMESHOp::OpConnection:
1603 aControl = SMESH_Actor::eMultiConnection;
1605 case SMESHOp::OpEqualEdge:
1606 aControl = SMESH_Actor::eCoincidentElems1D;
1608 case SMESHOp::OpFreeFace:
1609 aControl = SMESH_Actor::eFreeFaces;
1611 case SMESHOp::OpBareBorderFace:
1612 aControl = SMESH_Actor::eBareBorderFace;
1614 case SMESHOp::OpOverConstrainedFace:
1615 aControl = SMESH_Actor::eOverConstrainedFace;
1617 case SMESHOp::OpLength2D:
1618 aControl = SMESH_Actor::eLength2D;
1620 case SMESHOp::OpConnection2D:
1621 aControl = SMESH_Actor::eMultiConnection2D;
1623 case SMESHOp::OpArea:
1624 aControl = SMESH_Actor::eArea;
1626 case SMESHOp::OpTaper:
1627 aControl = SMESH_Actor::eTaper;
1629 case SMESHOp::OpAspectRatio:
1630 aControl = SMESH_Actor::eAspectRatio;
1632 case SMESHOp::OpMinimumAngle:
1633 aControl = SMESH_Actor::eMinimumAngle;
1635 case SMESHOp::OpWarpingAngle:
1636 aControl = SMESH_Actor::eWarping;
1638 case SMESHOp::OpSkew:
1639 aControl = SMESH_Actor::eSkew;
1641 case SMESHOp::OpMaxElementLength2D:
1642 aControl = SMESH_Actor::eMaxElementLength2D;
1644 case SMESHOp::OpEqualFace:
1645 aControl = SMESH_Actor:: eCoincidentElems2D;
1647 case SMESHOp::OpAspectRatio3D:
1648 aControl = SMESH_Actor::eAspectRatio3D;
1650 case SMESHOp::OpVolume:
1651 aControl = SMESH_Actor::eVolume3D;
1653 case SMESHOp::OpMaxElementLength3D:
1654 aControl = SMESH_Actor::eMaxElementLength3D;
1656 case SMESHOp::OpBareBorderVolume:
1657 aControl = SMESH_Actor::eBareBorderVolume;
1659 case SMESHOp::OpOverConstrainedVolume:
1660 aControl = SMESH_Actor::eOverConstrainedVolume;
1662 case SMESHOp::OpEqualVolume:
1663 aControl = SMESH_Actor::eCoincidentElems3D;
1666 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1667 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1668 SALOME_ListIO selected;
1670 aSel->selectedObjects( selected );
1672 if( !selected.IsEmpty() ){
1673 SALOME_ListIteratorOfListIO It(selected);
1674 for ( ; It.More(); It.Next())
1676 Handle(SALOME_InteractiveObject) anIO = It.Value();
1678 _PTR(SObject) SO = aStudy->FindObjectID( It.Value()->getEntry() );
1680 CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
1681 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_narrow( aObject );
1682 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( aObject );
1683 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( aObject );
1684 if ( !aMesh->_is_nil() || !aSubMesh->_is_nil() || !aGroup->_is_nil() ) {
1685 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIO->getEntry())) {
1686 anActor->SetControlMode(aControl);
1687 anActor->GetScalarBarActor()->SetTitle( functorToString( anActor->GetFunctor() ).toLatin1().constData() );
1688 SMESH::RepaintCurrentView();
1689 #ifndef DISABLE_PLOT2DVIEWER
1690 if(anActor->GetPlot2Histogram()) {
1691 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1692 QString functorName = functorToString( anActor->GetFunctor());
1693 QString aHistogramName("%1 : %2");
1694 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1695 aHistogram->setName(aHistogramName);
1696 aHistogram->setHorTitle(functorName);
1697 SMESH::ProcessIn2DViewers(anActor);
1709 bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1710 SMESH::MeshObjectType theType,
1711 const QString theInTypeName,
1712 QString & theOutTypeName)
1714 SMESH_TypeFilter aTypeFilter( theType );
1716 if( !theIO.IsNull() )
1718 entry = theIO->getEntry();
1719 LightApp_DataOwner owner( entry );
1720 if ( aTypeFilter.isOk( &owner )) {
1721 theOutTypeName = theInTypeName;
1729 QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1731 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1732 _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1734 _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1735 CORBA::String_var anID = aSComp->GetID().c_str();
1736 if (!strcmp(anID.in(),theIO->getEntry()))
1742 CheckOIType ( theIO, SMESH::HYPOTHESIS, "Hypothesis", aTypeName ) ||
1743 CheckOIType ( theIO, SMESH::ALGORITHM, "Algorithm", aTypeName ) ||
1744 CheckOIType ( theIO, SMESH::MESH, "Mesh", aTypeName ) ||
1745 CheckOIType ( theIO, SMESH::SUBMESH, "SubMesh", aTypeName ) ||
1746 CheckOIType ( theIO, SMESH::GROUP, "Group", aTypeName )
1754 QString CheckHomogeneousSelection()
1756 //SUIT_Study* aStudy = SMESH::GetActiveStudy();
1757 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1758 SALOME_ListIO selected;
1760 aSel->selectedObjects( selected );
1762 QString RefType = CheckTypeObject(selected.First());
1763 SALOME_ListIteratorOfListIO It(selected);
1764 for ( ; It.More(); It.Next())
1766 Handle(SALOME_InteractiveObject) IObject = It.Value();
1767 QString Type = CheckTypeObject(IObject);
1768 if (Type.compare(RefType) != 0)
1769 return "Heterogeneous Selection";
1775 uint randomize( uint size )
1777 static bool initialized = false;
1778 if ( !initialized ) {
1779 qsrand( QDateTime::currentDateTime().toTime_t() );
1783 v = uint( (double)( v ) / RAND_MAX * size );
1784 v = qMax( uint(0), qMin ( v, size-1 ) );
1790 void SMESHGUI::OnEditDelete()
1792 // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1793 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1794 SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1796 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1797 _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1798 _PTR(GenericAttribute) anAttr;
1799 _PTR(AttributeIOR) anIOR;
1801 int objectCount = 0;
1803 QString aParentComponent = QString::null;
1804 Handle(SALOME_InteractiveObject) anIO;
1805 for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1807 anIO = anIt.Value();
1808 QString cur = anIO->getComponentDataType();
1809 _PTR(SObject) aSO = aStudy->FindObjectID(anIO->getEntry());
1811 // check if object is reference
1812 _PTR(SObject) aRefSObj;
1813 aNameList.append("\n - ");
1814 if ( aSO->ReferencedObject( aRefSObj ) ) {
1815 QString aRefName = QString::fromStdString ( aRefSObj->GetName() );
1816 aNameList.append( aRefName );
1817 cur = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1820 aNameList.append(anIO->getName());
1824 if( aParentComponent.isNull() )
1825 aParentComponent = cur;
1826 else if( !aParentComponent.isEmpty() && aParentComponent!=cur )
1827 aParentComponent = "";
1830 if ( objectCount == 0 )
1831 return; // No Valid Objects Selected
1833 if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
1834 SUIT_MessageBox::warning( SMESHGUI::desktop(),
1835 QObject::tr("ERR_ERROR"),
1836 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
1839 // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
1840 if (SUIT_MessageBox::warning
1841 (SMESHGUI::desktop(),
1842 QObject::tr("SMESH_WRN_WARNING"),
1843 QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
1844 SUIT_MessageBox::Yes | SUIT_MessageBox::No,
1845 SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
1848 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1850 // Put the whole hierarchy of sub-objects of the selected SO's into a list and
1851 // then treat them all starting from the deepest objects (at list back)
1852 std::list< _PTR(SObject) > listSO;
1853 SALOME_ListIteratorOfListIO It(selected);
1854 for( ; It.More(); It.Next()) // loop on selected IO's
1856 Handle(SALOME_InteractiveObject) IObject = It.Value();
1857 if(IObject->hasEntry()) {
1858 _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
1860 // disable removal of "SMESH" component object
1861 if(aSO->FindAttribute(anAttr, "AttributeIOR")){
1863 if ( engineIOR() == anIOR->Value().c_str() )
1866 //Check the referenced object
1867 _PTR(SObject) aRefSObject;
1868 if ( aSO && aSO->ReferencedObject( aRefSObject ) )
1869 aSO = aRefSObject; // Delete main Object instead of reference
1871 listSO.push_back( aSO );
1872 std::list< _PTR(SObject) >::iterator itSO = --listSO.end();
1873 for ( ; itSO != listSO.end(); ++itSO ) {
1874 _PTR(ChildIterator) it = aStudy->NewChildIterator( *itSO );
1875 for (it->InitEx(false); it->More(); it->Next())
1876 listSO.push_back( it->Value() );
1880 // Check if none of objects to delete is referred from outside
1881 std::list< _PTR(SObject) >::reverse_iterator ritSO;
1882 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1884 _PTR(SObject) SO = *ritSO;
1885 if ( !SO ) continue;
1886 std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( *ritSO );
1887 for (size_t i = 0; i < aReferences.size(); i++) {
1888 _PTR(SComponent) aComponent = aReferences[i]->GetFatherComponent();
1889 std::string type = aComponent->ComponentDataType();
1890 if ( type != "SMESH" )
1892 SUIT_MessageBox::warning( anApp->desktop(),
1893 QObject::tr("WRN_WARNING"),
1894 QObject::tr("DEP_OBJECT") );
1895 return; // outside SMESH, there is an object depending on a SMESH object
1900 // Call mesh->Clear() to prevent loading mesh from file caused by hypotheses removal
1901 for( It.Initialize( selected ); It.More(); It.Next()) // loop on selected IO's
1903 Handle(SALOME_InteractiveObject) IObject = It.Value();
1904 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface< SMESH::SMESH_Mesh >( IObject );
1905 if ( !mesh->_is_nil() )
1909 // Treat SO's in the list starting from the back
1910 aStudyBuilder->NewCommand(); // There is a transaction
1911 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1913 _PTR(SObject) SO = *ritSO;
1914 if ( !SO ) continue;
1915 std::string anEntry = SO->GetID();
1917 /** Erase graphical object and remove all its data **/
1918 if(SO->FindAttribute(anAttr, "AttributeIOR")) {
1919 SMESH::RemoveVisualObjectWithActors( anEntry.c_str(), true);
1921 /** Remove an object from data structures **/
1922 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
1923 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
1924 if ( !aGroup->_is_nil() ) { // DELETE GROUP
1925 SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
1926 aMesh->RemoveGroup( aGroup );
1928 else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
1929 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
1930 aMesh->RemoveSubMesh( aSubMesh );
1932 _PTR(SObject) aMeshSO = SMESH::FindSObject(aMesh);
1934 SMESH::ModifiedMesh(aMeshSO, false, aMesh->NbNodes()==0);
1937 Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
1938 ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
1939 QString objType = CheckTypeObject(IObject);
1940 if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
1941 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
1942 aStudyBuilder->RemoveObjectWithChildren( SO );
1944 else {// default action: remove SObject from the study
1945 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
1946 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
1948 aStudyBuilder->RemoveObjectWithChildren( SO );
1952 } /* listSO back loop */
1954 aStudyBuilder->CommitCommand();
1956 /* Clear any previous selection */
1958 aSel->setSelectedObjects( l1 );
1960 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1964 SMESHGUI_EXPORT CAM_Module* createModule()
1966 return new SMESHGUI();
1969 SMESHGUI_EXPORT char* getModuleVersion() {
1970 return (char*)SMESH_VERSION_STR;
1974 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
1976 //=============================================================================
1980 //=============================================================================
1981 SMESHGUI::SMESHGUI() :
1982 SalomeApp_Module( "SMESH" )
1984 if ( CORBA::is_nil( myComponentSMESH ) )
1986 CORBA::Boolean anIsEmbeddedMode;
1987 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
1988 MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
1990 // 0019923: EDF 765 SMESH : default values of hypothesis
1991 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
1992 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
1993 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
1994 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
1995 myComponentSMESH->SetDefaultNbSegments( nbSeg );
1997 const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif" };
1998 for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
1999 if ( aResourceMgr->hasValue( "SMESH", options[i] ))
2001 QString val = aResourceMgr->stringValue( "SMESH", options[i] );
2002 myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
2006 myActiveDialogBox = 0;
2007 myFilterLibraryDlg = 0;
2011 myEventCallbackCommand = vtkCallbackCommand::New();
2012 myEventCallbackCommand->Delete();
2013 myEventCallbackCommand->SetClientData( this );
2014 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
2017 /* load resources for all available meshers */
2018 SMESH::InitAvailableHypotheses();
2021 //=============================================================================
2025 //=============================================================================
2026 SMESHGUI::~SMESHGUI()
2030 //=============================================================================
2034 //=============================================================================
2035 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
2037 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2039 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
2044 //=============================================================================
2048 //=============================================================================
2049 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
2051 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2055 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2056 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2057 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2058 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2059 return autoUpdate && !exceeded;
2062 //=============================================================================
2066 //=============================================================================
2067 bool SMESHGUI::automaticUpdate( SMESH::SMESH_IDSource_ptr theMesh,
2068 int* entities, bool* limitExceeded, int* hidden, long* nbElements )
2070 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2074 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2075 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2076 bool incrementalLimit = resMgr->booleanValue( "SMESH", "incremental_limit", false );
2078 SMESH::long_array_var info = theMesh->GetMeshInfo();
2079 long nbOdElems = info[SMDSEntity_0D];
2080 long nbEdges = info[SMDSEntity_Edge] + info[SMDSEntity_Quad_Edge];
2081 long nbFaces = info[SMDSEntity_Triangle] + info[SMDSEntity_Quad_Triangle] + info[SMDSEntity_BiQuad_Triangle] +
2082 info[SMDSEntity_Quadrangle] + info[SMDSEntity_Quad_Quadrangle] + info[SMDSEntity_BiQuad_Quadrangle] +
2083 info[SMDSEntity_Polygon] + info[SMDSEntity_Quad_Polygon];
2084 long nbVolumes = info[SMDSEntity_Tetra] + info[SMDSEntity_Quad_Tetra] +
2085 info[SMDSEntity_Hexa] + info[SMDSEntity_Quad_Hexa] + info[SMDSEntity_TriQuad_Hexa] +
2086 info[SMDSEntity_Pyramid] + info[SMDSEntity_Quad_Pyramid] +
2087 info[SMDSEntity_Penta] + info[SMDSEntity_Quad_Penta] +
2088 info[SMDSEntity_Polyhedra] +
2089 info[SMDSEntity_Hexagonal_Prism];
2090 long nbBalls = info[SMDSEntity_Ball];
2092 long requestedSize = nbOdElems + nbBalls + nbEdges + nbFaces + nbVolumes;
2093 *nbElements = requestedSize;
2095 *entities = SMESH_Actor::eAllEntity;
2098 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2100 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2102 if ( incrementalLimit ) {
2105 if ( nbOdElems > 0 ) {
2106 if ( total + nbOdElems > updateLimit ) {
2107 *entities = *entities & ~SMESH_Actor::e0DElements;
2108 *hidden = *hidden | SMESH_Actor::e0DElements;
2115 if ( nbEdges > 0 ) {
2116 if ( total + nbEdges > updateLimit ) {
2117 *entities = *entities & ~SMESH_Actor::eEdges;
2118 *hidden = *hidden | SMESH_Actor::eEdges;
2125 if ( nbFaces > 0 ) {
2126 if ( total + nbFaces > updateLimit ) {
2127 *entities = *entities & ~SMESH_Actor::eFaces;
2128 *hidden = *hidden | SMESH_Actor::eFaces;
2135 if ( nbVolumes > 0 ) {
2136 if ( total + nbVolumes > updateLimit ) {
2137 *entities = *entities & ~SMESH_Actor::eVolumes;
2138 *hidden = *hidden | SMESH_Actor::eVolumes;
2145 if ( nbBalls > 0 ) {
2146 if ( total + nbBalls > updateLimit ) {
2147 *entities = *entities & ~SMESH_Actor::eBallElem;
2148 *hidden = *hidden | SMESH_Actor::eBallElem;
2156 return autoUpdate && !exceeded;
2159 //=============================================================================
2163 //=============================================================================
2164 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
2166 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
2169 //=============================================================================
2173 //=============================================================================
2174 SMESHGUI* SMESHGUI::GetSMESHGUI()
2176 SMESHGUI* smeshMod = 0;
2177 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
2180 CAM_Module* module = app->module( "Mesh" );
2181 smeshMod = dynamic_cast<SMESHGUI*>( module );
2184 if ( smeshMod && smeshMod->application() && smeshMod->application()->activeStudy() )
2186 SalomeApp_Study* study = dynamic_cast<SalomeApp_Study*>( smeshMod->application()->activeStudy() );
2189 _PTR(Study) aStudy = study->studyDS();
2191 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
2200 Standard_EXPORT SMESHGUI* GetComponentGUI()
2202 return SMESHGUI::GetSMESHGUI();
2206 //=============================================================================
2210 //=============================================================================
2211 void SMESHGUI::SetState(int aState)
2216 //=============================================================================
2220 //=============================================================================
2221 void SMESHGUI::ResetState()
2226 //=============================================================================
2230 //=============================================================================
2231 void SMESHGUI::EmitSignalDeactivateDialog()
2233 emit SignalDeactivateActiveDialog();
2236 //=============================================================================
2240 //=============================================================================
2241 void SMESHGUI::EmitSignalStudyFrameChanged()
2243 emit SignalStudyFrameChanged();
2246 //=============================================================================
2250 //=============================================================================
2251 void SMESHGUI::EmitSignalCloseAllDialogs()
2253 emit SignalCloseAllDialogs();
2256 //=============================================================================
2260 //=============================================================================
2261 void SMESHGUI::EmitSignalVisibilityChanged()
2263 emit SignalVisibilityChanged();
2266 //=============================================================================
2270 //=============================================================================
2271 void SMESHGUI::EmitSignalCloseView()
2273 emit SignalCloseView();
2276 //=============================================================================
2280 //=============================================================================
2281 void SMESHGUI::EmitSignalActivatedViewManager()
2283 emit SignalActivatedViewManager();
2286 //=============================================================================
2290 //=============================================================================
2291 QDialog *SMESHGUI::GetActiveDialogBox()
2293 return myActiveDialogBox;
2296 //=============================================================================
2300 //=============================================================================
2301 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2303 myActiveDialogBox = (QDialog *) aDlg;
2307 //=============================================================================
2311 //=============================================================================
2312 SUIT_Desktop* SMESHGUI::desktop()
2314 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2316 return app->desktop();
2321 //=============================================================================
2325 //=============================================================================
2326 SalomeApp_Study* SMESHGUI::activeStudy()
2328 SUIT_Application* app = SUIT_Session::session()->activeApplication();
2330 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2335 //=============================================================================
2339 //=============================================================================
2340 void SMESHGUI::Modified( bool theIsUpdateActions )
2342 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2343 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2344 appStudy->Modified();
2345 if( theIsUpdateActions )
2346 app->updateActions();
2351 //=============================================================================
2355 //=============================================================================
2356 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2358 /* Here the position is on the bottom right corner - 10 */
2359 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2361 SUIT_Desktop *PP = desktop();
2362 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2363 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2367 //=============================================================================
2371 //=============================================================================
2372 static int isStudyLocked(_PTR(Study) theStudy){
2373 return theStudy->GetProperties()->IsLocked();
2376 static bool checkLock(_PTR(Study) theStudy) {
2377 if (isStudyLocked(theStudy)) {
2378 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2379 QObject::tr("WRN_WARNING"),
2380 QObject::tr("WRN_STUDY_LOCKED") );
2386 //=======================================================================
2387 //function : CheckActiveStudyLocked
2389 //=======================================================================
2391 bool SMESHGUI::isActiveStudyLocked()
2393 _PTR(Study) aStudy = activeStudy()->studyDS();
2394 return checkLock( aStudy );
2397 //=============================================================================
2401 //=============================================================================
2402 bool SMESHGUI::OnGUIEvent( int theCommandID )
2404 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2408 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
2409 SUIT_ResourceMgr* mgr = resourceMgr();
2413 if (CORBA::is_nil(GetSMESHGen()->GetCurrentStudy())) {
2414 GetSMESHGen()->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
2417 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2418 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2420 //QAction* act = action( theCommandID );
2422 switch (theCommandID) {
2423 case SMESHOp::OpDelete:
2424 if(checkLock(aStudy)) break;
2427 case SMESHOp::OpImportDAT:
2428 case SMESHOp::OpImportUNV:
2429 case SMESHOp::OpImportMED:
2430 case SMESHOp::OpImportSTL:
2432 case SMESHOp::OpImportCGNS:
2434 case SMESHOp::OpImportSAUV:
2435 case SMESHOp::OpImportGMF:
2437 if(checkLock(aStudy)) break;
2438 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2442 case SMESHOp::OpFileInformation:
2444 SALOME_ListIO selected;
2445 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2447 aSel->selectedObjects( selected );
2448 if( selected.Extent() )
2450 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2451 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2452 if ( !aMesh->_is_nil() )
2454 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2460 case SMESHOp::OpExportDAT:
2461 case SMESHOp::OpExportMED:
2462 case SMESHOp::OpExportUNV:
2463 case SMESHOp::OpExportSTL:
2465 case SMESHOp::OpExportCGNS:
2467 case SMESHOp::OpExportSAUV:
2468 case SMESHOp::OpExportGMF:
2469 case SMESHOp::OpPopupExportDAT:
2470 case SMESHOp::OpPopupExportMED:
2471 case SMESHOp::OpPopupExportUNV:
2472 case SMESHOp::OpPopupExportSTL:
2474 case SMESHOp::OpPopupExportCGNS:
2476 case SMESHOp::OpPopupExportSAUV:
2477 case SMESHOp::OpPopupExportGMF:
2479 ::ExportMeshToFile(theCommandID);
2483 case SMESHOp::OpReset: // SCALAR BAR
2485 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2486 SALOME_ListIO selected;
2488 aSel->selectedObjects( selected );
2490 if( selected.Extent() ) {
2491 Handle(SALOME_InteractiveObject) anIO = selected.First();
2492 if( anIO->hasEntry() ) {
2493 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2494 anActor->SetControlMode( SMESH_Actor::eNone );
2495 #ifndef DISABLE_PLOT2DVIEWER
2496 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2503 case SMESHOp::OpScalarBarProperties:
2505 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2508 case SMESHOp::OpShowScalarBar:
2510 // show/hide scalar bar
2511 ::ShowElement(theCommandID);
2514 case SMESHOp::OpSaveDistribution:
2516 // dump control distribution data to the text file
2517 ::SaveDistribution();
2521 case SMESHOp::OpShowDistribution:
2523 // show/hide distribution
2524 ::ShowElement(theCommandID);
2528 #ifndef DISABLE_PLOT2DVIEWER
2529 case SMESHOp::OpPlotDistribution:
2531 // plot distribution
2532 ::PlotDistribution();
2538 case SMESHOp::OpAutoColor:
2542 case SMESHOp::OpDisableAutoColor:
2543 ::DisableAutoColor();
2546 case SMESHOp::OpClipping:
2547 case SMESHOp::OpTransparency:
2548 case SMESHOp::OpProperties: // Display preferences (colors, shrink size, line width, ...)
2551 case SMESHOp::OpDMWireframe:
2552 case SMESHOp::OpDMShading:
2553 case SMESHOp::OpDMNodes:
2554 case SMESHOp::OpDMShrink:
2555 ::SetDisplayMode(theCommandID, myMarkerMap);
2558 //2D quadratic representation
2559 case SMESHOp::OpRepresentationLines:
2560 case SMESHOp::OpRepresentationArcs:
2561 ::SetDisplayMode(theCommandID, myMarkerMap);
2565 case SMESHOp::OpDE0DElements:
2566 case SMESHOp::OpDEEdges:
2567 case SMESHOp::OpDEFaces:
2568 case SMESHOp::OpDEVolumes:
2569 case SMESHOp::OpDEBalls:
2570 case SMESHOp::OpDEAllEntity:
2571 ::SetDisplayEntity(theCommandID);
2574 // Choose entities to be displayed
2575 case SMESHOp::OpDEChoose:
2577 ( new SMESHGUI_DisplayEntitiesDlg( SMESHGUI::desktop() ) )->exec();
2581 case SMESHOp::OpOrientationOnFaces:
2583 LightApp_SelectionMgr* mgr = selectionMgr();
2584 SALOME_ListIO selected; mgr->selectedObjects( selected );
2586 SALOME_ListIteratorOfListIO it(selected);
2587 for( ; it.More(); it.Next()) {
2588 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2589 if(anIObject->hasEntry()) {
2590 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2591 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2598 case SMESHOp::OpUpdate:
2600 if(checkLock(aStudy)) break;
2601 SUIT_OverrideCursor wc;
2603 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2606 SMESH::UpdateView();
2608 catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2609 SMESH::OnVisuException();
2611 catch (...) { // PAL16774 (Crash after display of many groups)
2612 SMESH::OnVisuException();
2616 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2617 aSel->selectedObjects( l );
2618 aSel->setSelectedObjects( l );
2622 case SMESHOp::OpHide:
2623 case SMESHOp::OpShow:
2624 case SMESHOp::OpShowOnly:
2626 SMESH::EDisplaing anAction;
2627 switch (theCommandID) {
2628 case SMESHOp::OpHide: anAction = SMESH::eErase; break;
2629 case SMESHOp::OpShow: anAction = SMESH::eDisplay; break;
2630 case SMESHOp::OpShowOnly: anAction = SMESH::eDisplayOnly; break;
2633 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2634 SALOME_ListIO sel_objects, to_process;
2636 aSel->selectedObjects( sel_objects );
2638 if( theCommandID==SMESHOp::OpShowOnly )
2640 MESSAGE("anAction = SMESH::eDisplayOnly");
2641 startOperation( myEraseAll );
2644 extractContainers( sel_objects, to_process );
2647 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2651 SALOME_ListIteratorOfListIO It( to_process );
2652 for ( ; It.More(); It.Next()) {
2654 Handle(SALOME_InteractiveObject) IOS = It.Value();
2655 if (IOS->hasEntry()) {
2657 if (!SMESH::UpdateView(anAction, IOS->getEntry())) {
2658 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2659 break; // PAL16774 (Crash after display of many groups)
2661 if (anAction == SMESH::eDisplayOnly)
2663 MESSAGE("anAction = SMESH::eDisplayOnly");
2664 anAction = SMESH::eDisplay;
2670 // PAL13338 + PAL15161 -->
2671 if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !checkLock(aStudy)) {
2672 MESSAGE("anAction = SMESH::eDisplayOnly");
2673 SMESH::UpdateView();
2674 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2676 // PAL13338 + PAL15161 <--
2678 catch (...) { // PAL16774 (Crash after display of many groups)
2679 SMESH::OnVisuException();
2682 if (anAction == SMESH::eErase) {
2683 MESSAGE("anAction == SMESH::eErase");
2685 aSel->setSelectedObjects( l1 );
2688 aSel->setSelectedObjects( to_process );
2693 case SMESHOp::OpNode:
2695 if(checkLock(aStudy)) break;
2698 EmitSignalDeactivateDialog();
2700 ( new SMESHGUI_NodesDlg( this ) )->show();
2703 SUIT_MessageBox::warning(desktop(),
2704 tr("SMESH_WRN_WARNING"),
2705 tr("SMESH_WRN_VIEWER_VTK"));
2710 case SMESHOp::OpCreateMesh:
2711 case SMESHOp::OpCreateSubMesh:
2712 case SMESHOp::OpEditMeshOrSubMesh:
2713 case SMESHOp::OpCompute:
2714 case SMESHOp::OpPreCompute:
2715 case SMESHOp::OpEvaluate:
2716 case SMESHOp::OpMeshOrder:
2717 startOperation( theCommandID );
2719 case SMESHOp::OpCopyMesh:
2721 if (checkLock(aStudy)) break;
2722 EmitSignalDeactivateDialog();
2723 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2726 case SMESHOp::OpBuildCompoundMesh:
2728 if (checkLock(aStudy)) break;
2729 EmitSignalDeactivateDialog();
2730 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2734 case SMESHOp::OpDiagonalInversion:
2735 case SMESHOp::OpUnionOfTwoTriangle:
2739 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2740 tr( "NOT_A_VTK_VIEWER" ) );
2744 if ( checkLock( aStudy ) )
2747 /*Standard_Boolean aRes;
2748 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2749 if ( aMesh->_is_nil() )
2751 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2752 tr( "SMESH_BAD_SELECTION" ) );
2756 EmitSignalDeactivateDialog();
2757 if ( theCommandID == SMESHOp::OpDiagonalInversion )
2758 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2760 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2763 case SMESHOp::OpOrientation:
2764 case SMESHOp::OpUnionOfTriangles:
2765 case SMESHOp::OpCuttingOfQuadrangles:
2766 case SMESHOp::OpSplitVolumes:
2770 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2771 tr( "NOT_A_VTK_VIEWER" ) );
2775 if ( checkLock( aStudy ) )
2778 EmitSignalDeactivateDialog();
2779 SMESHGUI_MultiEditDlg* aDlg = NULL;
2780 if ( theCommandID == SMESHOp::OpOrientation )
2781 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2782 else if ( theCommandID == SMESHOp::OpUnionOfTriangles )
2783 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2784 else if ( theCommandID == SMESHOp::OpSplitVolumes )
2785 aDlg = new SMESHGUI_SplitVolumesDlg(this);
2787 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2792 case SMESHOp::OpSmoothing:
2794 if(checkLock(aStudy)) break;
2796 EmitSignalDeactivateDialog();
2797 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2800 SUIT_MessageBox::warning(desktop(),
2801 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2805 case SMESHOp::OpExtrusion:
2807 if (checkLock(aStudy)) break;
2809 EmitSignalDeactivateDialog();
2810 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2812 SUIT_MessageBox::warning(desktop(),
2813 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2817 case SMESHOp::OpExtrusionAlongAPath:
2819 if (checkLock(aStudy)) break;
2821 EmitSignalDeactivateDialog();
2822 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2824 SUIT_MessageBox::warning(desktop(),
2825 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2829 case SMESHOp::OpRevolution:
2831 if(checkLock(aStudy)) break;
2833 EmitSignalDeactivateDialog();
2834 ( new SMESHGUI_RevolutionDlg( this ) )->show();
2837 SUIT_MessageBox::warning(desktop(),
2838 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2842 case SMESHOp::OpPatternMapping:
2844 if ( checkLock( aStudy ) )
2848 EmitSignalDeactivateDialog();
2849 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2852 SUIT_MessageBox::warning(desktop(),
2853 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2857 case SMESHOp::OpSplitBiQuadratic:
2858 case SMESHOp::OpConvertMeshToQuadratic:
2859 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
2860 case SMESHOp::OpReorientFaces:
2861 case SMESHOp::OpCreateGeometryGroup:
2863 startOperation( theCommandID );
2866 case SMESHOp::OpCreateGroup:
2870 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2871 tr( "NOT_A_VTK_VIEWER" ) );
2875 if(checkLock(aStudy)) break;
2876 EmitSignalDeactivateDialog();
2877 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2879 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2880 SALOME_ListIO selected;
2882 aSel->selectedObjects( selected );
2884 int nbSel = selected.Extent();
2886 // check if mesh is selected
2887 aMesh = SMESH::GetMeshByIO( selected.First() );
2889 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2894 case SMESHOp::OpConstructGroup:
2898 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2899 tr( "NOT_A_VTK_VIEWER" ) );
2903 if(checkLock(aStudy)) break;
2904 EmitSignalDeactivateDialog();
2906 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2907 SALOME_ListIO selected;
2909 aSel->selectedObjects( selected );
2911 int nbSel = selected.Extent();
2913 // check if submesh is selected
2914 Handle(SALOME_InteractiveObject) IObject = selected.First();
2915 if (IObject->hasEntry()) {
2916 _PTR(SObject) aSObj = aStudy->FindObjectID(IObject->getEntry());
2918 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2919 if (!aSubMesh->_is_nil()) {
2921 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2922 // get submesh elements list by types
2923 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2924 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2925 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2926 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2927 // create group for each type o elements
2928 QString aName = IObject->getName();
2929 QStringList anEntryList;
2930 if (aNodes->length() > 0) {
2931 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2932 aGroup->Add(aNodes.inout());
2933 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2934 anEntryList.append( aSObject->GetID().c_str() );
2936 if (aEdges->length() > 0) {
2937 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2938 aGroup->Add(aEdges.inout());
2939 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2940 anEntryList.append( aSObject->GetID().c_str() );
2942 if (aFaces->length() > 0) {
2943 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2944 aGroup->Add(aFaces.inout());
2945 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2946 anEntryList.append( aSObject->GetID().c_str() );
2948 if (aVolumes->length() > 0) {
2949 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2950 aGroup->Add(aVolumes.inout());
2951 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2952 anEntryList.append( aSObject->GetID().c_str() );
2955 anApp->browseObjects( anEntryList );
2957 catch(const SALOME::SALOME_Exception & S_ex){
2958 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2965 SUIT_MessageBox::warning(desktop(),
2966 tr("SMESH_WRN_WARNING"),
2967 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
2972 case SMESHOp::OpEditGroup:
2976 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2977 tr( "NOT_A_VTK_VIEWER" ) );
2981 if(checkLock(aStudy)) break;
2982 EmitSignalDeactivateDialog();
2984 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2985 SALOME_ListIO selected;
2987 aSel->selectedObjects( selected );
2989 SALOME_ListIteratorOfListIO It (selected);
2990 int nbSelectedGroups = 0;
2991 for ( ; It.More(); It.Next() )
2993 SMESH::SMESH_GroupBase_var aGroup =
2994 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
2995 if (!aGroup->_is_nil()) {
2997 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
3001 if (nbSelectedGroups == 0)
3003 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
3009 case SMESHOp::OpAddElemGroupPopup: // Add elements to group
3011 if(checkLock(aStudy)) break;
3012 if (myState == 800) {
3013 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3014 if (aDlg) aDlg->onAdd();
3019 case SMESHOp::OpRemoveElemGroupPopup: // Remove elements from group
3021 if(checkLock(aStudy)) break;
3022 if (myState == 800) {
3023 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
3024 if (aDlg) aDlg->onRemove();
3029 case SMESHOp::OpEditGeomGroupAsGroup:
3033 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
3034 tr( "NOT_A_VTK_VIEWER" ) );
3038 if(checkLock(aStudy)) break;
3039 EmitSignalDeactivateDialog();
3041 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3042 SALOME_ListIO selected;
3044 aSel->selectedObjects( selected );
3046 SALOME_ListIteratorOfListIO It (selected);
3047 for ( ; It.More(); It.Next() )
3049 SMESH::SMESH_GroupOnGeom_var aGroup =
3050 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
3051 if (!aGroup->_is_nil()) {
3052 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3057 SMESH::SMESH_GroupOnFilter_var aGroup =
3058 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
3059 if (!aGroup->_is_nil()) {
3060 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3068 case SMESHOp::OpUnionGroups:
3069 case SMESHOp::OpIntersectGroups:
3070 case SMESHOp::OpCutGroups:
3074 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
3075 tr( "NOT_A_VTK_VIEWER" ) );
3079 if ( checkLock( aStudy ) )
3082 EmitSignalDeactivateDialog();
3084 SMESHGUI_GroupOpDlg* aDlg = 0;
3085 if ( theCommandID == SMESHOp::OpUnionGroups )
3086 aDlg = new SMESHGUI_UnionGroupsDlg( this );
3087 else if ( theCommandID == SMESHOp::OpIntersectGroups )
3088 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3090 aDlg = new SMESHGUI_CutGroupsDlg( this );
3097 case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
3099 if ( checkLock( aStudy ) )
3102 EmitSignalDeactivateDialog();
3103 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3109 case SMESHOp::OpDeleteGroup: // Delete groups with their contents
3113 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
3114 tr( "NOT_A_VTK_VIEWER" ) );
3118 if ( checkLock( aStudy ) )
3121 EmitSignalDeactivateDialog();
3123 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3127 case SMESHOp::OpMeshInformation:
3128 case SMESHOp::OpWhatIs:
3130 int page = theCommandID == SMESHOp::OpMeshInformation ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3131 EmitSignalDeactivateDialog();
3132 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3133 SALOME_ListIO selected;
3135 aSel->selectedObjects( selected );
3137 if ( selected.Extent() > 1 ) { // a dlg for each IO
3138 SALOME_ListIteratorOfListIO It( selected );
3139 for ( ; It.More(); It.Next() ) {
3140 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3141 dlg->showInfo( It.Value() );
3146 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3152 case SMESHOp::OpFindElementByPoint:
3154 startOperation( theCommandID );
3158 case SMESHOp::OpEditHypothesis:
3160 if(checkLock(aStudy)) break;
3162 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3163 SALOME_ListIO selected;
3165 aSel->selectedObjects( selected );
3167 int nbSel = selected.Extent();
3170 Handle(SALOME_InteractiveObject) anIObject = selected.First();
3171 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3173 if ( !aHypothesis->_is_nil() )
3175 SMESHGUI_GenericHypothesisCreator* aCreator =
3176 SMESH::GetHypothesisCreator( SMESH::toQStr( aHypothesis->GetName() ));
3179 // set geometry of mesh and sub-mesh to aCreator
3180 aSel->selectedObjects( selected, "", /*convertReferences=*/false);
3181 if ( selected.Extent() == 1 )
3183 QString subGeomID, meshGeomID;
3184 Handle(SALOME_InteractiveObject) hypIO = selected.First();
3185 if ( SMESH::GetGeomEntries( hypIO, subGeomID, meshGeomID ))
3187 if ( subGeomID.isEmpty() ) subGeomID = meshGeomID;
3188 aCreator->setShapeEntry( subGeomID );
3189 aCreator->setMainShapeEntry( meshGeomID );
3193 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3203 case SMESHOp::OpUnassign: // REMOVE HYPOTHESIS / ALGORITHMS
3205 if(checkLock(aStudy)) break;
3206 SUIT_OverrideCursor wc;
3208 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3209 SALOME_ListIO selected;
3211 aSel->selectedObjects( selected, QString::null, false );
3213 SALOME_ListIteratorOfListIO It(selected);
3214 for (int i = 0; It.More(); It.Next(), i++) {
3215 Handle(SALOME_InteractiveObject) IObject = It.Value();
3216 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3219 aSel->setSelectedObjects( l1 );
3224 case SMESHOp::OpElem0D:
3225 case SMESHOp::OpBall:
3226 case SMESHOp::OpEdge:
3227 case SMESHOp::OpTriangle:
3228 case SMESHOp::OpQuadrangle:
3229 case SMESHOp::OpPolygon:
3230 case SMESHOp::OpTetrahedron:
3231 case SMESHOp::OpHexahedron:
3232 case SMESHOp::OpPentahedron:
3233 case SMESHOp::OpPyramid:
3234 case SMESHOp::OpHexagonalPrism:
3236 if(checkLock(aStudy)) break;
3238 EmitSignalDeactivateDialog();
3239 SMDSAbs_EntityType type = SMDSEntity_Edge;
3240 switch (theCommandID) {
3241 case SMESHOp::OpElem0D: type = SMDSEntity_0D; break;
3242 case SMESHOp::OpBall: type = SMDSEntity_Ball; break;
3243 case SMESHOp::OpTriangle: type = SMDSEntity_Triangle; break;
3244 case SMESHOp::OpQuadrangle: type = SMDSEntity_Quadrangle; break;
3245 case SMESHOp::OpTetrahedron: type = SMDSEntity_Tetra; break;
3246 case SMESHOp::OpPolygon: type = SMDSEntity_Polygon; break;
3247 case SMESHOp::OpHexahedron: type = SMDSEntity_Hexa; break;
3248 case SMESHOp::OpPentahedron: type = SMDSEntity_Penta; break;
3249 case SMESHOp::OpPyramid: type = SMDSEntity_Pyramid; break;
3250 case SMESHOp::OpHexagonalPrism: type = SMDSEntity_Hexagonal_Prism; break;
3253 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3256 SUIT_MessageBox::warning(desktop(),
3257 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3261 case SMESHOp::OpPolyhedron:
3263 if(checkLock(aStudy)) break;
3265 EmitSignalDeactivateDialog();
3266 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3269 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3270 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3274 case SMESHOp::OpQuadraticEdge:
3275 case SMESHOp::OpQuadraticTriangle:
3276 case SMESHOp::OpBiQuadraticTriangle:
3277 case SMESHOp::OpQuadraticQuadrangle:
3278 case SMESHOp::OpBiQuadraticQuadrangle:
3279 case SMESHOp::OpQuadraticPolygon:
3280 case SMESHOp::OpQuadraticTetrahedron:
3281 case SMESHOp::OpQuadraticPyramid:
3282 case SMESHOp::OpQuadraticPentahedron:
3283 case SMESHOp::OpQuadraticHexahedron:
3284 case SMESHOp::OpTriQuadraticHexahedron:
3286 if(checkLock(aStudy)) break;
3288 EmitSignalDeactivateDialog();
3289 SMDSAbs_EntityType type = SMDSEntity_Last;
3291 switch (theCommandID) {
3292 case SMESHOp::OpQuadraticEdge: type = SMDSEntity_Quad_Edge; break;
3293 case SMESHOp::OpQuadraticTriangle: type = SMDSEntity_Quad_Triangle; break;
3294 case SMESHOp::OpBiQuadraticTriangle: type = SMDSEntity_BiQuad_Triangle; break;
3295 case SMESHOp::OpQuadraticQuadrangle: type = SMDSEntity_Quad_Quadrangle; break;
3296 case SMESHOp::OpBiQuadraticQuadrangle: type = SMDSEntity_BiQuad_Quadrangle; break;
3297 case SMESHOp::OpQuadraticPolygon: type = SMDSEntity_Quad_Polygon; break;
3298 case SMESHOp::OpQuadraticTetrahedron: type = SMDSEntity_Quad_Tetra; break;
3299 case SMESHOp::OpQuadraticPyramid: type = SMDSEntity_Quad_Pyramid; break;
3300 case SMESHOp::OpQuadraticPentahedron: type = SMDSEntity_Quad_Penta; break;
3301 case SMESHOp::OpQuadraticHexahedron: type = SMDSEntity_Quad_Hexa; break;
3302 case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
3305 if ( type != SMDSEntity_Last )
3306 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3309 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3310 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3314 case SMESHOp::OpRemoveNodes:
3316 if(checkLock(aStudy)) break;
3318 EmitSignalDeactivateDialog();
3319 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3322 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3323 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3327 case SMESHOp::OpRemoveElements: // REMOVES ELEMENTS
3329 if(checkLock(aStudy)) break;
3331 EmitSignalDeactivateDialog();
3332 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3336 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3337 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3341 case SMESHOp::OpClearMesh: {
3343 if(checkLock(aStudy)) break;
3345 SALOME_ListIO selected;
3346 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3347 aSel->selectedObjects( selected );
3349 SUIT_OverrideCursor wc;
3350 SALOME_ListIteratorOfListIO It (selected);
3351 for ( ; It.More(); It.Next() )
3353 Handle(SALOME_InteractiveObject) IOS = It.Value();
3354 SMESH::SMESH_Mesh_var aMesh =
3355 SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3356 if ( aMesh->_is_nil()) continue;
3358 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3360 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3361 SMESH::ModifiedMesh( aMeshSObj, false, true);
3362 // hide groups and submeshes
3363 _PTR(ChildIterator) anIter =
3364 SMESH::GetActiveStudyDocument()->NewChildIterator( aMeshSObj );
3365 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3367 _PTR(SObject) so = anIter->Value();
3368 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3371 catch (const SALOME::SALOME_Exception& S_ex){
3373 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3377 SMESH::UpdateView();
3381 case SMESHOp::OpRemoveOrphanNodes:
3383 if(checkLock(aStudy)) break;
3384 SALOME_ListIO selected;
3385 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3386 aSel->selectedObjects( selected );
3387 if ( selected.Extent() == 1 ) {
3388 Handle(SALOME_InteractiveObject) anIO = selected.First();
3389 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3390 if ( !aMesh->_is_nil() ) {
3391 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3392 tr( "SMESH_WARNING" ),
3393 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3394 SUIT_MessageBox::Yes |
3395 SUIT_MessageBox::No,
3396 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3399 SUIT_OverrideCursor wc;
3400 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3401 int removed = aMeshEditor->RemoveOrphanNodes();
3402 SUIT_MessageBox::information(SMESHGUI::desktop(),
3403 tr("SMESH_INFORMATION"),
3404 tr("NB_NODES_REMOVED").arg(removed));
3405 if ( removed > 0 ) {
3406 SMESH::UpdateView();
3407 SMESHGUI::Modified();
3410 catch (const SALOME::SALOME_Exception& S_ex) {
3411 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3420 case SMESHOp::OpRenumberingNodes:
3422 if(checkLock(aStudy)) break;
3424 EmitSignalDeactivateDialog();
3425 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3429 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3430 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3434 case SMESHOp::OpRenumberingElements:
3436 if(checkLock(aStudy)) break;
3438 EmitSignalDeactivateDialog();
3439 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3443 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3444 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3448 case SMESHOp::OpTranslation:
3450 if(checkLock(aStudy)) break;
3452 EmitSignalDeactivateDialog();
3453 ( new SMESHGUI_TranslationDlg( this ) )->show();
3456 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3457 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3461 case SMESHOp::OpRotation:
3463 if(checkLock(aStudy)) break;
3465 EmitSignalDeactivateDialog();
3466 ( new SMESHGUI_RotationDlg( this ) )->show();
3469 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3470 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3474 case SMESHOp::OpSymmetry:
3476 if(checkLock(aStudy)) break;
3478 EmitSignalDeactivateDialog();
3479 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3482 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3483 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3487 case SMESHOp::OpScale:
3489 if(checkLock(aStudy)) break;
3491 EmitSignalDeactivateDialog();
3492 ( new SMESHGUI_ScaleDlg( this ) )->show();
3495 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3496 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3501 case SMESHOp::OpSewing:
3503 if(checkLock(aStudy)) break;
3505 EmitSignalDeactivateDialog();
3506 ( new SMESHGUI_SewingDlg( this ) )->show();
3509 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3510 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3514 case SMESHOp::OpMergeNodes:
3516 if(checkLock(aStudy)) break;
3518 EmitSignalDeactivateDialog();
3519 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3522 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3523 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3527 case SMESHOp::OpMergeElements:
3529 if (checkLock(aStudy)) break;
3531 EmitSignalDeactivateDialog();
3532 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3534 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3535 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3540 case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
3541 startOperation( SMESHOp::OpMoveNode );
3544 case SMESHOp::OpDuplicateNodes:
3546 if(checkLock(aStudy)) break;
3548 EmitSignalDeactivateDialog();
3549 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3552 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3553 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3558 case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
3559 startOperation( SMESHOp::OpElem0DOnElemNodes );
3562 case SMESHOp::OpSelectFiltersLibrary: // Library of selection filters
3564 static QList<int> aTypes;
3565 if ( aTypes.isEmpty() )
3567 aTypes.append( SMESH::NODE );
3568 aTypes.append( SMESH::EDGE );
3569 aTypes.append( SMESH::FACE );
3570 aTypes.append( SMESH::VOLUME );
3572 if (!myFilterLibraryDlg)
3573 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3574 else if (myFilterLibraryDlg->isHidden())
3575 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3576 myFilterLibraryDlg->raise();
3580 case SMESHOp::OpFreeNode:
3581 case SMESHOp::OpEqualNode:
3582 case SMESHOp::OpFreeEdge:
3583 case SMESHOp::OpFreeBorder:
3584 case SMESHOp::OpLength:
3585 case SMESHOp::OpConnection:
3586 case SMESHOp::OpEqualEdge:
3587 case SMESHOp::OpFreeFace:
3588 case SMESHOp::OpBareBorderFace:
3589 case SMESHOp::OpOverConstrainedFace:
3590 case SMESHOp::OpLength2D:
3591 case SMESHOp::OpConnection2D:
3592 case SMESHOp::OpArea:
3593 case SMESHOp::OpTaper:
3594 case SMESHOp::OpAspectRatio:
3595 case SMESHOp::OpMinimumAngle:
3596 case SMESHOp::OpWarpingAngle:
3597 case SMESHOp::OpSkew:
3598 case SMESHOp::OpMaxElementLength2D:
3599 case SMESHOp::OpEqualFace:
3600 case SMESHOp::OpAspectRatio3D:
3601 case SMESHOp::OpVolume:
3602 case SMESHOp::OpMaxElementLength3D:
3603 case SMESHOp::OpBareBorderVolume:
3604 case SMESHOp::OpOverConstrainedVolume:
3605 case SMESHOp::OpEqualVolume:
3608 LightApp_SelectionMgr* mgr = selectionMgr();
3609 SALOME_ListIO selected; mgr->selectedObjects( selected );
3611 if( !selected.IsEmpty() ) {
3612 SUIT_OverrideCursor wc;
3613 ::Control( theCommandID );
3616 SUIT_MessageBox::warning(desktop(),
3617 tr( "SMESH_WRN_WARNING" ),
3618 tr( "SMESH_BAD_SELECTION" ) );
3622 SUIT_MessageBox::warning(desktop(),
3623 tr( "SMESH_WRN_WARNING" ),
3624 tr( "NOT_A_VTK_VIEWER" ) );
3627 case SMESHOp::OpOverallMeshQuality:
3628 OverallMeshQuality();
3630 case SMESHOp::OpNumberingNodes:
3632 SUIT_OverrideCursor wc;
3633 LightApp_SelectionMgr* mgr = selectionMgr();
3634 SALOME_ListIO selected; mgr->selectedObjects( selected );
3636 SALOME_ListIteratorOfListIO it(selected);
3637 for( ; it.More(); it.Next()) {
3638 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3639 if(anIObject->hasEntry()) {
3640 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3641 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3647 case SMESHOp::OpNumberingElements:
3649 SUIT_OverrideCursor wc;
3650 LightApp_SelectionMgr* mgr = selectionMgr();
3651 SALOME_ListIO selected; mgr->selectedObjects( selected );
3653 SALOME_ListIteratorOfListIO it(selected);
3654 for( ; it.More(); it.Next()) {
3655 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3656 if(anIObject->hasEntry())
3657 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3658 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3663 case SMESHOp::OpPropertiesLength:
3664 case SMESHOp::OpPropertiesArea:
3665 case SMESHOp::OpPropertiesVolume:
3666 case SMESHOp::OpMinimumDistance:
3667 case SMESHOp::OpBoundingBox:
3669 int page = SMESHGUI_MeasureDlg::MinDistance;
3670 if ( theCommandID == SMESHOp::OpBoundingBox )
3671 page = SMESHGUI_MeasureDlg::BoundingBox;
3672 else if ( theCommandID == SMESHOp::OpPropertiesLength )
3673 page = SMESHGUI_MeasureDlg::Length;
3674 else if ( theCommandID == SMESHOp::OpPropertiesArea )
3675 page = SMESHGUI_MeasureDlg::Area;
3676 else if ( theCommandID == SMESHOp::OpPropertiesVolume )
3677 page = SMESHGUI_MeasureDlg::Volume;
3679 EmitSignalDeactivateDialog();
3680 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3684 case SMESHOp::OpSortChild:
3690 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3691 //updateObjBrowser();
3695 //=============================================================================
3699 //=============================================================================
3700 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3705 //=============================================================================
3709 //=============================================================================
3710 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3715 //=============================================================================
3719 //=============================================================================
3720 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3725 //=============================================================================
3726 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3727 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3729 //=============================================================================
3730 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3731 SUIT_ViewWindow* wnd )
3733 if(theIO->hasEntry()){
3734 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3735 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3739 //=======================================================================
3740 // function : createSMESHAction
3742 //=======================================================================
3743 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3744 const int key, const bool toggle, const QString& shortcutAction )
3747 QWidget* parent = application()->desktop();
3748 SUIT_ResourceMgr* resMgr = resourceMgr();
3750 if ( !icon_id.isEmpty() )
3751 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3753 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3754 if ( !pix.isNull() )
3755 icon = QIcon( pix );
3757 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3758 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3759 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3761 createAction( id, tooltip, icon, menu, status_bar, key, parent,
3762 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3765 //=======================================================================
3766 // function : createPopupItem
3768 //=======================================================================
3769 void SMESHGUI::createPopupItem( const int id,
3770 const QString& clients,
3771 const QString& types,
3772 const QString& theRule,
3775 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3776 popupMgr()->insert( action( id ), pId, 0 );
3778 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3779 QString dc = "selcount"; // VSR : insetad of QtxPopupSelection::defSelCountParam()
3780 QString rule = "(%1) and (%2) and (%3)";
3781 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3782 if( clients.isEmpty() )
3783 rule = rule.arg( QString( "true" ) );
3785 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3786 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3789 bool cont = myRules.contains( id );
3791 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3793 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3794 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3797 //=======================================================================
3798 // function : initialize
3800 //=======================================================================
3801 void SMESHGUI::initialize( CAM_Application* app )
3803 SalomeApp_Module::initialize( app );
3805 // SUIT_ResourceMgr* mgr = app->resourceMgr();
3807 /* Automatic Update flag */
3808 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3810 // ----- create actions --------------
3812 //createSMESHAction( SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
3813 createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_I) );
3814 createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
3815 //createSMESHAction( 114, "NUM" );
3816 createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL" );
3818 createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
3820 createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
3821 createSMESHAction( SMESHOp::OpImportGMF, "IMPORT_GMF" );
3822 createSMESHAction( SMESHOp::OpExportDAT, "DAT" );
3823 createSMESHAction( SMESHOp::OpExportMED, "MED" );
3824 createSMESHAction( SMESHOp::OpExportUNV, "UNV" );
3825 createSMESHAction( SMESHOp::OpExportSTL, "STL" );
3827 createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
3829 createSMESHAction( SMESHOp::OpExportSAUV, "SAUV");
3830 createSMESHAction( SMESHOp::OpExportGMF, "GMF" );
3831 createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
3832 createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
3833 createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
3834 createSMESHAction( SMESHOp::OpPopupExportSTL, "STL" );
3836 createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
3838 createSMESHAction( SMESHOp::OpPopupExportSAUV, "SAUV");
3839 createSMESHAction( SMESHOp::OpPopupExportGMF, "GMF" );
3840 createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
3841 createSMESHAction( SMESHOp::OpDelete, "DELETE", "ICON_DELETE", Qt::Key_Delete );
3842 createSMESHAction( SMESHOp::OpSelectFiltersLibrary, "SEL_FILTER_LIB" );
3843 createSMESHAction( SMESHOp::OpCreateMesh, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
3844 createSMESHAction( SMESHOp::OpCreateSubMesh, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
3845 createSMESHAction( SMESHOp::OpEditMeshOrSubMesh, "EDIT_MESHSUBMESH", "ICON_DLG_EDIT_MESH" );
3846 createSMESHAction( SMESHOp::OpBuildCompoundMesh, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
3847 createSMESHAction( SMESHOp::OpCopyMesh, "COPY_MESH", "ICON_COPY_MESH" );
3848 createSMESHAction( SMESHOp::OpCompute, "COMPUTE", "ICON_COMPUTE" );
3849 createSMESHAction( SMESHOp::OpPreCompute, "PRECOMPUTE", "ICON_PRECOMPUTE" );
3850 createSMESHAction( SMESHOp::OpEvaluate, "EVALUATE", "ICON_EVALUATE" );
3851 createSMESHAction( SMESHOp::OpMeshOrder, "MESH_ORDER", "ICON_MESH_ORDER");
3852 createSMESHAction( SMESHOp::OpCreateGroup, "CREATE_GROUP", "ICON_CREATE_GROUP" );
3853 createSMESHAction( SMESHOp::OpCreateGeometryGroup, "CREATE_GEO_GROUP", "ICON_CREATE_GEO_GROUP" );
3854 createSMESHAction( SMESHOp::OpConstructGroup, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
3855 createSMESHAction( SMESHOp::OpEditGroup, "EDIT_GROUP", "ICON_EDIT_GROUP" );
3856 createSMESHAction( SMESHOp::OpEditGeomGroupAsGroup, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3857 createSMESHAction( SMESHOp::OpUnionGroups, "UN_GROUP", "ICON_UNION" );
3858 createSMESHAction( SMESHOp::OpIntersectGroups, "INT_GROUP", "ICON_INTERSECT" );
3859 createSMESHAction( SMESHOp::OpCutGroups, "CUT_GROUP", "ICON_CUT" );
3860 createSMESHAction( SMESHOp::OpGroupUnderlyingElem, "UNDERLYING_ELEMS", "ICON_UNDERLYING_ELEMS" );
3861 createSMESHAction( SMESHOp::OpAddElemGroupPopup, "ADD" );
3862 createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE" );
3863 createSMESHAction( SMESHOp::OpDeleteGroup, "DEL_GROUP", "ICON_DEL_GROUP" );
3864 createSMESHAction( SMESHOp::OpMeshInformation , "ADV_INFO", "ICON_ADV_INFO" );
3865 //createSMESHAction( SMESHOp::OpStdInfo, "STD_INFO", "ICON_STD_INFO" );
3866 //createSMESHAction( SMESHOp::OpWhatIs, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3867 createSMESHAction( SMESHOp::OpFindElementByPoint, "FIND_ELEM", "ICON_FIND_ELEM" );
3869 createSMESHAction( SMESHOp::OpFreeNode, "FREE_NODE", "ICON_FREE_NODE", 0, true );
3870 createSMESHAction( SMESHOp::OpEqualNode, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
3871 createSMESHAction( SMESHOp::OpFreeEdge, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
3872 createSMESHAction( SMESHOp::OpFreeBorder, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
3873 createSMESHAction( SMESHOp::OpLength, "LENGTH", "ICON_LENGTH", 0, true );
3874 createSMESHAction( SMESHOp::OpConnection, "CONNECTION", "ICON_CONNECTION", 0, true );
3875 createSMESHAction( SMESHOp::OpEqualEdge, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
3876 createSMESHAction( SMESHOp::OpFreeFace, "FREE_FACES", "ICON_FREE_FACES", 0, true );
3877 createSMESHAction( SMESHOp::OpBareBorderFace, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
3878 createSMESHAction( SMESHOp::OpOverConstrainedFace, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
3879 createSMESHAction( SMESHOp::OpLength2D, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
3880 createSMESHAction( SMESHOp::OpConnection2D, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
3881 createSMESHAction( SMESHOp::OpArea, "AREA", "ICON_AREA", 0, true );
3882 createSMESHAction( SMESHOp::OpTaper, "TAPER", "ICON_TAPER", 0, true );
3883 createSMESHAction( SMESHOp::OpAspectRatio, "ASPECT", "ICON_ASPECT", 0, true );
3884 createSMESHAction( SMESHOp::OpMinimumAngle, "MIN_ANG", "ICON_ANGLE", 0, true );
3885 createSMESHAction( SMESHOp::OpWarpingAngle, "WARP", "ICON_WARP", 0, true );
3886 createSMESHAction( SMESHOp::OpSkew, "SKEW", "ICON_SKEW", 0, true );
3887 createSMESHAction( SMESHOp::OpMaxElementLength2D, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
3888 createSMESHAction( SMESHOp::OpEqualFace, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
3889 createSMESHAction( SMESHOp::OpAspectRatio3D, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
3890 createSMESHAction( SMESHOp::OpVolume, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
3891 createSMESHAction( SMESHOp::OpMaxElementLength3D, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
3892 createSMESHAction( SMESHOp::OpBareBorderVolume, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
3893 createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
3894 createSMESHAction( SMESHOp::OpEqualVolume, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
3895 createSMESHAction( SMESHOp::OpOverallMeshQuality, "OVERALL_MESH_QUALITY" );
3897 createSMESHAction( SMESHOp::OpNode, "NODE", "ICON_DLG_NODE" );
3898 createSMESHAction( SMESHOp::OpElem0D, "ELEM0D", "ICON_DLG_ELEM0D" );
3899 createSMESHAction( SMESHOp::OpElem0DOnElemNodes, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
3900 createSMESHAction( SMESHOp::OpBall, "BALL", "ICON_DLG_BALL" );
3901 createSMESHAction( SMESHOp::OpEdge, "EDGE", "ICON_DLG_EDGE" );
3902 createSMESHAction( SMESHOp::OpTriangle, "TRIANGLE", "ICON_DLG_TRIANGLE" );
3903 createSMESHAction( SMESHOp::OpQuadrangle, "QUAD", "ICON_DLG_QUADRANGLE" );
3904 createSMESHAction( SMESHOp::OpPolygon, "POLYGON", "ICON_DLG_POLYGON" );
3905 createSMESHAction( SMESHOp::OpTetrahedron, "TETRA", "ICON_DLG_TETRAS" );
3906 createSMESHAction( SMESHOp::OpHexahedron, "HEXA", "ICON_DLG_HEXAS" );
3907 createSMESHAction( SMESHOp::OpPentahedron, "PENTA", "ICON_DLG_PENTA" );
3908 createSMESHAction( SMESHOp::OpPyramid , "PYRAMID", "ICON_DLG_PYRAMID" );
3909 createSMESHAction( SMESHOp::OpHexagonalPrism, "OCTA", "ICON_DLG_OCTA" );
3910 createSMESHAction( SMESHOp::OpPolyhedron, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
3911 createSMESHAction( SMESHOp::OpQuadraticEdge, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
3912 createSMESHAction( SMESHOp::OpQuadraticTriangle, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
3913 createSMESHAction( SMESHOp::OpBiQuadraticTriangle, "BIQUADRATIC_TRIANGLE", "ICON_DLG_BIQUADRATIC_TRIANGLE" );
3914 createSMESHAction( SMESHOp::OpQuadraticQuadrangle, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
3915 createSMESHAction( SMESHOp::OpBiQuadraticQuadrangle, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
3916 createSMESHAction( SMESHOp::OpQuadraticPolygon, "QUADRATIC_POLYGON", "ICON_DLG_QUADRATIC_POLYGON" );
3917 createSMESHAction( SMESHOp::OpQuadraticTetrahedron, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
3918 createSMESHAction( SMESHOp::OpQuadraticPyramid, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
3919 createSMESHAction( SMESHOp::OpQuadraticPentahedron, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
3920 createSMESHAction( SMESHOp::OpQuadraticHexahedron, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
3921 createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
3923 createSMESHAction( SMESHOp::OpRemoveNodes, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
3924 createSMESHAction( SMESHOp::OpRemoveElements, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
3925 createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
3926 createSMESHAction( SMESHOp::OpClearMesh, "CLEAR_MESH", "ICON_CLEAR_MESH" );
3928 //createSMESHAction( SMESHOp::OpRenumberingNodes, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
3929 //createSMESHAction( SMESHOp::OpRenumberingElements, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
3931 createSMESHAction( SMESHOp::OpTranslation, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
3932 createSMESHAction( SMESHOp::OpRotation, "ROT", "ICON_DLG_MESH_ROTATION" );
3933 createSMESHAction( SMESHOp::OpSymmetry, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
3934 createSMESHAction( SMESHOp::OpScale, "SCALE", "ICON_DLG_MESH_SCALE" );
3935 createSMESHAction( SMESHOp::OpSewing, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
3936 createSMESHAction( SMESHOp::OpMergeNodes, "MERGE", "ICON_SMESH_MERGE_NODES" );
3937 createSMESHAction( SMESHOp::OpMergeElements, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
3938 createSMESHAction( SMESHOp::OpMoveNode, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
3939 createSMESHAction( SMESHOp::OpDuplicateNodes, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
3940 createSMESHAction( SMESHOp::OpDiagonalInversion, "INV", "ICON_DLG_MESH_DIAGONAL" );
3941 createSMESHAction( SMESHOp::OpUnionOfTwoTriangle, "UNION2", "ICON_UNION2TRI" );
3942 createSMESHAction( SMESHOp::OpOrientation, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
3943 createSMESHAction( SMESHOp::OpReorientFaces, "REORIENT_2D", "ICON_REORIENT_2D" );
3944 createSMESHAction( SMESHOp::OpUnionOfTriangles, "UNION", "ICON_UNIONTRI" );
3945 createSMESHAction( SMESHOp::OpCuttingOfQuadrangles, "CUT", "ICON_CUTQUAD" );
3946 createSMESHAction( SMESHOp::OpSplitVolumes, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
3947 createSMESHAction( SMESHOp::OpSplitBiQuadratic, "SPLIT_BIQUAD", "ICON_SPLIT_BIQUAD" );
3948 createSMESHAction( SMESHOp::OpSmoothing, "SMOOTH", "ICON_DLG_SMOOTHING" );
3949 createSMESHAction( SMESHOp::OpExtrusion, "EXTRUSION", "ICON_EXTRUSION" );
3950 createSMESHAction( SMESHOp::OpExtrusionAlongAPath, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
3951 createSMESHAction( SMESHOp::OpRevolution, "REVOLUTION", "ICON_REVOLUTION" );
3952 createSMESHAction( SMESHOp::OpPatternMapping, "MAP", "ICON_MAP" );
3953 createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
3954 createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D", "ICON_2D_FROM_3D" );
3956 createSMESHAction( SMESHOp::OpReset, "RESET" );
3957 createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
3958 createSMESHAction( SMESHOp::OpShowScalarBar, "SHOW_SCALAR_BAR","",0, true );
3959 createSMESHAction( SMESHOp::OpSaveDistribution, "SAVE_DISTRIBUTION" );
3960 createSMESHAction( SMESHOp::OpShowDistribution, "SHOW_DISTRIBUTION","",0, true );
3961 #ifndef DISABLE_PLOT2DVIEWER
3962 createSMESHAction( SMESHOp::OpPlotDistribution, "PLOT_DISTRIBUTION" );
3964 createSMESHAction( SMESHOp::OpDMWireframe, "WIRE", "ICON_WIRE", 0, true );
3965 createSMESHAction( SMESHOp::OpDMShading, "SHADE", "ICON_SHADE", 0, true );
3966 createSMESHAction( SMESHOp::OpDMNodes, "NODES", "ICON_POINTS", 0, true );
3967 createSMESHAction( SMESHOp::OpDMShrink, "SHRINK", "ICON_SHRINK", 0, true );
3968 createSMESHAction( SMESHOp::OpUpdate, "UPDATE", "ICON_UPDATE" );
3969 createSMESHAction( SMESHOp::OpDE0DElements, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
3970 createSMESHAction( SMESHOp::OpDEEdges, "EDGES", "ICON_DLG_EDGE", 0, true );
3971 createSMESHAction( SMESHOp::OpDEFaces, "FACES", "ICON_DLG_TRIANGLE", 0, true );
3972 createSMESHAction( SMESHOp::OpDEVolumes, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
3973 createSMESHAction( SMESHOp::OpDEBalls, "BALLS", "ICON_DLG_BALL", 0, true );
3974 createSMESHAction( SMESHOp::OpDEChoose, "CHOOSE", "ICON_DLG_CHOOSE", 0, false );
3975 createSMESHAction( SMESHOp::OpDEAllEntity, "ALL", "ICON_DLG_CHOOSE_ALL", 0, false );
3976 createSMESHAction( SMESHOp::OpOrientationOnFaces, "FACE_ORIENTATION", "", 0, true );
3978 createSMESHAction( SMESHOp::OpRepresentationLines, "LINE_REPRESENTATION", "", 0, true );
3979 createSMESHAction( SMESHOp::OpRepresentationArcs, "ARC_REPRESENTATION", "", 0, true );
3981 createSMESHAction( SMESHOp::OpEditHypothesis, "EDIT_HYPO" );
3982 createSMESHAction( SMESHOp::OpUnassign, "UNASSIGN" );
3983 createSMESHAction( SMESHOp::OpNumberingNodes, "NUM_NODES", "", 0, true );
3984 createSMESHAction( SMESHOp::OpNumberingElements, "NUM_ELEMENTS", "", 0, true );
3985 createSMESHAction( SMESHOp::OpProperties, "COLORS" );
3986 createSMESHAction( SMESHOp::OpTransparency, "TRANSP" );
3987 createSMESHAction( SMESHOp::OpClipping, "CLIP" );
3988 createSMESHAction( SMESHOp::OpAutoColor, "AUTO_COLOR" );
3989 createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
3991 createSMESHAction( SMESHOp::OpMinimumDistance, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
3992 createSMESHAction( SMESHOp::OpBoundingBox, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
3993 createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH", "ICON_MEASURE_LENGTH" );
3994 createSMESHAction( SMESHOp::OpPropertiesArea, "MEASURE_AREA", "ICON_MEASURE_AREA" );
3995 createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME", "ICON_MEASURE_VOLUME" );
3997 createSMESHAction( SMESHOp::OpHide, "HIDE" );
3998 createSMESHAction( SMESHOp::OpShow, "SHOW" );
3999 createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
4001 createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
4003 QList<int> aCtrlActions;
4004 aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode // node controls
4005 << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
4006 << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge // edge controls
4007 << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
4008 << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
4009 << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
4010 << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
4011 << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace // face controls
4012 << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
4013 << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
4014 << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume; // volume controls
4015 QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
4016 aCtrlGroup->setExclusive( true );
4017 for( int i = 0; i < aCtrlActions.size(); i++ )
4018 aCtrlGroup->addAction( action( aCtrlActions[i] ) );
4020 // ----- create menu --------------
4021 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
4022 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
4023 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
4024 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
4025 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
4026 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
4027 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
4028 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
4030 createMenu( separator(), fileId );
4032 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
4033 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
4034 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10 ),
4035 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10 ),
4036 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10 ),
4037 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10 ),
4038 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
4039 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
4040 //renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
4041 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
4042 basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
4044 //createMenu( SMESHOp::OpImportDAT, importId, -1 );
4045 createMenu( SMESHOp::OpImportUNV, importId, -1 );
4046 createMenu( SMESHOp::OpImportMED, importId, -1 );
4047 createMenu( SMESHOp::OpImportSTL, importId, -1 );
4049 createMenu( SMESHOp::OpImportCGNS, importId, -1 );
4051 createMenu( SMESHOp::OpImportSAUV, importId, -1 );
4052 createMenu( SMESHOp::OpImportGMF, importId, -1 );
4053 createMenu( SMESHOp::OpExportDAT, exportId, -1 );
4054 createMenu( SMESHOp::OpExportMED, exportId, -1 );
4055 createMenu( SMESHOp::OpExportUNV, exportId, -1 );
4056 createMenu( SMESHOp::OpExportSTL, exportId, -1 );
4058 createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
4060 createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
4061 createMenu( SMESHOp::OpExportGMF, exportId, -1 );
4062 createMenu( separator(), fileId, 10 );
4064 createMenu( SMESHOp::OpDelete, editId, -1 );
4066 createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
4068 createMenu( SMESHOp::OpCreateMesh, meshId, -1 ); // "Mesh" menu
4069 createMenu( SMESHOp::OpCreateSubMesh, meshId, -1 );
4070 createMenu( SMESHOp::OpEditMeshOrSubMesh, meshId, -1 );
4071 createMenu( SMESHOp::OpBuildCompoundMesh, meshId, -1 );
4072 createMenu( SMESHOp::OpCopyMesh, meshId, -1 );
4073 createMenu( separator(), meshId, -1 );
4074 createMenu( SMESHOp::OpCompute, meshId, -1 );
4075 createMenu( SMESHOp::OpPreCompute, meshId, -1 );
4076 createMenu( SMESHOp::OpEvaluate, meshId, -1 );
4077 createMenu( SMESHOp::OpMeshOrder, meshId, -1 );
4078 createMenu( separator(), meshId, -1 );
4079 createMenu( SMESHOp::OpCreateGroup, meshId, -1 );
4080 createMenu( SMESHOp::OpCreateGeometryGroup, meshId, -1 );
4081 createMenu( SMESHOp::OpConstructGroup, meshId, -1 );
4082 createMenu( SMESHOp::OpEditGroup, meshId, -1 );
4083 createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4084 createMenu( separator(), meshId, -1 );
4085 createMenu( SMESHOp::OpUnionGroups, meshId, -1 );
4086 createMenu( SMESHOp::OpIntersectGroups, meshId, -1 );
4087 createMenu( SMESHOp::OpCutGroups, meshId, -1 );
4088 createMenu( separator(), meshId, -1 );
4089 createMenu( SMESHOp::OpGroupUnderlyingElem, meshId, -1 );
4090 createMenu( separator(), meshId, -1 );
4091 createMenu( SMESHOp::OpMeshInformation, meshId, -1 );
4092 //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4093 //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4094 createMenu( SMESHOp::OpFindElementByPoint, meshId, -1 );
4095 createMenu( separator(), meshId, -1 );
4097 createMenu( SMESHOp::OpFreeNode, nodeId, -1 );
4098 createMenu( SMESHOp::OpEqualNode, nodeId, -1 );
4099 createMenu( SMESHOp::OpFreeEdge, edgeId, -1 );
4100 createMenu( SMESHOp::OpFreeBorder, edgeId, -1 );
4101 createMenu( SMESHOp::OpLength, edgeId, -1 );
4102 createMenu( SMESHOp::OpConnection, edgeId, -1 );
4103 createMenu( SMESHOp::OpEqualEdge, edgeId, -1 );
4104 createMenu( SMESHOp::OpFreeFace, faceId, -1 );
4105 createMenu( SMESHOp::OpBareBorderFace, faceId, -1 );
4106 createMenu( SMESHOp::OpOverConstrainedFace, faceId, -1 );
4107 createMenu( SMESHOp::OpLength2D, faceId, -1 );
4108 createMenu( SMESHOp::OpConnection2D, faceId, -1 );
4109 createMenu( SMESHOp::OpArea, faceId, -1 );
4110 createMenu( SMESHOp::OpTaper, faceId, -1 );
4111 createMenu( SMESHOp::OpAspectRatio, faceId, -1 );
4112 createMenu( SMESHOp::OpMinimumAngle, faceId, -1 );
4113 createMenu( SMESHOp::OpWarpingAngle, faceId, -1 );
4114 createMenu( SMESHOp::OpSkew, faceId, -1 );
4115 createMenu( SMESHOp::OpMaxElementLength2D, faceId, -1 );
4116 createMenu( SMESHOp::OpEqualFace, faceId, -1 );
4117 createMenu( SMESHOp::OpAspectRatio3D, volumeId, -1 );
4118 createMenu( SMESHOp::OpVolume, volumeId, -1 );
4119 createMenu( SMESHOp::OpMaxElementLength3D, volumeId, -1 );
4120 createMenu( SMESHOp::OpBareBorderVolume, volumeId, -1 );
4121 createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4122 createMenu( SMESHOp::OpEqualVolume, volumeId, -1 );
4123 createMenu( separator(), ctrlId, -1 );
4124 createMenu( SMESHOp::OpReset, ctrlId, -1 );
4125 createMenu( separator(), ctrlId, -1 );
4126 createMenu( SMESHOp::OpOverallMeshQuality, ctrlId, -1 );
4128 createMenu( SMESHOp::OpNode, addId, -1 );
4129 createMenu( SMESHOp::OpElem0D, addId, -1 );
4130 createMenu( SMESHOp::OpElem0DOnElemNodes, addId, -1 );
4131 createMenu( SMESHOp::OpBall, addId, -1 );
4132 createMenu( SMESHOp::OpEdge, addId, -1 );
4133 createMenu( SMESHOp::OpTriangle, addId, -1 );
4134 createMenu( SMESHOp::OpQuadrangle, addId, -1 );
4135 createMenu( SMESHOp::OpPolygon, addId, -1 );
4136 createMenu( SMESHOp::OpTetrahedron, addId, -1 );
4137 createMenu( SMESHOp::OpHexahedron, addId, -1 );
4138 createMenu( SMESHOp::OpPentahedron, addId, -1 );
4139 createMenu( SMESHOp::OpPyramid, addId, -1 );
4140 createMenu( SMESHOp::OpHexagonalPrism, addId, -1 );
4141 createMenu( SMESHOp::OpPolyhedron, addId, -1 );
4142 createMenu( separator(), addId, -1 );
4143 createMenu( SMESHOp::OpQuadraticEdge, addId, -1 );
4144 createMenu( SMESHOp::OpQuadraticTriangle, addId, -1 );
4145 createMenu( SMESHOp::OpBiQuadraticTriangle , addId, -1 );
4146 createMenu( SMESHOp::OpQuadraticQuadrangle, addId, -1 );
4147 createMenu( SMESHOp::OpBiQuadraticQuadrangle, addId, -1 );
4148 createMenu( SMESHOp::OpQuadraticPolygon, addId, -1 );
4149 createMenu( SMESHOp::OpQuadraticTetrahedron, addId, -1 );
4150 createMenu( SMESHOp::OpQuadraticPyramid, addId, -1 );
4151 createMenu( SMESHOp::OpQuadraticPentahedron, addId, -1 );
4152 createMenu( SMESHOp::OpQuadraticHexahedron, addId, -1 );
4153 createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4155 createMenu( SMESHOp::OpRemoveNodes, removeId, -1 );
4156 createMenu( SMESHOp::OpRemoveElements, removeId, -1 );
4157 createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4158 createMenu( separator(), removeId, -1 );
4159 createMenu( SMESHOp::OpDeleteGroup, removeId, -1 );
4160 createMenu( separator(), removeId, -1 );
4161 createMenu( SMESHOp::OpClearMesh, removeId, -1 );
4163 //createMenu( SMESHOp::OpRenumberingNodes, renumId, -1 );
4164 //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4166 createMenu( SMESHOp::OpTranslation, transfId, -1 );
4167 createMenu( SMESHOp::OpRotation, transfId, -1 );
4168 createMenu( SMESHOp::OpSymmetry, transfId, -1 );
4169 createMenu( SMESHOp::OpScale, transfId, -1 );
4170 createMenu( SMESHOp::OpSewing, transfId, -1 );
4171 createMenu( SMESHOp::OpMergeNodes, transfId, -1 );
4172 createMenu( SMESHOp::OpMergeElements, transfId, -1 );
4173 createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4175 createMenu( SMESHOp::OpMoveNode, modifyId, -1 );
4176 createMenu( SMESHOp::OpDiagonalInversion, modifyId, -1 );
4177 createMenu( SMESHOp::OpUnionOfTwoTriangle, modifyId, -1 );
4178 createMenu( SMESHOp::OpOrientation, modifyId, -1 );
4179 createMenu( SMESHOp::OpReorientFaces, modifyId, -1 );
4180 createMenu( SMESHOp::OpUnionOfTriangles, modifyId, -1 );
4181 createMenu( SMESHOp::OpCuttingOfQuadrangles, modifyId, -1 );
4182 createMenu( SMESHOp::OpSplitVolumes, modifyId, -1 );
4183 createMenu( SMESHOp::OpSplitBiQuadratic, modifyId, -1 );
4184 createMenu( SMESHOp::OpSmoothing, modifyId, -1 );
4185 createMenu( SMESHOp::OpExtrusion, modifyId, -1 );
4186 createMenu( SMESHOp::OpExtrusionAlongAPath , modifyId, -1 );
4187 createMenu( SMESHOp::OpRevolution, modifyId, -1 );
4188 createMenu( SMESHOp::OpPatternMapping, modifyId, -1 );
4189 createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4190 createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4192 createMenu( SMESHOp::OpMinimumDistance, measureId, -1 );
4193 createMenu( SMESHOp::OpBoundingBox, measureId, -1 );
4194 createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4195 createMenu( SMESHOp::OpPropertiesArea, basicPropId, -1 );
4196 createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4197 createMenu( SMESHOp::OpUpdate, viewId, -1 );
4199 // ----- create toolbars --------------
4200 int meshTb = createTool( tr( "TB_MESH" ), QString( "SMESHMeshToolbar" ) ),
4201 info = createTool( tr( "TB_INFO" ), QString( "SMESHInformationToolbar" ) ),
4202 groupTb = createTool( tr( "TB_GROUP" ), QString( "SMESHGroupToolbar" ) ),
4203 ctrl0dTb = createTool( tr( "TB_CTRL0D" ), QString( "SMESHNodeControlsToolbar" ) ),
4204 ctrl1dTb = createTool( tr( "TB_CTRL1D" ), QString( "SMESHEdgeControlsToolbar" ) ),
4205 ctrl2dTb = createTool( tr( "TB_CTRL2D" ), QString( "SMESHFaceControlsToolbar" ) ),
4206 ctrl3dTb = createTool( tr( "TB_CTRL3D" ), QString( "SMESHVolumeControlsToolbar" ) ),
4207 addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ),
4208 addNonElemTb = createTool( tr( "TB_ADDNON" ), QString( "SMESHAddElementToolbar" ) ),
4209 remTb = createTool( tr( "TB_REM" ), QString( "SMESHRemoveToolbar" ) ),
4210 //renumbTb = createTool( tr( "TB_RENUMBER" ), QString( "SMESHRenumberingToolbar" ) ),
4211 transformTb = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ),
4212 modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ),
4213 measuremTb = createTool( tr( "TB_MEASUREM" ), QString( "SMESHMeasurementsToolbar" ) ),
4214 dispModeTb = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4216 createTool( SMESHOp::OpCreateMesh, meshTb );
4217 createTool( SMESHOp::OpCreateSubMesh, meshTb );
4218 createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4219 createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4220 createTool( SMESHOp::OpCopyMesh, meshTb );
4221 createTool( separator(), meshTb );
4222 createTool( SMESHOp::OpCompute, meshTb );
4223 createTool( SMESHOp::OpPreCompute, meshTb );
4224 createTool( SMESHOp::OpEvaluate, meshTb );
4225 createTool( SMESHOp::OpMeshOrder, meshTb );
4227 createTool( SMESHOp::OpCreateGroup, groupTb );
4228 createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4229 createTool( SMESHOp::OpConstructGroup, groupTb );
4230 createTool( SMESHOp::OpEditGroup, groupTb );
4232 createTool( SMESHOp::OpMeshInformation, info );
4233 //createTool( SMESHOp::OpStdInfo, meshTb );
4234 //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4235 createTool( SMESHOp::OpFindElementByPoint, info );
4237 createTool( SMESHOp::OpFreeNode, ctrl0dTb );
4238 createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4240 createTool( SMESHOp::OpFreeEdge, ctrl1dTb );
4241 createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4242 createTool( SMESHOp::OpLength, ctrl1dTb );
4243 createTool( SMESHOp::OpConnection, ctrl1dTb );
4244 createTool( SMESHOp::OpEqualEdge, ctrl1dTb );
4246 createTool( SMESHOp::OpFreeFace, ctrl2dTb );
4247 createTool( SMESHOp::OpBareBorderFace, ctrl2dTb );
4248 createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4249 createTool( SMESHOp::OpLength2D, ctrl2dTb );
4250 createTool( SMESHOp::OpConnection2D, ctrl2dTb );
4251 createTool( SMESHOp::OpArea, ctrl2dTb );
4252 createTool( SMESHOp::OpTaper, ctrl2dTb );
4253 createTool( SMESHOp::OpAspectRatio, ctrl2dTb );
4254 createTool( SMESHOp::OpMinimumAngle, ctrl2dTb );
4255 createTool( SMESHOp::OpWarpingAngle, ctrl2dTb );
4256 createTool( SMESHOp::OpSkew, ctrl2dTb );
4257 createTool( SMESHOp::OpMaxElementLength2D, ctrl2dTb );
4258 createTool( SMESHOp::OpEqualFace, ctrl2dTb );
4260 createTool( SMESHOp::OpAspectRatio3D, ctrl3dTb );
4261 createTool( SMESHOp::OpVolume, ctrl3dTb );
4262 createTool( SMESHOp::OpMaxElementLength3D, ctrl3dTb );
4263 createTool( SMESHOp::OpBareBorderVolume, ctrl3dTb );
4264 createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
4265 createTool( SMESHOp::OpEqualVolume, ctrl3dTb );
4267 createTool( SMESHOp::OpNode, addElemTb );
4268 createTool( SMESHOp::OpElem0D, addElemTb );
4269 createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4270 createTool( SMESHOp::OpBall, addElemTb );
4271 createTool( SMESHOp::OpEdge, addElemTb );
4272 createTool( SMESHOp::OpTriangle, addElemTb );
4273 createTool( SMESHOp::OpQuadrangle, addElemTb );
4274 createTool( SMESHOp::OpPolygon, addElemTb );
4275 createTool( SMESHOp::OpTetrahedron, addElemTb );
4276 createTool( SMESHOp::OpHexahedron, addElemTb );
4277 createTool( SMESHOp::OpPentahedron, addElemTb );
4278 createTool( SMESHOp::OpPyramid, addElemTb );
4279 createTool( SMESHOp::OpHexagonalPrism, addElemTb );
4280 createTool( SMESHOp::OpPolyhedron, addElemTb );
4282 createTool( SMESHOp::OpQuadraticEdge, addNonElemTb );
4283 createTool( SMESHOp::OpQuadraticTriangle, addNonElemTb );
4284 createTool( SMESHOp::OpBiQuadraticTriangle, addNonElemTb );
4285 createTool( SMESHOp::OpQuadraticQuadrangle, addNonElemTb );
4286 createTool( SMESHOp::OpBiQuadraticQuadrangle, addNonElemTb );
4287 createTool( SMESHOp::OpQuadraticPolygon, addNonElemTb );
4288 createTool( SMESHOp::OpQuadraticTetrahedron, addNonElemTb );
4289 createTool( SMESHOp::OpQuadraticPyramid, addNonElemTb );
4290 createTool( SMESHOp::OpQuadraticPentahedron, addNonElemTb );
4291 createTool( SMESHOp::OpQuadraticHexahedron, addNonElemTb );
4292 createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4294 createTool( SMESHOp::OpRemoveNodes, remTb );
4295 createTool( SMESHOp::OpRemoveElements, remTb );
4296 createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4297 createTool( SMESHOp::OpClearMesh, remTb );
4299 //createTool( SMESHOp::OpRenumberingNodes, renumbTb );
4300 //createTool( SMESHOp::OpRenumberingElements, renumbTb );
4302 createTool( SMESHOp::OpTranslation, transformTb );
4303 createTool( SMESHOp::OpRotation, transformTb );
4304 createTool( SMESHOp::OpSymmetry, transformTb );
4305 createTool( SMESHOp::OpScale, transformTb );
4306 createTool( SMESHOp::OpSewing, transformTb );
4307 createTool( SMESHOp::OpMergeNodes, transformTb );
4308 createTool( SMESHOp::OpMergeElements, transformTb );
4309 createTool( SMESHOp::OpDuplicateNodes, transformTb );
4311 createTool( SMESHOp::OpMoveNode, modifyTb );
4312 createTool( SMESHOp::OpDiagonalInversion, modifyTb );
4313 createTool( SMESHOp::OpUnionOfTwoTriangle, modifyTb );
4314 createTool( SMESHOp::OpOrientation, modifyTb );
4315 createTool( SMESHOp::OpReorientFaces, modifyTb );
4316 createTool( SMESHOp::OpUnionOfTriangles, modifyTb );
4317 createTool( SMESHOp::OpCuttingOfQuadrangles, modifyTb );
4318 createTool( SMESHOp::OpSplitVolumes, modifyTb );
4319 createTool( SMESHOp::OpSplitBiQuadratic, modifyTb );
4320 createTool( SMESHOp::OpSmoothing, modifyTb );
4321 createTool( SMESHOp::OpExtrusion, modifyTb );
4322 createTool( SMESHOp::OpExtrusionAlongAPath, modifyTb );
4323 createTool( SMESHOp::OpRevolution, modifyTb );
4324 createTool( SMESHOp::OpPatternMapping, modifyTb );
4325 createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4326 createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4328 createTool( SMESHOp::OpMinimumDistance, measuremTb );
4330 createTool( SMESHOp::OpUpdate, dispModeTb );
4332 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4333 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4336 QString OB = "'ObjectBrowser'",
4337 View = "'" + SVTK_Viewer::Type() + "'",
4339 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4340 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4341 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4342 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4343 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4344 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4345 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4346 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4347 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4348 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4349 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4351 mesh_part = mesh + " " + subMesh + " " + group,
4352 mesh_group = mesh + " " + group,
4353 hyp_alg = hypo + " " + algo;
4355 // popup for object browser
4357 isInvisible("not( isVisible )"),
4358 isEmpty("numberOfNodes = 0"),
4359 isNotEmpty("numberOfNodes <> 0"),
4361 // has nodes, edges, etc in VISIBLE! actor
4362 hasNodes("(numberOfNodes > 0 )"),//&& isVisible)"),
4363 hasElems("(count( elemTypes ) > 0)"),
4364 hasDifferentElems("(count( elemTypes ) > 1)"),
4365 hasBalls("({'BallElem'} in elemTypes)"),
4366 hasElems0d("({'Elem0d'} in elemTypes)"),
4367 hasEdges("({'Edge'} in elemTypes)"),
4368 hasFaces("({'Face'} in elemTypes)"),
4369 hasVolumes("({'Volume'} in elemTypes)");
4371 createPopupItem( SMESHOp::OpFileInformation, OB, mesh, "&& selcount=1 && isImported" );
4372 createPopupItem( SMESHOp::OpCreateSubMesh, OB, mesh, "&& isComputable");
4373 createPopupItem( SMESHOp::OpEditMeshOrSubMesh, OB, mesh, "&& isComputable");
4374 createPopupItem( SMESHOp::OpEditMeshOrSubMesh, OB, subMesh, "&& isComputable" );
4375 createPopupItem( SMESHOp::OpEditGroup, OB, group );
4376 createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4378 popupMgr()->insert( separator(), -1, 0 );
4379 createPopupItem( SMESHOp::OpCompute, OB, mesh, "&& isComputable" );
4380 createPopupItem( SMESHOp::OpPreCompute, OB, mesh, "&& isComputable && isPreComputable" );
4381 createPopupItem( SMESHOp::OpEvaluate, OB, mesh, "&& isComputable" );
4382 createPopupItem( SMESHOp::OpMeshOrder, OB, mesh, "&& isComputable" );
4383 createPopupItem( SMESHOp::OpUpdate, OB, mesh_part );
4384 createPopupItem( SMESHOp::OpMeshInformation, OB, mesh_part );
4385 createPopupItem( SMESHOp::OpFindElementByPoint, OB, mesh_group );
4386 createPopupItem( SMESHOp::OpOverallMeshQuality, OB, mesh_part );
4387 popupMgr()->insert( separator(), -1, 0 );
4388 createPopupItem( SMESHOp::OpCreateGroup, OB, mesh );
4389 createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh );
4390 createPopupItem( SMESHOp::OpConstructGroup, OB, subMesh );
4391 popupMgr()->insert( separator(), -1, 0 );
4392 createPopupItem( SMESHOp::OpEditHypothesis, OB, hypo);
4393 createPopupItem( SMESHOp::OpUnassign, OB, hyp_alg ); // REMOVE HYPOTHESIS / ALGORITHMS
4394 popupMgr()->insert( separator(), -1, 0 );
4395 createPopupItem( SMESHOp::OpClearMesh, OB, mesh );
4396 popupMgr()->insert( separator(), -1, 0 );
4397 createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh + " " + subMesh ); // convert to quadratic
4398 createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh + " " + group, // create 2D mesh from 3D
4400 popupMgr()->insert( separator(), -1, 0 );
4402 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4403 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4404 QString only_one_2D = only_one_non_empty + " && dim>1";
4406 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4407 createPopupItem( SMESHOp::OpPopupExportMED, OB, mesh_group, multiple_non_empty, anId );
4408 createPopupItem( SMESHOp::OpPopupExportUNV, OB, mesh_group, only_one_non_empty, anId );
4409 createPopupItem( SMESHOp::OpPopupExportSTL, OB, mesh_group, only_one_2D, anId );
4411 createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4413 createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, only_one_non_empty, anId );
4414 createPopupItem( SMESHOp::OpPopupExportGMF, OB, mesh_group, only_one_non_empty, anId );
4415 createPopupItem( SMESHOp::OpPopupExportDAT, OB, mesh_group, only_one_non_empty, anId );
4416 createPopupItem( SMESHOp::OpDelete, OB, mesh_part + " " + hyp_alg );
4417 createPopupItem( SMESHOp::OpDeleteGroup, OB, group );
4418 popupMgr()->insert( separator(), -1, 0 );
4421 createPopupItem( SMESHOp::OpEditGroup, View, group );
4422 createPopupItem( SMESHOp::OpAddElemGroupPopup, View, elems );
4423 createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems );
4425 popupMgr()->insert( separator(), -1, 0 );
4426 createPopupItem( SMESHOp::OpUpdate, View, mesh_part );
4427 createPopupItem( SMESHOp::OpMeshInformation, View, mesh_part );
4428 createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4429 createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh );
4430 popupMgr()->insert( separator(), -1, 0 );
4432 createPopupItem( SMESHOp::OpAutoColor, OB + " " + View, mesh, "&& (not isAutoColor)" );
4433 createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4434 popupMgr()->insert( separator(), -1, 0 );
4436 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4437 QString aType = QString( "%1type in {%2}" ).arg( lc );
4438 aType = aType.arg( mesh_part );
4439 QString aMeshInVTK = aClient + "&&" + aType;
4441 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4442 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4443 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4445 //-------------------------------------------------
4447 //-------------------------------------------------
4448 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4450 popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4451 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4452 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4454 popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4455 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4456 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4458 popupMgr()->insert( separator(), -1, -1 );
4460 //-------------------------------------------------
4462 //-------------------------------------------------
4463 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4465 popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4466 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4467 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4469 popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4470 popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4471 popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4473 popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4474 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes, QtxPopupMgr::VisibleRule );
4475 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4477 popupMgr()->insert( separator(), anId, -1 );
4479 popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4480 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4481 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4483 //-------------------------------------------------
4485 //-------------------------------------------------
4486 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4488 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4490 popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4491 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4492 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4494 popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4495 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4496 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4498 popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4499 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4500 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4502 popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4503 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4504 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4506 popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4507 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4508 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4510 popupMgr()->insert( separator(), anId, -1 );
4512 popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4513 popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&&" + aType + "&&" + isNotEmpty, QtxPopupMgr::VisibleRule );
4515 popupMgr()->insert( separator(), anId, -1 );
4517 popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4518 popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4521 //-------------------------------------------------
4522 // Representation of the 2D Quadratic elements
4523 //-------------------------------------------------
4524 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4525 popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4526 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "and isVisible",QtxPopupMgr::VisibleRule );
4527 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4529 popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4530 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "and isVisible", QtxPopupMgr::VisibleRule );
4531 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4533 //-------------------------------------------------
4534 // Orientation of faces
4535 //-------------------------------------------------
4536 popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4537 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4538 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4540 //-------------------------------------------------
4542 //-------------------------------------------------
4543 popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4544 popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4546 //-------------------------------------------------
4548 //-------------------------------------------------
4549 popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4550 popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4552 //-------------------------------------------------
4554 //-------------------------------------------------
4556 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4557 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4558 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4559 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4561 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4563 popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4564 popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4566 popupMgr()->insert( separator(), anId, -1 );
4568 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4570 popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4571 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4572 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4574 popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4575 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4576 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4578 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4580 popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4581 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4582 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4584 popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4585 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4586 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4588 popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4589 popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4590 popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4592 popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4593 popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4594 popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4595 popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4596 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4597 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4599 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4601 popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4602 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4603 QtxPopupMgr::VisibleRule );
4604 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4606 popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4607 popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4608 popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4610 popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4611 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4612 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4614 popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
4615 popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4616 popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4618 popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
4619 popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4620 popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4622 popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
4623 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4624 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4626 popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
4627 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4628 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4630 popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
4631 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4632 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4634 popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
4635 popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4636 popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4638 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
4639 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4640 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4642 popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
4643 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4644 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4646 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
4647 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4648 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4649 popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
4650 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4651 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4653 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4655 popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D ), aSubId, -1 );
4656 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4657 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4659 popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
4660 popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4661 popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4663 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
4664 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4665 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4667 popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
4668 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4669 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4671 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
4672 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4673 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4675 popupMgr()->insert ( action( SMESHOp::OpEqualVolume ), aSubId, -1 );
4676 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4677 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4679 popupMgr()->insert( separator(), anId, -1 );
4681 popupMgr()->insert( action( SMESHOp::OpShowScalarBar ), anId, -1 );
4682 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4683 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone' && isScalarBarVisible", QtxPopupMgr::ToggleRule );
4684 popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
4685 popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4687 popupMgr()->insert( separator(), anId, -1 );
4689 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4691 popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
4692 popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4694 popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
4695 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4696 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isScalarBarVisible && isDistributionVisible", QtxPopupMgr::ToggleRule);
4698 #ifndef DISABLE_PLOT2DVIEWER
4699 popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
4700 popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4703 //-------------------------------------------------
4705 //-------------------------------------------------
4706 popupMgr()->insert( separator(), -1, -1 );
4707 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4708 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4709 popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
4710 popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4712 popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
4713 popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4715 popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
4716 popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4718 popupMgr()->insert( separator(), -1, -1 );
4720 //-------------------------------------------------
4722 //-------------------------------------------------
4723 popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
4724 popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4726 popupMgr()->insert( separator(), -1, -1 );
4728 popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
4729 popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
4730 popupMgr()->insert( separator(), -1, -1 );
4732 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4733 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4735 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4736 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4739 //================================================================================
4741 * \brief Return true if SMESH or GEOM objects are selected.
4742 * Is called form LightApp_Module::activateModule() which clear selection if
4743 * not isSelectionCompatible()
4745 //================================================================================
4747 bool SMESHGUI::isSelectionCompatible()
4749 bool isCompatible = true;
4750 SALOME_ListIO selected;
4751 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4752 Sel->selectedObjects( selected );
4754 SALOME_ListIteratorOfListIO It( selected );
4755 for ( ; isCompatible && It.More(); It.Next())
4757 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4758 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4760 return isCompatible;
4764 bool SMESHGUI::reusableOperation( const int id )
4766 // compute, evaluate and precompute are not reusable operations
4767 return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate ) ? false : SalomeApp_Module::reusableOperation( id );
4770 bool SMESHGUI::activateModule( SUIT_Study* study )
4772 bool res = SalomeApp_Module::activateModule( study );
4774 setMenuShown( true );
4775 setToolShown( true );
4777 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4778 PyGILState_STATE gstate = PyGILState_Ensure();
4779 PyObject* pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4780 if ( !pluginsmanager ) {
4784 PyObject* result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toUtf8().data(),tr("SMESH_PLUGINS_OTHER").toUtf8().data());
4789 PyGILState_Release(gstate);
4790 // end of SMESH plugins loading
4792 // Reset actions accelerator keys
4793 action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
4795 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4796 GetSMESHGen()->SetCurrentStudy(SALOMEDS::Study::_nil());
4797 if ( SalomeApp_Study* s = dynamic_cast<SalomeApp_Study*>( study )) {
4798 if ( _PTR(Study) aStudy = s->studyDS() )
4799 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
4802 // get all view currently opened in the study and connect their signals to
4803 // the corresponding slots of the class.
4804 SUIT_Desktop* aDesk = study->application()->desktop();
4806 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4807 SUIT_ViewWindow* wnd;
4808 foreach ( wnd, wndList )
4812 Py_XDECREF(pluginsmanager);
4816 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4818 setMenuShown( false );
4819 setToolShown( false );
4821 EmitSignalCloseAllDialogs();
4823 // Unset actions accelerator keys
4824 action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
4826 return SalomeApp_Module::deactivateModule( study );
4829 void SMESHGUI::studyClosed( SUIT_Study* s )
4833 SMESH::RemoveVisuData( s->id() );
4834 SalomeApp_Module::studyClosed( s );
4837 void SMESHGUI::OnGUIEvent()
4839 const QObject* obj = sender();
4840 if ( !obj || !obj->inherits( "QAction" ) )
4842 int id = actionId((QAction*)obj);
4847 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4849 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
4850 if ( CORBA::is_nil( myComponentSMESH ) )
4852 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4854 aGUI.myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4855 return aGUI.myComponentSMESH;
4858 myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4859 return myComponentSMESH;
4862 QString SMESHGUI::engineIOR() const
4864 CORBA::ORB_var anORB = getApp()->orb();
4865 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4866 return QString( anIOR.in() );
4869 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4871 SalomeApp_Module::contextMenuPopup( client, menu, title );
4873 selectionMgr()->selectedObjects( lst );
4874 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4875 Handle(SALOME_InteractiveObject) io = lst.First();
4876 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4877 _PTR(Study) study = appStudy->studyDS();
4878 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4880 QString aName = QString( SMESH::fromUtf8(obj->GetName()) );
4881 while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4882 aName.remove( (aName.length() - 1), 1 );
4888 LightApp_Selection* SMESHGUI::createSelection() const
4890 return new SMESHGUI_Selection();
4893 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4895 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4896 aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
4897 #ifndef DISABLE_PYCONSOLE
4898 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4902 void SMESHGUI::viewManagers( QStringList& list ) const
4904 list.append( SVTK_Viewer::Type() );
4907 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4909 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4910 SMESH::UpdateSelectionProp( this );
4912 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
4913 for(int i = 0; i < aViews.count() ; i++){
4914 SUIT_ViewWindow *sf = aViews[i];
4917 EmitSignalActivatedViewManager();
4921 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
4923 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
4924 myClippingPlaneInfoMap.erase( theViewManager );
4927 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
4929 theActor->AddObserver( SMESH::DeleteActorEvent,
4930 myEventCallbackCommand.GetPointer(),
4934 void SMESHGUI::ProcessEvents( vtkObject* theObject,
4935 unsigned long theEvent,
4936 void* theClientData,
4939 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
4940 if( theObject && theEvent == SMESH::DeleteActorEvent ) {
4941 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
4942 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
4943 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
4944 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
4945 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
4946 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
4947 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
4948 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
4949 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
4950 SMESH::TActorList::iterator anIter3 = anActorList.begin();
4951 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
4952 if( anActor == *anIter3 ) {
4953 anActorList.erase( anIter3 );
4964 void SMESHGUI::createPreferences()
4966 // General tab ------------------------------------------------------------------------
4967 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
4969 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
4970 setPreferenceProperty( autoUpdate, "columns", 2 );
4971 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
4972 setPreferenceProperty( lim, "min", 0 );
4973 setPreferenceProperty( lim, "max", 100000000 );
4974 setPreferenceProperty( lim, "step", 1000 );
4975 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4976 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
4978 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
4979 setPreferenceProperty( qaGroup, "columns", 2 );
4980 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
4981 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
4982 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
4983 setPreferenceProperty( prec, "min", 0 );
4984 setPreferenceProperty( prec, "max", 100 );
4985 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
4986 setPreferenceProperty( doubleNodesTol, "precision", 10 );
4987 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
4988 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
4989 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
4991 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
4992 setPreferenceProperty( dispgroup, "columns", 2 );
4993 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
4995 modes.append( tr("MEN_WIRE") );
4996 modes.append( tr("MEN_SHADE") );
4997 modes.append( tr("MEN_NODES") );
4998 modes.append( tr("MEN_SHRINK") );
4999 QList<QVariant> indices;
5000 indices.append( 0 );
5001 indices.append( 1 );
5002 indices.append( 2 );
5003 indices.append( 3 );
5004 setPreferenceProperty( dispmode, "strings", modes );
5005 setPreferenceProperty( dispmode, "indexes", indices );
5007 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
5008 setPreferenceProperty( arcgroup, "columns", 2 );
5009 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
5010 QStringList quadraticModes;
5011 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
5012 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
5014 indices.append( 0 );
5015 indices.append( 1 );
5016 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
5017 setPreferenceProperty( quadraticmode, "indexes", indices );
5019 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
5020 "SMESH", "max_angle" );
5021 setPreferenceProperty( maxAngle, "min", 1 );
5022 setPreferenceProperty( maxAngle, "max", 90 );
5026 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
5027 setPreferenceProperty( exportgroup, "columns", 2 );
5028 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
5029 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
5031 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
5032 setPreferenceProperty( computeGroup, "columns", 2 );
5033 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
5035 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5036 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5037 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5039 indices.append( 0 );
5040 indices.append( 1 );
5041 indices.append( 2 );
5042 setPreferenceProperty( notifyMode, "strings", modes );
5043 setPreferenceProperty( notifyMode, "indexes", indices );
5045 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5046 setPreferenceProperty( infoGroup, "columns", 2 );
5047 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5049 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5050 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5052 indices.append( 0 );
5053 indices.append( 1 );
5054 setPreferenceProperty( elemInfo, "strings", modes );
5055 setPreferenceProperty( elemInfo, "indexes", indices );
5056 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5057 setPreferenceProperty( nodesLim, "min", 0 );
5058 setPreferenceProperty( nodesLim, "max", 10000000 );
5059 setPreferenceProperty( nodesLim, "step", 10000 );
5060 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5061 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5062 setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5063 setPreferenceProperty( ctrlLim, "min", 0 );
5064 setPreferenceProperty( ctrlLim, "max", 10000000 );
5065 setPreferenceProperty( ctrlLim, "step", 1000 );
5066 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5067 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5068 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5069 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5070 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5072 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5073 setPreferenceProperty( segGroup, "columns", 2 );
5074 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5075 "SMESH", "segmentation" );
5076 setPreferenceProperty( segLen, "min", 1 );
5077 setPreferenceProperty( segLen, "max", 10000000 );
5078 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5079 "SMESH", "nb_segments_per_edge" );
5080 setPreferenceProperty( nbSeg, "min", 1 );
5081 setPreferenceProperty( nbSeg, "max", 10000000 );
5083 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5084 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5085 "SMESH", "forget_mesh_on_hyp_modif" );
5088 // Quantities with individual precision settings
5089 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5090 setPreferenceProperty( precGroup, "columns", 2 );
5092 const int nbQuantities = 6;
5093 int precs[nbQuantities], ii = 0;
5094 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5095 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5096 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5097 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5098 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5099 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5100 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5101 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5102 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5103 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5104 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5105 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5107 // Set property for precision value for spinboxes
5108 for ( ii = 0; ii < nbQuantities; ii++ ){
5109 setPreferenceProperty( precs[ii], "min", -14 );
5110 setPreferenceProperty( precs[ii], "max", 14 );
5111 setPreferenceProperty( precs[ii], "precision", 2 );
5114 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5115 setPreferenceProperty( previewGroup, "columns", 2 );
5116 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5117 setPreferenceProperty( chunkSize, "min", 1 );
5118 setPreferenceProperty( chunkSize, "max", 1000 );
5119 setPreferenceProperty( chunkSize, "step", 50 );
5121 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5122 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5124 // Mesh tab ------------------------------------------------------------------------
5125 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5126 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5127 setPreferenceProperty( nodeGroup, "columns", 3 );
5129 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5131 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5133 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5134 QList<QVariant> aMarkerTypeIndicesList;
5135 QList<QVariant> aMarkerTypeIconsList;
5136 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5137 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5138 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5139 aMarkerTypeIndicesList << i;
5140 aMarkerTypeIconsList << pixmap;
5142 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5143 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
5145 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5147 QList<QVariant> aMarkerScaleIndicesList;
5148 QStringList aMarkerScaleValuesList;
5149 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5150 aMarkerScaleIndicesList << i;
5151 aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5153 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5154 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5156 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5157 //setPreferenceProperty( elemGroup, "columns", 2 );
5159 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5160 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5161 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5162 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5163 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5164 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5165 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5166 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5167 addPreference( tr( "PREF_PREVIEW_COLOR" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5170 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5171 setPreferenceProperty( grpGroup, "columns", 2 );
5173 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5174 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5176 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5177 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5178 /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5179 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5180 double ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5181 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5182 double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5183 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5184 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
5185 LightApp_Preferences::IntSpin, "SMESH", "element_width");
5186 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5187 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5188 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5189 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5191 setPreferenceProperty( size0d, "min", 1 );
5192 setPreferenceProperty( size0d, "max", 10 );
5194 // setPreferenceProperty( ballSize, "min", 1 );
5195 // setPreferenceProperty( ballSize, "max", 10 );
5197 setPreferenceProperty( ballDiameter, "min", 1e-7 );
5198 setPreferenceProperty( ballDiameter, "max", 1e9 );
5199 setPreferenceProperty( ballDiameter, "step", 0.1 );
5201 setPreferenceProperty( ballScale, "min", 1e-2 );
5202 setPreferenceProperty( ballScale, "max", 1e7 );
5203 setPreferenceProperty( ballScale, "step", 0.5 );
5205 setPreferenceProperty( elemW, "min", 1 );
5206 setPreferenceProperty( elemW, "max", 5 );
5208 setPreferenceProperty( outW, "min", 1 );
5209 setPreferenceProperty( outW, "max", 5 );
5211 setPreferenceProperty( shrink, "min", 0 );
5212 setPreferenceProperty( shrink, "max", 100 );
5214 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5215 setPreferenceProperty( numGroup, "columns", 2 );
5217 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5218 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5220 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5221 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5223 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5224 setPreferenceProperty( orientGroup, "columns", 1 );
5226 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5227 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5229 setPreferenceProperty( orientScale, "min", 0.05 );
5230 setPreferenceProperty( orientScale, "max", 0.5 );
5231 setPreferenceProperty( orientScale, "step", 0.05 );
5233 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5235 // Selection tab ------------------------------------------------------------------------
5236 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5238 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5239 setPreferenceProperty( selGroup, "columns", 2 );
5241 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5242 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5244 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5245 setPreferenceProperty( preGroup, "columns", 2 );
5247 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5249 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5250 setPreferenceProperty( precSelGroup, "columns", 2 );
5252 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5253 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5254 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5256 // Scalar Bar tab ------------------------------------------------------------------------
5257 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5258 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5259 setPreferenceProperty( fontGr, "columns", 2 );
5261 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5262 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5264 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5265 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5267 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5268 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5270 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5271 setPreferenceProperty( numcol, "min", 2 );
5272 setPreferenceProperty( numcol, "max", 256 );
5274 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5275 setPreferenceProperty( numlab, "min", 2 );
5276 setPreferenceProperty( numlab, "max", 65 );
5278 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5279 setPreferenceProperty( orientGr, "columns", 2 );
5280 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5281 QStringList orients;
5282 orients.append( tr( "SMESH_VERTICAL" ) );
5283 orients.append( tr( "SMESH_HORIZONTAL" ) );
5284 indices.clear(); indices.append( 0 ); indices.append( 1 );
5285 setPreferenceProperty( orient, "strings", orients );
5286 setPreferenceProperty( orient, "indexes", indices );
5288 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5289 setPreferenceProperty( posVSizeGr, "columns", 2 );
5290 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5291 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5292 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5293 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5294 setPreferenceProperty( xv, "step", 0.1 );
5295 setPreferenceProperty( xv, "min", 0.0 );
5296 setPreferenceProperty( xv, "max", 1.0 );
5297 setPreferenceProperty( yv, "step", 0.1 );
5298 setPreferenceProperty( yv, "min", 0.0 );
5299 setPreferenceProperty( yv, "max", 1.0 );
5300 setPreferenceProperty( wv, "step", 0.1 );
5301 setPreferenceProperty( wv, "min", 0.0 );
5302 setPreferenceProperty( wv, "max", 1.0 );
5303 setPreferenceProperty( hv, "min", 0.0 );
5304 setPreferenceProperty( hv, "max", 1.0 );
5305 setPreferenceProperty( hv, "step", 0.1 );
5307 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5308 setPreferenceProperty( posHSizeGr, "columns", 2 );
5309 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5310 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5311 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5312 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5313 setPreferenceProperty( xv, "min", 0.0 );
5314 setPreferenceProperty( xv, "max", 1.0 );
5315 setPreferenceProperty( xv, "step", 0.1 );
5316 setPreferenceProperty( xh, "min", 0.0 );
5317 setPreferenceProperty( xh, "max", 1.0 );
5318 setPreferenceProperty( xh, "step", 0.1 );
5319 setPreferenceProperty( yh, "min", 0.0 );
5320 setPreferenceProperty( yh, "max", 1.0 );
5321 setPreferenceProperty( yh, "step", 0.1 );
5322 setPreferenceProperty( wh, "min", 0.0 );
5323 setPreferenceProperty( wh, "max", 1.0 );
5324 setPreferenceProperty( wh, "step", 0.1 );
5325 setPreferenceProperty( hh, "min", 0.0 );
5326 setPreferenceProperty( hh, "max", 1.0 );
5327 setPreferenceProperty( hh, "step", 0.1 );
5329 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5330 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5331 setPreferenceProperty( distributionGr, "columns", 3 );
5333 types.append( tr( "SMESH_MONOCOLOR" ) );
5334 types.append( tr( "SMESH_MULTICOLOR" ) );
5335 indices.clear(); indices.append( 0 ); indices.append( 1 );
5336 setPreferenceProperty( coloringType, "strings", types );
5337 setPreferenceProperty( coloringType, "indexes", indices );
5338 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5342 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5344 if( sect=="SMESH" ) {
5345 float sbX1,sbY1,sbW,sbH;
5346 float aTol = 1.00000009999999;
5347 std::string aWarning;
5348 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5349 if( name=="selection_object_color" || name=="selection_element_color" ||
5350 name=="highlight_color" ||
5351 name=="selection_precision_node" || name=="selection_precision_element" ||
5352 name=="selection_precision_object")
5353 SMESH::UpdateSelectionProp( this );
5354 else if (name == QString("scalar_bar_vertical_x") || name == QString("scalar_bar_vertical_width")){
5355 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5356 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5357 if(sbX1+sbW > aTol){
5358 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5361 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5362 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5365 else if(name == QString("scalar_bar_vertical_y") || name == QString("scalar_bar_vertical_height")){
5366 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5367 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5368 if(sbY1+sbH > aTol){
5369 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5370 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5371 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5374 else if(name == QString("scalar_bar_horizontal_x") || name == QString("scalar_bar_horizontal_width")){
5375 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5376 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5377 if(sbX1+sbW > aTol){
5378 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5381 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5382 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5385 else if(name == QString("scalar_bar_horizontal_y") || name == QString("scalar_bar_horizontal_height")){
5386 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5387 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5388 if(sbY1+sbH > aTol){
5389 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5392 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5393 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5396 else if ( name == "segmentation" ) {
5397 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5398 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5400 else if ( name == "nb_segments_per_edge" ) {
5401 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5402 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5404 else if ( name == "historical_python_dump" ||
5405 name == "forget_mesh_on_hyp_modif") {
5406 QString val = aResourceMgr->stringValue( "SMESH", name );
5407 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5409 else if ( name == QString( "numbering_node_color" ) || name == QString( "numbering_node_font" ) ) {
5410 SMESH::UpdateFontProp( this );
5412 else if ( name == QString( "numbering_elem_color" ) || name == QString( "numbering_elem_font" ) ) {
5413 SMESH::UpdateFontProp( this );
5416 if(aWarning.size() != 0){
5417 aWarning += "The default values are applied instead.";
5418 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5419 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5420 QObject::tr(aWarning.c_str()));
5425 //================================================================================
5427 * \brief Update something in accordance with update flags
5428 * \param theFlags - update flags
5430 * Update viewer or/and object browser etc. in accordance with update flags ( see
5431 * LightApp_UpdateFlags enumeration ).
5433 //================================================================================
5434 void SMESHGUI::update( const int flags )
5436 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5437 SMESH::UpdateView();
5439 SalomeApp_Module::update( flags );
5442 //================================================================================
5444 * \brief Set default selection mode
5446 * SLOT called when operation commited. Sets default selection mode
5448 //================================================================================
5449 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5451 SVTK_ViewWindow* vtkWnd =
5452 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5454 vtkWnd->SetSelectionMode( ActorSelection );
5457 //================================================================================
5459 * \brief Set default selection mode
5461 * SLOT called when operation aborted. Sets default selection mode
5463 //================================================================================
5464 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5466 SVTK_ViewWindow* vtkWnd =
5467 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5469 vtkWnd->SetSelectionMode( ActorSelection );
5472 //================================================================================
5474 * \brief Creates operation with given identifier
5475 * \param id - identifier of operation to be started
5476 * \return Pointer on created operation or NULL if operation is not created
5478 * Virtual method redefined from the base class creates operation with given id.
5479 * It is called called automatically from startOperation method of base class.
5481 //================================================================================
5482 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5484 LightApp_Operation* op = 0;
5485 // to do : create operation here
5488 case SMESHOp::OpSplitBiQuadratic:
5489 op = new SMESHGUI_SplitBiQuadOp();
5491 case SMESHOp::OpConvertMeshToQuadratic:
5492 op = new SMESHGUI_ConvToQuadOp();
5494 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5495 op = new SMESHGUI_Make2DFrom3DOp();
5497 case SMESHOp::OpReorientFaces:
5498 op = new SMESHGUI_ReorientFacesOp();
5500 case SMESHOp::OpCreateMesh:
5501 op = new SMESHGUI_MeshOp( true, true );
5503 case SMESHOp::OpCreateSubMesh:
5504 op = new SMESHGUI_MeshOp( true, false );
5506 case SMESHOp::OpEditMeshOrSubMesh:
5507 op = new SMESHGUI_MeshOp( false );
5509 case SMESHOp::OpCompute:
5510 op = new SMESHGUI_ComputeOp();
5512 case SMESHOp::OpPreCompute:
5513 op = new SMESHGUI_PrecomputeOp();
5515 case SMESHOp::OpEvaluate:
5516 op = new SMESHGUI_EvaluateOp();
5518 case SMESHOp::OpMeshOrder:
5519 op = new SMESHGUI_MeshOrderOp();
5521 case SMESHOp::OpCreateGeometryGroup:
5522 op = new SMESHGUI_GroupOnShapeOp();
5524 case SMESHOp::OpFindElementByPoint:
5525 op = new SMESHGUI_FindElemByPointOp();
5527 case SMESHOp::OpMoveNode: // Make mesh pass through point
5528 op = new SMESHGUI_MakeNodeAtPointOp();
5530 case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
5531 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5538 op = SalomeApp_Module::createOperation( id );
5542 //================================================================================
5544 * \brief Stops current operations and starts a given one
5545 * \param id - The id of the operation to start
5547 //================================================================================
5549 void SMESHGUI::switchToOperation(int id)
5551 if ( _PTR(Study) aStudy = SMESH::GetActiveStudyDocument() )
5552 activeStudy()->abortAllOperations();
5553 startOperation( id );
5556 LightApp_Displayer* SMESHGUI::displayer()
5559 myDisplayer = new SMESHGUI_Displayer( getApp() );
5563 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5566 int aTolerance = 64;
5567 int anIterations = 0;
5573 if( anIterations % aPeriod == 0 )
5576 if( aTolerance < 1 )
5580 aHue = (int)( 360.0 * rand() / RAND_MAX );
5583 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5584 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5585 for( ; it != itEnd; ++it )
5587 SALOMEDS::Color anAutoColor = *it;
5588 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5591 aQColor.getHsv( &h, &s, &v );
5592 if( abs( h - aHue ) < aTolerance )
5604 aColor.setHsv( aHue, 255, 255 );
5606 SALOMEDS::Color aSColor;
5607 aSColor.R = aColor.redF();
5608 aSColor.G = aColor.greenF();
5609 aSColor.B = aColor.blueF();
5614 const char* gSeparator = "_"; // character used to separate parameter names
5615 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5616 const char* gPathSep = "|"; // character used to separate paths
5619 * \brief Store visual parameters
5621 * This method is called just before the study document is saved.
5622 * Store visual parameters in AttributeParameter attribue(s)
5624 void SMESHGUI::storeVisualParameters (int savePoint)
5627 Kernel_Utils::Localizer loc;
5629 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5630 if (!appStudy || !appStudy->studyDS())
5632 _PTR(Study) studyDS = appStudy->studyDS();
5634 // componentName is used for encoding of entries when storing them in IParameters
5635 std::string componentName = myComponentSMESH->ComponentDataType();
5636 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5637 //if (!aSComponent) return;
5640 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5641 componentName.c_str(),
5643 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5645 // store map of custom markers
5646 const VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5647 if( !aMarkerMap.empty() )
5649 VTK::MarkerMap::const_iterator anIter = aMarkerMap.begin();
5650 for( ; anIter != aMarkerMap.end(); anIter++ )
5652 int anId = anIter->first;
5653 VTK::MarkerData aMarkerData = anIter->second;
5654 std::string aMarkerFileName = aMarkerData.first;
5655 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5656 if( aMarkerTexture.size() < 3 )
5657 continue; // should contain at least width, height and the first value
5659 QString aPropertyName( "texture" );
5660 aPropertyName += gSeparator;
5661 aPropertyName += QString::number( anId );
5663 QString aPropertyValue = aMarkerFileName.c_str();
5664 aPropertyValue += gPathSep;
5666 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5667 ushort aWidth = *aTextureIter++;
5668 ushort aHeight = *aTextureIter++;
5669 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5670 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5671 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5672 aPropertyValue += QString::number( *aTextureIter );
5674 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5678 // viewers counters are used for storing view_numbers in IParameters
5681 // main cycle to store parameters of displayed objects
5682 QList<SUIT_ViewManager*> lst;
5683 QList<SUIT_ViewManager*>::Iterator it;
5684 getApp()->viewManagers(lst);
5685 for (it = lst.begin(); it != lst.end(); it++)
5687 SUIT_ViewManager* vman = *it;
5688 QString vType = vman->getType();
5690 // saving VTK actors properties
5691 if (vType == SVTK_Viewer::Type())
5693 // store the clipping planes attached to the view manager
5694 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5695 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5696 if( anIter != myClippingPlaneInfoMap.end() )
5697 aClippingPlaneInfoList = anIter->second;
5699 if( !aClippingPlaneInfoList.empty() ) {
5700 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5701 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5703 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5704 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5706 QString aPropertyName( "ClippingPlane" );
5707 aPropertyName += gSeparator;
5708 aPropertyName += QString::number( vtkViewers );
5709 aPropertyName += gSeparator;
5710 aPropertyName += QString::number( anId );
5712 QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
5713 aPropertyValue += gDigitsSep;
5714 aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
5715 aPropertyValue += gDigitsSep;
5716 if ( aPlane->PlaneMode == SMESH::Absolute ) {
5717 aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
5718 aPropertyValue += gDigitsSep;
5719 aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
5720 aPropertyValue += gDigitsSep;
5721 aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
5722 aPropertyValue += gDigitsSep;
5723 aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
5724 aPropertyValue += gDigitsSep;
5725 aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
5726 aPropertyValue += gDigitsSep;
5727 aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
5728 aPropertyValue += gDigitsSep;
5729 aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
5731 else if ( aPlane->PlaneMode == SMESH::Relative ) {
5732 aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
5733 aPropertyValue += gDigitsSep;
5734 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5735 aPropertyValue += gDigitsSep;
5736 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5737 aPropertyValue += gDigitsSep;
5738 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5741 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5745 QVector<SUIT_ViewWindow*> views = vman->getViews();
5746 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5748 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5750 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5751 vtkActorCollection* allActors = aCopy.GetActors();
5752 allActors->InitTraversal();
5753 while (vtkActor* actor = allActors->GetNextActor())
5755 if (actor->GetVisibility()) // store only visible actors
5757 SMESH_Actor* aSmeshActor = 0;
5758 if (actor->IsA("SMESH_Actor"))
5759 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5760 if (aSmeshActor && aSmeshActor->hasIO())
5762 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5765 // entry is "encoded" = it does NOT contain component adress,
5766 // since it is a subject to change on next component loading
5767 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5769 std::string param, vtkParam = vType.toLatin1().data();
5770 vtkParam += gSeparator;
5771 vtkParam += QString::number(vtkViewers).toLatin1().data();
5772 vtkParam += gSeparator;
5775 param = vtkParam + "Visibility";
5776 ip->setParameter(entry, param, "On");
5779 param = vtkParam + "Representation";
5780 ip->setParameter(entry, param, QString::number
5781 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5784 param = vtkParam + "IsShrunk";
5785 ip->setParameter(entry, param, QString::number
5786 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5788 // Displayed entities
5789 unsigned int aMode = aSmeshActor->GetEntityMode();
5790 bool isE = aMode & SMESH_Actor::eEdges;
5791 bool isF = aMode & SMESH_Actor::eFaces;
5792 bool isV = aMode & SMESH_Actor::eVolumes;
5793 bool is0d = aMode & SMESH_Actor::e0DElements;
5794 bool isB = aMode & SMESH_Actor::eBallElem;
5796 QString modeStr ("e");
5797 modeStr += gDigitsSep; modeStr += QString::number(isE);
5798 modeStr += gDigitsSep; modeStr += "f";
5799 modeStr += gDigitsSep; modeStr += QString::number(isF);
5800 modeStr += gDigitsSep; modeStr += "v";
5801 modeStr += gDigitsSep; modeStr += QString::number(isV);
5802 modeStr += gDigitsSep; modeStr += "0d";
5803 modeStr += gDigitsSep; modeStr += QString::number(is0d);
5804 modeStr += gDigitsSep; modeStr += "b";
5805 modeStr += gDigitsSep; modeStr += QString::number(isB);
5807 param = vtkParam + "Entities";
5808 ip->setParameter(entry, param, modeStr.toLatin1().data());
5814 aSmeshActor->GetSufaceColor(r, g, b, delta);
5815 QStringList colorStr;
5816 colorStr << "surface";
5817 colorStr << QString::number(r);
5818 colorStr << QString::number(g);
5819 colorStr << QString::number(b);
5821 colorStr << "backsurface";
5822 colorStr << QString::number(delta);
5824 aSmeshActor->GetVolumeColor(r, g, b, delta);
5825 colorStr << "volume";
5826 colorStr << QString::number(r);
5827 colorStr << QString::number(g);
5828 colorStr << QString::number(b);
5829 colorStr << QString::number(delta);
5831 aSmeshActor->GetEdgeColor(r, g, b);
5833 colorStr << QString::number(r);
5834 colorStr << QString::number(g);
5835 colorStr << QString::number(b);
5837 aSmeshActor->GetNodeColor(r, g, b);
5839 colorStr << QString::number(r);
5840 colorStr << QString::number(g);
5841 colorStr << QString::number(b);
5843 aSmeshActor->GetOutlineColor(r, g, b);
5844 colorStr << "outline";
5845 colorStr << QString::number(r);
5846 colorStr << QString::number(g);
5847 colorStr << QString::number(b);
5849 aSmeshActor->Get0DColor(r, g, b);
5850 colorStr << "elem0d";
5851 colorStr << QString::number(r);
5852 colorStr << QString::number(g);
5853 colorStr << QString::number(b);
5855 aSmeshActor->GetBallColor(r, g, b);
5857 colorStr << QString::number(r);
5858 colorStr << QString::number(g);
5859 colorStr << QString::number(b);
5861 aSmeshActor->GetFacesOrientationColor(r, g, b);
5862 colorStr << "orientation";
5863 colorStr << QString::number(r);
5864 colorStr << QString::number(g);
5865 colorStr << QString::number(b);
5867 param = vtkParam + "Colors";
5868 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
5871 QStringList sizeStr;
5873 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
5874 sizeStr << "outline";
5875 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
5876 sizeStr << "elem0d";
5877 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
5879 //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
5880 sizeStr << QString::number((double)aSmeshActor->GetBallSize());
5881 sizeStr << QString::number((double)aSmeshActor->GetBallScale());
5882 sizeStr << "shrink";
5883 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
5884 sizeStr << "orientation";
5885 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
5886 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
5888 param = vtkParam + "Sizes";
5889 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
5894 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5895 if( aMarkerType == VTK::MT_USER ) {
5896 markerStr += "custom";
5897 markerStr += gDigitsSep;
5898 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
5902 markerStr += gDigitsSep;
5903 markerStr += QString::number( (int)aMarkerType );
5904 markerStr += gDigitsSep;
5905 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
5908 param = vtkParam + "PointMarker";
5909 ip->setParameter(entry, param, markerStr.toLatin1().data());
5912 param = vtkParam + "Opacity";
5913 ip->setParameter(entry, param,
5914 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
5917 param = vtkParam + "ClippingPlane";
5919 if( !aClippingPlaneInfoList.empty() ) {
5920 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
5921 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
5923 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
5924 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
5925 SMESH::TActorList::iterator anIter2 = anActorList.begin();
5926 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
5927 if( aSmeshActor == *anIter2 ) {
5928 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
5929 QString::number( anId ).toLatin1().constData() );
5936 ip->setParameter( entry, param, "Off" );
5937 } // if (io->hasEntry())
5938 } // SMESH_Actor && hasIO
5940 } // while.. actors traversal
5944 } // if (SVTK view model)
5945 } // for (viewManagers)
5948 // data structures for clipping planes processing
5952 bool isOpenGLClipping;
5953 vtkIdType RelativeOrientation;
5956 int AbsoluteOrientation;
5957 double X, Y, Z, Dx, Dy, Dz;
5959 typedef std::list<TPlaneData> TPlaneDataList;
5960 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
5962 typedef std::list<vtkActor*> TActorList;
5965 TActorList ActorList;
5966 SUIT_ViewManager* ViewManager;
5968 typedef std::list<TPlaneInfo> TPlaneInfoList;
5969 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
5972 * \brief Restore visual parameters
5974 * This method is called after the study document is opened.
5975 * Restore visual parameters from AttributeParameter attribue(s)
5977 void SMESHGUI::restoreVisualParameters (int savePoint)
5980 Kernel_Utils::Localizer loc;
5982 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5983 if (!appStudy || !appStudy->studyDS())
5985 _PTR(Study) studyDS = appStudy->studyDS();
5987 // componentName is used for encoding of entries when storing them in IParameters
5988 std::string componentName = myComponentSMESH->ComponentDataType();
5989 //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
5990 //if (!aSComponent) return;
5993 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5994 componentName.c_str(),
5996 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5998 // restore map of custom markers and map of clipping planes
5999 VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
6000 TPlaneDataMap aPlaneDataMap;
6002 std::vector<std::string> properties = ip->getProperties();
6003 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
6005 std::string property = *propIt;
6006 QString aPropertyName( property.c_str() );
6007 QString aPropertyValue( ip->getProperty( property ).c_str() );
6009 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
6010 if( aPropertyNameList.isEmpty() )
6013 QString aPropertyType = aPropertyNameList[0];
6014 if( aPropertyType == "texture" )
6016 if( aPropertyNameList.size() != 2 )
6020 int anId = aPropertyNameList[1].toInt( &ok );
6021 if( !ok || anId < 1 )
6024 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
6025 if( aPropertyValueList.size() != 2 )
6028 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
6029 QString aMarkerTextureString = aPropertyValueList[1];
6030 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
6031 if( aMarkerTextureStringList.size() != 3 )
6035 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6040 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6044 VTK::MarkerTexture aMarkerTexture;
6045 aMarkerTexture.push_back( aWidth );
6046 aMarkerTexture.push_back( aHeight );
6048 QString aMarkerTextureData = aMarkerTextureStringList[2];
6049 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6051 QChar aChar = aMarkerTextureData.at( i );
6052 if( aChar.isDigit() )
6053 aMarkerTexture.push_back( aChar.digitValue() );
6056 aMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6058 else if( aPropertyType == "ClippingPlane" )
6060 if( aPropertyNameList.size() != 3 )
6064 int aViewId = aPropertyNameList[1].toInt( &ok );
6065 if( !ok || aViewId < 0 )
6069 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6070 if( !ok || aClippingPlaneId < 0 )
6073 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6074 if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6077 TPlaneData aPlaneData;
6078 aPlaneData.Id = aClippingPlaneId;
6081 aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6086 aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6090 if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6093 aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6098 aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6103 aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6108 aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6113 aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6118 aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6123 aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6127 else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6129 aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6134 aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6139 aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6144 aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6149 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6150 aPlaneDataList.push_back( aPlaneData );
6154 TPlaneInfoMap aPlaneInfoMap;
6156 std::vector<std::string> entries = ip->getEntries();
6158 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6160 // entry is a normal entry - it should be "decoded" (setting base adress of component)
6161 QString entry (ip->decodeEntry(*entIt).c_str());
6163 // Check that the entry corresponds to a real object in the Study
6164 // as the object may be deleted or modified after the visual state is saved.
6165 _PTR(SObject) so = studyDS->FindObjectID(entry.toLatin1().data());
6166 if (!so) continue; //Skip the not existent entry
6168 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6169 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6171 std::vector<std::string>::iterator namesIt = paramNames.begin();
6172 std::vector<std::string>::iterator valuesIt = paramValues.begin();
6174 // actors are stored in a map after displaying of them for
6175 // quicker access in the future: map < viewID to actor >
6176 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6178 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6180 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6181 // '_' is used as separator and should not be used in viewer type or parameter names.
6182 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6183 if (lst.size() != 3)
6186 QString viewerTypStr = lst[0];
6187 QString viewIndexStr = lst[1];
6188 QString paramNameStr = lst[2];
6191 int viewIndex = viewIndexStr.toUInt(&ok);
6192 if (!ok) // bad conversion of view index to integer
6196 if (viewerTypStr == SVTK_Viewer::Type())
6198 SMESH_Actor* aSmeshActor = 0;
6199 if (vtkActors.IsBound(viewIndex))
6200 aSmeshActor = vtkActors.Find(viewIndex);
6202 QList<SUIT_ViewManager*> lst;
6203 getApp()->viewManagers(viewerTypStr, lst);
6205 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6206 SUIT_ViewManager* vman = NULL;
6207 if (viewIndex >= 0 && viewIndex < lst.count())
6208 vman = lst.at(viewIndex);
6210 if (paramNameStr == "Visibility")
6212 if (!aSmeshActor && displayer() && vman)
6214 SUIT_ViewModel* vmodel = vman->getViewModel();
6215 // SVTK view model can be casted to SALOME_View
6216 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6218 // store displayed actor in a temporary map for quicker
6219 // access later when restoring other parameters
6220 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6221 vtkRenderer* Renderer = vtkView->getRenderer();
6222 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6223 vtkActorCollection* theActors = aCopy.GetActors();
6224 theActors->InitTraversal();
6225 bool isFound = false;
6226 vtkActor *ac = theActors->GetNextActor();
6227 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6228 if (ac->IsA("SMESH_Actor")) {
6229 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6230 if (aGeomAc->hasIO()) {
6231 Handle(SALOME_InteractiveObject) io =
6232 Handle(SALOME_InteractiveObject)::DownCast(aGeomAc->getIO());
6233 if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) {
6235 vtkActors.Bind(viewIndex, aGeomAc);
6241 } // if (paramNameStr == "Visibility")
6244 // the rest properties "work" with SMESH_Actor
6247 QString val ((*valuesIt).c_str());
6250 if (paramNameStr == "Representation") {
6251 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6254 else if (paramNameStr == "IsShrunk") {
6256 if (!aSmeshActor->IsShrunk())
6257 aSmeshActor->SetShrink();
6260 if (aSmeshActor->IsShrunk())
6261 aSmeshActor->UnShrink();
6264 // Displayed entities
6265 else if (paramNameStr == "Entities") {
6266 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6267 int aEntityMode = SMESH_Actor::eAllEntity;
6268 for ( int i = 0; i < mode.count(); i+=2 ) {
6269 if ( i < mode.count()-1 ) {
6270 QString type = mode[i];
6271 bool val = mode[i+1].toInt();
6272 if ( type == "e" && !val )
6273 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6274 else if ( type == "f" && !val )
6275 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6276 else if ( type == "v" && !val )
6277 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6278 else if ( type == "0d" && !val )
6279 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6280 else if ( type == "b" && !val )
6281 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6284 aSmeshActor->SetEntityMode( aEntityMode );
6287 else if (paramNameStr == "Colors") {
6288 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6295 QColor outlineColor;
6296 QColor orientationColor;
6302 // below lines are required to get default values for delta coefficients
6303 // of backface color for faces and color of reversed volumes
6304 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
6305 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6306 for ( int i = 0; i < colors.count(); i++ ) {
6307 QString type = colors[i];
6308 if ( type == "surface" ) {
6309 // face color is set by 3 values r:g:b, where
6310 // - r,g,b - is rgb color components
6311 if ( i+1 >= colors.count() ) break; // format error
6312 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6313 if ( i+2 >= colors.count() ) break; // format error
6314 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6315 if ( i+3 >= colors.count() ) break; // format error
6316 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6317 faceColor.setRgbF( r, g, b );
6320 else if ( type == "backsurface" ) {
6321 // backface color can be defined in several ways
6322 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6323 // - in latest versions, it is set as delta coefficient
6324 bool rgbOk = false, deltaOk;
6325 if ( i+1 >= colors.count() ) break; // format error
6326 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6327 int delta = colors[i+1].toInt( &deltaOk );
6329 if ( i+1 < colors.count() ) // index is shifted to 1
6330 g = colors[i+1].toDouble( &rgbOk );
6331 if ( rgbOk ) i++; // shift index
6332 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6333 b = colors[i+1].toDouble( &rgbOk );
6335 // - as currently there's no way to set directly backsurface color as it was before,
6336 // we ignore old dump where r,g,b triple was set
6337 // - also we check that delta parameter is set properly
6338 if ( !rgbOk && deltaOk )
6341 else if ( type == "volume" ) {
6342 // volume color is set by 4 values r:g:b:delta, where
6343 // - r,g,b - is a normal volume rgb color components
6344 // - delta - is a reversed volume color delta coefficient
6345 if ( i+1 >= colors.count() ) break; // format error
6346 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6347 if ( i+2 >= colors.count() ) break; // format error
6348 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6349 if ( i+3 >= colors.count() ) break; // format error
6350 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6351 if ( i+4 >= colors.count() ) break; // format error
6352 int delta = colors[i+4].toInt( &bOk );
6353 if ( !bOk ) break; // format error
6354 volumeColor.setRgbF( r, g, b );
6358 else if ( type == "edge" ) {
6359 // edge color is set by 3 values r:g:b, where
6360 // - r,g,b - is rgb color components
6361 if ( i+1 >= colors.count() ) break; // format error
6362 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6363 if ( i+2 >= colors.count() ) break; // format error
6364 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6365 if ( i+3 >= colors.count() ) break; // format error
6366 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6367 edgeColor.setRgbF( r, g, b );
6370 else if ( type == "node" ) {
6371 // node color is set by 3 values r:g:b, where
6372 // - r,g,b - is rgb color components
6373 if ( i+1 >= colors.count() ) break; // format error
6374 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6375 if ( i+2 >= colors.count() ) break; // format error
6376 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6377 if ( i+3 >= colors.count() ) break; // format error
6378 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6379 nodeColor.setRgbF( r, g, b );
6382 else if ( type == "elem0d" ) {
6383 // 0d element color is set by 3 values r:g:b, where
6384 // - r,g,b - is rgb color components
6385 if ( i+1 >= colors.count() ) break; // format error
6386 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6387 if ( i+2 >= colors.count() ) break; // format error
6388 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6389 if ( i+3 >= colors.count() ) break; // format error
6390 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6391 elem0dColor.setRgbF( r, g, b );
6394 else if ( type == "ball" ) {
6395 // ball color is set by 3 values r:g:b, where
6396 // - r,g,b - is rgb color components
6397 if ( i+1 >= colors.count() ) break; // format error
6398 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6399 if ( i+2 >= colors.count() ) break; // format error
6400 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6401 if ( i+3 >= colors.count() ) break; // format error
6402 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6403 ballColor.setRgbF( r, g, b );
6406 else if ( type == "outline" ) {
6407 // outline color is set by 3 values r:g:b, where
6408 // - r,g,b - is rgb color components
6409 if ( i+1 >= colors.count() ) break; // format error
6410 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6411 if ( i+2 >= colors.count() ) break; // format error
6412 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6413 if ( i+3 >= colors.count() ) break; // format error
6414 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6415 outlineColor.setRgbF( r, g, b );
6418 else if ( type == "orientation" ) {
6419 // orientation color is set by 3 values r:g:b, where
6420 // - r,g,b - is rgb color components
6421 if ( i+1 >= colors.count() ) break; // format error
6422 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6423 if ( i+2 >= colors.count() ) break; // format error
6424 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6425 if ( i+3 >= colors.count() ) break; // format error
6426 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6427 orientationColor.setRgbF( r, g, b );
6432 if ( nodeColor.isValid() )
6433 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6435 if ( edgeColor.isValid() )
6436 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6438 if ( faceColor.isValid() )
6439 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6441 if ( volumeColor.isValid() )
6442 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6443 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6444 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6446 if ( elem0dColor.isValid() )
6447 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6449 if ( ballColor.isValid() )
6450 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6452 if ( outlineColor.isValid() )
6453 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6454 // orientation color
6455 if ( orientationColor.isValid() )
6456 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6459 else if (paramNameStr == "Sizes") {
6460 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6463 int outlineWidth = -1;
6464 int elem0dSize = -1;
6465 //int ballSize = -1;
6466 double ballDiameter = -1.0;
6467 double ballScale = -1.0;
6468 double shrinkSize = -1;
6469 double orientationSize = -1;
6470 bool orientation3d = false;
6471 for ( int i = 0; i < sizes.count(); i++ ) {
6472 QString type = sizes[i];
6473 if ( type == "line" ) {
6474 // line (wireframe) width is given as single integer value
6475 if ( i+1 >= sizes.count() ) break; // format error
6476 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6480 if ( type == "outline" ) {
6481 // outline width is given as single integer value
6482 if ( i+1 >= sizes.count() ) break; // format error
6483 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6487 else if ( type == "elem0d" ) {
6488 // 0d element size is given as single integer value
6489 if ( i+1 >= sizes.count() ) break; // format error
6490 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6494 else if ( type == "ball" ) {
6495 // balls are specified by two values: size:scale, where
6496 // - size - is a integer value specifying size
6497 // - scale - is a double value specifying scale factor
6498 if ( i+1 >= sizes.count() ) break; // format error
6499 //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6500 double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6501 if ( i+2 >= sizes.count() ) break; // format error
6502 double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6508 else if ( type == "shrink" ) {
6509 // shrink factor is given as single floating point value
6510 if ( i+1 >= sizes.count() ) break; // format error
6511 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6515 else if ( type == "orientation" ) {
6516 // orientation vectors are specified by two values size:3d, where
6517 // - size - is a floating point value specifying scale factor
6518 // - 3d - is a boolean
6519 if ( i+1 >= sizes.count() ) break; // format error
6520 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6521 if ( i+2 >= sizes.count() ) break; // format error
6522 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6523 orientationSize = v1;
6524 orientation3d = (bool)v2;
6528 // line (wireframe) width
6529 if ( lineWidth > 0 )
6530 aSmeshActor->SetLineWidth( lineWidth );
6532 if ( outlineWidth > 0 )
6533 aSmeshActor->SetOutlineWidth( outlineWidth );
6534 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6535 aSmeshActor->SetOutlineWidth( lineWidth );
6537 if ( elem0dSize > 0 )
6538 aSmeshActor->Set0DSize( elem0dSize );
6540 /*if ( ballSize > 0 )
6541 aSmeshActor->SetBallSize( ballSize );*/
6543 if ( ballDiameter > 0 )
6544 aSmeshActor->SetBallSize( ballDiameter );
6546 if ( ballScale > 0.0 )
6547 aSmeshActor->SetBallScale( ballScale );
6549 if ( shrinkSize > 0 )
6550 aSmeshActor->SetShrinkFactor( shrinkSize );
6551 // orientation vectors
6552 if ( orientationSize > 0 ) {
6553 aSmeshActor->SetFacesOrientationScale( orientationSize );
6554 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6558 else if (paramNameStr == "PointMarker") {
6559 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6560 if( data.count() >= 2 ) {
6562 int aParam1 = data[1].toInt( &ok );
6564 if( data[0] == "std" && data.count() == 3 ) {
6565 int aParam2 = data[2].toInt( &ok );
6566 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6568 else if( data[0] == "custom" ) {
6569 VTK::MarkerMap::const_iterator markerIt = aMarkerMap.find( aParam1 );
6570 if( markerIt != aMarkerMap.end() ) {
6571 VTK::MarkerData aMarkerData = markerIt->second;
6572 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6579 else if (paramNameStr == "Opacity") {
6580 aSmeshActor->SetOpacity(val.toFloat());
6583 else if (paramNameStr.startsWith("ClippingPlane")) {
6584 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6585 // old format - val looks like "Off" or "1:0:0:0.5:0:0"
6586 // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
6587 // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
6588 // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
6589 // new format - val looks like "Off" or "0" (plane id)
6590 // (note: in new format "Off" value is used only for consistency,
6591 // so it is processed together with values in old format)
6592 bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
6593 if( anIsOldFormat ) {
6594 if (paramNameStr == "ClippingPlane1" || val == "Off")
6595 aSmeshActor->RemoveAllClippingPlanes();
6597 QList<SUIT_ViewManager*> lst;
6598 getApp()->viewManagers(viewerTypStr, lst);
6599 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6600 if (viewIndex >= 0 && viewIndex < lst.count()) {
6601 SUIT_ViewManager* vman = lst.at(viewIndex);
6602 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6604 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6606 SMESH::TActorList anActorList;
6607 anActorList.push_back( aSmeshActor );
6608 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
6609 aPlane->myViewWindow = vtkView;
6610 SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
6611 aPlane->PlaneMode = aMode;
6612 bool isOpenGLClipping = ( bool )vals[1].toInt();
6613 aPlane->IsOpenGLClipping = isOpenGLClipping;
6614 if ( aMode == SMESH::Absolute ) {
6615 aPlane->myAbsoluteOrientation = vals[2].toInt();
6616 aPlane->X = vals[3].toFloat();
6617 aPlane->Y = vals[4].toFloat();
6618 aPlane->Z = vals[5].toFloat();
6619 aPlane->Dx = vals[6].toFloat();
6620 aPlane->Dy = vals[7].toFloat();
6621 aPlane->Dz = vals[8].toFloat();
6623 else if ( aMode == SMESH::Relative ) {
6624 aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
6625 aPlane->myDistance = vals[3].toFloat();
6626 aPlane->myAngle[0] = vals[4].toFloat();
6627 aPlane->myAngle[1] = vals[5].toFloat();
6631 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6632 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6633 aClippingPlaneInfo.Plane = aPlane;
6634 aClippingPlaneInfo.ActorList = anActorList;
6635 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6643 int aPlaneId = val.toInt( &ok );
6644 if( ok && aPlaneId >= 0 ) {
6645 bool anIsDefinedPlane = false;
6646 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6647 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6648 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6649 TPlaneInfo& aPlaneInfo = *anIter;
6650 if( aPlaneInfo.PlaneId == aPlaneId ) {
6651 aPlaneInfo.ActorList.push_back( aSmeshActor );
6652 anIsDefinedPlane = true;
6656 if( !anIsDefinedPlane ) {
6657 TPlaneInfo aPlaneInfo;
6658 aPlaneInfo.PlaneId = aPlaneId;
6659 aPlaneInfo.ActorList.push_back( aSmeshActor );
6660 aPlaneInfo.ViewManager = vman;
6662 // to make the list sorted by plane id
6663 anIter = aPlaneInfoList.begin();
6664 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6665 const TPlaneInfo& aPlaneInfoRef = *anIter;
6666 if( aPlaneInfoRef.PlaneId > aPlaneId )
6669 aPlaneInfoList.insert( anIter, aPlaneInfo );
6674 } // if (aSmeshActor)
6675 } // other parameters than Visibility
6677 } // for names/parameters iterator
6678 } // for entries iterator
6680 // take into account planes with empty list of actors referred to them
6681 QList<SUIT_ViewManager*> aVMList;
6682 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6684 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6685 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6686 int aViewId = aPlaneDataIter->first;
6687 if( aViewId >= 0 && aViewId < aVMList.count() ) {
6688 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6690 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6692 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6693 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6694 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6695 const TPlaneData& aPlaneData = *anIter2;
6696 int aPlaneId = aPlaneData.Id;
6698 bool anIsFound = false;
6699 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6700 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6701 const TPlaneInfo& aPlaneInfo = *anIter3;
6702 if( aPlaneInfo.PlaneId == aPlaneId ) {
6709 TPlaneInfo aPlaneInfo; // ActorList field is empty
6710 aPlaneInfo.PlaneId = aPlaneId;
6711 aPlaneInfo.ViewManager = aViewManager;
6713 // to make the list sorted by plane id
6714 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6715 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6716 const TPlaneInfo& aPlaneInfoRef = *anIter4;
6717 if( aPlaneInfoRef.PlaneId > aPlaneId )
6720 aPlaneInfoList.insert( anIter4, aPlaneInfo );
6726 // add clipping planes to actors according to the restored parameters
6727 // and update the clipping plane map
6728 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6729 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6730 int aViewId = anIter1->first;
6731 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6733 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6734 if( anIter2 == aPlaneDataMap.end() )
6736 const TPlaneDataList& aPlaneDataList = anIter2->second;
6738 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6739 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6740 const TPlaneInfo& aPlaneInfo = *anIter3;
6741 int aPlaneId = aPlaneInfo.PlaneId;
6742 const TActorList& anActorList = aPlaneInfo.ActorList;
6743 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6747 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6751 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6753 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6754 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6755 const TPlaneData& aPlaneData = *anIter4;
6756 if( aPlaneData.Id == aPlaneId ) {
6757 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
6758 aPlane->myViewWindow = aViewWindow;
6759 aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
6760 aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
6761 if ( aPlane->PlaneMode == SMESH::Absolute ) {
6762 aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
6763 aPlane->X = aPlaneData.X;
6764 aPlane->Y = aPlaneData.Y;
6765 aPlane->Z = aPlaneData.Z;
6766 aPlane->Dx = aPlaneData.Dx;
6767 aPlane->Dy = aPlaneData.Dy;
6768 aPlane->Dz = aPlaneData.Dz;
6770 else if ( aPlane->PlaneMode == SMESH::Relative ) {
6771 aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
6772 aPlane->myDistance = aPlaneData.Distance;
6773 aPlane->myAngle[0] = aPlaneData.Angle[0];
6774 aPlane->myAngle[1] = aPlaneData.Angle[1];
6777 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6778 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6779 aClippingPlaneInfo.Plane = aPlane;
6780 aClippingPlaneInfo.ActorList = anActorList;
6781 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6792 // update all VTK views
6793 QList<SUIT_ViewManager*> lst;
6794 getApp()->viewManagers(lst);
6795 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6796 SUIT_ViewModel* vmodel = (*it)->getViewModel();
6797 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6798 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6799 // set OpenGL clipping planes
6800 VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
6801 vtkActorCollection* anAllActors = aCopy.GetActors();
6802 anAllActors->InitTraversal();
6803 while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
6804 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
6805 anActor->SetOpenGLClippingPlane();
6807 vtkView->getRenderer()->ResetCameraClippingRange();
6814 \brief Adds preferences for dfont of VTK viewer
6816 \param pIf group identifier
6817 \param param parameter
6818 \return identifier of preferences
6820 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
6822 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6824 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6827 fam.append( tr( "SMESH_FONT_ARIAL" ) );
6828 fam.append( tr( "SMESH_FONT_COURIER" ) );
6829 fam.append( tr( "SMESH_FONT_TIMES" ) );
6831 setPreferenceProperty( tfont, "fonts", fam );
6833 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6834 if ( needSize ) f = f | QtxFontEdit::Size;
6835 setPreferenceProperty( tfont, "features", f );
6841 \brief Actions after hypothesis edition
6842 Updates object browser after hypothesis edition
6844 void SMESHGUI::onHypothesisEdit( int result )
6847 SMESHGUI::Modified();
6848 updateObjBrowser( true );
6853 \brief Signal handler closing(SUIT_ViewWindow*) of a view
6854 \param pview view being closed
6856 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
6857 #ifndef DISABLE_PLOT2DVIEWER
6858 //Crear all Plot2d Viewers if need.
6859 SMESH::ClearPlot2Viewers(pview);
6861 EmitSignalCloseView();
6864 void SMESHGUI::message( const QString& msg )
6867 QStringList data = msg.split("/");
6868 if ( data.count() > 0 ) {
6869 if ( data.first() == "mesh_loading" ) {
6871 QString entry = data.count() > 1 ? data[1] : QString();
6872 if ( entry.isEmpty() )
6875 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
6877 _PTR(SObject) obj = study->FindObjectID( entry.toLatin1().constData() );
6880 name = SMESH::fromUtf8(obj->GetName());
6881 if ( name.isEmpty() )
6884 if ( data.last() == "stop" )
6885 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
6887 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
6888 QApplication::processEvents();
6894 \brief Connects or disconnects signals about activating and cloning view on the module slots
6895 \param pview view which is connected/disconnected
6897 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
6901 SUIT_ViewManager* viewMgr = pview->getViewManager();
6903 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6904 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6906 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6907 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6912 \brief Return \c true if object can be renamed
6914 bool SMESHGUI::renameAllowed( const QString& entry) const {
6915 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6919 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6923 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
6928 if(appStudy->isComponent(entry) || obj->isReference())
6931 // check type to prevent renaming of inappropriate objects
6932 int aType = SMESHGUI_Selection::type(qPrintable(entry), SMESH::GetActiveStudyDocument());
6933 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6934 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6935 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6936 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6937 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
6944 Rename object by entry.
6945 \param entry entry of the object
6946 \param name new name of the object
6947 \brief Return \c true if rename operation finished successfully, \c false otherwise.
6949 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
6951 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6955 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6960 _PTR(Study) aStudy = appStudy->studyDS();
6965 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
6967 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
6972 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
6973 _PTR(GenericAttribute) anAttr;
6974 _PTR(AttributeName) aName;
6976 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
6978 // check type to prevent renaming of inappropriate objects
6979 int aType = SMESHGUI_Selection::type( qPrintable(entry), SMESH::GetActiveStudyDocument() );
6980 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6981 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6982 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6983 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6984 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
6985 if ( !name.isEmpty() ) {
6986 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
6988 // update name of group object and its actor
6989 Handle(SALOME_InteractiveObject) IObject =
6990 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
6992 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
6993 if( !aGroupObject->_is_nil() ) {
6994 aGroupObject->SetName( qPrintable(name) );
6995 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
6996 anActor->setName( qPrintable(name) );
7006 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
7008 static QList<QColor> colors;
7010 if ( colors.isEmpty() ) {
7012 for (int s = 0; s < 2 ; s++)
7014 for (int v = 100; v >= 40; v = v - 20)
7016 for (int h = 0; h < 359 ; h = h + 60)
7018 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
7023 static int currentColor = randomize( colors.size() );
7025 SALOMEDS::Color color;
7026 color.R = (double)colors[currentColor].red() / 255.0;
7027 color.G = (double)colors[currentColor].green() / 255.0;
7028 color.B = (double)colors[currentColor].blue() / 255.0;
7030 currentColor = (currentColor+1) % colors.count();