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)"),
4370 hasFacesOrVolumes("(({'Face'} in elemTypes) || ({'Volume'} in elemTypes)) ");
4372 createPopupItem( SMESHOp::OpFileInformation, OB, mesh, "&& selcount=1 && isImported" );
4373 createPopupItem( SMESHOp::OpCreateSubMesh, OB, mesh, "&& isComputable");
4374 createPopupItem( SMESHOp::OpEditMeshOrSubMesh, OB, mesh, "&& isComputable");
4375 createPopupItem( SMESHOp::OpEditMeshOrSubMesh, OB, subMesh, "&& isComputable" );
4376 createPopupItem( SMESHOp::OpEditGroup, OB, group );
4377 createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4379 popupMgr()->insert( separator(), -1, 0 );
4380 createPopupItem( SMESHOp::OpCompute, OB, mesh, "&& isComputable" );
4381 createPopupItem( SMESHOp::OpPreCompute, OB, mesh, "&& isComputable && isPreComputable" );
4382 createPopupItem( SMESHOp::OpEvaluate, OB, mesh, "&& isComputable" );
4383 createPopupItem( SMESHOp::OpMeshOrder, OB, mesh, "&& isComputable" );
4384 createPopupItem( SMESHOp::OpUpdate, OB, mesh_part );
4385 createPopupItem( SMESHOp::OpMeshInformation, OB, mesh_part );
4386 createPopupItem( SMESHOp::OpFindElementByPoint, OB, mesh_group );
4387 createPopupItem( SMESHOp::OpOverallMeshQuality, OB, mesh_part );
4388 popupMgr()->insert( separator(), -1, 0 );
4389 createPopupItem( SMESHOp::OpCreateGroup, OB, mesh );
4390 createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh );
4391 createPopupItem( SMESHOp::OpConstructGroup, OB, subMesh );
4392 popupMgr()->insert( separator(), -1, 0 );
4393 createPopupItem( SMESHOp::OpEditHypothesis, OB, hypo);
4394 createPopupItem( SMESHOp::OpUnassign, OB, hyp_alg ); // REMOVE HYPOTHESIS / ALGORITHMS
4395 popupMgr()->insert( separator(), -1, 0 );
4396 createPopupItem( SMESHOp::OpClearMesh, OB, mesh );
4397 popupMgr()->insert( separator(), -1, 0 );
4398 createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh + " " + subMesh ); // convert to quadratic
4399 createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh + " " + group, // create 2D mesh from 3D
4401 popupMgr()->insert( separator(), -1, 0 );
4403 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4404 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4405 QString only_one_2D = only_one_non_empty + " && dim>1";
4407 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4408 createPopupItem( SMESHOp::OpPopupExportMED, OB, mesh_group, multiple_non_empty, anId );
4409 createPopupItem( SMESHOp::OpPopupExportUNV, OB, mesh_group, only_one_non_empty, anId );
4410 createPopupItem( SMESHOp::OpPopupExportSTL, OB, mesh_group, only_one_2D, anId );
4412 createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4414 createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, only_one_non_empty, anId );
4415 createPopupItem( SMESHOp::OpPopupExportGMF, OB, mesh_group, only_one_non_empty, anId );
4416 createPopupItem( SMESHOp::OpPopupExportDAT, OB, mesh_group, only_one_non_empty, anId );
4417 createPopupItem( SMESHOp::OpDelete, OB, mesh_part + " " + hyp_alg );
4418 createPopupItem( SMESHOp::OpDeleteGroup, OB, group );
4419 popupMgr()->insert( separator(), -1, 0 );
4422 createPopupItem( SMESHOp::OpEditGroup, View, group );
4423 createPopupItem( SMESHOp::OpAddElemGroupPopup, View, elems );
4424 createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems );
4426 popupMgr()->insert( separator(), -1, 0 );
4427 createPopupItem( SMESHOp::OpUpdate, View, mesh_part );
4428 createPopupItem( SMESHOp::OpMeshInformation, View, mesh_part );
4429 createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4430 createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh );
4431 popupMgr()->insert( separator(), -1, 0 );
4433 createPopupItem( SMESHOp::OpAutoColor, OB + " " + View, mesh, "&& (not isAutoColor)" );
4434 createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4435 popupMgr()->insert( separator(), -1, 0 );
4437 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4438 QString aType = QString( "%1type in {%2}" ).arg( lc );
4439 aType = aType.arg( mesh_part );
4440 QString aMeshInVTK = aClient + "&&" + aType;
4442 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4443 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4444 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4446 //-------------------------------------------------
4448 //-------------------------------------------------
4449 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4451 popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4452 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4453 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4455 popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4456 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4457 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4459 popupMgr()->insert( separator(), -1, -1 );
4461 //-------------------------------------------------
4463 //-------------------------------------------------
4464 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4466 popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4467 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4468 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4470 popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4471 popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4472 popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4474 popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4475 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes, QtxPopupMgr::VisibleRule );
4476 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4478 popupMgr()->insert( separator(), anId, -1 );
4480 popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4481 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4482 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4484 //-------------------------------------------------
4486 //-------------------------------------------------
4487 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4489 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4491 popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4492 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4493 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4495 popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4496 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4497 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4499 popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4500 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4501 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4503 popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4504 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4505 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4507 popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4508 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4509 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4511 popupMgr()->insert( separator(), anId, -1 );
4513 popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4514 popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&&" + aType + "&&" + isNotEmpty, QtxPopupMgr::VisibleRule );
4516 popupMgr()->insert( separator(), anId, -1 );
4518 popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4519 popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4522 //-------------------------------------------------
4523 // Representation of the 2D Quadratic elements
4524 //-------------------------------------------------
4525 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4526 popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4527 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "and isVisible",QtxPopupMgr::VisibleRule );
4528 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4530 popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4531 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "and isVisible", QtxPopupMgr::VisibleRule );
4532 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4534 //-------------------------------------------------
4535 // Orientation of faces
4536 //-------------------------------------------------
4537 popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4538 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4539 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4541 //-------------------------------------------------
4543 //-------------------------------------------------
4544 popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4545 popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4547 //-------------------------------------------------
4549 //-------------------------------------------------
4550 popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4551 popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4553 //-------------------------------------------------
4555 //-------------------------------------------------
4557 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4558 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4559 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4560 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4562 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4564 popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4565 popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4567 popupMgr()->insert( separator(), anId, -1 );
4569 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4571 popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4572 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4573 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4575 popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4576 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4577 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4579 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4581 popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4582 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVTK + "&&" + hasEdges + "&&" + hasFacesOrVolumes, QtxPopupMgr::VisibleRule );
4583 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4585 popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4586 popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4587 popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4589 popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4590 popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4591 popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4592 popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4593 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4594 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4596 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4598 popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4599 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4600 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4602 popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4603 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4604 QtxPopupMgr::VisibleRule );
4605 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4607 popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4608 popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4609 popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4611 popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4612 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4613 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4615 popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
4616 popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4617 popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4619 popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
4620 popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4621 popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4623 popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
4624 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4625 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4627 popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
4628 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4629 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4631 popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
4632 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4633 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4635 popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
4636 popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4637 popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4639 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
4640 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4641 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4643 popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
4644 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4645 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4647 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
4648 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4649 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4650 popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
4651 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4652 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4654 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4656 popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D ), aSubId, -1 );
4657 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4658 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4660 popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
4661 popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4662 popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4664 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
4665 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4666 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4668 popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
4669 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4670 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4672 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
4673 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4674 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4676 popupMgr()->insert ( action( SMESHOp::OpEqualVolume ), aSubId, -1 );
4677 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4678 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4680 popupMgr()->insert( separator(), anId, -1 );
4682 popupMgr()->insert( action( SMESHOp::OpShowScalarBar ), anId, -1 );
4683 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4684 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone' && isScalarBarVisible", QtxPopupMgr::ToggleRule );
4685 popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
4686 popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4688 popupMgr()->insert( separator(), anId, -1 );
4690 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4692 popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
4693 popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4695 popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
4696 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4697 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isScalarBarVisible && isDistributionVisible", QtxPopupMgr::ToggleRule);
4699 #ifndef DISABLE_PLOT2DVIEWER
4700 popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
4701 popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4704 //-------------------------------------------------
4706 //-------------------------------------------------
4707 popupMgr()->insert( separator(), -1, -1 );
4708 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4709 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4710 popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
4711 popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4713 popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
4714 popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4716 popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
4717 popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4719 popupMgr()->insert( separator(), -1, -1 );
4721 //-------------------------------------------------
4723 //-------------------------------------------------
4724 popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
4725 popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4727 popupMgr()->insert( separator(), -1, -1 );
4729 popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
4730 popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
4731 popupMgr()->insert( separator(), -1, -1 );
4733 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4734 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4736 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4737 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4740 //================================================================================
4742 * \brief Return true if SMESH or GEOM objects are selected.
4743 * Is called form LightApp_Module::activateModule() which clear selection if
4744 * not isSelectionCompatible()
4746 //================================================================================
4748 bool SMESHGUI::isSelectionCompatible()
4750 bool isCompatible = true;
4751 SALOME_ListIO selected;
4752 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4753 Sel->selectedObjects( selected );
4755 SALOME_ListIteratorOfListIO It( selected );
4756 for ( ; isCompatible && It.More(); It.Next())
4758 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4759 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4761 return isCompatible;
4765 bool SMESHGUI::reusableOperation( const int id )
4767 // compute, evaluate and precompute are not reusable operations
4768 return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate ) ? false : SalomeApp_Module::reusableOperation( id );
4771 bool SMESHGUI::activateModule( SUIT_Study* study )
4773 bool res = SalomeApp_Module::activateModule( study );
4775 setMenuShown( true );
4776 setToolShown( true );
4778 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4779 PyGILState_STATE gstate = PyGILState_Ensure();
4780 PyObject* pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4781 if ( !pluginsmanager ) {
4785 PyObject* result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toUtf8().data(),tr("SMESH_PLUGINS_OTHER").toUtf8().data());
4790 PyGILState_Release(gstate);
4791 // end of SMESH plugins loading
4793 // Reset actions accelerator keys
4794 action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
4796 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4797 GetSMESHGen()->SetCurrentStudy(SALOMEDS::Study::_nil());
4798 if ( SalomeApp_Study* s = dynamic_cast<SalomeApp_Study*>( study )) {
4799 if ( _PTR(Study) aStudy = s->studyDS() )
4800 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
4803 // get all view currently opened in the study and connect their signals to
4804 // the corresponding slots of the class.
4805 SUIT_Desktop* aDesk = study->application()->desktop();
4807 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4808 SUIT_ViewWindow* wnd;
4809 foreach ( wnd, wndList )
4813 Py_XDECREF(pluginsmanager);
4817 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4819 setMenuShown( false );
4820 setToolShown( false );
4822 EmitSignalCloseAllDialogs();
4824 // Unset actions accelerator keys
4825 action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
4827 return SalomeApp_Module::deactivateModule( study );
4830 void SMESHGUI::studyClosed( SUIT_Study* s )
4834 SMESH::RemoveVisuData( s->id() );
4835 SalomeApp_Module::studyClosed( s );
4838 void SMESHGUI::OnGUIEvent()
4840 const QObject* obj = sender();
4841 if ( !obj || !obj->inherits( "QAction" ) )
4843 int id = actionId((QAction*)obj);
4848 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4850 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
4851 if ( CORBA::is_nil( myComponentSMESH ) )
4853 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4855 aGUI.myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4856 return aGUI.myComponentSMESH;
4859 myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4860 return myComponentSMESH;
4863 QString SMESHGUI::engineIOR() const
4865 CORBA::ORB_var anORB = getApp()->orb();
4866 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4867 return QString( anIOR.in() );
4870 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4872 SalomeApp_Module::contextMenuPopup( client, menu, title );
4874 selectionMgr()->selectedObjects( lst );
4875 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4876 Handle(SALOME_InteractiveObject) io = lst.First();
4877 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4878 _PTR(Study) study = appStudy->studyDS();
4879 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4881 QString aName = QString( SMESH::fromUtf8(obj->GetName()) );
4882 while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4883 aName.remove( (aName.length() - 1), 1 );
4889 LightApp_Selection* SMESHGUI::createSelection() const
4891 return new SMESHGUI_Selection();
4894 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4896 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4897 aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
4898 #ifndef DISABLE_PYCONSOLE
4899 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4903 void SMESHGUI::viewManagers( QStringList& list ) const
4905 list.append( SVTK_Viewer::Type() );
4908 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4910 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4911 SMESH::UpdateSelectionProp( this );
4913 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
4914 for(int i = 0; i < aViews.count() ; i++){
4915 SUIT_ViewWindow *sf = aViews[i];
4918 EmitSignalActivatedViewManager();
4922 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
4924 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
4925 myClippingPlaneInfoMap.erase( theViewManager );
4928 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
4930 theActor->AddObserver( SMESH::DeleteActorEvent,
4931 myEventCallbackCommand.GetPointer(),
4935 void SMESHGUI::ProcessEvents( vtkObject* theObject,
4936 unsigned long theEvent,
4937 void* theClientData,
4940 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
4941 if( theObject && theEvent == SMESH::DeleteActorEvent ) {
4942 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
4943 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
4944 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
4945 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
4946 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
4947 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
4948 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
4949 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
4950 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
4951 SMESH::TActorList::iterator anIter3 = anActorList.begin();
4952 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
4953 if( anActor == *anIter3 ) {
4954 anActorList.erase( anIter3 );
4965 void SMESHGUI::createPreferences()
4967 // General tab ------------------------------------------------------------------------
4968 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
4970 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
4971 setPreferenceProperty( autoUpdate, "columns", 2 );
4972 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
4973 setPreferenceProperty( lim, "min", 0 );
4974 setPreferenceProperty( lim, "max", 100000000 );
4975 setPreferenceProperty( lim, "step", 1000 );
4976 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4977 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
4979 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
4980 setPreferenceProperty( qaGroup, "columns", 2 );
4981 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
4982 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
4983 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
4984 setPreferenceProperty( prec, "min", 0 );
4985 setPreferenceProperty( prec, "max", 100 );
4986 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
4987 setPreferenceProperty( doubleNodesTol, "precision", 10 );
4988 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
4989 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
4990 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
4992 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
4993 setPreferenceProperty( dispgroup, "columns", 2 );
4994 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
4996 modes.append( tr("MEN_WIRE") );
4997 modes.append( tr("MEN_SHADE") );
4998 modes.append( tr("MEN_NODES") );
4999 modes.append( tr("MEN_SHRINK") );
5000 QList<QVariant> indices;
5001 indices.append( 0 );
5002 indices.append( 1 );
5003 indices.append( 2 );
5004 indices.append( 3 );
5005 setPreferenceProperty( dispmode, "strings", modes );
5006 setPreferenceProperty( dispmode, "indexes", indices );
5008 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
5009 setPreferenceProperty( arcgroup, "columns", 2 );
5010 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
5011 QStringList quadraticModes;
5012 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
5013 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
5015 indices.append( 0 );
5016 indices.append( 1 );
5017 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
5018 setPreferenceProperty( quadraticmode, "indexes", indices );
5020 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
5021 "SMESH", "max_angle" );
5022 setPreferenceProperty( maxAngle, "min", 1 );
5023 setPreferenceProperty( maxAngle, "max", 90 );
5027 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
5028 setPreferenceProperty( exportgroup, "columns", 2 );
5029 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
5030 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
5032 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
5033 setPreferenceProperty( computeGroup, "columns", 2 );
5034 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
5036 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5037 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5038 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5040 indices.append( 0 );
5041 indices.append( 1 );
5042 indices.append( 2 );
5043 setPreferenceProperty( notifyMode, "strings", modes );
5044 setPreferenceProperty( notifyMode, "indexes", indices );
5046 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5047 setPreferenceProperty( infoGroup, "columns", 2 );
5048 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5050 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5051 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5053 indices.append( 0 );
5054 indices.append( 1 );
5055 setPreferenceProperty( elemInfo, "strings", modes );
5056 setPreferenceProperty( elemInfo, "indexes", indices );
5057 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5058 setPreferenceProperty( nodesLim, "min", 0 );
5059 setPreferenceProperty( nodesLim, "max", 10000000 );
5060 setPreferenceProperty( nodesLim, "step", 10000 );
5061 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5062 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5063 setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5064 setPreferenceProperty( ctrlLim, "min", 0 );
5065 setPreferenceProperty( ctrlLim, "max", 10000000 );
5066 setPreferenceProperty( ctrlLim, "step", 1000 );
5067 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5068 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5069 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5070 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5071 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5073 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5074 setPreferenceProperty( segGroup, "columns", 2 );
5075 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5076 "SMESH", "segmentation" );
5077 setPreferenceProperty( segLen, "min", 1 );
5078 setPreferenceProperty( segLen, "max", 10000000 );
5079 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5080 "SMESH", "nb_segments_per_edge" );
5081 setPreferenceProperty( nbSeg, "min", 1 );
5082 setPreferenceProperty( nbSeg, "max", 10000000 );
5084 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5085 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5086 "SMESH", "forget_mesh_on_hyp_modif" );
5089 // Quantities with individual precision settings
5090 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5091 setPreferenceProperty( precGroup, "columns", 2 );
5093 const int nbQuantities = 6;
5094 int precs[nbQuantities], ii = 0;
5095 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5096 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5097 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5098 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5099 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5100 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5101 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5102 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5103 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5104 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5105 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5106 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5108 // Set property for precision value for spinboxes
5109 for ( ii = 0; ii < nbQuantities; ii++ ){
5110 setPreferenceProperty( precs[ii], "min", -14 );
5111 setPreferenceProperty( precs[ii], "max", 14 );
5112 setPreferenceProperty( precs[ii], "precision", 2 );
5115 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5116 setPreferenceProperty( previewGroup, "columns", 2 );
5117 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5118 setPreferenceProperty( chunkSize, "min", 1 );
5119 setPreferenceProperty( chunkSize, "max", 1000 );
5120 setPreferenceProperty( chunkSize, "step", 50 );
5122 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5123 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5125 // Mesh tab ------------------------------------------------------------------------
5126 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5127 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5128 setPreferenceProperty( nodeGroup, "columns", 3 );
5130 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5132 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5134 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5135 QList<QVariant> aMarkerTypeIndicesList;
5136 QList<QVariant> aMarkerTypeIconsList;
5137 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5138 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5139 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5140 aMarkerTypeIndicesList << i;
5141 aMarkerTypeIconsList << pixmap;
5143 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5144 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
5146 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5148 QList<QVariant> aMarkerScaleIndicesList;
5149 QStringList aMarkerScaleValuesList;
5150 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5151 aMarkerScaleIndicesList << i;
5152 aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5154 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5155 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5157 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5158 //setPreferenceProperty( elemGroup, "columns", 2 );
5160 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5161 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5162 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5163 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5164 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5165 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5166 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5167 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5168 addPreference( tr( "PREF_PREVIEW_COLOR" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5171 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5172 setPreferenceProperty( grpGroup, "columns", 2 );
5174 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5175 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5177 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5178 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5179 /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5180 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5181 double ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5182 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5183 double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5184 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5185 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
5186 LightApp_Preferences::IntSpin, "SMESH", "element_width");
5187 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5188 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5189 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5190 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5192 setPreferenceProperty( size0d, "min", 1 );
5193 setPreferenceProperty( size0d, "max", 10 );
5195 // setPreferenceProperty( ballSize, "min", 1 );
5196 // setPreferenceProperty( ballSize, "max", 10 );
5198 setPreferenceProperty( ballDiameter, "min", 1e-7 );
5199 setPreferenceProperty( ballDiameter, "max", 1e9 );
5200 setPreferenceProperty( ballDiameter, "step", 0.1 );
5202 setPreferenceProperty( ballScale, "min", 1e-2 );
5203 setPreferenceProperty( ballScale, "max", 1e7 );
5204 setPreferenceProperty( ballScale, "step", 0.5 );
5206 setPreferenceProperty( elemW, "min", 1 );
5207 setPreferenceProperty( elemW, "max", 5 );
5209 setPreferenceProperty( outW, "min", 1 );
5210 setPreferenceProperty( outW, "max", 5 );
5212 setPreferenceProperty( shrink, "min", 0 );
5213 setPreferenceProperty( shrink, "max", 100 );
5215 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5216 setPreferenceProperty( numGroup, "columns", 2 );
5218 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5219 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5221 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5222 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5224 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5225 setPreferenceProperty( orientGroup, "columns", 1 );
5227 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5228 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5230 setPreferenceProperty( orientScale, "min", 0.05 );
5231 setPreferenceProperty( orientScale, "max", 0.5 );
5232 setPreferenceProperty( orientScale, "step", 0.05 );
5234 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5236 // Selection tab ------------------------------------------------------------------------
5237 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5239 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5240 setPreferenceProperty( selGroup, "columns", 2 );
5242 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5243 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5245 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5246 setPreferenceProperty( preGroup, "columns", 2 );
5248 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5250 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5251 setPreferenceProperty( precSelGroup, "columns", 2 );
5253 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5254 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5255 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5257 // Scalar Bar tab ------------------------------------------------------------------------
5258 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5259 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5260 setPreferenceProperty( fontGr, "columns", 2 );
5262 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5263 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5265 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5266 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5268 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5269 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5271 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5272 setPreferenceProperty( numcol, "min", 2 );
5273 setPreferenceProperty( numcol, "max", 256 );
5275 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5276 setPreferenceProperty( numlab, "min", 2 );
5277 setPreferenceProperty( numlab, "max", 65 );
5279 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5280 setPreferenceProperty( orientGr, "columns", 2 );
5281 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5282 QStringList orients;
5283 orients.append( tr( "SMESH_VERTICAL" ) );
5284 orients.append( tr( "SMESH_HORIZONTAL" ) );
5285 indices.clear(); indices.append( 0 ); indices.append( 1 );
5286 setPreferenceProperty( orient, "strings", orients );
5287 setPreferenceProperty( orient, "indexes", indices );
5289 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5290 setPreferenceProperty( posVSizeGr, "columns", 2 );
5291 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5292 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5293 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5294 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5295 setPreferenceProperty( xv, "step", 0.1 );
5296 setPreferenceProperty( xv, "min", 0.0 );
5297 setPreferenceProperty( xv, "max", 1.0 );
5298 setPreferenceProperty( yv, "step", 0.1 );
5299 setPreferenceProperty( yv, "min", 0.0 );
5300 setPreferenceProperty( yv, "max", 1.0 );
5301 setPreferenceProperty( wv, "step", 0.1 );
5302 setPreferenceProperty( wv, "min", 0.0 );
5303 setPreferenceProperty( wv, "max", 1.0 );
5304 setPreferenceProperty( hv, "min", 0.0 );
5305 setPreferenceProperty( hv, "max", 1.0 );
5306 setPreferenceProperty( hv, "step", 0.1 );
5308 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5309 setPreferenceProperty( posHSizeGr, "columns", 2 );
5310 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5311 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5312 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5313 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5314 setPreferenceProperty( xv, "min", 0.0 );
5315 setPreferenceProperty( xv, "max", 1.0 );
5316 setPreferenceProperty( xv, "step", 0.1 );
5317 setPreferenceProperty( xh, "min", 0.0 );
5318 setPreferenceProperty( xh, "max", 1.0 );
5319 setPreferenceProperty( xh, "step", 0.1 );
5320 setPreferenceProperty( yh, "min", 0.0 );
5321 setPreferenceProperty( yh, "max", 1.0 );
5322 setPreferenceProperty( yh, "step", 0.1 );
5323 setPreferenceProperty( wh, "min", 0.0 );
5324 setPreferenceProperty( wh, "max", 1.0 );
5325 setPreferenceProperty( wh, "step", 0.1 );
5326 setPreferenceProperty( hh, "min", 0.0 );
5327 setPreferenceProperty( hh, "max", 1.0 );
5328 setPreferenceProperty( hh, "step", 0.1 );
5330 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5331 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5332 setPreferenceProperty( distributionGr, "columns", 3 );
5334 types.append( tr( "SMESH_MONOCOLOR" ) );
5335 types.append( tr( "SMESH_MULTICOLOR" ) );
5336 indices.clear(); indices.append( 0 ); indices.append( 1 );
5337 setPreferenceProperty( coloringType, "strings", types );
5338 setPreferenceProperty( coloringType, "indexes", indices );
5339 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5343 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5345 if( sect=="SMESH" ) {
5346 float sbX1,sbY1,sbW,sbH;
5347 float aTol = 1.00000009999999;
5348 std::string aWarning;
5349 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5350 if( name=="selection_object_color" || name=="selection_element_color" ||
5351 name=="highlight_color" ||
5352 name=="selection_precision_node" || name=="selection_precision_element" ||
5353 name=="selection_precision_object")
5354 SMESH::UpdateSelectionProp( this );
5355 else if (name == QString("scalar_bar_vertical_x") || name == QString("scalar_bar_vertical_width")){
5356 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5357 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5358 if(sbX1+sbW > aTol){
5359 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5362 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5363 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5366 else if(name == QString("scalar_bar_vertical_y") || name == QString("scalar_bar_vertical_height")){
5367 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5368 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5369 if(sbY1+sbH > aTol){
5370 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5371 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5372 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5375 else if(name == QString("scalar_bar_horizontal_x") || name == QString("scalar_bar_horizontal_width")){
5376 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5377 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5378 if(sbX1+sbW > aTol){
5379 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5382 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5383 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5386 else if(name == QString("scalar_bar_horizontal_y") || name == QString("scalar_bar_horizontal_height")){
5387 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5388 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5389 if(sbY1+sbH > aTol){
5390 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5393 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5394 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5397 else if ( name == "segmentation" ) {
5398 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5399 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5401 else if ( name == "nb_segments_per_edge" ) {
5402 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5403 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5405 else if ( name == "historical_python_dump" ||
5406 name == "forget_mesh_on_hyp_modif") {
5407 QString val = aResourceMgr->stringValue( "SMESH", name );
5408 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5410 else if ( name == QString( "numbering_node_color" ) || name == QString( "numbering_node_font" ) ) {
5411 SMESH::UpdateFontProp( this );
5413 else if ( name == QString( "numbering_elem_color" ) || name == QString( "numbering_elem_font" ) ) {
5414 SMESH::UpdateFontProp( this );
5417 if(aWarning.size() != 0){
5418 aWarning += "The default values are applied instead.";
5419 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5420 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5421 QObject::tr(aWarning.c_str()));
5426 //================================================================================
5428 * \brief Update something in accordance with update flags
5429 * \param theFlags - update flags
5431 * Update viewer or/and object browser etc. in accordance with update flags ( see
5432 * LightApp_UpdateFlags enumeration ).
5434 //================================================================================
5435 void SMESHGUI::update( const int flags )
5437 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5438 SMESH::UpdateView();
5440 SalomeApp_Module::update( flags );
5443 //================================================================================
5445 * \brief Set default selection mode
5447 * SLOT called when operation commited. Sets default selection mode
5449 //================================================================================
5450 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5452 SVTK_ViewWindow* vtkWnd =
5453 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5455 vtkWnd->SetSelectionMode( ActorSelection );
5458 //================================================================================
5460 * \brief Set default selection mode
5462 * SLOT called when operation aborted. Sets default selection mode
5464 //================================================================================
5465 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5467 SVTK_ViewWindow* vtkWnd =
5468 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5470 vtkWnd->SetSelectionMode( ActorSelection );
5473 //================================================================================
5475 * \brief Creates operation with given identifier
5476 * \param id - identifier of operation to be started
5477 * \return Pointer on created operation or NULL if operation is not created
5479 * Virtual method redefined from the base class creates operation with given id.
5480 * It is called called automatically from startOperation method of base class.
5482 //================================================================================
5483 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5485 LightApp_Operation* op = 0;
5486 // to do : create operation here
5489 case SMESHOp::OpSplitBiQuadratic:
5490 op = new SMESHGUI_SplitBiQuadOp();
5492 case SMESHOp::OpConvertMeshToQuadratic:
5493 op = new SMESHGUI_ConvToQuadOp();
5495 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5496 op = new SMESHGUI_Make2DFrom3DOp();
5498 case SMESHOp::OpReorientFaces:
5499 op = new SMESHGUI_ReorientFacesOp();
5501 case SMESHOp::OpCreateMesh:
5502 op = new SMESHGUI_MeshOp( true, true );
5504 case SMESHOp::OpCreateSubMesh:
5505 op = new SMESHGUI_MeshOp( true, false );
5507 case SMESHOp::OpEditMeshOrSubMesh:
5508 op = new SMESHGUI_MeshOp( false );
5510 case SMESHOp::OpCompute:
5511 op = new SMESHGUI_ComputeOp();
5513 case SMESHOp::OpPreCompute:
5514 op = new SMESHGUI_PrecomputeOp();
5516 case SMESHOp::OpEvaluate:
5517 op = new SMESHGUI_EvaluateOp();
5519 case SMESHOp::OpMeshOrder:
5520 op = new SMESHGUI_MeshOrderOp();
5522 case SMESHOp::OpCreateGeometryGroup:
5523 op = new SMESHGUI_GroupOnShapeOp();
5525 case SMESHOp::OpFindElementByPoint:
5526 op = new SMESHGUI_FindElemByPointOp();
5528 case SMESHOp::OpMoveNode: // Make mesh pass through point
5529 op = new SMESHGUI_MakeNodeAtPointOp();
5531 case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
5532 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5539 op = SalomeApp_Module::createOperation( id );
5543 //================================================================================
5545 * \brief Stops current operations and starts a given one
5546 * \param id - The id of the operation to start
5548 //================================================================================
5550 void SMESHGUI::switchToOperation(int id)
5552 if ( _PTR(Study) aStudy = SMESH::GetActiveStudyDocument() )
5553 activeStudy()->abortAllOperations();
5554 startOperation( id );
5557 LightApp_Displayer* SMESHGUI::displayer()
5560 myDisplayer = new SMESHGUI_Displayer( getApp() );
5564 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5567 int aTolerance = 64;
5568 int anIterations = 0;
5574 if( anIterations % aPeriod == 0 )
5577 if( aTolerance < 1 )
5581 aHue = (int)( 360.0 * rand() / RAND_MAX );
5584 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5585 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5586 for( ; it != itEnd; ++it )
5588 SALOMEDS::Color anAutoColor = *it;
5589 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5592 aQColor.getHsv( &h, &s, &v );
5593 if( abs( h - aHue ) < aTolerance )
5605 aColor.setHsv( aHue, 255, 255 );
5607 SALOMEDS::Color aSColor;
5608 aSColor.R = aColor.redF();
5609 aSColor.G = aColor.greenF();
5610 aSColor.B = aColor.blueF();
5615 const char* gSeparator = "_"; // character used to separate parameter names
5616 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5617 const char* gPathSep = "|"; // character used to separate paths
5620 * \brief Store visual parameters
5622 * This method is called just before the study document is saved.
5623 * Store visual parameters in AttributeParameter attribue(s)
5625 void SMESHGUI::storeVisualParameters (int savePoint)
5628 Kernel_Utils::Localizer loc;
5630 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5631 if (!appStudy || !appStudy->studyDS())
5633 _PTR(Study) studyDS = appStudy->studyDS();
5635 // componentName is used for encoding of entries when storing them in IParameters
5636 std::string componentName = myComponentSMESH->ComponentDataType();
5637 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5638 //if (!aSComponent) return;
5641 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5642 componentName.c_str(),
5644 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5646 // store map of custom markers
5647 const VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5648 if( !aMarkerMap.empty() )
5650 VTK::MarkerMap::const_iterator anIter = aMarkerMap.begin();
5651 for( ; anIter != aMarkerMap.end(); anIter++ )
5653 int anId = anIter->first;
5654 VTK::MarkerData aMarkerData = anIter->second;
5655 std::string aMarkerFileName = aMarkerData.first;
5656 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5657 if( aMarkerTexture.size() < 3 )
5658 continue; // should contain at least width, height and the first value
5660 QString aPropertyName( "texture" );
5661 aPropertyName += gSeparator;
5662 aPropertyName += QString::number( anId );
5664 QString aPropertyValue = aMarkerFileName.c_str();
5665 aPropertyValue += gPathSep;
5667 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5668 ushort aWidth = *aTextureIter++;
5669 ushort aHeight = *aTextureIter++;
5670 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5671 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5672 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5673 aPropertyValue += QString::number( *aTextureIter );
5675 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5679 // viewers counters are used for storing view_numbers in IParameters
5682 // main cycle to store parameters of displayed objects
5683 QList<SUIT_ViewManager*> lst;
5684 QList<SUIT_ViewManager*>::Iterator it;
5685 getApp()->viewManagers(lst);
5686 for (it = lst.begin(); it != lst.end(); it++)
5688 SUIT_ViewManager* vman = *it;
5689 QString vType = vman->getType();
5691 // saving VTK actors properties
5692 if (vType == SVTK_Viewer::Type())
5694 // store the clipping planes attached to the view manager
5695 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5696 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5697 if( anIter != myClippingPlaneInfoMap.end() )
5698 aClippingPlaneInfoList = anIter->second;
5700 if( !aClippingPlaneInfoList.empty() ) {
5701 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5702 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5704 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5705 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5707 QString aPropertyName( "ClippingPlane" );
5708 aPropertyName += gSeparator;
5709 aPropertyName += QString::number( vtkViewers );
5710 aPropertyName += gSeparator;
5711 aPropertyName += QString::number( anId );
5713 QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
5714 aPropertyValue += gDigitsSep;
5715 aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
5716 aPropertyValue += gDigitsSep;
5717 if ( aPlane->PlaneMode == SMESH::Absolute ) {
5718 aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
5719 aPropertyValue += gDigitsSep;
5720 aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
5721 aPropertyValue += gDigitsSep;
5722 aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
5723 aPropertyValue += gDigitsSep;
5724 aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
5725 aPropertyValue += gDigitsSep;
5726 aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
5727 aPropertyValue += gDigitsSep;
5728 aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
5729 aPropertyValue += gDigitsSep;
5730 aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
5732 else if ( aPlane->PlaneMode == SMESH::Relative ) {
5733 aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
5734 aPropertyValue += gDigitsSep;
5735 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5736 aPropertyValue += gDigitsSep;
5737 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5738 aPropertyValue += gDigitsSep;
5739 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5742 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5746 QVector<SUIT_ViewWindow*> views = vman->getViews();
5747 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5749 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5751 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5752 vtkActorCollection* allActors = aCopy.GetActors();
5753 allActors->InitTraversal();
5754 while (vtkActor* actor = allActors->GetNextActor())
5756 if (actor->GetVisibility()) // store only visible actors
5758 SMESH_Actor* aSmeshActor = 0;
5759 if (actor->IsA("SMESH_Actor"))
5760 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5761 if (aSmeshActor && aSmeshActor->hasIO())
5763 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5766 // entry is "encoded" = it does NOT contain component adress,
5767 // since it is a subject to change on next component loading
5768 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5770 std::string param, vtkParam = vType.toLatin1().data();
5771 vtkParam += gSeparator;
5772 vtkParam += QString::number(vtkViewers).toLatin1().data();
5773 vtkParam += gSeparator;
5776 param = vtkParam + "Visibility";
5777 ip->setParameter(entry, param, "On");
5780 param = vtkParam + "Representation";
5781 ip->setParameter(entry, param, QString::number
5782 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5785 param = vtkParam + "IsShrunk";
5786 ip->setParameter(entry, param, QString::number
5787 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5789 // Displayed entities
5790 unsigned int aMode = aSmeshActor->GetEntityMode();
5791 bool isE = aMode & SMESH_Actor::eEdges;
5792 bool isF = aMode & SMESH_Actor::eFaces;
5793 bool isV = aMode & SMESH_Actor::eVolumes;
5794 bool is0d = aMode & SMESH_Actor::e0DElements;
5795 bool isB = aMode & SMESH_Actor::eBallElem;
5797 QString modeStr ("e");
5798 modeStr += gDigitsSep; modeStr += QString::number(isE);
5799 modeStr += gDigitsSep; modeStr += "f";
5800 modeStr += gDigitsSep; modeStr += QString::number(isF);
5801 modeStr += gDigitsSep; modeStr += "v";
5802 modeStr += gDigitsSep; modeStr += QString::number(isV);
5803 modeStr += gDigitsSep; modeStr += "0d";
5804 modeStr += gDigitsSep; modeStr += QString::number(is0d);
5805 modeStr += gDigitsSep; modeStr += "b";
5806 modeStr += gDigitsSep; modeStr += QString::number(isB);
5808 param = vtkParam + "Entities";
5809 ip->setParameter(entry, param, modeStr.toLatin1().data());
5815 aSmeshActor->GetSufaceColor(r, g, b, delta);
5816 QStringList colorStr;
5817 colorStr << "surface";
5818 colorStr << QString::number(r);
5819 colorStr << QString::number(g);
5820 colorStr << QString::number(b);
5822 colorStr << "backsurface";
5823 colorStr << QString::number(delta);
5825 aSmeshActor->GetVolumeColor(r, g, b, delta);
5826 colorStr << "volume";
5827 colorStr << QString::number(r);
5828 colorStr << QString::number(g);
5829 colorStr << QString::number(b);
5830 colorStr << QString::number(delta);
5832 aSmeshActor->GetEdgeColor(r, g, b);
5834 colorStr << QString::number(r);
5835 colorStr << QString::number(g);
5836 colorStr << QString::number(b);
5838 aSmeshActor->GetNodeColor(r, g, b);
5840 colorStr << QString::number(r);
5841 colorStr << QString::number(g);
5842 colorStr << QString::number(b);
5844 aSmeshActor->GetOutlineColor(r, g, b);
5845 colorStr << "outline";
5846 colorStr << QString::number(r);
5847 colorStr << QString::number(g);
5848 colorStr << QString::number(b);
5850 aSmeshActor->Get0DColor(r, g, b);
5851 colorStr << "elem0d";
5852 colorStr << QString::number(r);
5853 colorStr << QString::number(g);
5854 colorStr << QString::number(b);
5856 aSmeshActor->GetBallColor(r, g, b);
5858 colorStr << QString::number(r);
5859 colorStr << QString::number(g);
5860 colorStr << QString::number(b);
5862 aSmeshActor->GetFacesOrientationColor(r, g, b);
5863 colorStr << "orientation";
5864 colorStr << QString::number(r);
5865 colorStr << QString::number(g);
5866 colorStr << QString::number(b);
5868 param = vtkParam + "Colors";
5869 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
5872 QStringList sizeStr;
5874 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
5875 sizeStr << "outline";
5876 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
5877 sizeStr << "elem0d";
5878 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
5880 //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
5881 sizeStr << QString::number((double)aSmeshActor->GetBallSize());
5882 sizeStr << QString::number((double)aSmeshActor->GetBallScale());
5883 sizeStr << "shrink";
5884 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
5885 sizeStr << "orientation";
5886 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
5887 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
5889 param = vtkParam + "Sizes";
5890 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
5895 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5896 if( aMarkerType == VTK::MT_USER ) {
5897 markerStr += "custom";
5898 markerStr += gDigitsSep;
5899 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
5903 markerStr += gDigitsSep;
5904 markerStr += QString::number( (int)aMarkerType );
5905 markerStr += gDigitsSep;
5906 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
5909 param = vtkParam + "PointMarker";
5910 ip->setParameter(entry, param, markerStr.toLatin1().data());
5913 param = vtkParam + "Opacity";
5914 ip->setParameter(entry, param,
5915 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
5918 param = vtkParam + "ClippingPlane";
5920 if( !aClippingPlaneInfoList.empty() ) {
5921 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
5922 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
5924 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
5925 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
5926 SMESH::TActorList::iterator anIter2 = anActorList.begin();
5927 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
5928 if( aSmeshActor == *anIter2 ) {
5929 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
5930 QString::number( anId ).toLatin1().constData() );
5937 ip->setParameter( entry, param, "Off" );
5938 } // if (io->hasEntry())
5939 } // SMESH_Actor && hasIO
5941 } // while.. actors traversal
5945 } // if (SVTK view model)
5946 } // for (viewManagers)
5949 // data structures for clipping planes processing
5953 bool isOpenGLClipping;
5954 vtkIdType RelativeOrientation;
5957 int AbsoluteOrientation;
5958 double X, Y, Z, Dx, Dy, Dz;
5960 typedef std::list<TPlaneData> TPlaneDataList;
5961 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
5963 typedef std::list<vtkActor*> TActorList;
5966 TActorList ActorList;
5967 SUIT_ViewManager* ViewManager;
5969 typedef std::list<TPlaneInfo> TPlaneInfoList;
5970 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
5973 * \brief Restore visual parameters
5975 * This method is called after the study document is opened.
5976 * Restore visual parameters from AttributeParameter attribue(s)
5978 void SMESHGUI::restoreVisualParameters (int savePoint)
5981 Kernel_Utils::Localizer loc;
5983 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5984 if (!appStudy || !appStudy->studyDS())
5986 _PTR(Study) studyDS = appStudy->studyDS();
5988 // componentName is used for encoding of entries when storing them in IParameters
5989 std::string componentName = myComponentSMESH->ComponentDataType();
5990 //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
5991 //if (!aSComponent) return;
5994 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5995 componentName.c_str(),
5997 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5999 // restore map of custom markers and map of clipping planes
6000 VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
6001 TPlaneDataMap aPlaneDataMap;
6003 std::vector<std::string> properties = ip->getProperties();
6004 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
6006 std::string property = *propIt;
6007 QString aPropertyName( property.c_str() );
6008 QString aPropertyValue( ip->getProperty( property ).c_str() );
6010 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
6011 if( aPropertyNameList.isEmpty() )
6014 QString aPropertyType = aPropertyNameList[0];
6015 if( aPropertyType == "texture" )
6017 if( aPropertyNameList.size() != 2 )
6021 int anId = aPropertyNameList[1].toInt( &ok );
6022 if( !ok || anId < 1 )
6025 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
6026 if( aPropertyValueList.size() != 2 )
6029 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
6030 QString aMarkerTextureString = aPropertyValueList[1];
6031 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
6032 if( aMarkerTextureStringList.size() != 3 )
6036 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6041 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6045 VTK::MarkerTexture aMarkerTexture;
6046 aMarkerTexture.push_back( aWidth );
6047 aMarkerTexture.push_back( aHeight );
6049 QString aMarkerTextureData = aMarkerTextureStringList[2];
6050 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6052 QChar aChar = aMarkerTextureData.at( i );
6053 if( aChar.isDigit() )
6054 aMarkerTexture.push_back( aChar.digitValue() );
6057 aMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6059 else if( aPropertyType == "ClippingPlane" )
6061 if( aPropertyNameList.size() != 3 )
6065 int aViewId = aPropertyNameList[1].toInt( &ok );
6066 if( !ok || aViewId < 0 )
6070 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6071 if( !ok || aClippingPlaneId < 0 )
6074 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6075 if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6078 TPlaneData aPlaneData;
6079 aPlaneData.Id = aClippingPlaneId;
6082 aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6087 aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6091 if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6094 aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6099 aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6104 aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6109 aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6114 aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6119 aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6124 aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6128 else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6130 aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6135 aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6140 aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6145 aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6150 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6151 aPlaneDataList.push_back( aPlaneData );
6155 TPlaneInfoMap aPlaneInfoMap;
6157 std::vector<std::string> entries = ip->getEntries();
6159 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6161 // entry is a normal entry - it should be "decoded" (setting base adress of component)
6162 QString entry (ip->decodeEntry(*entIt).c_str());
6164 // Check that the entry corresponds to a real object in the Study
6165 // as the object may be deleted or modified after the visual state is saved.
6166 _PTR(SObject) so = studyDS->FindObjectID(entry.toLatin1().data());
6167 if (!so) continue; //Skip the not existent entry
6169 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6170 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6172 std::vector<std::string>::iterator namesIt = paramNames.begin();
6173 std::vector<std::string>::iterator valuesIt = paramValues.begin();
6175 // actors are stored in a map after displaying of them for
6176 // quicker access in the future: map < viewID to actor >
6177 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6179 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6181 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6182 // '_' is used as separator and should not be used in viewer type or parameter names.
6183 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6184 if (lst.size() != 3)
6187 QString viewerTypStr = lst[0];
6188 QString viewIndexStr = lst[1];
6189 QString paramNameStr = lst[2];
6192 int viewIndex = viewIndexStr.toUInt(&ok);
6193 if (!ok) // bad conversion of view index to integer
6197 if (viewerTypStr == SVTK_Viewer::Type())
6199 SMESH_Actor* aSmeshActor = 0;
6200 if (vtkActors.IsBound(viewIndex))
6201 aSmeshActor = vtkActors.Find(viewIndex);
6203 QList<SUIT_ViewManager*> lst;
6204 getApp()->viewManagers(viewerTypStr, lst);
6206 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6207 SUIT_ViewManager* vman = NULL;
6208 if (viewIndex >= 0 && viewIndex < lst.count())
6209 vman = lst.at(viewIndex);
6211 if (paramNameStr == "Visibility")
6213 if (!aSmeshActor && displayer() && vman)
6215 SUIT_ViewModel* vmodel = vman->getViewModel();
6216 // SVTK view model can be casted to SALOME_View
6217 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6219 // store displayed actor in a temporary map for quicker
6220 // access later when restoring other parameters
6221 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6222 vtkRenderer* Renderer = vtkView->getRenderer();
6223 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6224 vtkActorCollection* theActors = aCopy.GetActors();
6225 theActors->InitTraversal();
6226 bool isFound = false;
6227 vtkActor *ac = theActors->GetNextActor();
6228 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6229 if (ac->IsA("SMESH_Actor")) {
6230 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6231 if (aGeomAc->hasIO()) {
6232 Handle(SALOME_InteractiveObject) io =
6233 Handle(SALOME_InteractiveObject)::DownCast(aGeomAc->getIO());
6234 if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) {
6236 vtkActors.Bind(viewIndex, aGeomAc);
6242 } // if (paramNameStr == "Visibility")
6245 // the rest properties "work" with SMESH_Actor
6248 QString val ((*valuesIt).c_str());
6251 if (paramNameStr == "Representation") {
6252 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6255 else if (paramNameStr == "IsShrunk") {
6257 if (!aSmeshActor->IsShrunk())
6258 aSmeshActor->SetShrink();
6261 if (aSmeshActor->IsShrunk())
6262 aSmeshActor->UnShrink();
6265 // Displayed entities
6266 else if (paramNameStr == "Entities") {
6267 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6268 int aEntityMode = SMESH_Actor::eAllEntity;
6269 for ( int i = 0; i < mode.count(); i+=2 ) {
6270 if ( i < mode.count()-1 ) {
6271 QString type = mode[i];
6272 bool val = mode[i+1].toInt();
6273 if ( type == "e" && !val )
6274 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6275 else if ( type == "f" && !val )
6276 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6277 else if ( type == "v" && !val )
6278 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6279 else if ( type == "0d" && !val )
6280 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6281 else if ( type == "b" && !val )
6282 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6285 aSmeshActor->SetEntityMode( aEntityMode );
6288 else if (paramNameStr == "Colors") {
6289 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6296 QColor outlineColor;
6297 QColor orientationColor;
6303 // below lines are required to get default values for delta coefficients
6304 // of backface color for faces and color of reversed volumes
6305 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
6306 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6307 for ( int i = 0; i < colors.count(); i++ ) {
6308 QString type = colors[i];
6309 if ( type == "surface" ) {
6310 // face color is set by 3 values r:g:b, where
6311 // - r,g,b - is rgb color components
6312 if ( i+1 >= colors.count() ) break; // format error
6313 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6314 if ( i+2 >= colors.count() ) break; // format error
6315 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6316 if ( i+3 >= colors.count() ) break; // format error
6317 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6318 faceColor.setRgbF( r, g, b );
6321 else if ( type == "backsurface" ) {
6322 // backface color can be defined in several ways
6323 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6324 // - in latest versions, it is set as delta coefficient
6325 bool rgbOk = false, deltaOk;
6326 if ( i+1 >= colors.count() ) break; // format error
6327 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6328 int delta = colors[i+1].toInt( &deltaOk );
6330 if ( i+1 < colors.count() ) // index is shifted to 1
6331 g = colors[i+1].toDouble( &rgbOk );
6332 if ( rgbOk ) i++; // shift index
6333 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6334 b = colors[i+1].toDouble( &rgbOk );
6336 // - as currently there's no way to set directly backsurface color as it was before,
6337 // we ignore old dump where r,g,b triple was set
6338 // - also we check that delta parameter is set properly
6339 if ( !rgbOk && deltaOk )
6342 else if ( type == "volume" ) {
6343 // volume color is set by 4 values r:g:b:delta, where
6344 // - r,g,b - is a normal volume rgb color components
6345 // - delta - is a reversed volume color delta coefficient
6346 if ( i+1 >= colors.count() ) break; // format error
6347 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6348 if ( i+2 >= colors.count() ) break; // format error
6349 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6350 if ( i+3 >= colors.count() ) break; // format error
6351 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6352 if ( i+4 >= colors.count() ) break; // format error
6353 int delta = colors[i+4].toInt( &bOk );
6354 if ( !bOk ) break; // format error
6355 volumeColor.setRgbF( r, g, b );
6359 else if ( type == "edge" ) {
6360 // edge color is set by 3 values r:g:b, where
6361 // - r,g,b - is rgb color components
6362 if ( i+1 >= colors.count() ) break; // format error
6363 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6364 if ( i+2 >= colors.count() ) break; // format error
6365 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6366 if ( i+3 >= colors.count() ) break; // format error
6367 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6368 edgeColor.setRgbF( r, g, b );
6371 else if ( type == "node" ) {
6372 // node color is set by 3 values r:g:b, where
6373 // - r,g,b - is rgb color components
6374 if ( i+1 >= colors.count() ) break; // format error
6375 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6376 if ( i+2 >= colors.count() ) break; // format error
6377 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6378 if ( i+3 >= colors.count() ) break; // format error
6379 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6380 nodeColor.setRgbF( r, g, b );
6383 else if ( type == "elem0d" ) {
6384 // 0d element color is set by 3 values r:g:b, where
6385 // - r,g,b - is rgb color components
6386 if ( i+1 >= colors.count() ) break; // format error
6387 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6388 if ( i+2 >= colors.count() ) break; // format error
6389 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6390 if ( i+3 >= colors.count() ) break; // format error
6391 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6392 elem0dColor.setRgbF( r, g, b );
6395 else if ( type == "ball" ) {
6396 // ball color is set by 3 values r:g:b, where
6397 // - r,g,b - is rgb color components
6398 if ( i+1 >= colors.count() ) break; // format error
6399 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6400 if ( i+2 >= colors.count() ) break; // format error
6401 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6402 if ( i+3 >= colors.count() ) break; // format error
6403 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6404 ballColor.setRgbF( r, g, b );
6407 else if ( type == "outline" ) {
6408 // outline color is set by 3 values r:g:b, where
6409 // - r,g,b - is rgb color components
6410 if ( i+1 >= colors.count() ) break; // format error
6411 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6412 if ( i+2 >= colors.count() ) break; // format error
6413 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6414 if ( i+3 >= colors.count() ) break; // format error
6415 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6416 outlineColor.setRgbF( r, g, b );
6419 else if ( type == "orientation" ) {
6420 // orientation color is set by 3 values r:g:b, where
6421 // - r,g,b - is rgb color components
6422 if ( i+1 >= colors.count() ) break; // format error
6423 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6424 if ( i+2 >= colors.count() ) break; // format error
6425 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6426 if ( i+3 >= colors.count() ) break; // format error
6427 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6428 orientationColor.setRgbF( r, g, b );
6433 if ( nodeColor.isValid() )
6434 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6436 if ( edgeColor.isValid() )
6437 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6439 if ( faceColor.isValid() )
6440 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6442 if ( volumeColor.isValid() )
6443 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6444 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6445 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6447 if ( elem0dColor.isValid() )
6448 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6450 if ( ballColor.isValid() )
6451 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6453 if ( outlineColor.isValid() )
6454 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6455 // orientation color
6456 if ( orientationColor.isValid() )
6457 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6460 else if (paramNameStr == "Sizes") {
6461 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6464 int outlineWidth = -1;
6465 int elem0dSize = -1;
6466 //int ballSize = -1;
6467 double ballDiameter = -1.0;
6468 double ballScale = -1.0;
6469 double shrinkSize = -1;
6470 double orientationSize = -1;
6471 bool orientation3d = false;
6472 for ( int i = 0; i < sizes.count(); i++ ) {
6473 QString type = sizes[i];
6474 if ( type == "line" ) {
6475 // line (wireframe) width is given as single integer value
6476 if ( i+1 >= sizes.count() ) break; // format error
6477 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6481 if ( type == "outline" ) {
6482 // outline width is given as single integer value
6483 if ( i+1 >= sizes.count() ) break; // format error
6484 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6488 else if ( type == "elem0d" ) {
6489 // 0d element size is given as single integer value
6490 if ( i+1 >= sizes.count() ) break; // format error
6491 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6495 else if ( type == "ball" ) {
6496 // balls are specified by two values: size:scale, where
6497 // - size - is a integer value specifying size
6498 // - scale - is a double value specifying scale factor
6499 if ( i+1 >= sizes.count() ) break; // format error
6500 //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6501 double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6502 if ( i+2 >= sizes.count() ) break; // format error
6503 double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6509 else if ( type == "shrink" ) {
6510 // shrink factor is given as single floating point value
6511 if ( i+1 >= sizes.count() ) break; // format error
6512 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6516 else if ( type == "orientation" ) {
6517 // orientation vectors are specified by two values size:3d, where
6518 // - size - is a floating point value specifying scale factor
6519 // - 3d - is a boolean
6520 if ( i+1 >= sizes.count() ) break; // format error
6521 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6522 if ( i+2 >= sizes.count() ) break; // format error
6523 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6524 orientationSize = v1;
6525 orientation3d = (bool)v2;
6529 // line (wireframe) width
6530 if ( lineWidth > 0 )
6531 aSmeshActor->SetLineWidth( lineWidth );
6533 if ( outlineWidth > 0 )
6534 aSmeshActor->SetOutlineWidth( outlineWidth );
6535 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6536 aSmeshActor->SetOutlineWidth( lineWidth );
6538 if ( elem0dSize > 0 )
6539 aSmeshActor->Set0DSize( elem0dSize );
6541 /*if ( ballSize > 0 )
6542 aSmeshActor->SetBallSize( ballSize );*/
6544 if ( ballDiameter > 0 )
6545 aSmeshActor->SetBallSize( ballDiameter );
6547 if ( ballScale > 0.0 )
6548 aSmeshActor->SetBallScale( ballScale );
6550 if ( shrinkSize > 0 )
6551 aSmeshActor->SetShrinkFactor( shrinkSize );
6552 // orientation vectors
6553 if ( orientationSize > 0 ) {
6554 aSmeshActor->SetFacesOrientationScale( orientationSize );
6555 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6559 else if (paramNameStr == "PointMarker") {
6560 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6561 if( data.count() >= 2 ) {
6563 int aParam1 = data[1].toInt( &ok );
6565 if( data[0] == "std" && data.count() == 3 ) {
6566 int aParam2 = data[2].toInt( &ok );
6567 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6569 else if( data[0] == "custom" ) {
6570 VTK::MarkerMap::const_iterator markerIt = aMarkerMap.find( aParam1 );
6571 if( markerIt != aMarkerMap.end() ) {
6572 VTK::MarkerData aMarkerData = markerIt->second;
6573 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6580 else if (paramNameStr == "Opacity") {
6581 aSmeshActor->SetOpacity(val.toFloat());
6584 else if (paramNameStr.startsWith("ClippingPlane")) {
6585 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6586 // old format - val looks like "Off" or "1:0:0:0.5:0:0"
6587 // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
6588 // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
6589 // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
6590 // new format - val looks like "Off" or "0" (plane id)
6591 // (note: in new format "Off" value is used only for consistency,
6592 // so it is processed together with values in old format)
6593 bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
6594 if( anIsOldFormat ) {
6595 if (paramNameStr == "ClippingPlane1" || val == "Off")
6596 aSmeshActor->RemoveAllClippingPlanes();
6598 QList<SUIT_ViewManager*> lst;
6599 getApp()->viewManagers(viewerTypStr, lst);
6600 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6601 if (viewIndex >= 0 && viewIndex < lst.count()) {
6602 SUIT_ViewManager* vman = lst.at(viewIndex);
6603 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6605 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6607 SMESH::TActorList anActorList;
6608 anActorList.push_back( aSmeshActor );
6609 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
6610 aPlane->myViewWindow = vtkView;
6611 SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
6612 aPlane->PlaneMode = aMode;
6613 bool isOpenGLClipping = ( bool )vals[1].toInt();
6614 aPlane->IsOpenGLClipping = isOpenGLClipping;
6615 if ( aMode == SMESH::Absolute ) {
6616 aPlane->myAbsoluteOrientation = vals[2].toInt();
6617 aPlane->X = vals[3].toFloat();
6618 aPlane->Y = vals[4].toFloat();
6619 aPlane->Z = vals[5].toFloat();
6620 aPlane->Dx = vals[6].toFloat();
6621 aPlane->Dy = vals[7].toFloat();
6622 aPlane->Dz = vals[8].toFloat();
6624 else if ( aMode == SMESH::Relative ) {
6625 aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
6626 aPlane->myDistance = vals[3].toFloat();
6627 aPlane->myAngle[0] = vals[4].toFloat();
6628 aPlane->myAngle[1] = vals[5].toFloat();
6632 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6633 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6634 aClippingPlaneInfo.Plane = aPlane;
6635 aClippingPlaneInfo.ActorList = anActorList;
6636 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6644 int aPlaneId = val.toInt( &ok );
6645 if( ok && aPlaneId >= 0 ) {
6646 bool anIsDefinedPlane = false;
6647 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6648 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6649 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6650 TPlaneInfo& aPlaneInfo = *anIter;
6651 if( aPlaneInfo.PlaneId == aPlaneId ) {
6652 aPlaneInfo.ActorList.push_back( aSmeshActor );
6653 anIsDefinedPlane = true;
6657 if( !anIsDefinedPlane ) {
6658 TPlaneInfo aPlaneInfo;
6659 aPlaneInfo.PlaneId = aPlaneId;
6660 aPlaneInfo.ActorList.push_back( aSmeshActor );
6661 aPlaneInfo.ViewManager = vman;
6663 // to make the list sorted by plane id
6664 anIter = aPlaneInfoList.begin();
6665 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6666 const TPlaneInfo& aPlaneInfoRef = *anIter;
6667 if( aPlaneInfoRef.PlaneId > aPlaneId )
6670 aPlaneInfoList.insert( anIter, aPlaneInfo );
6675 } // if (aSmeshActor)
6676 } // other parameters than Visibility
6678 } // for names/parameters iterator
6679 } // for entries iterator
6681 // take into account planes with empty list of actors referred to them
6682 QList<SUIT_ViewManager*> aVMList;
6683 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6685 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6686 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6687 int aViewId = aPlaneDataIter->first;
6688 if( aViewId >= 0 && aViewId < aVMList.count() ) {
6689 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6691 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6693 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6694 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6695 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6696 const TPlaneData& aPlaneData = *anIter2;
6697 int aPlaneId = aPlaneData.Id;
6699 bool anIsFound = false;
6700 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6701 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6702 const TPlaneInfo& aPlaneInfo = *anIter3;
6703 if( aPlaneInfo.PlaneId == aPlaneId ) {
6710 TPlaneInfo aPlaneInfo; // ActorList field is empty
6711 aPlaneInfo.PlaneId = aPlaneId;
6712 aPlaneInfo.ViewManager = aViewManager;
6714 // to make the list sorted by plane id
6715 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6716 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6717 const TPlaneInfo& aPlaneInfoRef = *anIter4;
6718 if( aPlaneInfoRef.PlaneId > aPlaneId )
6721 aPlaneInfoList.insert( anIter4, aPlaneInfo );
6727 // add clipping planes to actors according to the restored parameters
6728 // and update the clipping plane map
6729 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6730 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6731 int aViewId = anIter1->first;
6732 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6734 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6735 if( anIter2 == aPlaneDataMap.end() )
6737 const TPlaneDataList& aPlaneDataList = anIter2->second;
6739 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6740 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6741 const TPlaneInfo& aPlaneInfo = *anIter3;
6742 int aPlaneId = aPlaneInfo.PlaneId;
6743 const TActorList& anActorList = aPlaneInfo.ActorList;
6744 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6748 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6752 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6754 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6755 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6756 const TPlaneData& aPlaneData = *anIter4;
6757 if( aPlaneData.Id == aPlaneId ) {
6758 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
6759 aPlane->myViewWindow = aViewWindow;
6760 aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
6761 aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
6762 if ( aPlane->PlaneMode == SMESH::Absolute ) {
6763 aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
6764 aPlane->X = aPlaneData.X;
6765 aPlane->Y = aPlaneData.Y;
6766 aPlane->Z = aPlaneData.Z;
6767 aPlane->Dx = aPlaneData.Dx;
6768 aPlane->Dy = aPlaneData.Dy;
6769 aPlane->Dz = aPlaneData.Dz;
6771 else if ( aPlane->PlaneMode == SMESH::Relative ) {
6772 aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
6773 aPlane->myDistance = aPlaneData.Distance;
6774 aPlane->myAngle[0] = aPlaneData.Angle[0];
6775 aPlane->myAngle[1] = aPlaneData.Angle[1];
6778 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6779 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6780 aClippingPlaneInfo.Plane = aPlane;
6781 aClippingPlaneInfo.ActorList = anActorList;
6782 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6793 // update all VTK views
6794 QList<SUIT_ViewManager*> lst;
6795 getApp()->viewManagers(lst);
6796 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6797 SUIT_ViewModel* vmodel = (*it)->getViewModel();
6798 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6799 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6800 // set OpenGL clipping planes
6801 VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
6802 vtkActorCollection* anAllActors = aCopy.GetActors();
6803 anAllActors->InitTraversal();
6804 while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
6805 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
6806 anActor->SetOpenGLClippingPlane();
6808 vtkView->getRenderer()->ResetCameraClippingRange();
6815 \brief Adds preferences for dfont of VTK viewer
6817 \param pIf group identifier
6818 \param param parameter
6819 \return identifier of preferences
6821 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
6823 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6825 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6828 fam.append( tr( "SMESH_FONT_ARIAL" ) );
6829 fam.append( tr( "SMESH_FONT_COURIER" ) );
6830 fam.append( tr( "SMESH_FONT_TIMES" ) );
6832 setPreferenceProperty( tfont, "fonts", fam );
6834 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6835 if ( needSize ) f = f | QtxFontEdit::Size;
6836 setPreferenceProperty( tfont, "features", f );
6842 \brief Actions after hypothesis edition
6843 Updates object browser after hypothesis edition
6845 void SMESHGUI::onHypothesisEdit( int result )
6848 SMESHGUI::Modified();
6849 updateObjBrowser( true );
6854 \brief Signal handler closing(SUIT_ViewWindow*) of a view
6855 \param pview view being closed
6857 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
6858 #ifndef DISABLE_PLOT2DVIEWER
6859 //Crear all Plot2d Viewers if need.
6860 SMESH::ClearPlot2Viewers(pview);
6862 EmitSignalCloseView();
6865 void SMESHGUI::message( const QString& msg )
6868 QStringList data = msg.split("/");
6869 if ( data.count() > 0 ) {
6870 if ( data.first() == "mesh_loading" ) {
6872 QString entry = data.count() > 1 ? data[1] : QString();
6873 if ( entry.isEmpty() )
6876 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
6878 _PTR(SObject) obj = study->FindObjectID( entry.toLatin1().constData() );
6881 name = SMESH::fromUtf8(obj->GetName());
6882 if ( name.isEmpty() )
6885 if ( data.last() == "stop" )
6886 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
6888 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
6889 QApplication::processEvents();
6895 \brief Connects or disconnects signals about activating and cloning view on the module slots
6896 \param pview view which is connected/disconnected
6898 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
6902 SUIT_ViewManager* viewMgr = pview->getViewManager();
6904 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6905 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6907 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6908 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6913 \brief Return \c true if object can be renamed
6915 bool SMESHGUI::renameAllowed( const QString& entry) const {
6916 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6920 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6924 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
6929 if(appStudy->isComponent(entry) || obj->isReference())
6932 // check type to prevent renaming of inappropriate objects
6933 int aType = SMESHGUI_Selection::type(qPrintable(entry), SMESH::GetActiveStudyDocument());
6934 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6935 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6936 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6937 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6938 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
6945 Rename object by entry.
6946 \param entry entry of the object
6947 \param name new name of the object
6948 \brief Return \c true if rename operation finished successfully, \c false otherwise.
6950 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
6952 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6956 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6961 _PTR(Study) aStudy = appStudy->studyDS();
6966 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
6968 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
6973 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
6974 _PTR(GenericAttribute) anAttr;
6975 _PTR(AttributeName) aName;
6977 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
6979 // check type to prevent renaming of inappropriate objects
6980 int aType = SMESHGUI_Selection::type( qPrintable(entry), SMESH::GetActiveStudyDocument() );
6981 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6982 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6983 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6984 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6985 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
6986 if ( !name.isEmpty() ) {
6987 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
6989 // update name of group object and its actor
6990 Handle(SALOME_InteractiveObject) IObject =
6991 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
6993 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
6994 if( !aGroupObject->_is_nil() ) {
6995 aGroupObject->SetName( qPrintable(name) );
6996 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
6997 anActor->setName( qPrintable(name) );
7007 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
7009 static QList<QColor> colors;
7011 if ( colors.isEmpty() ) {
7013 for (int s = 0; s < 2 ; s++)
7015 for (int v = 100; v >= 40; v = v - 20)
7017 for (int h = 0; h < 359 ; h = h + 60)
7019 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
7024 static int currentColor = randomize( colors.size() );
7026 SALOMEDS::Color color;
7027 color.R = (double)colors[currentColor].red() / 255.0;
7028 color.G = (double)colors[currentColor].green() / 255.0;
7029 color.B = (double)colors[currentColor].blue() / 255.0;
7031 currentColor = (currentColor+1) % colors.count();