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"
86 #include "SMESHGUI_FilterUtils.h"
87 #include "SMESHGUI_GEOMGenUtils.h"
88 #include "SMESHGUI_GroupUtils.h"
89 #include "SMESHGUI_HypothesesUtils.h"
90 #include "SMESHGUI_MeshUtils.h"
91 #include "SMESHGUI_PatternUtils.h"
92 #include "SMESHGUI_Utils.h"
93 #include "SMESHGUI_VTKUtils.h"
95 #include "SMESH_version.h"
97 #include "SMESH_ControlsDef.hxx"
98 #include "SMESH_Actor.h"
99 #include "SMESH_ActorUtils.h"
100 #include "SMESH_Client.hxx"
101 #include "SMESH_ScalarBarActor.h"
102 #include "SMESH_TypeFilter.hxx"
104 // SALOME GUI includes
105 #include <SalomeApp_Application.h>
106 #include <SalomeApp_CheckFileDlg.h>
107 #include <SalomeApp_DataObject.h>
108 #include <SalomeApp_Study.h>
109 #include <SalomeApp_Tools.h>
111 #include <LightApp_DataOwner.h>
112 #include <LightApp_NameDlg.h>
113 #include <LightApp_Preferences.h>
114 #include <LightApp_SelectionMgr.h>
115 #include <LightApp_UpdateFlags.h>
117 #include <SVTK_ViewManager.h>
118 #include <SVTK_ViewModel.h>
119 #include <SVTK_ViewWindow.h>
121 #include <VTKViewer_Algorithm.h>
123 #include <PyInterp_Interp.h>
125 #include <SUIT_Desktop.h>
126 #include <SUIT_FileDlg.h>
127 #include <SUIT_MessageBox.h>
128 #include <SUIT_OverrideCursor.h>
129 #include <SUIT_ResourceMgr.h>
130 #include <SUIT_Session.h>
132 #include <QtxPopupMgr.h>
133 #include <QtxFontEdit.h>
135 #include <SALOME_ListIO.hxx>
137 #ifndef DISABLE_PLOT2DVIEWER
138 #include <SPlot2d_ViewModel.h>
139 #include <SPlot2d_Histogram.h>
143 #include <SALOMEconfig.h>
144 #include CORBA_CLIENT_HEADER(SALOMEDS_Attributes)
145 #include CORBA_CLIENT_HEADER(SMESH_MeshEditor)
146 #include CORBA_CLIENT_HEADER(SMESH_Measurements)
149 // #define INCLUDE_MENUITEM_DEF // VSR commented ????????
150 #include <QApplication>
152 #include <QTextStream>
155 #include <boost/shared_ptr.hpp>
158 #include <vtkCallbackCommand.h>
159 #include <vtkCamera.h>
160 #include <vtkLookupTable.h>
161 #include <vtkPlane.h>
162 #include <vtkRenderer.h>
164 // SALOME KERNEL includes
165 #include <SALOMEDSClient_ClientFactory.hxx>
166 #include <SALOMEDSClient_IParameters.hxx>
167 #include <SALOMEDSClient_SComponent.hxx>
168 #include <SALOMEDSClient_StudyBuilder.hxx>
169 #include <SALOMEDS_Study.hxx>
170 #include <SALOMEDS_SObject.hxx>
171 #include "utilities.h"
174 #include <Standard_ErrorHandler.hxx>
175 #include <NCollection_DataMap.hxx>
177 #include <Basics_Utils.hxx>
179 //To disable automatic genericobj management, the following line should be commented.
180 //Otherwise, it should be uncommented.
181 //Refer to KERNEL_SRC/src/SALOMEDSImpl/SALOMEDSImpl_AttributeIOR.cxx
182 #define WITHGENERICOBJ
184 // Below macro, when uncommented, switches on simplified (more performant) algorithm
185 // of auto-color picking up
186 #define SIMPLE_AUTOCOLOR
191 //=============================================================
192 void ImportMeshesFromFile(SMESH::SMESH_Gen_ptr theComponentMesh,
195 void ExportMeshToFile(int theCommandID);
197 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap);
199 void SetDisplayEntity(int theCommandID);
201 void Control( int theCommandID );
204 //================================================================================
206 * \brief Reads meshes from file
208 //================================================================================
210 void ImportMeshesFromFile( SMESH::SMESH_Gen_ptr theComponentMesh,
214 std::string myExtension;
216 if ( theCommandID == SMESHOp::OpImportMED ) {
217 filter.append( QObject::tr( "MED_FILES_FILTER" ) + " (*.*med)" );
218 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
220 else if ( theCommandID == SMESHOp::OpImportUNV ) {
221 filter.append( QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)" );
223 else if ( theCommandID == SMESHOp::OpImportDAT ) {
224 filter.append( QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)" );
226 else if ( theCommandID == SMESHOp::OpImportSTL ) {
227 filter.append( QObject::tr( "STL_FILES_FILTER" ) + " (*.stl)" );
230 else if ( theCommandID == SMESHOp::OpImportCGNS ) {
231 filter.append( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
234 else if ( theCommandID == SMESHOp::OpImportSAUV ) {
235 filter.append( QObject::tr( "SAUV files (*.sauv*)" ) );
236 filter.append( QObject::tr( "All files (*)" ) );
238 else if ( theCommandID == SMESHOp::OpImportGMF ) {
239 filter.append( QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" );
240 filter.append( QObject::tr( "GMF_BINARY_FILES_FILTER") + " (*.meshb)" );
243 QString anInitialPath = "";
244 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
245 anInitialPath = QDir::currentPath();
247 QStringList filenames;
248 bool toCreateGroups = true;
250 // if ( theCommandID == SMESHOp::OpImportGMF ) { // GMF
251 // SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg
252 // ( SMESHGUI::desktop(), true, QObject::tr("SMESH_REQUIRED_GROUPS"), true, true );
253 // fd->setWindowTitle( QObject::tr( "SMESH_IMPORT_MESH" ) );
254 // fd->setNameFilters( filter );
255 // fd->SetChecked( true );
257 // filenames << fd->selectedFile();
258 // toCreateGroups = fd->IsChecked();
264 filenames = SUIT_FileDlg::getOpenFileNames( SMESHGUI::desktop(),
267 QObject::tr( "SMESH_IMPORT_MESH" ) );
269 if ( filenames.count() > 0 ) {
270 SUIT_OverrideCursor wc;
271 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
274 QStringList anEntryList;
275 bool isEmpty = false;
276 for ( QStringList::ConstIterator it = filenames.begin(); it != filenames.end(); ++it ) {
277 QString filename = *it;
278 SMESH::mesh_array_var aMeshes = new SMESH::mesh_array;
280 switch ( theCommandID ) {
281 case SMESHOp::OpImportDAT:
283 // DAT format (currently unsupported)
284 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
285 arg( QObject::tr( "SMESH_ERR_NOT_SUPPORTED_FORMAT" ) ) );
288 case SMESHOp::OpImportUNV:
291 aMeshes->length( 1 );
292 aMeshes[0] = theComponentMesh->CreateMeshesFromUNV( filename.toUtf8().constData() );
293 if ( aMeshes[0]->_is_nil() )
294 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
295 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
298 case SMESHOp::OpImportMED:
301 SMESH::DriverMED_ReadStatus res;
302 aMeshes = theComponentMesh->CreateMeshesFromMED( filename.toUtf8().constData(), res );
303 if ( res != SMESH::DRS_OK ) {
304 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
305 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
309 case SMESHOp::OpImportSTL:
312 aMeshes->length( 1 );
313 aMeshes[0] = theComponentMesh->CreateMeshesFromSTL( filename.toUtf8().constData() );
314 if ( aMeshes[0]->_is_nil() ) {
315 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
316 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
321 case SMESHOp::OpImportCGNS:
324 SMESH::DriverMED_ReadStatus res;
325 aMeshes = theComponentMesh->CreateMeshesFromCGNS( filename.toUtf8().constData(), res );
326 if ( res != SMESH::DRS_OK ) {
327 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
328 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
333 case SMESHOp::OpImportSAUV:
336 SMESH::DriverMED_ReadStatus res;
337 aMeshes = theComponentMesh->CreateMeshesFromSAUV( filename.toUtf8().constData(), res );
338 if ( res != SMESH::DRS_OK ) {
339 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
340 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
344 case SMESHOp::OpImportGMF:
347 SMESH::ComputeError_var res;
348 aMeshes->length( 1 );
349 aMeshes[0] = theComponentMesh->CreateMeshesFromGMF( filename.toUtf8().constData(),
352 if ( res->code != SMESH::DRS_OK ) {
353 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
354 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res->code ).toLatin1().data() ) ) );
355 if ( strlen( res->comment.in() ) > 0 ) {
356 errors.back() += ": ";
357 errors.back() += res->comment.in();
364 catch ( const SALOME::SALOME_Exception& S_ex ) {
365 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
366 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
369 for ( int i = 0, iEnd = aMeshes->length(); i < iEnd; i++ ) {
370 _PTR(SObject) aMeshSO = SMESH::FindSObject( aMeshes[i] );
372 _PTR(StudyBuilder) aBuilder = aStudy->NewBuilder();
373 _PTR(AttributePixMap) aPixmap = aBuilder->FindOrCreateAttribute( aMeshSO, "AttributePixMap" );
374 aPixmap->SetPixMap( "ICON_SMESH_TREE_MESH_IMPORTED" );
375 if ( theCommandID == SMESHOp::OpImportUNV ) // mesh names aren't taken from the file for UNV import
376 SMESH::SetName( aMeshSO, QFileInfo(filename).fileName() );
378 anEntryList.append( aMeshSO->GetID().c_str() );
386 // update Object browser
387 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
389 // browse to the published meshes
390 if( LightApp_Application* anApp =
391 dynamic_cast<LightApp_Application*>( SUIT_Session::session()->activeApplication() ) )
392 anApp->browseObjects( anEntryList );
394 // show Error message box if there were errors
395 if ( errors.count() > 0 ) {
396 SUIT_MessageBox::critical( SMESHGUI::desktop(),
397 QObject::tr( "SMESH_ERROR" ),
398 QObject::tr( "SMESH_IMPORT_ERRORS" ) + "\n" + errors.join( "\n" ) );
401 // show warning message box, if some imported mesh is empty
403 SUIT_MessageBox::warning( SMESHGUI::desktop(),
404 QObject::tr( "SMESH_WRN_WARNING" ),
405 QObject::tr( "SMESH_DRS_SOME_EMPTY" ) );
410 //================================================================================
412 * \brief Export selected meshes or groups into a file
414 //================================================================================
416 void ExportMeshToFile( int theCommandID )
418 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
419 SALOME_ListIO selected;
421 aSel->selectedObjects( selected );
423 const bool isDAT = ( theCommandID == SMESHOp::OpExportDAT || theCommandID == SMESHOp::OpPopupExportDAT );
424 const bool isMED = ( theCommandID == SMESHOp::OpExportMED || theCommandID == SMESHOp::OpPopupExportMED );
425 const bool isUNV = ( theCommandID == SMESHOp::OpExportUNV || theCommandID == SMESHOp::OpPopupExportUNV );
426 const bool isSTL = ( theCommandID == SMESHOp::OpExportSTL || theCommandID == SMESHOp::OpPopupExportSTL );
428 const bool isCGNS= ( theCommandID == SMESHOp::OpExportCGNS || theCommandID == SMESHOp::OpPopupExportCGNS );
430 const bool isCGNS= false;
432 const bool isSAUV= ( theCommandID == SMESHOp::OpExportSAUV || theCommandID == SMESHOp::OpPopupExportSAUV );
433 const bool isGMF = ( theCommandID == SMESHOp::OpExportGMF || theCommandID == SMESHOp::OpPopupExportGMF );
435 // actually, the following condition can't be met (added for insurance)
436 if( selected.Extent() == 0 ||
437 ( selected.Extent() > 1 && !isMED && !isSTL ))
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 );
536 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Triangle );
541 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
542 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Triangle );
543 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Quadrangle );
544 notSupportedElemTypes.push_back( SMESH::Entity_TriQuad_Hexa );
545 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
546 notSupportedElemTypes.push_back( SMESH::Entity_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);
719 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
720 fd->setValidator( fv );
725 aFilename = fd->selectedFile();
727 aFilename = QString::null;
730 aFormat = aFilterMap[fd->selectedNameFilter()];
731 toOverwrite = fv->isOverwrite();
733 if ( !aFilename.isEmpty() ) {
734 // med-2.1 does not support poly elements
735 if ( aFormat==SMESH::MED_V2_1 )
736 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
737 SMESH::SMESH_IDSource_var aMeshItem = (*aMeshIter).first;
738 SMESH::long_array_var nbElems = aMeshItem->GetMeshInfo();
739 if ( nbElems[ SMESH::Entity_Polygon ] + nbElems[ SMESH::Entity_Quad_Polygon ] +
740 nbElems[ SMESH::Entity_Polyhedra ] + nbElems[ SMESH::Entity_Quad_Polyhedra ])
742 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
743 QObject::tr("SMESH_WRN_WARNING"),
744 QObject::tr("SMESH_EXPORT_MED_V2_1").arg((*aMeshIter).second),
745 QObject::tr("SMESH_BUT_YES"),
746 QObject::tr("SMESH_BUT_NO"), 0, 1);
754 // can't append to an existing using other format
755 SMESH::MED_VERSION aVersion = SMESH::MED_V2_1;
756 bool isVersionOk = SMESHGUI::GetSMESHGen()->GetMEDVersion( aFilename.toUtf8().constData(), aVersion );
757 if( !isVersionOk || aVersion != aFormat ) {
758 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
759 QObject::tr("SMESH_WRN_WARNING"),
760 QObject::tr("SMESH_EXPORT_MED_VERSION_COLLISION").arg(aFilename),
761 QObject::tr("SMESH_BUT_YES"),
762 QObject::tr("SMESH_BUT_NO"), 0, 1);
769 QStringList aMeshNamesCollisionList;
770 SMESH::string_array_var aMeshNames = SMESHGUI::GetSMESHGen()->GetMeshNames( aFilename.toUtf8().constData() );
771 for( int i = 0, n = aMeshNames->length(); i < n; i++ ) {
772 QString anExistingMeshName( aMeshNames[ i ] );
773 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
774 QString anExportMeshName = (*aMeshIter).second;
775 if( anExportMeshName == anExistingMeshName ) {
776 aMeshNamesCollisionList.append( anExportMeshName );
781 if( !aMeshNamesCollisionList.isEmpty() ) {
782 QString aMeshNamesCollisionString = aMeshNamesCollisionList.join( ", " );
783 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
784 QObject::tr("SMESH_WRN_WARNING"),
785 QObject::tr("SMESH_EXPORT_MED_MESH_NAMES_COLLISION").arg(aMeshNamesCollisionString),
786 QObject::tr("SMESH_BUT_YES"),
787 QObject::tr("SMESH_BUT_NO"),
788 QObject::tr("SMESH_BUT_CANCEL"), 0, 2);
797 toCreateGroups = fd->IsChecked(0);
798 toFindOutDim = fd->IsChecked(1);
799 fieldSelWdg->GetSelectedFeilds();
800 if ( !fieldSelWdg->parent() )
811 if ( !aFilename.isEmpty() ) {
812 // Check whether the file already exists and delete it if yes
813 QFile aFile( aFilename );
814 if ( aFile.exists() && toOverwrite )
816 SUIT_OverrideCursor wc;
819 // Renumbering is not needed since SMDS redesign in V6.2.0 (Nov 2010)
820 // bool Renumber = false;
821 // // PAL 14172 : Check of we have to renumber or not from the preferences before export
823 // Renumber= resMgr->booleanValue("renumbering");
825 // SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
826 // aMeshEditor->RenumberNodes();
827 // aMeshEditor->RenumberElements();
828 // if ( SMESHGUI::automaticUpdate() )
829 // SMESH::UpdateView();
833 aMeshIter = aMeshList.begin();
834 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
836 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
837 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
838 const GEOM::ListOfFields& fields = aFieldList[ aMeshIndex ].first.in();
839 const QString& geoAssFields = aFieldList[ aMeshIndex ].second;
840 const bool hasFields = ( fields.length() || !geoAssFields.isEmpty() );
841 if ( !hasFields && aMeshOrGroup->_is_equivalent( aMeshItem ))
842 aMeshItem->ExportToMEDX( aFilename.toUtf8().data(), toCreateGroups,
843 aFormat, toOverwrite && aMeshIndex == 0, toFindOutDim );
845 aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups,
846 aFormat, toOverwrite && aMeshIndex == 0, toFindOutDim,
847 fields, geoAssFields.toLatin1().data() );
852 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ )
854 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
855 if( !aMeshItem->_is_nil() )
856 aMeshItem->ExportSAUV( aFilename.toUtf8().data(), toCreateGroups );
861 if ( aMeshOrGroup->_is_equivalent( aMesh ))
862 aMesh->ExportDAT( aFilename.toUtf8().data() );
864 aMesh->ExportPartToDAT( aMeshOrGroup, aFilename.toUtf8().data() );
868 if ( aMeshOrGroup->_is_equivalent( aMesh ))
869 aMesh->ExportUNV( aFilename.toUtf8().data() );
871 aMesh->ExportPartToUNV( aMeshOrGroup, aFilename.toUtf8().data() );
875 if ( aMeshOrGroup->_is_equivalent( aMesh ))
876 aMesh->ExportSTL( aFilename.toUtf8().data(), aIsASCII_STL );
878 aMesh->ExportPartToSTL( aMeshOrGroup, aFilename.toUtf8().data(), aIsASCII_STL );
882 aMeshIter = aMeshList.begin();
883 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
885 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
886 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
887 aMeshItem->ExportCGNS( aMeshOrGroup,
888 aFilename.toUtf8().data(),
889 toOverwrite && aMeshIndex == 0 );
894 toCreateGroups = true;
895 aMesh->ExportGMF( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups );
898 catch (const SALOME::SALOME_Exception& S_ex){
900 SUIT_MessageBox::warning(SMESHGUI::desktop(),
901 QObject::tr("SMESH_WRN_WARNING"),
902 QObject::tr("SMESH_EXPORT_FAILED"));
908 inline void InverseEntityMode(unsigned int& theOutputMode,
909 unsigned int theMode)
911 bool anIsNotPresent = ~theOutputMode & theMode;
913 theOutputMode |= theMode;
915 theOutputMode &= ~theMode;
918 void SetDisplayEntity(int theCommandID){
919 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
920 SALOME_ListIO selected;
922 aSel->selectedObjects( selected );
924 if(selected.Extent() >= 1){
925 SALOME_ListIteratorOfListIO It( selected );
926 for( ; It.More(); It.Next()){
927 Handle(SALOME_InteractiveObject) IObject = It.Value();
928 if(IObject->hasEntry()){
929 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
930 unsigned int aMode = anActor->GetEntityMode();
931 switch(theCommandID){
932 case SMESHOp::OpDE0DElements:
933 InverseEntityMode(aMode,SMESH_Actor::e0DElements);
935 case SMESHOp::OpDEEdges:
936 InverseEntityMode(aMode,SMESH_Actor::eEdges);
938 case SMESHOp::OpDEFaces:
939 InverseEntityMode(aMode,SMESH_Actor::eFaces);
941 case SMESHOp::OpDEVolumes:
942 InverseEntityMode(aMode,SMESH_Actor::eVolumes);
944 case SMESHOp::OpDEBalls:
945 InverseEntityMode(aMode,SMESH_Actor::eBallElem);
947 case SMESHOp::OpDEAllEntity:
948 aMode = SMESH_Actor::eAllEntity;
952 anActor->SetEntityMode(aMode);
961 SALOME_ListIO selected;
962 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
966 LightApp_SelectionMgr* aSel = app->selectionMgr();
967 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
968 if( !aSel || !appStudy )
971 aSel->selectedObjects( selected );
972 if( selected.IsEmpty() )
975 Handle(SALOME_InteractiveObject) anIObject = selected.First();
977 _PTR(Study) aStudy = appStudy->studyDS();
978 _PTR(SObject) aMainSObject( aStudy->FindObjectID( anIObject->getEntry() ) );
979 SMESH::SMESH_Mesh_var aMainObject = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
980 if( aMainObject->_is_nil() )
983 SUIT_OverrideCursor wc;
985 aMainObject->SetAutoColor( true ); // mesh groups are re-colored here
987 QList<SALOMEDS::Color> aReservedColors;
989 SMESH::ListOfGroups aListOfGroups = *aMainObject->GetGroups();
990 for( int i = 0, n = aListOfGroups.length(); i < n; i++ )
992 SMESH::SMESH_GroupBase_var aGroupObject = aListOfGroups[i];
993 //SALOMEDS::Color aColor = aGroupObject->GetColor();
995 #ifdef SIMPLE_AUTOCOLOR // simplified algorithm for auto-colors
996 SALOMEDS::Color aColor = SMESHGUI::getPredefinedUniqueColor();
997 #else // old algorithm for auto-colors
998 SALOMEDS::Color aColor = SMESHGUI::getUniqueColor( aReservedColors );
999 aReservedColors.append( aColor );
1000 #endif // SIMPLE_AUTOCOLOR
1001 aGroupObject->SetColor( aColor );
1003 _PTR(SObject) aGroupSObject = SMESH::FindSObject(aGroupObject);
1004 if (aGroupSObject) {
1007 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(aGroupSObject->GetID().c_str())) {
1008 switch ( aGroupObject->GetType ()) {
1010 anActor->SetNodeColor( aColor.R, aColor.G, aColor.B ); break;
1012 anActor->SetEdgeColor( aColor.R, aColor.G, aColor.B ); break;
1014 anActor->Set0DColor( aColor.R, aColor.G, aColor.B ); break;
1016 anActor->SetBallColor( aColor.R, aColor.G, aColor.B ); break;
1018 SMESH::GetColor("SMESH", "volume_color", c, delta, "255,0,170|-100");
1019 anActor->SetVolumeColor( aColor.R, aColor.G, aColor.B, delta ); break;
1022 SMESH::GetColor("SMESH", "fill_color", c, delta, "0,170,255|-100");
1023 anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B, delta );
1029 SMESH::RepaintCurrentView();
1032 void OverallMeshQuality() {
1033 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1034 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1035 SALOME_ListIO selected;
1037 aSel->selectedObjects( selected );
1039 if ( selected.IsEmpty() ) return;
1040 SALOME_ListIteratorOfListIO It( selected );
1041 for ( ; It.More(); It.Next() ) {
1042 SMESHGUI_CtrlInfoDlg* ctrlDlg = new SMESHGUI_CtrlInfoDlg( SMESHGUI::desktop() );
1043 ctrlDlg->showInfo( It.Value() );
1048 QString functorToString( SMESH::Controls::FunctorPtr f )
1050 QString type = QObject::tr( "UNKNOWN_CONTROL" );
1051 if ( dynamic_cast< SMESH::Controls::Volume* >( f.get() ) )
1052 type = QObject::tr( "VOLUME_3D_ELEMENTS" );
1053 else if ( dynamic_cast< SMESH::Controls::MaxElementLength2D* >( f.get() ) )
1054 type = QObject::tr( "MAX_ELEMENT_LENGTH_2D" );
1055 else if ( dynamic_cast< SMESH::Controls::MaxElementLength3D* >( f.get() ) )
1056 type = QObject::tr( "MAX_ELEMENT_LENGTH_3D" );
1057 else if ( dynamic_cast< SMESH::Controls::MinimumAngle* >( f.get() ) )
1058 type = QObject::tr( "MINIMUMANGLE_ELEMENTS" );
1059 else if ( dynamic_cast< SMESH::Controls::AspectRatio* >( f.get() ) )
1060 type = QObject::tr( "ASPECTRATIO_ELEMENTS" );
1061 else if ( dynamic_cast< SMESH::Controls::AspectRatio3D* >( f.get() ) )
1062 type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" );
1063 else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) )
1064 type = QObject::tr( "WARP_ELEMENTS" );
1065 else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) )
1066 type = QObject::tr( "TAPER_ELEMENTS" );
1067 else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) )
1068 type = QObject::tr( "SKEW_ELEMENTS" );
1069 else if ( dynamic_cast< SMESH::Controls::Area* >( f.get() ) )
1070 type = QObject::tr( "AREA_ELEMENTS" );
1071 else if ( dynamic_cast< SMESH::Controls::Length* >( f.get() ) )
1072 type = QObject::tr( "LENGTH_EDGES" );
1073 else if ( dynamic_cast< SMESH::Controls::Length2D* >( f.get() ) )
1074 type = QObject::tr( "LENGTH2D_EDGES" );
1075 else if ( dynamic_cast< SMESH::Controls::MultiConnection* >( f.get() ) )
1076 type = QObject::tr( "MULTI_BORDERS" );
1077 else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) )
1078 type = QObject::tr( "MULTI2D_BORDERS" );
1079 else if ( dynamic_cast< SMESH::Controls::FreeNodes* >( f.get() ) )
1080 type = QObject::tr( "FREE_NODES" );
1081 else if ( dynamic_cast< SMESH::Controls::FreeEdges* >( f.get() ) )
1082 type = QObject::tr( "FREE_EDGES" );
1083 else if ( dynamic_cast< SMESH::Controls::FreeBorders* >( f.get() ) )
1084 type = QObject::tr( "FREE_BORDERS" );
1085 else if ( dynamic_cast< SMESH::Controls::FreeFaces* >( f.get() ) )
1086 type = QObject::tr( "FREE_FACES" );
1087 else if ( dynamic_cast< SMESH::Controls::BareBorderVolume* >( f.get() ) )
1088 type = QObject::tr( "BARE_BORDER_VOLUME" );
1089 else if ( dynamic_cast< SMESH::Controls::BareBorderFace* >( f.get() ) )
1090 type = QObject::tr( "BARE_BORDER_FACE" );
1091 else if ( dynamic_cast< SMESH::Controls::OverConstrainedVolume* >( f.get() ) )
1092 type = QObject::tr( "OVER_CONSTRAINED_VOLUME" );
1093 else if ( dynamic_cast< SMESH::Controls::OverConstrainedFace* >( f.get() ) )
1094 type = QObject::tr( "OVER_CONSTRAINED_FACE" );
1095 else if ( dynamic_cast< SMESH::Controls::CoincidentNodes* >( f.get() ) )
1096 type = QObject::tr( "EQUAL_NODE" );
1097 else if ( dynamic_cast< SMESH::Controls::CoincidentElements1D* >( f.get() ) )
1098 type = QObject::tr( "EQUAL_EDGE" );
1099 else if ( dynamic_cast< SMESH::Controls::CoincidentElements2D* >( f.get() ) )
1100 type = QObject::tr( "EQUAL_FACE" );
1101 else if ( dynamic_cast< SMESH::Controls::CoincidentElements3D* >( f.get() ) )
1102 type = QObject::tr( "EQUAL_VOLUME" );
1106 void SaveDistribution()
1108 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1109 SALOME_ListIO selected;
1111 aSel->selectedObjects( selected );
1113 if ( selected.Extent() == 1 ) {
1114 Handle(SALOME_InteractiveObject) anIO = selected.First();
1115 if ( anIO->hasEntry() ) {
1116 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1117 if ( anActor && anActor->GetScalarBarActor() && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1118 SMESH_ScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor();
1119 SMESH::Controls::FunctorPtr aFunctor = anActor->GetFunctor();
1120 if ( aScalarBarActor && aFunctor ) {
1121 SMESH::Controls::NumericalFunctor* aNumFun = dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
1123 std::vector<int> elements;
1124 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
1125 if ( mesh->_is_nil() ) {
1126 SMESH::SMESH_IDSource_var idSource =
1127 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
1128 if ( !idSource->_is_nil() )
1130 SMESH::long_array_var ids = idSource->GetIDs();
1131 elements.resize( ids->length() );
1132 for ( unsigned i = 0; i < elements.size(); ++i )
1133 elements[i] = ids[i];
1136 int nbIntervals = aScalarBarActor->GetMaximumNumberOfColors();
1137 vtkLookupTable* lookupTable =
1138 static_cast<vtkLookupTable*>(aScalarBarActor->GetLookupTable());
1139 double * minmax = lookupTable->GetRange();
1140 bool isLogarithmic = lookupTable->GetScale() == VTK_SCALE_LOG10;
1141 std::vector<int> nbEvents;
1142 std::vector<double> funValues;
1143 aNumFun->GetHistogram( nbIntervals, nbEvents, funValues, elements, minmax, isLogarithmic );
1144 QString anInitialPath = "";
1145 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
1146 anInitialPath = QDir::currentPath();
1147 QString aMeshName = anIO->getName();
1149 filter.append( QObject::tr( "TEXT_FILES_FILTER" ) + " (*.txt)" );
1150 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
1151 QString aFilename = anInitialPath + "/" + aMeshName + "_" +
1152 functorToString( aFunctor ).toLower().simplified().replace( QRegExp( " |-" ), "_" ) + ".txt";
1153 aFilename = SUIT_FileDlg::getFileName( SMESHGUI::desktop(),
1156 QObject::tr( "SMESH_SAVE_DISTRIBUTION" ),
1158 if ( !aFilename.isEmpty() ) {
1159 QFile f( aFilename );
1160 if ( f.open( QFile::WriteOnly | QFile::Truncate ) ) {
1161 QTextStream out( &f );
1162 out << "# Mesh: " << aMeshName << endl;
1163 out << "# Control: " << functorToString( aFunctor ) << endl;
1165 out.setFieldWidth( 10 );
1166 for ( int i = 0; i < qMin( nbEvents.size(), funValues.size()-1 ); i++ )
1167 out << funValues[i] << "\t" << funValues[i+1] << "\t" << nbEvents[i] << endl;
1178 void ShowDistribution() {
1179 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1180 SALOME_ListIO selected;
1182 aSel->selectedObjects( selected );
1184 if ( selected.Extent() == 1 ) {
1185 Handle(SALOME_InteractiveObject) anIO = selected.First();
1186 if ( anIO->hasEntry() ) {
1187 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1188 if ( anActor && anActor->GetScalarBarActor() && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1189 SMESH_ScalarBarActor *aScalarBarActor = anActor->GetScalarBarActor();
1190 aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility());
1196 #ifndef DISABLE_PLOT2DVIEWER
1197 void PlotDistribution() {
1198 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1202 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1203 SALOME_ListIO selected;
1205 aSel->selectedObjects( selected );
1207 if ( selected.Extent() == 1 ) {
1208 Handle(SALOME_InteractiveObject) anIO = selected.First();
1209 if ( anIO->hasEntry() ) {
1210 //Find Actor by entry before getting Plot2d viewer,
1211 //because after call getViewManager( Plot2d_Viewer::Type(), true ) active window is Plot2d Viewer
1212 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1214 SUIT_ViewManager* aViewManager = app->getViewManager( Plot2d_Viewer::Type(), true ); // create if necessary
1219 SPlot2d_Viewer* aView = dynamic_cast<SPlot2d_Viewer*>(aViewManager->getViewModel());
1223 Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
1227 if ( anActor && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1228 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1229 QString functorName = functorToString( anActor->GetFunctor());
1230 QString aHistogramName("%1 : %2");
1231 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1232 aHistogram->setName(aHistogramName);
1233 aHistogram->setHorTitle(functorName);
1234 aHistogram->setVerTitle(QObject::tr("DISTRIBUTION_NB_ENT"));
1235 aPlot->displayObject(aHistogram, true);
1240 #endif //DISABLE_PLOT2DVIEWER
1242 void DisableAutoColor(){
1243 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1244 SALOME_ListIO selected;
1246 aSel->selectedObjects( selected );
1248 if(selected.Extent()){
1249 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1250 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1251 if ( !aMesh->_is_nil() ) {
1252 aMesh->SetAutoColor( false );
1257 void sortChildren(){
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 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1266 _PTR(SObject) aSObj = aStudy->FindObjectID(anIObject->getEntry());
1268 if ( aStudy->GetUseCaseBuilder()->SortChildren( aSObj, true/*AscendingOrder*/ ) ) {
1269 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1276 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap)
1278 SALOME_ListIO selected;
1279 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1283 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1284 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1285 if( !aSel || !appStudy )
1288 if( theCommandID == SMESHOp::OpClipping ) { // Clipping dialog can be activated without selection
1289 if( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
1290 aModule->EmitSignalDeactivateDialog();
1291 if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
1292 (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
1297 _PTR(Study) aStudy = appStudy->studyDS();
1299 aSel->selectedObjects( selected );
1301 if(selected.Extent() >= 1){
1302 switch(theCommandID){
1303 case SMESHOp::OpTransparency:{
1304 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1305 (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
1308 case SMESHOp::OpProperties: {
1310 QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
1311 QColor orientationColor, outlineColor, volumeColor;
1312 int deltaF = 0, deltaV = 0;
1315 double ballScale = 1.0;
1317 int outlineWidth = 1;
1318 double shrinkCoef = 0.0;
1319 double orientationScale = 0.0;
1320 bool orientation3d = false;
1321 VTK::MarkerType markerType = VTK::MT_NONE;
1322 VTK::MarkerScale markerScale = VTK::MS_NONE;
1324 bool hasNodes = false;
1325 int presentEntities = 0;
1326 bool firstTime = true;
1328 SALOME_ListIteratorOfListIO It( selected );
1329 for ( ; It.More(); It.Next() ) {
1330 Handle(SALOME_InteractiveObject) IObject = It.Value();
1331 if ( !IObject->hasEntry() ) continue;
1332 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1333 if ( !anActor || !anActor->GetObject() ) continue;
1336 // nodes: color, marker
1337 anActor->GetNodeColor( color[0], color[1], color[2] );
1338 nodeColor.setRgbF( color[0], color[1], color[2] );
1339 markerType = anActor->GetMarkerType();
1340 markerScale = anActor->GetMarkerScale();
1341 markerId = anActor->GetMarkerTexture();
1342 // edges: color, width
1343 anActor->GetEdgeColor( color[0], color[1], color[2] );
1344 edgeColor.setRgbF( color[0], color[1], color[2] );
1345 edgeWidth = qMax( (int)anActor->GetLineWidth(), 1 ); // minimum allowed width is 1
1346 // faces: front color, back color (delta)
1347 anActor->GetSufaceColor( color[0], color[1], color[2], deltaF );
1348 faceColor.setRgbF( color[0], color[1], color[2] );
1349 // faces: front color, back color (delta)
1350 anActor->GetVolumeColor( color[0], color[1], color[2], deltaV );
1351 volumeColor.setRgbF( color[0], color[1], color[2] );
1352 // 0d elements: color, size
1353 anActor->Get0DColor( color[0], color[1], color[2] );
1354 elem0dColor.setRgbF( color[0], color[1], color[2] );
1355 elem0dSize = qMax( (int)anActor->Get0DSize(), 1 ); // minimum allowed size is 1
1356 // balls: color, size
1357 anActor->GetBallColor( color[0], color[1], color[2] );
1358 ballColor.setRgbF( color[0], color[1], color[2] );
1359 ballSize = qMax( (int)anActor->GetBallSize(), 1 ); // minimum allowed size is 1
1360 ballScale = qMax( (double)anActor->GetBallScale(), 1e-2 ); // minimum allowed scale is 1e-2
1362 anActor->GetOutlineColor( color[0], color[1], color[2] );
1363 outlineColor.setRgbF( color[0], color[1], color[2] );
1364 outlineWidth = qMax( (int)anActor->GetOutlineWidth(), 1 ); // minimum allowed width is 1
1365 // orientation vectors: color, scale, 3d flag
1366 anActor->GetFacesOrientationColor( color[0], color[1], color[2] );
1367 orientationColor.setRgbF( color[0], color[1], color[2] );
1368 orientationScale = anActor->GetFacesOrientationScale();
1369 orientation3d = anActor->GetFacesOrientation3DVectors();
1371 shrinkCoef = anActor->GetShrinkFactor();
1374 firstTime = false; // we only take properties from first object (for performance reasons)
1377 hasNodes = anActor->GetObject()->GetNbEntities( SMDSAbs_Node );
1378 if ( !(presentEntities & SMESH_Actor::eEdges) && anActor->GetObject()->GetNbEntities( SMDSAbs_Edge ) )
1379 presentEntities = presentEntities | SMESH_Actor::eEdges;
1380 if ( !(presentEntities & SMESH_Actor::eFaces) && anActor->GetObject()->GetNbEntities( SMDSAbs_Face ) )
1381 presentEntities = presentEntities | SMESH_Actor::eFaces;
1382 if ( !(presentEntities & SMESH_Actor::eVolumes) && anActor->GetObject()->GetNbEntities( SMDSAbs_Volume ) )
1383 presentEntities = presentEntities | SMESH_Actor::eVolumes;
1384 if ( !(presentEntities & SMESH_Actor::e0DElements) && anActor->GetObject()->GetNbEntities( SMDSAbs_0DElement ) )
1385 presentEntities = presentEntities | SMESH_Actor::e0DElements;
1386 if ( !(presentEntities & SMESH_Actor::eBallElem) && anActor->GetObject()->GetNbEntities( SMDSAbs_Ball ) )
1387 presentEntities = presentEntities | SMESH_Actor::eBallElem;
1389 // as we know that all types of elements are present, we can exit the loop
1390 if ( presentEntities == SMESH_Actor::eAllEntity )
1394 SMESHGUI_PropertiesDlg dlg( theMarkerMap[ aStudy->StudyId() ], SMESHGUI::desktop() );
1395 // nodes: color, marker
1396 dlg.setNodeColor( nodeColor );
1397 if( markerType != VTK::MT_USER )
1398 dlg.setNodeMarker( markerType, markerScale );
1400 dlg.setNodeCustomMarker( markerId );
1401 // edges: color, line width
1402 dlg.setEdgeColor( edgeColor );
1403 dlg.setEdgeWidth( edgeWidth );
1404 // faces: front color, back color
1405 dlg.setFaceColor( faceColor, deltaF );
1406 // volumes: normal color, reversed color
1407 dlg.setVolumeColor( volumeColor, deltaV );
1408 // outlines: color, line width
1409 dlg.setOutlineColor( outlineColor );
1410 dlg.setOutlineWidth( outlineWidth );
1411 // 0d elements: color, size
1412 dlg.setElem0dColor( elem0dColor );
1413 dlg.setElem0dSize( elem0dSize );
1414 // balls: color, size
1415 dlg.setBallColor( ballColor );
1416 dlg.setBallSize( ballSize );
1417 dlg.setBallScale( ballScale );
1418 // orientation: color, scale, 3d flag
1419 dlg.setOrientationColor( orientationColor );
1420 dlg.setOrientationSize( int( orientationScale * 100. ) );
1421 dlg.setOrientation3d( orientation3d );
1422 // shrink: scale factor
1423 dlg.setShrinkCoef( int( shrinkCoef * 100. ) );
1424 // hide unused controls
1425 dlg.showControls( presentEntities, hasNodes );
1428 nodeColor = dlg.nodeColor();
1429 markerType = dlg.nodeMarkerType();
1430 markerScale = dlg.nodeMarkerScale();
1431 markerId = dlg.nodeMarkerId();
1432 edgeColor = dlg.edgeColor();
1433 edgeWidth = dlg.edgeWidth();
1434 faceColor = dlg.faceColor();
1435 deltaF = dlg.faceColorDelta();
1436 volumeColor = dlg.volumeColor();
1437 deltaV = dlg.volumeColorDelta();
1438 outlineColor = dlg.outlineColor();
1439 outlineWidth = dlg.outlineWidth();
1440 elem0dColor = dlg.elem0dColor();
1441 elem0dSize = dlg.elem0dSize();
1442 ballColor = dlg.ballColor();
1443 ballSize = dlg.ballSize();
1444 ballScale = dlg.ballScale();
1445 orientationColor = dlg.orientationColor();
1446 orientationScale = dlg.orientationSize() / 100.;
1447 orientation3d = dlg.orientation3d();
1448 shrinkCoef = dlg.shrinkCoef() / 100.;
1450 // store point markers map that might be changed by the user
1451 theMarkerMap[ aStudy->StudyId() ] = dlg.customMarkers();
1453 // set properties from dialog box to the presentations
1454 SALOME_ListIteratorOfListIO It( selected );
1455 for ( ; It.More(); It.Next() ) {
1456 Handle(SALOME_InteractiveObject) IObject = It.Value();
1457 if ( !IObject->hasEntry() ) continue;
1458 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1459 if ( !anActor ) continue;
1461 // nodes: color, marker
1462 anActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
1463 if ( markerType != VTK::MT_USER ) {
1464 anActor->SetMarkerStd( markerType, markerScale );
1467 const VTK::MarkerMap& markerMap = theMarkerMap[ aStudy->StudyId() ];
1468 VTK::MarkerMap::const_iterator iter = markerMap.find( markerId );
1469 if ( iter != markerMap.end() )
1470 anActor->SetMarkerTexture( markerId, iter->second.second );
1472 // volumes: normal color, reversed color (delta)
1473 anActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
1474 // faces: front color, back color (delta)
1475 anActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
1476 // edges: color, width
1477 anActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
1478 anActor->SetLineWidth( edgeWidth );
1480 anActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
1481 anActor->SetOutlineWidth( outlineWidth );
1482 // 0D elements: color, size
1483 anActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
1484 anActor->Set0DSize( elem0dSize );
1485 // balls: color, size
1486 anActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
1487 anActor->SetBallSize( ballSize );
1488 anActor->SetBallScale( ballScale );
1489 // orientation: color, scale, 3d flag
1490 anActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
1491 anActor->SetFacesOrientationScale( orientationScale );
1492 anActor->SetFacesOrientation3DVectors( orientation3d );
1494 anActor->SetShrinkFactor( shrinkCoef );
1496 // for groups, set also proper color
1497 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1498 if ( !aGroupObject->_is_nil() ) {
1499 SMESH::ElementType anElementType = aGroupObject->GetType();
1501 switch( anElementType ) {
1503 aColor = nodeColor; break;
1505 aColor = edgeColor; break;
1507 aColor = faceColor; break;
1509 aColor = volumeColor; break;
1511 aColor = elem0dColor; break;
1513 aColor = ballColor; break;
1517 if ( aColor.isValid() ) {
1518 SALOMEDS::Color aGroupColor;
1519 aGroupColor.R = aColor.redF();
1520 aGroupColor.G = aColor.greenF();
1521 aGroupColor.B = aColor.blueF();
1522 aGroupObject->SetColor( aGroupColor );
1524 } // if ( !aGroupObject->_is_nil() )
1525 } // for ( ; It.More(); It.Next() )
1526 SMESH::RepaintCurrentView();
1527 } // if ( dlg.exec() )
1529 } // case SMESHOp::OpProperties:
1530 } // switch(theCommandID)
1531 SALOME_ListIteratorOfListIO It( selected );
1532 for( ; It.More(); It.Next()){
1533 Handle(SALOME_InteractiveObject) IObject = It.Value();
1534 if(IObject->hasEntry()){
1535 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1536 switch(theCommandID){
1537 case SMESHOp::OpDMWireframe:
1538 anActor->SetRepresentation(SMESH_Actor::eEdge);
1540 case SMESHOp::OpDMShading:
1541 anActor->SetRepresentation(SMESH_Actor::eSurface);
1543 case SMESHOp::OpDMShrink:
1544 if(anActor->IsShrunk())
1545 anActor->UnShrink();
1547 anActor->SetShrink();
1549 case SMESHOp::OpDMNodes:
1550 anActor->SetRepresentation(SMESH_Actor::ePoint);
1552 case SMESHOp::OpRepresentationLines:
1553 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1554 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1556 case SMESHOp::OpRepresentationArcs:
1557 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1558 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1564 SMESH::RepaintCurrentView();
1568 void Control( int theCommandID )
1570 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
1571 switch ( theCommandID ){
1572 case SMESHOp::OpFreeNode:
1573 aControl = SMESH_Actor::eFreeNodes;
1575 case SMESHOp::OpEqualNode:
1576 aControl = SMESH_Actor::eCoincidentNodes;
1578 case SMESHOp::OpFreeEdge:
1579 aControl = SMESH_Actor::eFreeEdges;
1581 case SMESHOp::OpFreeBorder:
1582 aControl = SMESH_Actor::eFreeBorders;
1584 case SMESHOp::OpLength:
1585 aControl = SMESH_Actor::eLength;
1587 case SMESHOp::OpConnection:
1588 aControl = SMESH_Actor::eMultiConnection;
1590 case SMESHOp::OpEqualEdge:
1591 aControl = SMESH_Actor::eCoincidentElems1D;
1593 case SMESHOp::OpFreeFace:
1594 aControl = SMESH_Actor::eFreeFaces;
1596 case SMESHOp::OpBareBorderFace:
1597 aControl = SMESH_Actor::eBareBorderFace;
1599 case SMESHOp::OpOverConstrainedFace:
1600 aControl = SMESH_Actor::eOverConstrainedFace;
1602 case SMESHOp::OpLength2D:
1603 aControl = SMESH_Actor::eLength2D;
1605 case SMESHOp::OpConnection2D:
1606 aControl = SMESH_Actor::eMultiConnection2D;
1608 case SMESHOp::OpArea:
1609 aControl = SMESH_Actor::eArea;
1611 case SMESHOp::OpTaper:
1612 aControl = SMESH_Actor::eTaper;
1614 case SMESHOp::OpAspectRatio:
1615 aControl = SMESH_Actor::eAspectRatio;
1617 case SMESHOp::OpMinimumAngle:
1618 aControl = SMESH_Actor::eMinimumAngle;
1620 case SMESHOp::OpWarpingAngle:
1621 aControl = SMESH_Actor::eWarping;
1623 case SMESHOp::OpSkew:
1624 aControl = SMESH_Actor::eSkew;
1626 case SMESHOp::OpMaxElementLength2D:
1627 aControl = SMESH_Actor::eMaxElementLength2D;
1629 case SMESHOp::OpEqualFace:
1630 aControl = SMESH_Actor:: eCoincidentElems2D;
1632 case SMESHOp::OpAspectRatio3D:
1633 aControl = SMESH_Actor::eAspectRatio3D;
1635 case SMESHOp::OpVolume:
1636 aControl = SMESH_Actor::eVolume3D;
1638 case SMESHOp::OpMaxElementLength3D:
1639 aControl = SMESH_Actor::eMaxElementLength3D;
1641 case SMESHOp::OpBareBorderVolume:
1642 aControl = SMESH_Actor::eBareBorderVolume;
1644 case SMESHOp::OpOverConstrainedVolume:
1645 aControl = SMESH_Actor::eOverConstrainedVolume;
1647 case SMESHOp::OpEqualVolume:
1648 aControl = SMESH_Actor::eCoincidentElems3D;
1651 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1652 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1653 SALOME_ListIO selected;
1655 aSel->selectedObjects( selected );
1657 if( !selected.IsEmpty() ){
1658 SALOME_ListIteratorOfListIO It(selected);
1659 for ( ; It.More(); It.Next())
1661 Handle(SALOME_InteractiveObject) anIO = It.Value();
1663 _PTR(SObject) SO = aStudy->FindObjectID( It.Value()->getEntry() );
1665 CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
1666 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_narrow( aObject );
1667 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( aObject );
1668 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( aObject );
1669 if ( !aMesh->_is_nil() || !aSubMesh->_is_nil() || !aGroup->_is_nil() ) {
1670 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIO->getEntry())) {
1671 anActor->SetControlMode(aControl);
1672 anActor->GetScalarBarActor()->SetTitle( functorToString( anActor->GetFunctor() ).toLatin1().constData() );
1673 SMESH::RepaintCurrentView();
1674 #ifndef DISABLE_PLOT2DVIEWER
1675 if(anActor->GetPlot2Histogram()) {
1676 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1677 QString functorName = functorToString( anActor->GetFunctor());
1678 QString aHistogramName("%1 : %2");
1679 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1680 aHistogram->setName(aHistogramName);
1681 aHistogram->setHorTitle(functorName);
1682 SMESH::ProcessIn2DViewers(anActor);
1694 bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1695 SMESH::MeshObjectType theType,
1696 const QString theInTypeName,
1697 QString & theOutTypeName)
1699 SMESH_TypeFilter aTypeFilter( theType );
1701 if( !theIO.IsNull() )
1703 entry = theIO->getEntry();
1704 LightApp_DataOwner owner( entry );
1705 if ( aTypeFilter.isOk( &owner )) {
1706 theOutTypeName = theInTypeName;
1714 QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1716 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1717 _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1719 _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1720 CORBA::String_var anID = aSComp->GetID().c_str();
1721 if (!strcmp(anID.in(),theIO->getEntry()))
1727 CheckOIType ( theIO, SMESH::HYPOTHESIS, "Hypothesis", aTypeName ) ||
1728 CheckOIType ( theIO, SMESH::ALGORITHM, "Algorithm", aTypeName ) ||
1729 CheckOIType ( theIO, SMESH::MESH, "Mesh", aTypeName ) ||
1730 CheckOIType ( theIO, SMESH::SUBMESH, "SubMesh", aTypeName ) ||
1731 CheckOIType ( theIO, SMESH::GROUP, "Group", aTypeName )
1739 QString CheckHomogeneousSelection()
1741 //SUIT_Study* aStudy = SMESH::GetActiveStudy();
1742 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1743 SALOME_ListIO selected;
1745 aSel->selectedObjects( selected );
1747 QString RefType = CheckTypeObject(selected.First());
1748 SALOME_ListIteratorOfListIO It(selected);
1749 for ( ; It.More(); It.Next())
1751 Handle(SALOME_InteractiveObject) IObject = It.Value();
1752 QString Type = CheckTypeObject(IObject);
1753 if (Type.compare(RefType) != 0)
1754 return "Heterogeneous Selection";
1760 uint randomize( uint size )
1762 static bool initialized = false;
1763 if ( !initialized ) {
1764 qsrand( QDateTime::currentDateTime().toTime_t() );
1768 v = uint( (double)( v ) / RAND_MAX * size );
1769 v = qMax( uint(0), qMin ( v, size-1 ) );
1775 void SMESHGUI::OnEditDelete()
1777 // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1778 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1779 SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1781 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1782 _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1783 _PTR(GenericAttribute) anAttr;
1784 _PTR(AttributeIOR) anIOR;
1786 int objectCount = 0;
1788 QString aParentComponent = QString::null;
1789 Handle(SALOME_InteractiveObject) anIO;
1790 for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1792 anIO = anIt.Value();
1793 QString cur = anIO->getComponentDataType();
1794 _PTR(SObject) aSO = aStudy->FindObjectID(anIO->getEntry());
1796 // check if object is reference
1797 _PTR(SObject) aRefSObj;
1798 aNameList.append("\n - ");
1799 if ( aSO->ReferencedObject( aRefSObj ) ) {
1800 QString aRefName = QString::fromStdString ( aRefSObj->GetName() );
1801 aNameList.append( aRefName );
1802 cur = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1805 aNameList.append(anIO->getName());
1809 if( aParentComponent.isNull() )
1810 aParentComponent = cur;
1811 else if( !aParentComponent.isEmpty() && aParentComponent!=cur )
1812 aParentComponent = "";
1815 if ( objectCount == 0 )
1816 return; // No Valid Objects Selected
1818 if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
1819 SUIT_MessageBox::warning( SMESHGUI::desktop(),
1820 QObject::tr("ERR_ERROR"),
1821 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
1824 // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
1825 if (SUIT_MessageBox::warning
1826 (SMESHGUI::desktop(),
1827 QObject::tr("SMESH_WRN_WARNING"),
1828 QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
1829 SUIT_MessageBox::Yes | SUIT_MessageBox::No,
1830 SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
1833 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1835 // Put the whole hierarchy of sub-objects of the selected SO's into a list and
1836 // then treat them all starting from the deepest objects (at list back)
1837 std::list< _PTR(SObject) > listSO;
1838 SALOME_ListIteratorOfListIO It(selected);
1839 for( ; It.More(); It.Next()) // loop on selected IO's
1841 Handle(SALOME_InteractiveObject) IObject = It.Value();
1842 if(IObject->hasEntry()) {
1843 _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
1845 // disable removal of "SMESH" component object
1846 if(aSO->FindAttribute(anAttr, "AttributeIOR")){
1848 if ( engineIOR() == anIOR->Value().c_str() )
1851 //Check the referenced object
1852 _PTR(SObject) aRefSObject;
1853 if ( aSO && aSO->ReferencedObject( aRefSObject ) )
1854 aSO = aRefSObject; // Delete main Object instead of reference
1856 listSO.push_back( aSO );
1857 std::list< _PTR(SObject) >::iterator itSO = --listSO.end();
1858 for ( ; itSO != listSO.end(); ++itSO ) {
1859 _PTR(ChildIterator) it = aStudy->NewChildIterator( *itSO );
1860 for (it->InitEx(false); it->More(); it->Next())
1861 listSO.push_back( it->Value() );
1865 // Check if none of objects to delete is referred from outside
1866 std::list< _PTR(SObject) >::reverse_iterator ritSO;
1867 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1869 _PTR(SObject) SO = *ritSO;
1870 if ( !SO ) continue;
1871 std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( *ritSO );
1872 for (size_t i = 0; i < aReferences.size(); i++) {
1873 _PTR(SComponent) aComponent = aReferences[i]->GetFatherComponent();
1874 std::string type = aComponent->ComponentDataType();
1875 if ( type != "SMESH" )
1877 SUIT_MessageBox::warning( anApp->desktop(),
1878 QObject::tr("WRN_WARNING"),
1879 QObject::tr("DEP_OBJECT") );
1880 return; // outside SMESH, there is an object depending on a SMESH object
1885 // Call mesh->Clear() to prevent loading mesh from file caused by hypotheses removal
1886 for( It.Initialize( selected ); It.More(); It.Next()) // loop on selected IO's
1888 Handle(SALOME_InteractiveObject) IObject = It.Value();
1889 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface< SMESH::SMESH_Mesh >( IObject );
1890 if ( !mesh->_is_nil() )
1894 // Treat SO's in the list starting from the back
1895 aStudyBuilder->NewCommand(); // There is a transaction
1896 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1898 _PTR(SObject) SO = *ritSO;
1899 if ( !SO ) continue;
1900 std::string anEntry = SO->GetID();
1902 /** Erase graphical object and remove all its data **/
1903 if(SO->FindAttribute(anAttr, "AttributeIOR")) {
1904 SMESH::RemoveVisualObjectWithActors( anEntry.c_str(), true);
1906 /** Remove an object from data structures **/
1907 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
1908 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
1909 if ( !aGroup->_is_nil() ) { // DELETE GROUP
1910 SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
1911 aMesh->RemoveGroup( aGroup );
1913 else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
1914 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
1915 aMesh->RemoveSubMesh( aSubMesh );
1917 _PTR(SObject) aMeshSO = SMESH::FindSObject(aMesh);
1919 SMESH::ModifiedMesh(aMeshSO, false, aMesh->NbNodes()==0);
1922 Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
1923 ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
1924 QString objType = CheckTypeObject(IObject);
1925 if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
1926 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
1927 aStudyBuilder->RemoveObjectWithChildren( SO );
1929 else {// default action: remove SObject from the study
1930 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
1931 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
1933 aStudyBuilder->RemoveObjectWithChildren( SO );
1937 } /* listSO back loop */
1939 aStudyBuilder->CommitCommand();
1941 /* Clear any previous selection */
1943 aSel->setSelectedObjects( l1 );
1945 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1949 SMESHGUI_EXPORT CAM_Module* createModule()
1951 return new SMESHGUI();
1954 SMESHGUI_EXPORT char* getModuleVersion() {
1955 return (char*)SMESH_VERSION_STR;
1959 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
1961 //=============================================================================
1965 //=============================================================================
1966 SMESHGUI::SMESHGUI() :
1967 SalomeApp_Module( "SMESH" )
1969 if ( CORBA::is_nil( myComponentSMESH ) )
1971 CORBA::Boolean anIsEmbeddedMode;
1972 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
1973 MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
1975 // 0019923: EDF 765 SMESH : default values of hypothesis
1976 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
1977 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
1978 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
1979 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
1980 myComponentSMESH->SetDefaultNbSegments( nbSeg );
1982 const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif" };
1983 for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
1984 if ( aResourceMgr->hasValue( "SMESH", options[i] ))
1986 QString val = aResourceMgr->stringValue( "SMESH", options[i] );
1987 myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
1991 myActiveDialogBox = 0;
1992 myFilterLibraryDlg = 0;
1996 myEventCallbackCommand = vtkCallbackCommand::New();
1997 myEventCallbackCommand->Delete();
1998 myEventCallbackCommand->SetClientData( this );
1999 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
2002 /* load resources for all available meshers */
2003 SMESH::InitAvailableHypotheses();
2006 //=============================================================================
2010 //=============================================================================
2011 SMESHGUI::~SMESHGUI()
2015 //=============================================================================
2019 //=============================================================================
2020 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
2022 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2024 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
2029 //=============================================================================
2033 //=============================================================================
2034 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
2036 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2040 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2041 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2042 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2043 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2044 return autoUpdate && !exceeded;
2047 //=============================================================================
2051 //=============================================================================
2052 bool SMESHGUI::automaticUpdate( SMESH::SMESH_IDSource_ptr theMesh,
2053 int* entities, bool* limitExceeded, int* hidden, long* nbElements )
2055 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2059 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2060 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2061 bool incrementalLimit = resMgr->booleanValue( "SMESH", "incremental_limit", false );
2063 SMESH::long_array_var info = theMesh->GetMeshInfo();
2064 long nbOdElems = info[SMDSEntity_0D];
2065 long nbEdges = info[SMDSEntity_Edge] + info[SMDSEntity_Quad_Edge];
2066 long nbFaces = info[SMDSEntity_Triangle] + info[SMDSEntity_Quad_Triangle] + info[SMDSEntity_BiQuad_Triangle] +
2067 info[SMDSEntity_Quadrangle] + info[SMDSEntity_Quad_Quadrangle] + info[SMDSEntity_BiQuad_Quadrangle] +
2068 info[SMDSEntity_Polygon];
2069 long nbVolumes = info[SMDSEntity_Tetra] + info[SMDSEntity_Quad_Tetra] +
2070 info[SMDSEntity_Hexa] + info[SMDSEntity_Quad_Hexa] + info[SMDSEntity_TriQuad_Hexa] +
2071 info[SMDSEntity_Pyramid] + info[SMDSEntity_Quad_Pyramid] +
2072 info[SMDSEntity_Penta] + info[SMDSEntity_Quad_Penta] +
2073 info[SMDSEntity_Polyhedra] +
2074 info[SMDSEntity_Hexagonal_Prism];
2075 long nbBalls = info[SMDSEntity_Ball];
2077 long requestedSize = nbOdElems + nbBalls + nbEdges + nbFaces + nbVolumes;
2078 *nbElements = requestedSize;
2080 *entities = SMESH_Actor::eAllEntity;
2083 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2085 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2087 if ( incrementalLimit ) {
2090 if ( nbOdElems > 0 ) {
2091 if ( total + nbOdElems > updateLimit ) {
2092 *entities = *entities & ~SMESH_Actor::e0DElements;
2093 *hidden = *hidden | SMESH_Actor::e0DElements;
2100 if ( nbEdges > 0 ) {
2101 if ( total + nbEdges > updateLimit ) {
2102 *entities = *entities & ~SMESH_Actor::eEdges;
2103 *hidden = *hidden | SMESH_Actor::eEdges;
2110 if ( nbFaces > 0 ) {
2111 if ( total + nbFaces > updateLimit ) {
2112 *entities = *entities & ~SMESH_Actor::eFaces;
2113 *hidden = *hidden | SMESH_Actor::eFaces;
2120 if ( nbVolumes > 0 ) {
2121 if ( total + nbVolumes > updateLimit ) {
2122 *entities = *entities & ~SMESH_Actor::eVolumes;
2123 *hidden = *hidden | SMESH_Actor::eVolumes;
2130 if ( nbBalls > 0 ) {
2131 if ( total + nbBalls > updateLimit ) {
2132 *entities = *entities & ~SMESH_Actor::eBallElem;
2133 *hidden = *hidden | SMESH_Actor::eBallElem;
2141 return autoUpdate && !exceeded;
2144 //=============================================================================
2148 //=============================================================================
2149 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
2151 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
2154 //=============================================================================
2158 //=============================================================================
2159 SMESHGUI* SMESHGUI::GetSMESHGUI()
2161 SMESHGUI* smeshMod = 0;
2162 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
2165 CAM_Module* module = app->module( "Mesh" );
2166 smeshMod = dynamic_cast<SMESHGUI*>( module );
2169 if ( smeshMod && smeshMod->application() && smeshMod->application()->activeStudy() )
2171 SalomeApp_Study* study = dynamic_cast<SalomeApp_Study*>( smeshMod->application()->activeStudy() );
2174 _PTR(Study) aStudy = study->studyDS();
2176 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
2185 Standard_EXPORT SMESHGUI* GetComponentGUI()
2187 return SMESHGUI::GetSMESHGUI();
2191 //=============================================================================
2195 //=============================================================================
2196 void SMESHGUI::SetState(int aState)
2201 //=============================================================================
2205 //=============================================================================
2206 void SMESHGUI::ResetState()
2211 //=============================================================================
2215 //=============================================================================
2216 void SMESHGUI::EmitSignalDeactivateDialog()
2218 emit SignalDeactivateActiveDialog();
2221 //=============================================================================
2225 //=============================================================================
2226 void SMESHGUI::EmitSignalStudyFrameChanged()
2228 emit SignalStudyFrameChanged();
2231 //=============================================================================
2235 //=============================================================================
2236 void SMESHGUI::EmitSignalCloseAllDialogs()
2238 emit SignalCloseAllDialogs();
2241 //=============================================================================
2245 //=============================================================================
2246 void SMESHGUI::EmitSignalVisibilityChanged()
2248 emit SignalVisibilityChanged();
2251 //=============================================================================
2255 //=============================================================================
2256 QDialog *SMESHGUI::GetActiveDialogBox()
2258 return myActiveDialogBox;
2261 //=============================================================================
2265 //=============================================================================
2266 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2268 myActiveDialogBox = (QDialog *) aDlg;
2272 //=============================================================================
2276 //=============================================================================
2277 SUIT_Desktop* SMESHGUI::desktop()
2279 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2281 return app->desktop();
2286 //=============================================================================
2290 //=============================================================================
2291 SalomeApp_Study* SMESHGUI::activeStudy()
2293 SUIT_Application* app = SUIT_Session::session()->activeApplication();
2295 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2300 //=============================================================================
2304 //=============================================================================
2305 void SMESHGUI::Modified( bool theIsUpdateActions )
2307 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2308 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2309 appStudy->Modified();
2310 if( theIsUpdateActions )
2311 app->updateActions();
2316 //=============================================================================
2320 //=============================================================================
2321 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2323 /* Here the position is on the bottom right corner - 10 */
2324 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2326 SUIT_Desktop *PP = desktop();
2327 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2328 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2332 //=============================================================================
2336 //=============================================================================
2337 static int isStudyLocked(_PTR(Study) theStudy){
2338 return theStudy->GetProperties()->IsLocked();
2341 static bool checkLock(_PTR(Study) theStudy) {
2342 if (isStudyLocked(theStudy)) {
2343 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2344 QObject::tr("WRN_WARNING"),
2345 QObject::tr("WRN_STUDY_LOCKED") );
2351 //=======================================================================
2352 //function : CheckActiveStudyLocked
2354 //=======================================================================
2356 bool SMESHGUI::isActiveStudyLocked()
2358 _PTR(Study) aStudy = activeStudy()->studyDS();
2359 return checkLock( aStudy );
2362 //=============================================================================
2366 //=============================================================================
2367 bool SMESHGUI::OnGUIEvent( int theCommandID )
2369 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2373 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
2374 SUIT_ResourceMgr* mgr = resourceMgr();
2378 if (CORBA::is_nil(GetSMESHGen()->GetCurrentStudy())) {
2379 GetSMESHGen()->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
2382 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2383 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2385 //QAction* act = action( theCommandID );
2387 switch (theCommandID) {
2388 case SMESHOp::OpDelete:
2389 if(checkLock(aStudy)) break;
2392 case SMESHOp::OpImportDAT:
2393 case SMESHOp::OpImportUNV:
2394 case SMESHOp::OpImportMED:
2395 case SMESHOp::OpImportSTL:
2397 case SMESHOp::OpImportCGNS:
2399 case SMESHOp::OpImportSAUV:
2400 case SMESHOp::OpImportGMF:
2402 if(checkLock(aStudy)) break;
2403 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2407 case SMESHOp::OpFileInformation:
2409 SALOME_ListIO selected;
2410 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2412 aSel->selectedObjects( selected );
2413 if( selected.Extent() )
2415 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2416 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2417 if ( !aMesh->_is_nil() )
2419 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2425 case SMESHOp::OpExportDAT:
2426 case SMESHOp::OpExportMED:
2427 case SMESHOp::OpExportUNV:
2428 case SMESHOp::OpExportSTL:
2430 case SMESHOp::OpExportCGNS:
2432 case SMESHOp::OpExportSAUV:
2433 case SMESHOp::OpExportGMF:
2434 case SMESHOp::OpPopupExportDAT:
2435 case SMESHOp::OpPopupExportMED:
2436 case SMESHOp::OpPopupExportUNV:
2437 case SMESHOp::OpPopupExportSTL:
2439 case SMESHOp::OpPopupExportCGNS:
2441 case SMESHOp::OpPopupExportSAUV:
2442 case SMESHOp::OpPopupExportGMF:
2444 ::ExportMeshToFile(theCommandID);
2448 case SMESHOp::OpReset: // SCALAR BAR
2450 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2451 SALOME_ListIO selected;
2453 aSel->selectedObjects( selected );
2455 if( selected.Extent() ) {
2456 Handle(SALOME_InteractiveObject) anIO = selected.First();
2457 if( anIO->hasEntry() ) {
2458 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2459 anActor->SetControlMode( SMESH_Actor::eNone );
2460 #ifndef DISABLE_PLOT2DVIEWER
2461 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2468 case SMESHOp::OpScalarBarProperties:
2470 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2473 case SMESHOp::OpSaveDistribution:
2475 // dump control distribution data to the text file
2476 ::SaveDistribution();
2480 case SMESHOp::OpShowDistribution:
2482 // show/ distribution
2483 ::ShowDistribution();
2487 #ifndef DISABLE_PLOT2DVIEWER
2488 case SMESHOp::OpPlotDistribution:
2490 // plot distribution
2491 ::PlotDistribution();
2497 case SMESHOp::OpAutoColor:
2501 case SMESHOp::OpDisableAutoColor:
2502 ::DisableAutoColor();
2505 case SMESHOp::OpClipping:
2506 case SMESHOp::OpTransparency:
2507 case SMESHOp::OpProperties: // Display preferences (colors, shrink size, line width, ...)
2510 case SMESHOp::OpDMWireframe:
2511 case SMESHOp::OpDMShading:
2512 case SMESHOp::OpDMNodes:
2513 case SMESHOp::OpDMShrink:
2514 ::SetDisplayMode(theCommandID, myMarkerMap);
2517 //2D quadratic representation
2518 case SMESHOp::OpRepresentationLines:
2519 case SMESHOp::OpRepresentationArcs:
2520 ::SetDisplayMode(theCommandID, myMarkerMap);
2524 case SMESHOp::OpDE0DElements:
2525 case SMESHOp::OpDEEdges:
2526 case SMESHOp::OpDEFaces:
2527 case SMESHOp::OpDEVolumes:
2528 case SMESHOp::OpDEBalls:
2529 case SMESHOp::OpDEAllEntity:
2530 ::SetDisplayEntity(theCommandID);
2533 // Choose entities to be displayed
2534 case SMESHOp::OpDEChoose:
2536 ( new SMESHGUI_DisplayEntitiesDlg( SMESHGUI::desktop() ) )->exec();
2540 case SMESHOp::OpOrientationOnFaces:
2542 LightApp_SelectionMgr* mgr = selectionMgr();
2543 SALOME_ListIO selected; mgr->selectedObjects( selected );
2545 SALOME_ListIteratorOfListIO it(selected);
2546 for( ; it.More(); it.Next()) {
2547 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2548 if(anIObject->hasEntry()) {
2549 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2550 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2557 case SMESHOp::OpUpdate:
2559 if(checkLock(aStudy)) break;
2560 SUIT_OverrideCursor wc;
2562 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2565 SMESH::UpdateView();
2567 catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2568 SMESH::OnVisuException();
2570 catch (...) { // PAL16774 (Crash after display of many groups)
2571 SMESH::OnVisuException();
2575 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2576 aSel->selectedObjects( l );
2577 aSel->setSelectedObjects( l );
2581 case SMESHOp::OpHide:
2582 case SMESHOp::OpShow:
2583 case SMESHOp::OpShowOnly:
2585 SMESH::EDisplaing anAction;
2586 switch (theCommandID) {
2587 case SMESHOp::OpHide: anAction = SMESH::eErase; break;
2588 case SMESHOp::OpShow: anAction = SMESH::eDisplay; break;
2589 case SMESHOp::OpShowOnly: anAction = SMESH::eDisplayOnly; break;
2592 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2593 SALOME_ListIO sel_objects, to_process;
2595 aSel->selectedObjects( sel_objects );
2597 if( theCommandID==SMESHOp::OpShowOnly )
2599 MESSAGE("anAction = SMESH::eDisplayOnly");
2600 startOperation( myEraseAll );
2603 extractContainers( sel_objects, to_process );
2606 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2610 SALOME_ListIteratorOfListIO It( to_process );
2611 for ( ; It.More(); It.Next()) {
2613 Handle(SALOME_InteractiveObject) IOS = It.Value();
2614 if (IOS->hasEntry()) {
2616 if (!SMESH::UpdateView(anAction, IOS->getEntry())) {
2617 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2618 break; // PAL16774 (Crash after display of many groups)
2620 if (anAction == SMESH::eDisplayOnly)
2622 MESSAGE("anAction = SMESH::eDisplayOnly");
2623 anAction = SMESH::eDisplay;
2629 // PAL13338 + PAL15161 -->
2630 if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !checkLock(aStudy)) {
2631 MESSAGE("anAction = SMESH::eDisplayOnly");
2632 SMESH::UpdateView();
2633 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2635 // PAL13338 + PAL15161 <--
2637 catch (...) { // PAL16774 (Crash after display of many groups)
2638 SMESH::OnVisuException();
2641 if (anAction == SMESH::eErase) {
2642 MESSAGE("anAction == SMESH::eErase");
2644 aSel->setSelectedObjects( l1 );
2647 aSel->setSelectedObjects( to_process );
2652 case SMESHOp::OpNode:
2654 if(checkLock(aStudy)) break;
2657 EmitSignalDeactivateDialog();
2659 ( new SMESHGUI_NodesDlg( this ) )->show();
2662 SUIT_MessageBox::warning(desktop(),
2663 tr("SMESH_WRN_WARNING"),
2664 tr("SMESH_WRN_VIEWER_VTK"));
2669 case SMESHOp::OpCreateMesh:
2670 case SMESHOp::OpCreateSubMesh:
2671 case SMESHOp::OpEditMeshOrSubMesh:
2672 case SMESHOp::OpCompute:
2673 case SMESHOp::OpPreCompute:
2674 case SMESHOp::OpEvaluate:
2675 case SMESHOp::OpMeshOrder:
2676 startOperation( theCommandID );
2678 case SMESHOp::OpCopyMesh:
2680 if (checkLock(aStudy)) break;
2681 EmitSignalDeactivateDialog();
2682 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2685 case SMESHOp::OpBuildCompoundMesh:
2687 if (checkLock(aStudy)) break;
2688 EmitSignalDeactivateDialog();
2689 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2693 case SMESHOp::OpDiagonalInversion:
2694 case SMESHOp::OpUnionOfTwoTriangle:
2698 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2699 tr( "NOT_A_VTK_VIEWER" ) );
2703 if ( checkLock( aStudy ) )
2706 /*Standard_Boolean aRes;
2707 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2708 if ( aMesh->_is_nil() )
2710 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2711 tr( "SMESH_BAD_SELECTION" ) );
2715 EmitSignalDeactivateDialog();
2716 if ( theCommandID == SMESHOp::OpDiagonalInversion )
2717 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2719 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2722 case SMESHOp::OpOrientation:
2723 case SMESHOp::OpUnionOfTriangles:
2724 case SMESHOp::OpCuttingOfQuadrangles:
2725 case SMESHOp::OpSplitVolumes:
2729 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2730 tr( "NOT_A_VTK_VIEWER" ) );
2734 if ( checkLock( aStudy ) )
2737 EmitSignalDeactivateDialog();
2738 SMESHGUI_MultiEditDlg* aDlg = NULL;
2739 if ( theCommandID == SMESHOp::OpOrientation )
2740 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2741 else if ( theCommandID == SMESHOp::OpUnionOfTriangles )
2742 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2743 else if ( theCommandID == SMESHOp::OpSplitVolumes )
2744 aDlg = new SMESHGUI_SplitVolumesDlg(this);
2746 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2751 case SMESHOp::OpSmoothing:
2753 if(checkLock(aStudy)) break;
2755 EmitSignalDeactivateDialog();
2756 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2759 SUIT_MessageBox::warning(desktop(),
2760 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2764 case SMESHOp::OpExtrusion:
2766 if (checkLock(aStudy)) break;
2768 EmitSignalDeactivateDialog();
2769 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2771 SUIT_MessageBox::warning(desktop(),
2772 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2776 case SMESHOp::OpExtrusionAlongAPath:
2778 if (checkLock(aStudy)) break;
2780 EmitSignalDeactivateDialog();
2781 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2783 SUIT_MessageBox::warning(desktop(),
2784 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2788 case SMESHOp::OpRevolution:
2790 if(checkLock(aStudy)) break;
2792 EmitSignalDeactivateDialog();
2793 ( new SMESHGUI_RevolutionDlg( this ) )->show();
2796 SUIT_MessageBox::warning(desktop(),
2797 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2801 case SMESHOp::OpPatternMapping:
2803 if ( checkLock( aStudy ) )
2807 EmitSignalDeactivateDialog();
2808 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2811 SUIT_MessageBox::warning(desktop(),
2812 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2816 case SMESHOp::OpConvertMeshToQuadratic:
2817 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
2818 case SMESHOp::OpReorientFaces:
2819 case SMESHOp::OpCreateGeometryGroup:
2821 startOperation( theCommandID );
2824 case SMESHOp::OpCreateGroup:
2828 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2829 tr( "NOT_A_VTK_VIEWER" ) );
2833 if(checkLock(aStudy)) break;
2834 EmitSignalDeactivateDialog();
2835 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2837 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2838 SALOME_ListIO selected;
2840 aSel->selectedObjects( selected );
2842 int nbSel = selected.Extent();
2844 // check if mesh is selected
2845 aMesh = SMESH::GetMeshByIO( selected.First() );
2847 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2852 case SMESHOp::OpConstructGroup:
2856 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2857 tr( "NOT_A_VTK_VIEWER" ) );
2861 if(checkLock(aStudy)) break;
2862 EmitSignalDeactivateDialog();
2864 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2865 SALOME_ListIO selected;
2867 aSel->selectedObjects( selected );
2869 int nbSel = selected.Extent();
2871 // check if submesh is selected
2872 Handle(SALOME_InteractiveObject) IObject = selected.First();
2873 if (IObject->hasEntry()) {
2874 _PTR(SObject) aSObj = aStudy->FindObjectID(IObject->getEntry());
2876 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2877 if (!aSubMesh->_is_nil()) {
2879 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2880 // get submesh elements list by types
2881 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2882 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2883 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2884 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2885 // create group for each type o elements
2886 QString aName = IObject->getName();
2887 QStringList anEntryList;
2888 if (aNodes->length() > 0) {
2889 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2890 aGroup->Add(aNodes.inout());
2891 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2892 anEntryList.append( aSObject->GetID().c_str() );
2894 if (aEdges->length() > 0) {
2895 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2896 aGroup->Add(aEdges.inout());
2897 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2898 anEntryList.append( aSObject->GetID().c_str() );
2900 if (aFaces->length() > 0) {
2901 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2902 aGroup->Add(aFaces.inout());
2903 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2904 anEntryList.append( aSObject->GetID().c_str() );
2906 if (aVolumes->length() > 0) {
2907 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2908 aGroup->Add(aVolumes.inout());
2909 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2910 anEntryList.append( aSObject->GetID().c_str() );
2913 anApp->browseObjects( anEntryList );
2915 catch(const SALOME::SALOME_Exception & S_ex){
2916 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2923 SUIT_MessageBox::warning(desktop(),
2924 tr("SMESH_WRN_WARNING"),
2925 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
2930 case SMESHOp::OpEditGroup:
2934 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2935 tr( "NOT_A_VTK_VIEWER" ) );
2939 if(checkLock(aStudy)) break;
2940 EmitSignalDeactivateDialog();
2942 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2943 SALOME_ListIO selected;
2945 aSel->selectedObjects( selected );
2947 SALOME_ListIteratorOfListIO It (selected);
2948 int nbSelectedGroups = 0;
2949 for ( ; It.More(); It.Next() )
2951 SMESH::SMESH_GroupBase_var aGroup =
2952 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
2953 if (!aGroup->_is_nil()) {
2955 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
2959 if (nbSelectedGroups == 0)
2961 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
2967 case SMESHOp::OpAddElemGroupPopup: // Add elements to group
2969 if(checkLock(aStudy)) break;
2970 if (myState == 800) {
2971 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2972 if (aDlg) aDlg->onAdd();
2977 case SMESHOp::OpRemoveElemGroupPopup: // Remove elements from group
2979 if(checkLock(aStudy)) break;
2980 if (myState == 800) {
2981 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2982 if (aDlg) aDlg->onRemove();
2987 case SMESHOp::OpEditGeomGroupAsGroup:
2991 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2992 tr( "NOT_A_VTK_VIEWER" ) );
2996 if(checkLock(aStudy)) break;
2997 EmitSignalDeactivateDialog();
2999 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3000 SALOME_ListIO selected;
3002 aSel->selectedObjects( selected );
3004 SALOME_ListIteratorOfListIO It (selected);
3005 for ( ; It.More(); It.Next() )
3007 SMESH::SMESH_GroupOnGeom_var aGroup =
3008 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
3009 if (!aGroup->_is_nil()) {
3010 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3015 SMESH::SMESH_GroupOnFilter_var aGroup =
3016 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
3017 if (!aGroup->_is_nil()) {
3018 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3026 case SMESHOp::OpUnionGroups:
3027 case SMESHOp::OpIntersectGroups:
3028 case SMESHOp::OpCutGroups:
3032 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
3033 tr( "NOT_A_VTK_VIEWER" ) );
3037 if ( checkLock( aStudy ) )
3040 EmitSignalDeactivateDialog();
3042 SMESHGUI_GroupOpDlg* aDlg = 0;
3043 if ( theCommandID == SMESHOp::OpUnionGroups )
3044 aDlg = new SMESHGUI_UnionGroupsDlg( this );
3045 else if ( theCommandID == SMESHOp::OpIntersectGroups )
3046 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3048 aDlg = new SMESHGUI_CutGroupsDlg( this );
3055 case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
3057 if ( checkLock( aStudy ) )
3060 EmitSignalDeactivateDialog();
3061 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3067 case SMESHOp::OpDeleteGroup: // Delete groups with their contents
3071 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
3072 tr( "NOT_A_VTK_VIEWER" ) );
3076 if ( checkLock( aStudy ) )
3079 EmitSignalDeactivateDialog();
3081 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3085 case SMESHOp::OpMeshInformation:
3086 case SMESHOp::OpWhatIs:
3088 int page = theCommandID == SMESHOp::OpMeshInformation ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3089 EmitSignalDeactivateDialog();
3090 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3091 SALOME_ListIO selected;
3093 aSel->selectedObjects( selected );
3095 if ( selected.Extent() > 1 ) { // a dlg for each IO
3096 SALOME_ListIteratorOfListIO It( selected );
3097 for ( ; It.More(); It.Next() ) {
3098 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3099 dlg->showInfo( It.Value() );
3104 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3110 case SMESHOp::OpFindElementByPoint:
3112 startOperation( theCommandID );
3116 case SMESHOp::OpEditHypothesis:
3118 if(checkLock(aStudy)) break;
3120 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3121 SALOME_ListIO selected;
3123 aSel->selectedObjects( selected );
3125 int nbSel = selected.Extent();
3128 Handle(SALOME_InteractiveObject) anIObject = selected.First();
3129 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3131 if ( !aHypothesis->_is_nil() )
3133 SMESHGUI_GenericHypothesisCreator* aCreator =
3134 SMESH::GetHypothesisCreator( SMESH::toQStr( aHypothesis->GetName() ));
3137 // set geometry of mesh and sub-mesh to aCreator
3138 aSel->selectedObjects( selected, "", /*convertReferences=*/false);
3139 if ( selected.Extent() == 1 )
3141 QString subGeomID, meshGeomID;
3142 Handle(SALOME_InteractiveObject) hypIO = selected.First();
3143 if ( SMESH::GetGeomEntries( hypIO, subGeomID, meshGeomID ))
3145 if ( subGeomID.isEmpty() ) subGeomID = meshGeomID;
3146 aCreator->setShapeEntry( subGeomID );
3147 aCreator->setMainShapeEntry( meshGeomID );
3151 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3161 case SMESHOp::OpUnassign: // REMOVE HYPOTHESIS / ALGORITHMS
3163 if(checkLock(aStudy)) break;
3164 SUIT_OverrideCursor wc;
3166 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3167 SALOME_ListIO selected;
3169 aSel->selectedObjects( selected, QString::null, false );
3171 SALOME_ListIteratorOfListIO It(selected);
3172 for (int i = 0; It.More(); It.Next(), i++) {
3173 Handle(SALOME_InteractiveObject) IObject = It.Value();
3174 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3177 aSel->setSelectedObjects( l1 );
3182 case SMESHOp::OpElem0D:
3183 case SMESHOp::OpBall:
3184 case SMESHOp::OpEdge:
3185 case SMESHOp::OpTriangle:
3186 case SMESHOp::OpQuadrangle:
3187 case SMESHOp::OpPolygon:
3188 case SMESHOp::OpTetrahedron:
3189 case SMESHOp::OpHexahedron:
3190 case SMESHOp::OpPentahedron:
3191 case SMESHOp::OpPyramid:
3192 case SMESHOp::OpHexagonalPrism:
3194 if(checkLock(aStudy)) break;
3196 EmitSignalDeactivateDialog();
3197 SMDSAbs_EntityType type = SMDSEntity_Edge;
3198 switch (theCommandID) {
3199 case SMESHOp::OpElem0D: type = SMDSEntity_0D; break;
3200 case SMESHOp::OpBall: type = SMDSEntity_Ball; break;
3201 case SMESHOp::OpTriangle: type = SMDSEntity_Triangle; break;
3202 case SMESHOp::OpQuadrangle: type = SMDSEntity_Quadrangle; break;
3203 case SMESHOp::OpTetrahedron: type = SMDSEntity_Tetra; break;
3204 case SMESHOp::OpPolygon: type = SMDSEntity_Polygon; break;
3205 case SMESHOp::OpHexahedron: type = SMDSEntity_Hexa; break;
3206 case SMESHOp::OpPentahedron: type = SMDSEntity_Penta; break;
3207 case SMESHOp::OpPyramid: type = SMDSEntity_Pyramid; break;
3208 case SMESHOp::OpHexagonalPrism: type = SMDSEntity_Hexagonal_Prism; break;
3211 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3214 SUIT_MessageBox::warning(desktop(),
3215 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3219 case SMESHOp::OpPolyhedron:
3221 if(checkLock(aStudy)) break;
3223 EmitSignalDeactivateDialog();
3224 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3227 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3228 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3232 case SMESHOp::OpQuadraticEdge:
3233 case SMESHOp::OpQuadraticTriangle:
3234 case SMESHOp::OpBiQuadraticTriangle:
3235 case SMESHOp::OpQuadraticQuadrangle:
3236 case SMESHOp::OpBiQuadraticQuadrangle:
3237 case SMESHOp::OpQuadraticTetrahedron:
3238 case SMESHOp::OpQuadraticPyramid:
3239 case SMESHOp::OpQuadraticPentahedron:
3240 case SMESHOp::OpQuadraticHexahedron:
3241 case SMESHOp::OpTriQuadraticHexahedron:
3243 if(checkLock(aStudy)) break;
3245 EmitSignalDeactivateDialog();
3246 SMDSAbs_EntityType type = SMDSEntity_Last;
3248 switch (theCommandID) {
3249 case SMESHOp::OpQuadraticEdge: type = SMDSEntity_Quad_Edge; break;
3250 case SMESHOp::OpQuadraticTriangle: type = SMDSEntity_Quad_Triangle; break;
3251 case SMESHOp::OpBiQuadraticTriangle: type = SMDSEntity_BiQuad_Triangle; break;
3252 case SMESHOp::OpQuadraticQuadrangle: type = SMDSEntity_Quad_Quadrangle; break;
3253 case SMESHOp::OpBiQuadraticQuadrangle: type = SMDSEntity_BiQuad_Quadrangle; break;
3254 case SMESHOp::OpQuadraticTetrahedron: type = SMDSEntity_Quad_Tetra; break;
3255 case SMESHOp::OpQuadraticPyramid: type = SMDSEntity_Quad_Pyramid; break;
3256 case SMESHOp::OpQuadraticPentahedron: type = SMDSEntity_Quad_Penta; break;
3257 case SMESHOp::OpQuadraticHexahedron: type = SMDSEntity_Quad_Hexa; break;
3258 case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
3261 if ( type != SMDSEntity_Last )
3262 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3265 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3266 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3270 case SMESHOp::OpRemoveNodes:
3272 if(checkLock(aStudy)) break;
3274 EmitSignalDeactivateDialog();
3275 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3278 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3279 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3283 case SMESHOp::OpRemoveElements: // REMOVES ELEMENTS
3285 if(checkLock(aStudy)) break;
3287 EmitSignalDeactivateDialog();
3288 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3292 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3293 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3297 case SMESHOp::OpClearMesh: {
3299 if(checkLock(aStudy)) break;
3301 SALOME_ListIO selected;
3302 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3303 aSel->selectedObjects( selected );
3305 SUIT_OverrideCursor wc;
3306 SALOME_ListIteratorOfListIO It (selected);
3307 for ( ; It.More(); It.Next() )
3309 Handle(SALOME_InteractiveObject) IOS = It.Value();
3310 SMESH::SMESH_Mesh_var aMesh =
3311 SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3312 if ( aMesh->_is_nil()) continue;
3314 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3316 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3317 SMESH::ModifiedMesh( aMeshSObj, false, true);
3318 // hide groups and submeshes
3319 _PTR(ChildIterator) anIter =
3320 SMESH::GetActiveStudyDocument()->NewChildIterator( aMeshSObj );
3321 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3323 _PTR(SObject) so = anIter->Value();
3324 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3327 catch (const SALOME::SALOME_Exception& S_ex){
3329 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3333 SMESH::UpdateView();
3337 case SMESHOp::OpRemoveOrphanNodes:
3339 if(checkLock(aStudy)) break;
3340 SALOME_ListIO selected;
3341 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3342 aSel->selectedObjects( selected );
3343 if ( selected.Extent() == 1 ) {
3344 Handle(SALOME_InteractiveObject) anIO = selected.First();
3345 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3346 if ( !aMesh->_is_nil() ) {
3347 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3348 tr( "SMESH_WARNING" ),
3349 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3350 SUIT_MessageBox::Yes |
3351 SUIT_MessageBox::No,
3352 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3355 SUIT_OverrideCursor wc;
3356 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3357 int removed = aMeshEditor->RemoveOrphanNodes();
3358 SUIT_MessageBox::information(SMESHGUI::desktop(),
3359 tr("SMESH_INFORMATION"),
3360 tr("NB_NODES_REMOVED").arg(removed));
3361 if ( removed > 0 ) {
3362 SMESH::UpdateView();
3363 SMESHGUI::Modified();
3366 catch (const SALOME::SALOME_Exception& S_ex) {
3367 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3376 case SMESHOp::OpRenumberingNodes:
3378 if(checkLock(aStudy)) break;
3380 EmitSignalDeactivateDialog();
3381 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3385 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3386 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3390 case SMESHOp::OpRenumberingElements:
3392 if(checkLock(aStudy)) break;
3394 EmitSignalDeactivateDialog();
3395 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3399 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3400 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3404 case SMESHOp::OpTranslation:
3406 if(checkLock(aStudy)) break;
3408 EmitSignalDeactivateDialog();
3409 ( new SMESHGUI_TranslationDlg( this ) )->show();
3412 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3413 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3417 case SMESHOp::OpRotation:
3419 if(checkLock(aStudy)) break;
3421 EmitSignalDeactivateDialog();
3422 ( new SMESHGUI_RotationDlg( this ) )->show();
3425 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3426 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3430 case SMESHOp::OpSymmetry:
3432 if(checkLock(aStudy)) break;
3434 EmitSignalDeactivateDialog();
3435 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3438 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3439 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3443 case SMESHOp::OpScale:
3445 if(checkLock(aStudy)) break;
3447 EmitSignalDeactivateDialog();
3448 ( new SMESHGUI_ScaleDlg( this ) )->show();
3451 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3452 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3457 case SMESHOp::OpSewing:
3459 if(checkLock(aStudy)) break;
3461 EmitSignalDeactivateDialog();
3462 ( new SMESHGUI_SewingDlg( this ) )->show();
3465 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3466 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3470 case SMESHOp::OpMergeNodes:
3472 if(checkLock(aStudy)) break;
3474 EmitSignalDeactivateDialog();
3475 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3478 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3479 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3483 case SMESHOp::OpMergeElements:
3485 if (checkLock(aStudy)) break;
3487 EmitSignalDeactivateDialog();
3488 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3490 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3491 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3496 case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
3497 startOperation( SMESHOp::OpMoveNode );
3500 case SMESHOp::OpDuplicateNodes:
3502 if(checkLock(aStudy)) break;
3504 EmitSignalDeactivateDialog();
3505 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3508 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3509 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3514 case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
3515 startOperation( SMESHOp::OpElem0DOnElemNodes );
3518 case SMESHOp::OpSelectFiltersLibrary: // Library of selection filters
3520 static QList<int> aTypes;
3521 if ( aTypes.isEmpty() )
3523 aTypes.append( SMESH::NODE );
3524 aTypes.append( SMESH::EDGE );
3525 aTypes.append( SMESH::FACE );
3526 aTypes.append( SMESH::VOLUME );
3528 if (!myFilterLibraryDlg)
3529 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3530 else if (myFilterLibraryDlg->isHidden())
3531 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3532 myFilterLibraryDlg->raise();
3536 case SMESHOp::OpFreeNode:
3537 case SMESHOp::OpEqualNode:
3538 case SMESHOp::OpFreeEdge:
3539 case SMESHOp::OpFreeBorder:
3540 case SMESHOp::OpLength:
3541 case SMESHOp::OpConnection:
3542 case SMESHOp::OpEqualEdge:
3543 case SMESHOp::OpFreeFace:
3544 case SMESHOp::OpBareBorderFace:
3545 case SMESHOp::OpOverConstrainedFace:
3546 case SMESHOp::OpLength2D:
3547 case SMESHOp::OpConnection2D:
3548 case SMESHOp::OpArea:
3549 case SMESHOp::OpTaper:
3550 case SMESHOp::OpAspectRatio:
3551 case SMESHOp::OpMinimumAngle:
3552 case SMESHOp::OpWarpingAngle:
3553 case SMESHOp::OpSkew:
3554 case SMESHOp::OpMaxElementLength2D:
3555 case SMESHOp::OpEqualFace:
3556 case SMESHOp::OpAspectRatio3D:
3557 case SMESHOp::OpVolume:
3558 case SMESHOp::OpMaxElementLength3D:
3559 case SMESHOp::OpBareBorderVolume:
3560 case SMESHOp::OpOverConstrainedVolume:
3561 case SMESHOp::OpEqualVolume:
3564 LightApp_SelectionMgr* mgr = selectionMgr();
3565 SALOME_ListIO selected; mgr->selectedObjects( selected );
3567 if( !selected.IsEmpty() ) {
3568 SUIT_OverrideCursor wc;
3569 ::Control( theCommandID );
3572 SUIT_MessageBox::warning(desktop(),
3573 tr( "SMESH_WRN_WARNING" ),
3574 tr( "SMESH_BAD_SELECTION" ) );
3578 SUIT_MessageBox::warning(desktop(),
3579 tr( "SMESH_WRN_WARNING" ),
3580 tr( "NOT_A_VTK_VIEWER" ) );
3583 case SMESHOp::OpOverallMeshQuality:
3584 OverallMeshQuality();
3586 case SMESHOp::OpNumberingNodes:
3588 SUIT_OverrideCursor wc;
3589 LightApp_SelectionMgr* mgr = selectionMgr();
3590 SALOME_ListIO selected; mgr->selectedObjects( selected );
3592 SALOME_ListIteratorOfListIO it(selected);
3593 for( ; it.More(); it.Next()) {
3594 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3595 if(anIObject->hasEntry()) {
3596 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3597 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3603 case SMESHOp::OpNumberingElements:
3605 SUIT_OverrideCursor wc;
3606 LightApp_SelectionMgr* mgr = selectionMgr();
3607 SALOME_ListIO selected; mgr->selectedObjects( selected );
3609 SALOME_ListIteratorOfListIO it(selected);
3610 for( ; it.More(); it.Next()) {
3611 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3612 if(anIObject->hasEntry())
3613 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3614 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3619 case SMESHOp::OpPropertiesLength:
3620 case SMESHOp::OpPropertiesArea:
3621 case SMESHOp::OpPropertiesVolume:
3622 case SMESHOp::OpMinimumDistance:
3623 case SMESHOp::OpBoundingBox:
3625 int page = SMESHGUI_MeasureDlg::MinDistance;
3626 if ( theCommandID == SMESHOp::OpBoundingBox )
3627 page = SMESHGUI_MeasureDlg::BoundingBox;
3628 else if ( theCommandID == SMESHOp::OpPropertiesLength )
3629 page = SMESHGUI_MeasureDlg::Length;
3630 else if ( theCommandID == SMESHOp::OpPropertiesArea )
3631 page = SMESHGUI_MeasureDlg::Area;
3632 else if ( theCommandID == SMESHOp::OpPropertiesVolume )
3633 page = SMESHGUI_MeasureDlg::Volume;
3635 EmitSignalDeactivateDialog();
3636 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3640 case SMESHOp::OpSortChild:
3646 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3647 //updateObjBrowser();
3651 //=============================================================================
3655 //=============================================================================
3656 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3661 //=============================================================================
3665 //=============================================================================
3666 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3671 //=============================================================================
3675 //=============================================================================
3676 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3681 //=============================================================================
3682 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3683 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3685 //=============================================================================
3686 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3687 SUIT_ViewWindow* wnd )
3689 if(theIO->hasEntry()){
3690 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3691 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3695 //=======================================================================
3696 // function : createSMESHAction
3698 //=======================================================================
3699 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3700 const int key, const bool toggle, const QString& shortcutAction )
3703 QWidget* parent = application()->desktop();
3704 SUIT_ResourceMgr* resMgr = resourceMgr();
3706 if ( !icon_id.isEmpty() )
3707 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3709 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3710 if ( !pix.isNull() )
3711 icon = QIcon( pix );
3713 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3714 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3715 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3717 createAction( id, tooltip, icon, menu, status_bar, key, parent,
3718 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3721 //=======================================================================
3722 // function : createPopupItem
3724 //=======================================================================
3725 void SMESHGUI::createPopupItem( const int id,
3726 const QString& clients,
3727 const QString& types,
3728 const QString& theRule,
3731 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3732 popupMgr()->insert( action( id ), pId, 0 );
3734 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3735 QString dc = "selcount"; // VSR : insetad of QtxPopupSelection::defSelCountParam()
3736 QString rule = "(%1) and (%2) and (%3)";
3737 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3738 if( clients.isEmpty() )
3739 rule = rule.arg( QString( "true" ) );
3741 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3742 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3745 bool cont = myRules.contains( id );
3747 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3749 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3750 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3753 //=======================================================================
3754 // function : initialize
3756 //=======================================================================
3757 void SMESHGUI::initialize( CAM_Application* app )
3759 SalomeApp_Module::initialize( app );
3761 // SUIT_ResourceMgr* mgr = app->resourceMgr();
3763 /* Automatic Update flag */
3764 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3766 // ----- create actions --------------
3768 //createSMESHAction( SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
3769 createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_I) );
3770 createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
3771 //createSMESHAction( 114, "NUM" );
3772 createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL" );
3774 createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
3776 createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
3777 createSMESHAction( SMESHOp::OpImportGMF, "IMPORT_GMF" );
3778 createSMESHAction( SMESHOp::OpExportDAT, "DAT" );
3779 createSMESHAction( SMESHOp::OpExportMED, "MED" );
3780 createSMESHAction( SMESHOp::OpExportUNV, "UNV" );
3781 createSMESHAction( SMESHOp::OpExportSTL, "STL" );
3783 createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
3785 createSMESHAction( SMESHOp::OpExportSAUV, "SAUV");
3786 createSMESHAction( SMESHOp::OpExportGMF, "GMF" );
3787 createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
3788 createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
3789 createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
3790 createSMESHAction( SMESHOp::OpPopupExportSTL, "STL" );
3792 createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
3794 createSMESHAction( SMESHOp::OpPopupExportSAUV, "SAUV");
3795 createSMESHAction( SMESHOp::OpPopupExportGMF, "GMF" );
3796 createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
3797 createSMESHAction( SMESHOp::OpDelete, "DELETE", "ICON_DELETE", Qt::Key_Delete );
3798 createSMESHAction( SMESHOp::OpSelectFiltersLibrary, "SEL_FILTER_LIB" );
3799 createSMESHAction( SMESHOp::OpCreateMesh, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
3800 createSMESHAction( SMESHOp::OpCreateSubMesh, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
3801 createSMESHAction( SMESHOp::OpEditMeshOrSubMesh, "EDIT_MESHSUBMESH", "ICON_DLG_EDIT_MESH" );
3802 createSMESHAction( SMESHOp::OpBuildCompoundMesh, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
3803 createSMESHAction( SMESHOp::OpCopyMesh, "COPY_MESH", "ICON_COPY_MESH" );
3804 createSMESHAction( SMESHOp::OpCompute, "COMPUTE", "ICON_COMPUTE" );
3805 createSMESHAction( SMESHOp::OpPreCompute, "PRECOMPUTE", "ICON_PRECOMPUTE" );
3806 createSMESHAction( SMESHOp::OpEvaluate, "EVALUATE", "ICON_EVALUATE" );
3807 createSMESHAction( SMESHOp::OpMeshOrder, "MESH_ORDER", "ICON_MESH_ORDER");
3808 createSMESHAction( SMESHOp::OpCreateGroup, "CREATE_GROUP", "ICON_CREATE_GROUP" );
3809 createSMESHAction( SMESHOp::OpCreateGeometryGroup, "CREATE_GEO_GROUP", "ICON_CREATE_GEO_GROUP" );
3810 createSMESHAction( SMESHOp::OpConstructGroup, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
3811 createSMESHAction( SMESHOp::OpEditGroup, "EDIT_GROUP", "ICON_EDIT_GROUP" );
3812 createSMESHAction( SMESHOp::OpEditGeomGroupAsGroup, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3813 createSMESHAction( SMESHOp::OpUnionGroups, "UN_GROUP", "ICON_UNION" );
3814 createSMESHAction( SMESHOp::OpIntersectGroups, "INT_GROUP", "ICON_INTERSECT" );
3815 createSMESHAction( SMESHOp::OpCutGroups, "CUT_GROUP", "ICON_CUT" );
3816 createSMESHAction( SMESHOp::OpGroupUnderlyingElem, "UNDERLYING_ELEMS", "ICON_UNDERLYING_ELEMS" );
3817 createSMESHAction( SMESHOp::OpAddElemGroupPopup, "ADD" );
3818 createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE" );
3819 createSMESHAction( SMESHOp::OpDeleteGroup, "DEL_GROUP", "ICON_DEL_GROUP" );
3820 createSMESHAction( SMESHOp::OpMeshInformation , "ADV_INFO", "ICON_ADV_INFO" );
3821 //createSMESHAction( SMESHOp::OpStdInfo, "STD_INFO", "ICON_STD_INFO" );
3822 //createSMESHAction( SMESHOp::OpWhatIs, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3823 createSMESHAction( SMESHOp::OpFindElementByPoint, "FIND_ELEM", "ICON_FIND_ELEM" );
3825 createSMESHAction( SMESHOp::OpFreeNode, "FREE_NODE", "ICON_FREE_NODE", 0, true );
3826 createSMESHAction( SMESHOp::OpEqualNode, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
3827 createSMESHAction( SMESHOp::OpFreeEdge, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
3828 createSMESHAction( SMESHOp::OpFreeBorder, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
3829 createSMESHAction( SMESHOp::OpLength, "LENGTH", "ICON_LENGTH", 0, true );
3830 createSMESHAction( SMESHOp::OpConnection, "CONNECTION", "ICON_CONNECTION", 0, true );
3831 createSMESHAction( SMESHOp::OpEqualEdge, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
3832 createSMESHAction( SMESHOp::OpFreeFace, "FREE_FACES", "ICON_FREE_FACES", 0, true );
3833 createSMESHAction( SMESHOp::OpBareBorderFace, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
3834 createSMESHAction( SMESHOp::OpOverConstrainedFace, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
3835 createSMESHAction( SMESHOp::OpLength2D, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
3836 createSMESHAction( SMESHOp::OpConnection2D, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
3837 createSMESHAction( SMESHOp::OpArea, "AREA", "ICON_AREA", 0, true );
3838 createSMESHAction( SMESHOp::OpTaper, "TAPER", "ICON_TAPER", 0, true );
3839 createSMESHAction( SMESHOp::OpAspectRatio, "ASPECT", "ICON_ASPECT", 0, true );
3840 createSMESHAction( SMESHOp::OpMinimumAngle, "MIN_ANG", "ICON_ANGLE", 0, true );
3841 createSMESHAction( SMESHOp::OpWarpingAngle, "WARP", "ICON_WARP", 0, true );
3842 createSMESHAction( SMESHOp::OpSkew, "SKEW", "ICON_SKEW", 0, true );
3843 createSMESHAction( SMESHOp::OpMaxElementLength2D, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
3844 createSMESHAction( SMESHOp::OpEqualFace, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
3845 createSMESHAction( SMESHOp::OpAspectRatio3D, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
3846 createSMESHAction( SMESHOp::OpVolume, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
3847 createSMESHAction( SMESHOp::OpMaxElementLength3D, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
3848 createSMESHAction( SMESHOp::OpBareBorderVolume, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
3849 createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
3850 createSMESHAction( SMESHOp::OpEqualVolume, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
3851 createSMESHAction( SMESHOp::OpOverallMeshQuality, "OVERALL_MESH_QUALITY" );
3853 createSMESHAction( SMESHOp::OpNode, "NODE", "ICON_DLG_NODE" );
3854 createSMESHAction( SMESHOp::OpElem0D, "ELEM0D", "ICON_DLG_ELEM0D" );
3855 createSMESHAction( SMESHOp::OpElem0DOnElemNodes, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
3856 createSMESHAction( SMESHOp::OpBall, "BALL", "ICON_DLG_BALL" );
3857 createSMESHAction( SMESHOp::OpEdge, "EDGE", "ICON_DLG_EDGE" );
3858 createSMESHAction( SMESHOp::OpTriangle, "TRIANGLE", "ICON_DLG_TRIANGLE" );
3859 createSMESHAction( SMESHOp::OpQuadrangle, "QUAD", "ICON_DLG_QUADRANGLE" );
3860 createSMESHAction( SMESHOp::OpPolygon, "POLYGON", "ICON_DLG_POLYGON" );
3861 createSMESHAction( SMESHOp::OpTetrahedron, "TETRA", "ICON_DLG_TETRAS" );
3862 createSMESHAction( SMESHOp::OpHexahedron, "HEXA", "ICON_DLG_HEXAS" );
3863 createSMESHAction( SMESHOp::OpPentahedron, "PENTA", "ICON_DLG_PENTA" );
3864 createSMESHAction( SMESHOp::OpPyramid , "PYRAMID", "ICON_DLG_PYRAMID" );
3865 createSMESHAction( SMESHOp::OpHexagonalPrism, "OCTA", "ICON_DLG_OCTA" );
3866 createSMESHAction( SMESHOp::OpPolyhedron, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
3867 createSMESHAction( SMESHOp::OpQuadraticEdge, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
3868 createSMESHAction( SMESHOp::OpQuadraticTriangle, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
3869 createSMESHAction( SMESHOp::OpBiQuadraticTriangle, "BIQUADRATIC_TRIANGLE", "ICON_DLG_BIQUADRATIC_TRIANGLE" );
3870 createSMESHAction( SMESHOp::OpQuadraticQuadrangle, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
3871 createSMESHAction( SMESHOp::OpBiQuadraticQuadrangle, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
3872 createSMESHAction( SMESHOp::OpQuadraticTetrahedron, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
3873 createSMESHAction( SMESHOp::OpQuadraticPyramid, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
3874 createSMESHAction( SMESHOp::OpQuadraticPentahedron, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
3875 createSMESHAction( SMESHOp::OpQuadraticHexahedron, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
3876 createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
3878 createSMESHAction( SMESHOp::OpRemoveNodes, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
3879 createSMESHAction( SMESHOp::OpRemoveElements, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
3880 createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
3881 createSMESHAction( SMESHOp::OpClearMesh, "CLEAR_MESH", "ICON_CLEAR_MESH" );
3883 //createSMESHAction( SMESHOp::OpRenumberingNodes, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
3884 //createSMESHAction( SMESHOp::OpRenumberingElements, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
3886 createSMESHAction( SMESHOp::OpTranslation, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
3887 createSMESHAction( SMESHOp::OpRotation, "ROT", "ICON_DLG_MESH_ROTATION" );
3888 createSMESHAction( SMESHOp::OpSymmetry, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
3889 createSMESHAction( SMESHOp::OpScale, "SCALE", "ICON_DLG_MESH_SCALE" );
3890 createSMESHAction( SMESHOp::OpSewing, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
3891 createSMESHAction( SMESHOp::OpMergeNodes, "MERGE", "ICON_SMESH_MERGE_NODES" );
3892 createSMESHAction( SMESHOp::OpMergeElements, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
3893 createSMESHAction( SMESHOp::OpMoveNode, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
3894 createSMESHAction( SMESHOp::OpDuplicateNodes, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
3895 createSMESHAction( SMESHOp::OpDiagonalInversion, "INV", "ICON_DLG_MESH_DIAGONAL" );
3896 createSMESHAction( SMESHOp::OpUnionOfTwoTriangle, "UNION2", "ICON_UNION2TRI" );
3897 createSMESHAction( SMESHOp::OpOrientation, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
3898 createSMESHAction( SMESHOp::OpReorientFaces, "REORIENT_2D", "ICON_REORIENT_2D" );
3899 createSMESHAction( SMESHOp::OpUnionOfTriangles, "UNION", "ICON_UNIONTRI" );
3900 createSMESHAction( SMESHOp::OpCuttingOfQuadrangles, "CUT", "ICON_CUTQUAD" );
3901 createSMESHAction( SMESHOp::OpSplitVolumes, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
3902 createSMESHAction( SMESHOp::OpSmoothing, "SMOOTH", "ICON_DLG_SMOOTHING" );
3903 createSMESHAction( SMESHOp::OpExtrusion, "EXTRUSION", "ICON_EXTRUSION" );
3904 createSMESHAction( SMESHOp::OpExtrusionAlongAPath, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
3905 createSMESHAction( SMESHOp::OpRevolution, "REVOLUTION", "ICON_REVOLUTION" );
3906 createSMESHAction( SMESHOp::OpPatternMapping, "MAP", "ICON_MAP" );
3907 createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
3908 createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D", "ICON_2D_FROM_3D" );
3910 createSMESHAction( SMESHOp::OpReset, "RESET" );
3911 createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
3912 createSMESHAction( SMESHOp::OpSaveDistribution, "SAVE_DISTRIBUTION" );
3913 createSMESHAction( SMESHOp::OpShowDistribution, "SHOW_DISTRIBUTION","",0, true );
3914 #ifndef DISABLE_PLOT2DVIEWER
3915 createSMESHAction( SMESHOp::OpPlotDistribution, "PLOT_DISTRIBUTION" );
3917 createSMESHAction( SMESHOp::OpDMWireframe, "WIRE", "ICON_WIRE", 0, true );
3918 createSMESHAction( SMESHOp::OpDMShading, "SHADE", "ICON_SHADE", 0, true );
3919 createSMESHAction( SMESHOp::OpDMNodes, "NODES", "ICON_POINTS", 0, true );
3920 createSMESHAction( SMESHOp::OpDMShrink, "SHRINK", "ICON_SHRINK", 0, true );
3921 createSMESHAction( SMESHOp::OpUpdate, "UPDATE", "ICON_UPDATE" );
3922 createSMESHAction( SMESHOp::OpDE0DElements, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
3923 createSMESHAction( SMESHOp::OpDEEdges, "EDGES", "ICON_DLG_EDGE", 0, true );
3924 createSMESHAction( SMESHOp::OpDEFaces, "FACES", "ICON_DLG_TRIANGLE", 0, true );
3925 createSMESHAction( SMESHOp::OpDEVolumes, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
3926 createSMESHAction( SMESHOp::OpDEBalls, "BALLS", "ICON_DLG_BALL", 0, true );
3927 createSMESHAction( SMESHOp::OpDEChoose, "CHOOSE", "ICON_DLG_CHOOSE", 0, false );
3928 createSMESHAction( SMESHOp::OpDEAllEntity, "ALL", "ICON_DLG_CHOOSE_ALL", 0, false );
3929 createSMESHAction( SMESHOp::OpOrientationOnFaces, "FACE_ORIENTATION", "", 0, true );
3931 createSMESHAction( SMESHOp::OpRepresentationLines, "LINE_REPRESENTATION", "", 0, true );
3932 createSMESHAction( SMESHOp::OpRepresentationArcs, "ARC_REPRESENTATION", "", 0, true );
3934 createSMESHAction( SMESHOp::OpEditHypothesis, "EDIT_HYPO" );
3935 createSMESHAction( SMESHOp::OpUnassign, "UNASSIGN" );
3936 createSMESHAction( SMESHOp::OpNumberingNodes, "NUM_NODES", "", 0, true );
3937 createSMESHAction( SMESHOp::OpNumberingElements, "NUM_ELEMENTS", "", 0, true );
3938 createSMESHAction( SMESHOp::OpProperties, "COLORS" );
3939 createSMESHAction( SMESHOp::OpTransparency, "TRANSP" );
3940 createSMESHAction( SMESHOp::OpClipping, "CLIP" );
3941 createSMESHAction( SMESHOp::OpAutoColor, "AUTO_COLOR" );
3942 createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
3944 createSMESHAction( SMESHOp::OpMinimumDistance, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
3945 createSMESHAction( SMESHOp::OpBoundingBox, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
3946 createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH", "ICON_MEASURE_LENGTH" );
3947 createSMESHAction( SMESHOp::OpPropertiesArea, "MEASURE_AREA", "ICON_MEASURE_AREA" );
3948 createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME", "ICON_MEASURE_VOLUME" );
3950 createSMESHAction( SMESHOp::OpHide, "HIDE" );
3951 createSMESHAction( SMESHOp::OpShow, "SHOW" );
3952 createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
3954 createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
3956 QList<int> aCtrlActions;
3957 aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode // node controls
3958 << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
3959 << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge // edge controls
3960 << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
3961 << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
3962 << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
3963 << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
3964 << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace // face controls
3965 << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
3966 << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
3967 << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume; // volume controls
3968 QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
3969 aCtrlGroup->setExclusive( true );
3970 for( int i = 0; i < aCtrlActions.size(); i++ )
3971 aCtrlGroup->addAction( action( aCtrlActions[i] ) );
3973 // ----- create menu --------------
3974 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
3975 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
3976 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
3977 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
3978 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
3979 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
3980 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
3981 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
3983 createMenu( separator(), fileId );
3985 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
3986 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
3987 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10 ),
3988 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10 ),
3989 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10 ),
3990 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10 ),
3991 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
3992 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
3993 //renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
3994 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
3995 basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
3997 //createMenu( SMESHOp::OpImportDAT, importId, -1 );
3998 createMenu( SMESHOp::OpImportUNV, importId, -1 );
3999 createMenu( SMESHOp::OpImportMED, importId, -1 );
4000 createMenu( SMESHOp::OpImportSTL, importId, -1 );
4002 createMenu( SMESHOp::OpImportCGNS, importId, -1 );
4004 createMenu( SMESHOp::OpImportSAUV, importId, -1 );
4005 createMenu( SMESHOp::OpImportGMF, importId, -1 );
4006 createMenu( SMESHOp::OpExportDAT, exportId, -1 );
4007 createMenu( SMESHOp::OpExportMED, exportId, -1 );
4008 createMenu( SMESHOp::OpExportUNV, exportId, -1 );
4009 createMenu( SMESHOp::OpExportSTL, exportId, -1 );
4011 createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
4013 createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
4014 createMenu( SMESHOp::OpExportGMF, exportId, -1 );
4015 createMenu( separator(), fileId, 10 );
4017 createMenu( SMESHOp::OpDelete, editId, -1 );
4019 createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
4021 createMenu( SMESHOp::OpCreateMesh, meshId, -1 ); // "Mesh" menu
4022 createMenu( SMESHOp::OpCreateSubMesh, meshId, -1 );
4023 createMenu( SMESHOp::OpEditMeshOrSubMesh, meshId, -1 );
4024 createMenu( SMESHOp::OpBuildCompoundMesh, meshId, -1 );
4025 createMenu( SMESHOp::OpCopyMesh, meshId, -1 );
4026 createMenu( separator(), meshId, -1 );
4027 createMenu( SMESHOp::OpCompute, meshId, -1 );
4028 createMenu( SMESHOp::OpPreCompute, meshId, -1 );
4029 createMenu( SMESHOp::OpEvaluate, meshId, -1 );
4030 createMenu( SMESHOp::OpMeshOrder, meshId, -1 );
4031 createMenu( separator(), meshId, -1 );
4032 createMenu( SMESHOp::OpCreateGroup, meshId, -1 );
4033 createMenu( SMESHOp::OpCreateGeometryGroup, meshId, -1 );
4034 createMenu( SMESHOp::OpConstructGroup, meshId, -1 );
4035 createMenu( SMESHOp::OpEditGroup, meshId, -1 );
4036 createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4037 createMenu( separator(), meshId, -1 );
4038 createMenu( SMESHOp::OpUnionGroups, meshId, -1 );
4039 createMenu( SMESHOp::OpIntersectGroups, meshId, -1 );
4040 createMenu( SMESHOp::OpCutGroups, meshId, -1 );
4041 createMenu( separator(), meshId, -1 );
4042 createMenu( SMESHOp::OpGroupUnderlyingElem, meshId, -1 );
4043 createMenu( separator(), meshId, -1 );
4044 createMenu( SMESHOp::OpMeshInformation, meshId, -1 );
4045 //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4046 //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4047 createMenu( SMESHOp::OpFindElementByPoint, meshId, -1 );
4048 createMenu( separator(), meshId, -1 );
4050 createMenu( SMESHOp::OpFreeNode, nodeId, -1 );
4051 createMenu( SMESHOp::OpEqualNode, nodeId, -1 );
4052 createMenu( SMESHOp::OpFreeEdge, edgeId, -1 );
4053 createMenu( SMESHOp::OpFreeBorder, edgeId, -1 );
4054 createMenu( SMESHOp::OpLength, edgeId, -1 );
4055 createMenu( SMESHOp::OpConnection, edgeId, -1 );
4056 createMenu( SMESHOp::OpEqualEdge, edgeId, -1 );
4057 createMenu( SMESHOp::OpFreeFace, faceId, -1 );
4058 createMenu( SMESHOp::OpBareBorderFace, faceId, -1 );
4059 createMenu( SMESHOp::OpOverConstrainedFace, faceId, -1 );
4060 createMenu( SMESHOp::OpLength2D, faceId, -1 );
4061 createMenu( SMESHOp::OpConnection2D, faceId, -1 );
4062 createMenu( SMESHOp::OpArea, faceId, -1 );
4063 createMenu( SMESHOp::OpTaper, faceId, -1 );
4064 createMenu( SMESHOp::OpAspectRatio, faceId, -1 );
4065 createMenu( SMESHOp::OpMinimumAngle, faceId, -1 );
4066 createMenu( SMESHOp::OpWarpingAngle, faceId, -1 );
4067 createMenu( SMESHOp::OpSkew, faceId, -1 );
4068 createMenu( SMESHOp::OpMaxElementLength2D, faceId, -1 );
4069 createMenu( SMESHOp::OpEqualFace, faceId, -1 );
4070 createMenu( SMESHOp::OpAspectRatio3D, volumeId, -1 );
4071 createMenu( SMESHOp::OpVolume, volumeId, -1 );
4072 createMenu( SMESHOp::OpMaxElementLength3D, volumeId, -1 );
4073 createMenu( SMESHOp::OpBareBorderVolume, volumeId, -1 );
4074 createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4075 createMenu( SMESHOp::OpEqualVolume, volumeId, -1 );
4076 createMenu( separator(), ctrlId, -1 );
4077 createMenu( SMESHOp::OpReset, ctrlId, -1 );
4078 createMenu( separator(), ctrlId, -1 );
4079 createMenu( SMESHOp::OpOverallMeshQuality, ctrlId, -1 );
4081 createMenu( SMESHOp::OpNode, addId, -1 );
4082 createMenu( SMESHOp::OpElem0D, addId, -1 );
4083 createMenu( SMESHOp::OpElem0DOnElemNodes, addId, -1 );
4084 createMenu( SMESHOp::OpBall, addId, -1 );
4085 createMenu( SMESHOp::OpEdge, addId, -1 );
4086 createMenu( SMESHOp::OpTriangle, addId, -1 );
4087 createMenu( SMESHOp::OpQuadrangle, addId, -1 );
4088 createMenu( SMESHOp::OpPolygon, addId, -1 );
4089 createMenu( SMESHOp::OpTetrahedron, addId, -1 );
4090 createMenu( SMESHOp::OpHexahedron, addId, -1 );
4091 createMenu( SMESHOp::OpPentahedron, addId, -1 );
4092 createMenu( SMESHOp::OpPyramid, addId, -1 );
4093 createMenu( SMESHOp::OpHexagonalPrism, addId, -1 );
4094 createMenu( SMESHOp::OpPolyhedron, addId, -1 );
4095 createMenu( separator(), addId, -1 );
4096 createMenu( SMESHOp::OpQuadraticEdge, addId, -1 );
4097 createMenu( SMESHOp::OpQuadraticTriangle, addId, -1 );
4098 createMenu( SMESHOp::OpBiQuadraticTriangle , addId, -1 );
4099 createMenu( SMESHOp::OpQuadraticQuadrangle, addId, -1 );
4100 createMenu( SMESHOp::OpBiQuadraticQuadrangle, addId, -1 );
4101 createMenu( SMESHOp::OpQuadraticTetrahedron, addId, -1 );
4102 createMenu( SMESHOp::OpQuadraticPyramid, addId, -1 );
4103 createMenu( SMESHOp::OpQuadraticPentahedron, addId, -1 );
4104 createMenu( SMESHOp::OpQuadraticHexahedron, addId, -1 );
4105 createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4107 createMenu( SMESHOp::OpRemoveNodes, removeId, -1 );
4108 createMenu( SMESHOp::OpRemoveElements, removeId, -1 );
4109 createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4110 createMenu( separator(), removeId, -1 );
4111 createMenu( SMESHOp::OpDeleteGroup, removeId, -1 );
4112 createMenu( separator(), removeId, -1 );
4113 createMenu( SMESHOp::OpClearMesh, removeId, -1 );
4115 //createMenu( SMESHOp::OpRenumberingNodes, renumId, -1 );
4116 //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4118 createMenu( SMESHOp::OpTranslation, transfId, -1 );
4119 createMenu( SMESHOp::OpRotation, transfId, -1 );
4120 createMenu( SMESHOp::OpSymmetry, transfId, -1 );
4121 createMenu( SMESHOp::OpScale, transfId, -1 );
4122 createMenu( SMESHOp::OpSewing, transfId, -1 );
4123 createMenu( SMESHOp::OpMergeNodes, transfId, -1 );
4124 createMenu( SMESHOp::OpMergeElements, transfId, -1 );
4125 createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4127 createMenu( SMESHOp::OpMoveNode, modifyId, -1 );
4128 createMenu( SMESHOp::OpDiagonalInversion, modifyId, -1 );
4129 createMenu( SMESHOp::OpUnionOfTwoTriangle, modifyId, -1 );
4130 createMenu( SMESHOp::OpOrientation, modifyId, -1 );
4131 createMenu( SMESHOp::OpReorientFaces, modifyId, -1 );
4132 createMenu( SMESHOp::OpUnionOfTriangles, modifyId, -1 );
4133 createMenu( SMESHOp::OpCuttingOfQuadrangles, modifyId, -1 );
4134 createMenu( SMESHOp::OpSplitVolumes, modifyId, -1 );
4135 createMenu( SMESHOp::OpSmoothing, modifyId, -1 );
4136 createMenu( SMESHOp::OpExtrusion, modifyId, -1 );
4137 createMenu( SMESHOp::OpExtrusionAlongAPath , modifyId, -1 );
4138 createMenu( SMESHOp::OpRevolution, modifyId, -1 );
4139 createMenu( SMESHOp::OpPatternMapping, modifyId, -1 );
4140 createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4141 createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4143 createMenu( SMESHOp::OpMinimumDistance, measureId, -1 );
4144 createMenu( SMESHOp::OpBoundingBox, measureId, -1 );
4145 createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4146 createMenu( SMESHOp::OpPropertiesArea, basicPropId, -1 );
4147 createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4148 createMenu( SMESHOp::OpUpdate, viewId, -1 );
4150 // ----- create toolbars --------------
4151 int meshTb = createTool( tr( "TB_MESH" ), QString( "SMESHMeshToolbar" ) ),
4152 info = createTool( tr( "TB_INFO" ), QString( "SMESHInformationToolbar" ) ),
4153 groupTb = createTool( tr( "TB_GROUP" ), QString( "SMESHGroupToolbar" ) ),
4154 ctrl0dTb = createTool( tr( "TB_CTRL0D" ), QString( "SMESHNodeControlsToolbar" ) ),
4155 ctrl1dTb = createTool( tr( "TB_CTRL1D" ), QString( "SMESHEdgeControlsToolbar" ) ),
4156 ctrl2dTb = createTool( tr( "TB_CTRL2D" ), QString( "SMESHFaceControlsToolbar" ) ),
4157 ctrl3dTb = createTool( tr( "TB_CTRL3D" ), QString( "SMESHVolumeControlsToolbar" ) ),
4158 addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ),
4159 addNonElemTb = createTool( tr( "TB_ADDNON" ), QString( "SMESHAddElementToolbar" ) ),
4160 remTb = createTool( tr( "TB_REM" ), QString( "SMESHRemoveToolbar" ) ),
4161 //renumbTb = createTool( tr( "TB_RENUMBER" ), QString( "SMESHRenumberingToolbar" ) ),
4162 transformTb = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ),
4163 modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ),
4164 measuremTb = createTool( tr( "TB_MEASUREM" ), QString( "SMESHMeasurementsToolbar" ) ),
4165 dispModeTb = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4167 createTool( SMESHOp::OpCreateMesh, meshTb );
4168 createTool( SMESHOp::OpCreateSubMesh, meshTb );
4169 createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4170 createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4171 createTool( SMESHOp::OpCopyMesh, meshTb );
4172 createTool( separator(), meshTb );
4173 createTool( SMESHOp::OpCompute, meshTb );
4174 createTool( SMESHOp::OpPreCompute, meshTb );
4175 createTool( SMESHOp::OpEvaluate, meshTb );
4176 createTool( SMESHOp::OpMeshOrder, meshTb );
4178 createTool( SMESHOp::OpCreateGroup, groupTb );
4179 createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4180 createTool( SMESHOp::OpConstructGroup, groupTb );
4181 createTool( SMESHOp::OpEditGroup, groupTb );
4183 createTool( SMESHOp::OpMeshInformation, info );
4184 //createTool( SMESHOp::OpStdInfo, meshTb );
4185 //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4186 createTool( SMESHOp::OpFindElementByPoint, info );
4188 createTool( SMESHOp::OpFreeNode, ctrl0dTb );
4189 createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4191 createTool( SMESHOp::OpFreeEdge, ctrl1dTb );
4192 createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4193 createTool( SMESHOp::OpLength, ctrl1dTb );
4194 createTool( SMESHOp::OpConnection, ctrl1dTb );
4195 createTool( SMESHOp::OpEqualEdge, ctrl1dTb );
4197 createTool( SMESHOp::OpFreeFace, ctrl2dTb );
4198 createTool( SMESHOp::OpBareBorderFace, ctrl2dTb );
4199 createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4200 createTool( SMESHOp::OpLength2D, ctrl2dTb );
4201 createTool( SMESHOp::OpConnection2D, ctrl2dTb );
4202 createTool( SMESHOp::OpArea, ctrl2dTb );
4203 createTool( SMESHOp::OpTaper, ctrl2dTb );
4204 createTool( SMESHOp::OpAspectRatio, ctrl2dTb );
4205 createTool( SMESHOp::OpMinimumAngle, ctrl2dTb );
4206 createTool( SMESHOp::OpWarpingAngle, ctrl2dTb );
4207 createTool( SMESHOp::OpSkew, ctrl2dTb );
4208 createTool( SMESHOp::OpMaxElementLength2D, ctrl2dTb );
4209 createTool( SMESHOp::OpEqualFace, ctrl2dTb );
4211 createTool( SMESHOp::OpAspectRatio3D, ctrl3dTb );
4212 createTool( SMESHOp::OpVolume, ctrl3dTb );
4213 createTool( SMESHOp::OpMaxElementLength3D, ctrl3dTb );
4214 createTool( SMESHOp::OpBareBorderVolume, ctrl3dTb );
4215 createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
4216 createTool( SMESHOp::OpEqualVolume, ctrl3dTb );
4218 createTool( SMESHOp::OpNode, addElemTb );
4219 createTool( SMESHOp::OpElem0D, addElemTb );
4220 createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4221 createTool( SMESHOp::OpBall, addElemTb );
4222 createTool( SMESHOp::OpEdge, addElemTb );
4223 createTool( SMESHOp::OpTriangle, addElemTb );
4224 createTool( SMESHOp::OpQuadrangle, addElemTb );
4225 createTool( SMESHOp::OpPolygon, addElemTb );
4226 createTool( SMESHOp::OpTetrahedron, addElemTb );
4227 createTool( SMESHOp::OpHexahedron, addElemTb );
4228 createTool( SMESHOp::OpPentahedron, addElemTb );
4229 createTool( SMESHOp::OpPyramid, addElemTb );
4230 createTool( SMESHOp::OpHexagonalPrism, addElemTb );
4231 createTool( SMESHOp::OpPolyhedron, addElemTb );
4233 createTool( SMESHOp::OpQuadraticEdge, addNonElemTb );
4234 createTool( SMESHOp::OpQuadraticTriangle, addNonElemTb );
4235 createTool( SMESHOp::OpBiQuadraticTriangle, addNonElemTb );
4236 createTool( SMESHOp::OpQuadraticQuadrangle, addNonElemTb );
4237 createTool( SMESHOp::OpBiQuadraticQuadrangle, addNonElemTb );
4238 createTool( SMESHOp::OpQuadraticTetrahedron, addNonElemTb );
4239 createTool( SMESHOp::OpQuadraticPyramid, addNonElemTb );
4240 createTool( SMESHOp::OpQuadraticPentahedron, addNonElemTb );
4241 createTool( SMESHOp::OpQuadraticHexahedron, addNonElemTb );
4242 createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4244 createTool( SMESHOp::OpRemoveNodes, remTb );
4245 createTool( SMESHOp::OpRemoveElements, remTb );
4246 createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4247 createTool( SMESHOp::OpClearMesh, remTb );
4249 //createTool( SMESHOp::OpRenumberingNodes, renumbTb );
4250 //createTool( SMESHOp::OpRenumberingElements, renumbTb );
4252 createTool( SMESHOp::OpTranslation, transformTb );
4253 createTool( SMESHOp::OpRotation, transformTb );
4254 createTool( SMESHOp::OpSymmetry, transformTb );
4255 createTool( SMESHOp::OpScale, transformTb );
4256 createTool( SMESHOp::OpSewing, transformTb );
4257 createTool( SMESHOp::OpMergeNodes, transformTb );
4258 createTool( SMESHOp::OpMergeElements, transformTb );
4259 createTool( SMESHOp::OpDuplicateNodes, transformTb );
4261 createTool( SMESHOp::OpMoveNode, modifyTb );
4262 createTool( SMESHOp::OpDiagonalInversion, modifyTb );
4263 createTool( SMESHOp::OpUnionOfTwoTriangle, modifyTb );
4264 createTool( SMESHOp::OpOrientation, modifyTb );
4265 createTool( SMESHOp::OpReorientFaces, modifyTb );
4266 createTool( SMESHOp::OpUnionOfTriangles, modifyTb );
4267 createTool( SMESHOp::OpCuttingOfQuadrangles, modifyTb );
4268 createTool( SMESHOp::OpSplitVolumes, modifyTb );
4269 createTool( SMESHOp::OpSmoothing, modifyTb );
4270 createTool( SMESHOp::OpExtrusion, modifyTb );
4271 createTool( SMESHOp::OpExtrusionAlongAPath, modifyTb );
4272 createTool( SMESHOp::OpRevolution, modifyTb );
4273 createTool( SMESHOp::OpPatternMapping, modifyTb );
4274 createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4275 createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4277 createTool( SMESHOp::OpMinimumDistance, measuremTb );
4279 createTool( SMESHOp::OpUpdate, dispModeTb );
4281 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4282 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4285 QString OB = "'ObjectBrowser'",
4286 View = "'" + SVTK_Viewer::Type() + "'",
4288 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4289 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4290 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4291 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4292 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4293 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4294 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4295 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4296 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4297 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4298 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4300 mesh_part = mesh + " " + subMesh + " " + group,
4301 mesh_group = mesh + " " + group,
4302 hyp_alg = hypo + " " + algo;
4304 // popup for object browser
4306 isInvisible("not( isVisible )"),
4307 isEmpty("numberOfNodes = 0"),
4308 isNotEmpty("numberOfNodes <> 0"),
4310 // has nodes, edges, etc in VISIBLE! actor
4311 hasNodes("(numberOfNodes > 0 )"),//&& isVisible)"),
4312 hasElems("(count( elemTypes ) > 0)"),
4313 hasDifferentElems("(count( elemTypes ) > 1)"),
4314 hasBalls("({'BallElem'} in elemTypes)"),
4315 hasElems0d("({'Elem0d'} in elemTypes)"),
4316 hasEdges("({'Edge'} in elemTypes)"),
4317 hasFaces("({'Face'} in elemTypes)"),
4318 hasVolumes("({'Volume'} in elemTypes)");
4320 createPopupItem( SMESHOp::OpFileInformation, OB, mesh, "&& selcount=1 && isImported" );
4321 createPopupItem( SMESHOp::OpCreateSubMesh, OB, mesh, "&& isComputable");
4322 createPopupItem( SMESHOp::OpEditMeshOrSubMesh, OB, mesh, "&& isComputable");
4323 createPopupItem( SMESHOp::OpEditMeshOrSubMesh, OB, subMesh, "&& isComputable" );
4324 createPopupItem( SMESHOp::OpEditGroup, OB, group );
4325 createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4327 popupMgr()->insert( separator(), -1, 0 );
4328 createPopupItem( SMESHOp::OpCompute, OB, mesh, "&& isComputable" );
4329 createPopupItem( SMESHOp::OpPreCompute, OB, mesh, "&& isComputable && isPreComputable" );
4330 createPopupItem( SMESHOp::OpEvaluate, OB, mesh, "&& isComputable" );
4331 createPopupItem( SMESHOp::OpMeshOrder, OB, mesh, "&& isComputable" );
4332 createPopupItem( SMESHOp::OpUpdate, OB, mesh_part );
4333 createPopupItem( SMESHOp::OpMeshInformation, OB, mesh_part );
4334 createPopupItem( SMESHOp::OpFindElementByPoint, OB, mesh_group );
4335 createPopupItem( SMESHOp::OpOverallMeshQuality, OB, mesh_part );
4336 popupMgr()->insert( separator(), -1, 0 );
4337 createPopupItem( SMESHOp::OpCreateGroup, OB, mesh );
4338 createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh );
4339 createPopupItem( SMESHOp::OpConstructGroup, OB, subMesh );
4340 popupMgr()->insert( separator(), -1, 0 );
4341 createPopupItem( SMESHOp::OpEditHypothesis, OB, hypo);
4342 createPopupItem( SMESHOp::OpUnassign, OB, hyp_alg ); // REMOVE HYPOTHESIS / ALGORITHMS
4343 popupMgr()->insert( separator(), -1, 0 );
4344 createPopupItem( SMESHOp::OpClearMesh, OB, mesh );
4345 popupMgr()->insert( separator(), -1, 0 );
4346 createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh + " " + subMesh ); // convert to quadratic
4347 createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh + " " + group, // create 2D mesh from 3D
4349 popupMgr()->insert( separator(), -1, 0 );
4351 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4352 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4353 QString only_one_2D = only_one_non_empty + " && dim>1";
4355 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4356 createPopupItem( SMESHOp::OpPopupExportMED, OB, mesh_group, multiple_non_empty, anId );
4357 createPopupItem( SMESHOp::OpPopupExportUNV, OB, mesh_group, only_one_non_empty, anId );
4358 createPopupItem( SMESHOp::OpPopupExportSTL, OB, mesh_group, only_one_2D, anId );
4360 createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4362 createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, multiple_non_empty, anId );
4363 createPopupItem( SMESHOp::OpPopupExportGMF, OB, mesh_group, multiple_non_empty, anId );
4364 createPopupItem( SMESHOp::OpPopupExportDAT, OB, mesh_group, multiple_non_empty, anId );
4365 createPopupItem( SMESHOp::OpDelete, OB, mesh_part + " " + hyp_alg );
4366 createPopupItem( SMESHOp::OpDeleteGroup, OB, group );
4367 popupMgr()->insert( separator(), -1, 0 );
4370 createPopupItem( SMESHOp::OpEditGroup, View, group );
4371 createPopupItem( SMESHOp::OpAddElemGroupPopup, View, elems );
4372 createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems );
4374 popupMgr()->insert( separator(), -1, 0 );
4375 createPopupItem( SMESHOp::OpUpdate, View, mesh_part );
4376 createPopupItem( SMESHOp::OpMeshInformation, View, mesh_part );
4377 createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4378 createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh );
4379 popupMgr()->insert( separator(), -1, 0 );
4381 createPopupItem( SMESHOp::OpAutoColor, OB + " " + View, mesh, "&& (not isAutoColor)" );
4382 createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4383 popupMgr()->insert( separator(), -1, 0 );
4385 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4386 QString aType = QString( "%1type in {%2}" ).arg( lc );
4387 aType = aType.arg( mesh_part );
4388 QString aMeshInVTK = aClient + "&&" + aType;
4390 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4391 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4392 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4394 //-------------------------------------------------
4396 //-------------------------------------------------
4397 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4399 popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4400 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4401 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4403 popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4404 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4405 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4407 popupMgr()->insert( separator(), -1, -1 );
4409 //-------------------------------------------------
4411 //-------------------------------------------------
4412 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4414 popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4415 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4416 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4418 popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4419 popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4420 popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4422 popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4423 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes, QtxPopupMgr::VisibleRule );
4424 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4426 popupMgr()->insert( separator(), anId, -1 );
4428 popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4429 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4430 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4432 //-------------------------------------------------
4434 //-------------------------------------------------
4435 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4437 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4439 popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4440 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4441 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4443 popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4444 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4445 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4447 popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4448 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4449 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4451 popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4452 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4453 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4455 popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4456 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4457 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4459 popupMgr()->insert( separator(), anId, -1 );
4461 popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4462 popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&&" + aType + "&&" + isNotEmpty, QtxPopupMgr::VisibleRule );
4464 popupMgr()->insert( separator(), anId, -1 );
4466 popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4467 popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4470 //-------------------------------------------------
4471 // Representation of the 2D Quadratic elements
4472 //-------------------------------------------------
4473 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4474 popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4475 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "and isVisible",QtxPopupMgr::VisibleRule );
4476 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4478 popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4479 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "and isVisible", QtxPopupMgr::VisibleRule );
4480 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4482 //-------------------------------------------------
4483 // Orientation of faces
4484 //-------------------------------------------------
4485 popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4486 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4487 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4489 //-------------------------------------------------
4491 //-------------------------------------------------
4492 popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4493 popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4495 //-------------------------------------------------
4497 //-------------------------------------------------
4498 popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4499 popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4501 //-------------------------------------------------
4503 //-------------------------------------------------
4505 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4506 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4507 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4508 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4510 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4512 popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4513 popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4515 popupMgr()->insert( separator(), anId, -1 );
4517 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4519 popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4520 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4521 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4523 popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4524 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4525 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4527 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4529 popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4530 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4531 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4533 popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4534 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4535 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4537 popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4538 popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4539 popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4541 popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4542 popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4543 popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4544 popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4545 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4546 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4548 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4550 popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4551 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4552 QtxPopupMgr::VisibleRule );
4553 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4555 popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4556 popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4557 popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4559 popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4560 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4561 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4563 popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
4564 popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4565 popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4567 popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
4568 popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4569 popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4571 popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
4572 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4573 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4575 popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
4576 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4577 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4579 popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
4580 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4581 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4583 popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
4584 popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4585 popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4587 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
4588 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4589 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4591 popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
4592 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4593 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4595 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
4596 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4597 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4598 popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
4599 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4600 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4602 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4604 popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D ), aSubId, -1 );
4605 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4606 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4608 popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
4609 popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4610 popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4612 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
4613 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4614 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4616 popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
4617 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4618 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4620 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
4621 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4622 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4624 popupMgr()->insert ( action( SMESHOp::OpEqualVolume ), aSubId, -1 );
4625 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4626 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4628 popupMgr()->insert( separator(), anId, -1 );
4630 popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
4631 popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4633 popupMgr()->insert( separator(), anId, -1 );
4635 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4637 popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
4638 popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4640 popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
4641 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4642 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isDistributionVisible", QtxPopupMgr::ToggleRule);
4644 #ifndef DISABLE_PLOT2DVIEWER
4645 popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
4646 popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4649 //-------------------------------------------------
4651 //-------------------------------------------------
4652 popupMgr()->insert( separator(), -1, -1 );
4653 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4654 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4655 popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
4656 popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4658 popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
4659 popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4661 popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
4662 popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4664 popupMgr()->insert( separator(), -1, -1 );
4666 //-------------------------------------------------
4668 //-------------------------------------------------
4669 popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
4670 popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4672 popupMgr()->insert( separator(), -1, -1 );
4674 popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
4675 popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
4676 popupMgr()->insert( separator(), -1, -1 );
4678 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4679 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4681 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4682 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4685 //================================================================================
4687 * \brief Return true if SMESH or GEOM objects are selected.
4688 * Is called form LightApp_Module::activateModule() which clear selection if
4689 * not isSelectionCompatible()
4691 //================================================================================
4693 bool SMESHGUI::isSelectionCompatible()
4695 bool isCompatible = true;
4696 SALOME_ListIO selected;
4697 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4698 Sel->selectedObjects( selected );
4700 SALOME_ListIteratorOfListIO It( selected );
4701 for ( ; isCompatible && It.More(); It.Next())
4703 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4704 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4706 return isCompatible;
4710 bool SMESHGUI::reusableOperation( const int id )
4712 // compute, evaluate and precompute are not reusable operations
4713 return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate ) ? false : SalomeApp_Module::reusableOperation( id );
4716 bool SMESHGUI::activateModule( SUIT_Study* study )
4718 bool res = SalomeApp_Module::activateModule( study );
4720 setMenuShown( true );
4721 setToolShown( true );
4723 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4724 PyGILState_STATE gstate = PyGILState_Ensure();
4725 PyObjWrapper pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4726 if ( !pluginsmanager ) {
4730 PyObjWrapper result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toStdString().c_str(),tr("SMESH_PLUGINS_OTHER").toStdString().c_str());
4734 PyGILState_Release(gstate);
4735 // end of SMESH plugins loading
4737 // Reset actions accelerator keys
4738 action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
4740 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4741 GetSMESHGen()->SetCurrentStudy(SALOMEDS::Study::_nil());
4742 if ( SalomeApp_Study* s = dynamic_cast<SalomeApp_Study*>( study ))
4743 if ( _PTR(Study) aStudy = s->studyDS()) {
4744 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
4745 updateObjBrowser(); // objects can be removed
4748 // get all view currently opened in the study and connect their signals to
4749 // the corresponding slots of the class.
4750 SUIT_Desktop* aDesk = study->application()->desktop();
4752 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4753 SUIT_ViewWindow* wnd;
4754 foreach ( wnd, wndList )
4761 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4763 setMenuShown( false );
4764 setToolShown( false );
4766 EmitSignalCloseAllDialogs();
4768 // Unset actions accelerator keys
4769 action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
4771 return SalomeApp_Module::deactivateModule( study );
4774 void SMESHGUI::studyClosed( SUIT_Study* s )
4778 SMESH::RemoveVisuData( s->id() );
4779 SalomeApp_Module::studyClosed( s );
4782 void SMESHGUI::OnGUIEvent()
4784 const QObject* obj = sender();
4785 if ( !obj || !obj->inherits( "QAction" ) )
4787 int id = actionId((QAction*)obj);
4792 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4794 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
4795 if ( CORBA::is_nil( myComponentSMESH ) )
4797 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4799 aGUI.myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4800 return aGUI.myComponentSMESH;
4803 myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4804 return myComponentSMESH;
4807 QString SMESHGUI::engineIOR() const
4809 CORBA::ORB_var anORB = getApp()->orb();
4810 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4811 return QString( anIOR.in() );
4814 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4816 SalomeApp_Module::contextMenuPopup( client, menu, title );
4818 selectionMgr()->selectedObjects( lst );
4819 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4820 Handle(SALOME_InteractiveObject) io = lst.First();
4821 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4822 _PTR(Study) study = appStudy->studyDS();
4823 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4825 QString aName = QString( SMESH::fromUtf8(obj->GetName()) );
4826 while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4827 aName.remove( (aName.length() - 1), 1 );
4833 LightApp_Selection* SMESHGUI::createSelection() const
4835 return new SMESHGUI_Selection();
4838 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4840 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4841 aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
4842 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4845 void SMESHGUI::viewManagers( QStringList& list ) const
4847 list.append( SVTK_Viewer::Type() );
4850 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4852 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4853 SMESH::UpdateSelectionProp( this );
4855 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
4856 for(int i = 0; i < aViews.count() ; i++){
4857 SUIT_ViewWindow *sf = aViews[i];
4863 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
4865 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
4866 myClippingPlaneInfoMap.erase( theViewManager );
4869 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
4871 theActor->AddObserver( SMESH::DeleteActorEvent,
4872 myEventCallbackCommand.GetPointer(),
4876 void SMESHGUI::ProcessEvents( vtkObject* theObject,
4877 unsigned long theEvent,
4878 void* theClientData,
4881 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
4882 if( theObject && theEvent == SMESH::DeleteActorEvent ) {
4883 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
4884 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
4885 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
4886 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
4887 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
4888 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
4889 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
4890 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
4891 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
4892 SMESH::TActorList::iterator anIter3 = anActorList.begin();
4893 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
4894 if( anActor == *anIter3 ) {
4895 anActorList.erase( anIter3 );
4906 void SMESHGUI::createPreferences()
4908 // General tab ------------------------------------------------------------------------
4909 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
4911 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
4912 setPreferenceProperty( autoUpdate, "columns", 2 );
4913 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
4914 setPreferenceProperty( lim, "min", 0 );
4915 setPreferenceProperty( lim, "max", 100000000 );
4916 setPreferenceProperty( lim, "step", 1000 );
4917 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4918 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
4920 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
4921 setPreferenceProperty( qaGroup, "columns", 2 );
4922 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
4923 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
4924 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
4925 setPreferenceProperty( prec, "min", 0 );
4926 setPreferenceProperty( prec, "max", 100 );
4927 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
4928 setPreferenceProperty( doubleNodesTol, "precision", 10 );
4929 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
4930 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
4931 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
4933 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE" ), genTab );
4934 setPreferenceProperty( dispgroup, "columns", 2 );
4935 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
4937 modes.append( tr("MEN_WIRE") );
4938 modes.append( tr("MEN_SHADE") );
4939 modes.append( tr("MEN_NODES") );
4940 modes.append( tr("MEN_SHRINK") );
4941 QList<QVariant> indices;
4942 indices.append( 0 );
4943 indices.append( 1 );
4944 indices.append( 2 );
4945 indices.append( 3 );
4946 setPreferenceProperty( dispmode, "strings", modes );
4947 setPreferenceProperty( dispmode, "indexes", indices );
4949 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), genTab );
4950 setPreferenceProperty( arcgroup, "columns", 2 );
4951 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
4952 QStringList quadraticModes;
4953 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
4954 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
4956 indices.append( 0 );
4957 indices.append( 1 );
4958 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
4959 setPreferenceProperty( quadraticmode, "indexes", indices );
4961 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
4962 "SMESH", "max_angle" );
4963 setPreferenceProperty( maxAngle, "min", 1 );
4964 setPreferenceProperty( maxAngle, "max", 90 );
4968 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
4969 setPreferenceProperty( exportgroup, "columns", 2 );
4970 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
4971 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
4973 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
4974 setPreferenceProperty( computeGroup, "columns", 2 );
4975 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
4977 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
4978 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
4979 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
4981 indices.append( 0 );
4982 indices.append( 1 );
4983 indices.append( 2 );
4984 setPreferenceProperty( notifyMode, "strings", modes );
4985 setPreferenceProperty( notifyMode, "indexes", indices );
4987 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
4988 setPreferenceProperty( infoGroup, "columns", 2 );
4989 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
4991 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
4992 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
4994 indices.append( 0 );
4995 indices.append( 1 );
4996 setPreferenceProperty( elemInfo, "strings", modes );
4997 setPreferenceProperty( elemInfo, "indexes", indices );
4998 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
4999 setPreferenceProperty( nodesLim, "min", 0 );
5000 setPreferenceProperty( nodesLim, "max", 10000000 );
5001 setPreferenceProperty( nodesLim, "step", 10000 );
5002 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5003 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5004 setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5005 setPreferenceProperty( ctrlLim, "min", 0 );
5006 setPreferenceProperty( ctrlLim, "max", 10000000 );
5007 setPreferenceProperty( ctrlLim, "step", 1000 );
5008 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5009 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5010 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5011 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5012 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5014 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5015 setPreferenceProperty( segGroup, "columns", 2 );
5016 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5017 "SMESH", "segmentation" );
5018 setPreferenceProperty( segLen, "min", 1 );
5019 setPreferenceProperty( segLen, "max", 10000000 );
5020 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5021 "SMESH", "nb_segments_per_edge" );
5022 setPreferenceProperty( nbSeg, "min", 1 );
5023 setPreferenceProperty( nbSeg, "max", 10000000 );
5025 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5026 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5027 "SMESH", "forget_mesh_on_hyp_modif" );
5030 // Quantities with individual precision settings
5031 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5032 setPreferenceProperty( precGroup, "columns", 2 );
5034 const int nbQuantities = 6;
5035 int precs[nbQuantities], ii = 0;
5036 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5037 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5038 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5039 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5040 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5041 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5042 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5043 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5044 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5045 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5046 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5047 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5049 // Set property for precision value for spinboxes
5050 for ( ii = 0; ii < nbQuantities; ii++ ){
5051 setPreferenceProperty( precs[ii], "min", -14 );
5052 setPreferenceProperty( precs[ii], "max", 14 );
5053 setPreferenceProperty( precs[ii], "precision", 2 );
5056 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5057 setPreferenceProperty( previewGroup, "columns", 2 );
5058 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5059 setPreferenceProperty( chunkSize, "min", 1 );
5060 setPreferenceProperty( chunkSize, "max", 1000 );
5061 setPreferenceProperty( chunkSize, "step", 50 );
5063 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5064 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5066 // Mesh tab ------------------------------------------------------------------------
5067 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5068 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5069 setPreferenceProperty( nodeGroup, "columns", 3 );
5071 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5073 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5075 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5076 QList<QVariant> aMarkerTypeIndicesList;
5077 QList<QVariant> aMarkerTypeIconsList;
5078 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5079 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5080 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5081 aMarkerTypeIndicesList << i;
5082 aMarkerTypeIconsList << pixmap;
5084 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5085 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
5087 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5089 QList<QVariant> aMarkerScaleIndicesList;
5090 QStringList aMarkerScaleValuesList;
5091 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5092 aMarkerScaleIndicesList << i;
5093 aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5095 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5096 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5098 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5099 //setPreferenceProperty( elemGroup, "columns", 2 );
5101 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5102 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5103 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5104 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5105 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5106 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5107 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5108 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5109 addPreference( tr( "PREF_PREVIEW_COLOR" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5112 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5113 setPreferenceProperty( grpGroup, "columns", 2 );
5115 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5116 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5118 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5119 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5120 int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5121 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size");
5122 double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5123 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5124 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
5125 LightApp_Preferences::IntSpin, "SMESH", "element_width");
5126 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5127 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5128 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5129 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5131 setPreferenceProperty( size0d, "min", 1 );
5132 setPreferenceProperty( size0d, "max", 10 );
5134 setPreferenceProperty( ballSize, "min", 1 );
5135 setPreferenceProperty( ballSize, "max", 10 );
5137 setPreferenceProperty( ballScale, "min", 1e-2 );
5138 setPreferenceProperty( ballScale, "max", 1e7 );
5139 setPreferenceProperty( ballScale, "step", 0.5 );
5141 setPreferenceProperty( elemW, "min", 1 );
5142 setPreferenceProperty( elemW, "max", 5 );
5144 setPreferenceProperty( outW, "min", 1 );
5145 setPreferenceProperty( outW, "max", 5 );
5147 setPreferenceProperty( shrink, "min", 0 );
5148 setPreferenceProperty( shrink, "max", 100 );
5150 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5151 setPreferenceProperty( numGroup, "columns", 2 );
5153 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5154 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5156 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5157 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5159 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5160 setPreferenceProperty( orientGroup, "columns", 1 );
5162 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5163 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5165 setPreferenceProperty( orientScale, "min", 0.05 );
5166 setPreferenceProperty( orientScale, "max", 0.5 );
5167 setPreferenceProperty( orientScale, "step", 0.05 );
5169 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5171 // Selection tab ------------------------------------------------------------------------
5172 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5174 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5175 setPreferenceProperty( selGroup, "columns", 2 );
5177 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5178 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5180 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5181 setPreferenceProperty( preGroup, "columns", 2 );
5183 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5185 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5186 setPreferenceProperty( precSelGroup, "columns", 2 );
5188 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5189 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5190 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5192 // Scalar Bar tab ------------------------------------------------------------------------
5193 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5194 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5195 setPreferenceProperty( fontGr, "columns", 2 );
5197 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5198 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5200 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5201 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5203 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5204 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5206 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5207 setPreferenceProperty( numcol, "min", 2 );
5208 setPreferenceProperty( numcol, "max", 256 );
5210 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5211 setPreferenceProperty( numlab, "min", 2 );
5212 setPreferenceProperty( numlab, "max", 65 );
5214 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5215 setPreferenceProperty( orientGr, "columns", 2 );
5216 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5217 QStringList orients;
5218 orients.append( tr( "SMESH_VERTICAL" ) );
5219 orients.append( tr( "SMESH_HORIZONTAL" ) );
5220 indices.clear(); indices.append( 0 ); indices.append( 1 );
5221 setPreferenceProperty( orient, "strings", orients );
5222 setPreferenceProperty( orient, "indexes", indices );
5224 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5225 setPreferenceProperty( posVSizeGr, "columns", 2 );
5226 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5227 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5228 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5229 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5230 setPreferenceProperty( xv, "step", 0.1 );
5231 setPreferenceProperty( xv, "min", 0.0 );
5232 setPreferenceProperty( xv, "max", 1.0 );
5233 setPreferenceProperty( yv, "step", 0.1 );
5234 setPreferenceProperty( yv, "min", 0.0 );
5235 setPreferenceProperty( yv, "max", 1.0 );
5236 setPreferenceProperty( wv, "step", 0.1 );
5237 setPreferenceProperty( wv, "min", 0.0 );
5238 setPreferenceProperty( wv, "max", 1.0 );
5239 setPreferenceProperty( hv, "min", 0.0 );
5240 setPreferenceProperty( hv, "max", 1.0 );
5241 setPreferenceProperty( hv, "step", 0.1 );
5243 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5244 setPreferenceProperty( posHSizeGr, "columns", 2 );
5245 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5246 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5247 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5248 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5249 setPreferenceProperty( xv, "min", 0.0 );
5250 setPreferenceProperty( xv, "max", 1.0 );
5251 setPreferenceProperty( xv, "step", 0.1 );
5252 setPreferenceProperty( xh, "min", 0.0 );
5253 setPreferenceProperty( xh, "max", 1.0 );
5254 setPreferenceProperty( xh, "step", 0.1 );
5255 setPreferenceProperty( yh, "min", 0.0 );
5256 setPreferenceProperty( yh, "max", 1.0 );
5257 setPreferenceProperty( yh, "step", 0.1 );
5258 setPreferenceProperty( wh, "min", 0.0 );
5259 setPreferenceProperty( wh, "max", 1.0 );
5260 setPreferenceProperty( wh, "step", 0.1 );
5261 setPreferenceProperty( hh, "min", 0.0 );
5262 setPreferenceProperty( hh, "max", 1.0 );
5263 setPreferenceProperty( hh, "step", 0.1 );
5265 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5266 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5267 setPreferenceProperty( distributionGr, "columns", 3 );
5269 types.append( tr( "SMESH_MONOCOLOR" ) );
5270 types.append( tr( "SMESH_MULTICOLOR" ) );
5271 indices.clear(); indices.append( 0 ); indices.append( 1 );
5272 setPreferenceProperty( coloringType, "strings", types );
5273 setPreferenceProperty( coloringType, "indexes", indices );
5274 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5278 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5280 if( sect=="SMESH" ) {
5281 float sbX1,sbY1,sbW,sbH;
5282 float aTol = 1.00000009999999;
5283 std::string aWarning;
5284 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5285 if( name=="selection_object_color" || name=="selection_element_color" ||
5286 name=="highlight_color" ||
5287 name=="selection_precision_node" || name=="selection_precision_element" ||
5288 name=="selection_precision_object")
5289 SMESH::UpdateSelectionProp( this );
5290 else if (name == QString("scalar_bar_vertical_x") || name == QString("scalar_bar_vertical_width")){
5291 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5292 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5293 if(sbX1+sbW > aTol){
5294 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5297 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5298 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5301 else if(name == QString("scalar_bar_vertical_y") || name == QString("scalar_bar_vertical_height")){
5302 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5303 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5304 if(sbY1+sbH > aTol){
5305 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5306 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5307 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5310 else if(name == QString("scalar_bar_horizontal_x") || name == QString("scalar_bar_horizontal_width")){
5311 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5312 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5313 if(sbX1+sbW > aTol){
5314 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5317 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5318 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5321 else if(name == QString("scalar_bar_horizontal_y") || name == QString("scalar_bar_horizontal_height")){
5322 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5323 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5324 if(sbY1+sbH > aTol){
5325 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5328 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5329 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5332 else if ( name == "segmentation" ) {
5333 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5334 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5336 else if ( name == "nb_segments_per_edge" ) {
5337 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5338 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5340 else if ( name == "historical_python_dump" ||
5341 name == "forget_mesh_on_hyp_modif") {
5342 QString val = aResourceMgr->stringValue( "SMESH", name );
5343 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5345 else if ( name == QString( "numbering_node_color" ) || name == QString( "numbering_node_font" ) ) {
5346 SMESH::UpdateFontProp( this );
5348 else if ( name == QString( "numbering_elem_color" ) || name == QString( "numbering_elem_font" ) ) {
5349 SMESH::UpdateFontProp( this );
5352 if(aWarning.size() != 0){
5353 aWarning += "The default values are applied instead.";
5354 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5355 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5356 QObject::tr(aWarning.c_str()));
5361 //================================================================================
5363 * \brief Update something in accordance with update flags
5364 * \param theFlags - update flags
5366 * Update viewer or/and object browser etc. in accordance with update flags ( see
5367 * LightApp_UpdateFlags enumeration ).
5369 //================================================================================
5370 void SMESHGUI::update( const int flags )
5372 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5373 SMESH::UpdateView();
5375 SalomeApp_Module::update( flags );
5378 //================================================================================
5380 * \brief Set default selection mode
5382 * SLOT called when operation commited. Sets default selection mode
5384 //================================================================================
5385 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5387 SVTK_ViewWindow* vtkWnd =
5388 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5390 vtkWnd->SetSelectionMode( ActorSelection );
5393 //================================================================================
5395 * \brief Set default selection mode
5397 * SLOT called when operation aborted. Sets default selection mode
5399 //================================================================================
5400 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5402 SVTK_ViewWindow* vtkWnd =
5403 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5405 vtkWnd->SetSelectionMode( ActorSelection );
5408 //================================================================================
5410 * \brief Creates operation with given identifier
5411 * \param id - identifier of operation to be started
5412 * \return Pointer on created operation or NULL if operation is not created
5414 * Virtual method redefined from the base class creates operation with given id.
5415 * It is called called automatically from startOperation method of base class.
5417 //================================================================================
5418 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5420 LightApp_Operation* op = 0;
5421 // to do : create operation here
5424 case SMESHOp::OpConvertMeshToQuadratic:
5425 op = new SMESHGUI_ConvToQuadOp();
5427 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5428 op = new SMESHGUI_Make2DFrom3DOp();
5430 case SMESHOp::OpReorientFaces:
5431 op = new SMESHGUI_ReorientFacesOp();
5433 case SMESHOp::OpCreateMesh:
5434 op = new SMESHGUI_MeshOp( true, true );
5436 case SMESHOp::OpCreateSubMesh:
5437 op = new SMESHGUI_MeshOp( true, false );
5439 case SMESHOp::OpEditMeshOrSubMesh:
5440 op = new SMESHGUI_MeshOp( false );
5442 case SMESHOp::OpCompute:
5443 op = new SMESHGUI_ComputeOp();
5445 case SMESHOp::OpPreCompute:
5446 op = new SMESHGUI_PrecomputeOp();
5448 case SMESHOp::OpEvaluate:
5449 op = new SMESHGUI_EvaluateOp();
5451 case SMESHOp::OpMeshOrder:
5452 op = new SMESHGUI_MeshOrderOp();
5454 case SMESHOp::OpCreateGeometryGroup:
5455 op = new SMESHGUI_GroupOnShapeOp();
5457 case SMESHOp::OpFindElementByPoint:
5458 op = new SMESHGUI_FindElemByPointOp();
5460 case SMESHOp::OpMoveNode: // Make mesh pass through point
5461 op = new SMESHGUI_MakeNodeAtPointOp();
5463 case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
5464 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5471 op = SalomeApp_Module::createOperation( id );
5475 //================================================================================
5477 * \brief Stops current operations and starts a given one
5478 * \param id - The id of the operation to start
5480 //================================================================================
5482 void SMESHGUI::switchToOperation(int id)
5484 if ( _PTR(Study) aStudy = SMESH::GetActiveStudyDocument() )
5485 activeStudy()->abortAllOperations();
5486 startOperation( id );
5489 LightApp_Displayer* SMESHGUI::displayer()
5492 myDisplayer = new SMESHGUI_Displayer( getApp() );
5496 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5499 int aTolerance = 64;
5500 int anIterations = 0;
5506 if( anIterations % aPeriod == 0 )
5509 if( aTolerance < 1 )
5513 aHue = (int)( 360.0 * rand() / RAND_MAX );
5516 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5517 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5518 for( ; it != itEnd; ++it )
5520 SALOMEDS::Color anAutoColor = *it;
5521 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5524 aQColor.getHsv( &h, &s, &v );
5525 if( abs( h - aHue ) < aTolerance )
5537 aColor.setHsv( aHue, 255, 255 );
5539 SALOMEDS::Color aSColor;
5540 aSColor.R = aColor.redF();
5541 aSColor.G = aColor.greenF();
5542 aSColor.B = aColor.blueF();
5547 const char* gSeparator = "_"; // character used to separate parameter names
5548 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5549 const char* gPathSep = "|"; // character used to separate paths
5552 * \brief Store visual parameters
5554 * This method is called just before the study document is saved.
5555 * Store visual parameters in AttributeParameter attribue(s)
5557 void SMESHGUI::storeVisualParameters (int savePoint)
5560 Kernel_Utils::Localizer loc;
5562 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5563 if (!appStudy || !appStudy->studyDS())
5565 _PTR(Study) studyDS = appStudy->studyDS();
5567 // componentName is used for encoding of entries when storing them in IParameters
5568 std::string componentName = myComponentSMESH->ComponentDataType();
5569 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5570 //if (!aSComponent) return;
5573 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5574 componentName.c_str(),
5576 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5578 // store map of custom markers
5579 const VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5580 if( !aMarkerMap.empty() )
5582 VTK::MarkerMap::const_iterator anIter = aMarkerMap.begin();
5583 for( ; anIter != aMarkerMap.end(); anIter++ )
5585 int anId = anIter->first;
5586 VTK::MarkerData aMarkerData = anIter->second;
5587 std::string aMarkerFileName = aMarkerData.first;
5588 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5589 if( aMarkerTexture.size() < 3 )
5590 continue; // should contain at least width, height and the first value
5592 QString aPropertyName( "texture" );
5593 aPropertyName += gSeparator;
5594 aPropertyName += QString::number( anId );
5596 QString aPropertyValue = aMarkerFileName.c_str();
5597 aPropertyValue += gPathSep;
5599 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5600 ushort aWidth = *aTextureIter++;
5601 ushort aHeight = *aTextureIter++;
5602 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5603 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5604 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5605 aPropertyValue += QString::number( *aTextureIter );
5607 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5611 // viewers counters are used for storing view_numbers in IParameters
5614 // main cycle to store parameters of displayed objects
5615 QList<SUIT_ViewManager*> lst;
5616 QList<SUIT_ViewManager*>::Iterator it;
5617 getApp()->viewManagers(lst);
5618 for (it = lst.begin(); it != lst.end(); it++)
5620 SUIT_ViewManager* vman = *it;
5621 QString vType = vman->getType();
5623 // saving VTK actors properties
5624 if (vType == SVTK_Viewer::Type())
5626 // store the clipping planes attached to the view manager
5627 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5628 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5629 if( anIter != myClippingPlaneInfoMap.end() )
5630 aClippingPlaneInfoList = anIter->second;
5632 if( !aClippingPlaneInfoList.empty() ) {
5633 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5634 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5636 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5637 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5639 QString aPropertyName( "ClippingPlane" );
5640 aPropertyName += gSeparator;
5641 aPropertyName += QString::number( vtkViewers );
5642 aPropertyName += gSeparator;
5643 aPropertyName += QString::number( anId );
5645 QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
5646 aPropertyValue += gDigitsSep;
5647 aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
5648 aPropertyValue += gDigitsSep;
5649 if ( aPlane->PlaneMode == SMESH::Absolute ) {
5650 aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
5651 aPropertyValue += gDigitsSep;
5652 aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
5653 aPropertyValue += gDigitsSep;
5654 aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
5655 aPropertyValue += gDigitsSep;
5656 aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
5657 aPropertyValue += gDigitsSep;
5658 aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
5659 aPropertyValue += gDigitsSep;
5660 aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
5661 aPropertyValue += gDigitsSep;
5662 aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
5664 else if ( aPlane->PlaneMode == SMESH::Relative ) {
5665 aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
5666 aPropertyValue += gDigitsSep;
5667 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5668 aPropertyValue += gDigitsSep;
5669 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5670 aPropertyValue += gDigitsSep;
5671 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5674 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5678 QVector<SUIT_ViewWindow*> views = vman->getViews();
5679 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5681 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5683 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5684 vtkActorCollection* allActors = aCopy.GetActors();
5685 allActors->InitTraversal();
5686 while (vtkActor* actor = allActors->GetNextActor())
5688 if (actor->GetVisibility()) // store only visible actors
5690 SMESH_Actor* aSmeshActor = 0;
5691 if (actor->IsA("SMESH_Actor"))
5692 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5693 if (aSmeshActor && aSmeshActor->hasIO())
5695 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5698 // entry is "encoded" = it does NOT contain component adress,
5699 // since it is a subject to change on next component loading
5700 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5702 std::string param, vtkParam = vType.toLatin1().data();
5703 vtkParam += gSeparator;
5704 vtkParam += QString::number(vtkViewers).toLatin1().data();
5705 vtkParam += gSeparator;
5708 param = vtkParam + "Visibility";
5709 ip->setParameter(entry, param, "On");
5712 param = vtkParam + "Representation";
5713 ip->setParameter(entry, param, QString::number
5714 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5717 param = vtkParam + "IsShrunk";
5718 ip->setParameter(entry, param, QString::number
5719 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5721 // Displayed entities
5722 unsigned int aMode = aSmeshActor->GetEntityMode();
5723 bool isE = aMode & SMESH_Actor::eEdges;
5724 bool isF = aMode & SMESH_Actor::eFaces;
5725 bool isV = aMode & SMESH_Actor::eVolumes;
5726 bool is0d = aMode & SMESH_Actor::e0DElements;
5727 bool isB = aMode & SMESH_Actor::eBallElem;
5729 QString modeStr ("e");
5730 modeStr += gDigitsSep; modeStr += QString::number(isE);
5731 modeStr += gDigitsSep; modeStr += "f";
5732 modeStr += gDigitsSep; modeStr += QString::number(isF);
5733 modeStr += gDigitsSep; modeStr += "v";
5734 modeStr += gDigitsSep; modeStr += QString::number(isV);
5735 modeStr += gDigitsSep; modeStr += "0d";
5736 modeStr += gDigitsSep; modeStr += QString::number(is0d);
5737 modeStr += gDigitsSep; modeStr += "b";
5738 modeStr += gDigitsSep; modeStr += QString::number(isB);
5740 param = vtkParam + "Entities";
5741 ip->setParameter(entry, param, modeStr.toLatin1().data());
5747 aSmeshActor->GetSufaceColor(r, g, b, delta);
5748 QStringList colorStr;
5749 colorStr << "surface";
5750 colorStr << QString::number(r);
5751 colorStr << QString::number(g);
5752 colorStr << QString::number(b);
5754 colorStr << "backsurface";
5755 colorStr << QString::number(delta);
5757 aSmeshActor->GetVolumeColor(r, g, b, delta);
5758 colorStr << "volume";
5759 colorStr << QString::number(r);
5760 colorStr << QString::number(g);
5761 colorStr << QString::number(b);
5762 colorStr << QString::number(delta);
5764 aSmeshActor->GetEdgeColor(r, g, b);
5766 colorStr << QString::number(r);
5767 colorStr << QString::number(g);
5768 colorStr << QString::number(b);
5770 aSmeshActor->GetNodeColor(r, g, b);
5772 colorStr << QString::number(r);
5773 colorStr << QString::number(g);
5774 colorStr << QString::number(b);
5776 aSmeshActor->GetOutlineColor(r, g, b);
5777 colorStr << "outline";
5778 colorStr << QString::number(r);
5779 colorStr << QString::number(g);
5780 colorStr << QString::number(b);
5782 aSmeshActor->Get0DColor(r, g, b);
5783 colorStr << "elem0d";
5784 colorStr << QString::number(r);
5785 colorStr << QString::number(g);
5786 colorStr << QString::number(b);
5788 aSmeshActor->GetBallColor(r, g, b);
5790 colorStr << QString::number(r);
5791 colorStr << QString::number(g);
5792 colorStr << QString::number(b);
5794 aSmeshActor->GetFacesOrientationColor(r, g, b);
5795 colorStr << "orientation";
5796 colorStr << QString::number(r);
5797 colorStr << QString::number(g);
5798 colorStr << QString::number(b);
5800 param = vtkParam + "Colors";
5801 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
5804 QStringList sizeStr;
5806 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
5807 sizeStr << "outline";
5808 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
5809 sizeStr << "elem0d";
5810 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
5812 sizeStr << QString::number((int)aSmeshActor->GetBallSize());
5813 sizeStr << QString::number((double)aSmeshActor->GetBallScale());
5814 sizeStr << "shrink";
5815 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
5816 sizeStr << "orientation";
5817 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
5818 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
5820 param = vtkParam + "Sizes";
5821 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
5826 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5827 if( aMarkerType == VTK::MT_USER ) {
5828 markerStr += "custom";
5829 markerStr += gDigitsSep;
5830 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
5834 markerStr += gDigitsSep;
5835 markerStr += QString::number( (int)aMarkerType );
5836 markerStr += gDigitsSep;
5837 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
5840 param = vtkParam + "PointMarker";
5841 ip->setParameter(entry, param, markerStr.toLatin1().data());
5844 param = vtkParam + "Opacity";
5845 ip->setParameter(entry, param,
5846 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
5849 param = vtkParam + "ClippingPlane";
5851 if( !aClippingPlaneInfoList.empty() ) {
5852 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
5853 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
5855 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
5856 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
5857 SMESH::TActorList::iterator anIter2 = anActorList.begin();
5858 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
5859 if( aSmeshActor == *anIter2 ) {
5860 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
5861 QString::number( anId ).toLatin1().constData() );
5868 ip->setParameter( entry, param, "Off" );
5869 } // if (io->hasEntry())
5870 } // SMESH_Actor && hasIO
5872 } // while.. actors traversal
5876 } // if (SVTK view model)
5877 } // for (viewManagers)
5880 // data structures for clipping planes processing
5884 bool isOpenGLClipping;
5885 vtkIdType RelativeOrientation;
5888 int AbsoluteOrientation;
5889 double X, Y, Z, Dx, Dy, Dz;
5891 typedef std::list<TPlaneData> TPlaneDataList;
5892 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
5894 typedef std::list<vtkActor*> TActorList;
5897 TActorList ActorList;
5898 SUIT_ViewManager* ViewManager;
5900 typedef std::list<TPlaneInfo> TPlaneInfoList;
5901 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
5904 * \brief Restore visual parameters
5906 * This method is called after the study document is opened.
5907 * Restore visual parameters from AttributeParameter attribue(s)
5909 void SMESHGUI::restoreVisualParameters (int savePoint)
5912 Kernel_Utils::Localizer loc;
5914 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5915 if (!appStudy || !appStudy->studyDS())
5917 _PTR(Study) studyDS = appStudy->studyDS();
5919 // componentName is used for encoding of entries when storing them in IParameters
5920 std::string componentName = myComponentSMESH->ComponentDataType();
5921 //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
5922 //if (!aSComponent) return;
5925 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5926 componentName.c_str(),
5928 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5930 // restore map of custom markers and map of clipping planes
5931 VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5932 TPlaneDataMap aPlaneDataMap;
5934 std::vector<std::string> properties = ip->getProperties();
5935 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
5937 std::string property = *propIt;
5938 QString aPropertyName( property.c_str() );
5939 QString aPropertyValue( ip->getProperty( property ).c_str() );
5941 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
5942 if( aPropertyNameList.isEmpty() )
5945 QString aPropertyType = aPropertyNameList[0];
5946 if( aPropertyType == "texture" )
5948 if( aPropertyNameList.size() != 2 )
5952 int anId = aPropertyNameList[1].toInt( &ok );
5953 if( !ok || anId < 1 )
5956 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
5957 if( aPropertyValueList.size() != 2 )
5960 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
5961 QString aMarkerTextureString = aPropertyValueList[1];
5962 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
5963 if( aMarkerTextureStringList.size() != 3 )
5967 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
5972 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
5976 VTK::MarkerTexture aMarkerTexture;
5977 aMarkerTexture.push_back( aWidth );
5978 aMarkerTexture.push_back( aHeight );
5980 QString aMarkerTextureData = aMarkerTextureStringList[2];
5981 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
5983 QChar aChar = aMarkerTextureData.at( i );
5984 if( aChar.isDigit() )
5985 aMarkerTexture.push_back( aChar.digitValue() );
5988 aMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
5990 else if( aPropertyType == "ClippingPlane" )
5992 if( aPropertyNameList.size() != 3 )
5996 int aViewId = aPropertyNameList[1].toInt( &ok );
5997 if( !ok || aViewId < 0 )
6001 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6002 if( !ok || aClippingPlaneId < 0 )
6005 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6006 if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6009 TPlaneData aPlaneData;
6010 aPlaneData.Id = aClippingPlaneId;
6013 aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6018 aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6022 if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6025 aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6030 aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6035 aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6040 aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6045 aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6050 aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6055 aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6059 else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6061 aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6066 aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6071 aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6076 aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6081 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6082 aPlaneDataList.push_back( aPlaneData );
6086 TPlaneInfoMap aPlaneInfoMap;
6088 std::vector<std::string> entries = ip->getEntries();
6090 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6092 // entry is a normal entry - it should be "decoded" (setting base adress of component)
6093 QString entry (ip->decodeEntry(*entIt).c_str());
6095 // Check that the entry corresponds to a real object in the Study
6096 // as the object may be deleted or modified after the visual state is saved.
6097 _PTR(SObject) so = studyDS->FindObjectID(entry.toLatin1().data());
6098 if (!so) continue; //Skip the not existent entry
6100 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6101 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6103 std::vector<std::string>::iterator namesIt = paramNames.begin();
6104 std::vector<std::string>::iterator valuesIt = paramValues.begin();
6106 // actors are stored in a map after displaying of them for
6107 // quicker access in the future: map < viewID to actor >
6108 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6110 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6112 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6113 // '_' is used as separator and should not be used in viewer type or parameter names.
6114 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6115 if (lst.size() != 3)
6118 QString viewerTypStr = lst[0];
6119 QString viewIndexStr = lst[1];
6120 QString paramNameStr = lst[2];
6123 int viewIndex = viewIndexStr.toUInt(&ok);
6124 if (!ok) // bad conversion of view index to integer
6128 if (viewerTypStr == SVTK_Viewer::Type())
6130 SMESH_Actor* aSmeshActor = 0;
6131 if (vtkActors.IsBound(viewIndex))
6132 aSmeshActor = vtkActors.Find(viewIndex);
6134 QList<SUIT_ViewManager*> lst;
6135 getApp()->viewManagers(viewerTypStr, lst);
6137 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6138 SUIT_ViewManager* vman = NULL;
6139 if (viewIndex >= 0 && viewIndex < lst.count())
6140 vman = lst.at(viewIndex);
6142 if (paramNameStr == "Visibility")
6144 if (!aSmeshActor && displayer() && vman)
6146 SUIT_ViewModel* vmodel = vman->getViewModel();
6147 // SVTK view model can be casted to SALOME_View
6148 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6150 // store displayed actor in a temporary map for quicker
6151 // access later when restoring other parameters
6152 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6153 vtkRenderer* Renderer = vtkView->getRenderer();
6154 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6155 vtkActorCollection* theActors = aCopy.GetActors();
6156 theActors->InitTraversal();
6157 bool isFound = false;
6158 vtkActor *ac = theActors->GetNextActor();
6159 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6160 if (ac->IsA("SMESH_Actor")) {
6161 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6162 if (aGeomAc->hasIO()) {
6163 Handle(SALOME_InteractiveObject) io =
6164 Handle(SALOME_InteractiveObject)::DownCast(aGeomAc->getIO());
6165 if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) {
6167 vtkActors.Bind(viewIndex, aGeomAc);
6173 } // if (paramNameStr == "Visibility")
6176 // the rest properties "work" with SMESH_Actor
6179 QString val ((*valuesIt).c_str());
6182 if (paramNameStr == "Representation") {
6183 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6186 else if (paramNameStr == "IsShrunk") {
6188 if (!aSmeshActor->IsShrunk())
6189 aSmeshActor->SetShrink();
6192 if (aSmeshActor->IsShrunk())
6193 aSmeshActor->UnShrink();
6196 // Displayed entities
6197 else if (paramNameStr == "Entities") {
6198 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6199 int aEntityMode = SMESH_Actor::eAllEntity;
6200 for ( int i = 0; i < mode.count(); i+=2 ) {
6201 if ( i < mode.count()-1 ) {
6202 QString type = mode[i];
6203 bool val = mode[i+1].toInt();
6204 if ( type == "e" && !val )
6205 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6206 else if ( type == "f" && !val )
6207 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6208 else if ( type == "v" && !val )
6209 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6210 else if ( type == "0d" && !val )
6211 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6212 else if ( type == "b" && !val )
6213 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6216 aSmeshActor->SetEntityMode( aEntityMode );
6219 else if (paramNameStr == "Colors") {
6220 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6227 QColor outlineColor;
6228 QColor orientationColor;
6234 // below lines are required to get default values for delta coefficients
6235 // of backface color for faces and color of reversed volumes
6236 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
6237 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6238 for ( int i = 0; i < colors.count(); i++ ) {
6239 QString type = colors[i];
6240 if ( type == "surface" ) {
6241 // face color is set by 3 values r:g:b, where
6242 // - r,g,b - is rgb color components
6243 if ( i+1 >= colors.count() ) break; // format error
6244 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6245 if ( i+2 >= colors.count() ) break; // format error
6246 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6247 if ( i+3 >= colors.count() ) break; // format error
6248 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6249 faceColor.setRgbF( r, g, b );
6252 else if ( type == "backsurface" ) {
6253 // backface color can be defined in several ways
6254 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6255 // - in latest versions, it is set as delta coefficient
6256 bool rgbOk = false, deltaOk;
6257 if ( i+1 >= colors.count() ) break; // format error
6258 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6259 int delta = colors[i+1].toInt( &deltaOk );
6261 if ( i+1 < colors.count() ) // index is shifted to 1
6262 g = colors[i+1].toDouble( &rgbOk );
6263 if ( rgbOk ) i++; // shift index
6264 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6265 b = colors[i+1].toDouble( &rgbOk );
6267 // - as currently there's no way to set directly backsurface color as it was before,
6268 // we ignore old dump where r,g,b triple was set
6269 // - also we check that delta parameter is set properly
6270 if ( !rgbOk && deltaOk )
6273 else if ( type == "volume" ) {
6274 // volume color is set by 4 values r:g:b:delta, where
6275 // - r,g,b - is a normal volume rgb color components
6276 // - delta - is a reversed volume color delta coefficient
6277 if ( i+1 >= colors.count() ) break; // format error
6278 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6279 if ( i+2 >= colors.count() ) break; // format error
6280 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6281 if ( i+3 >= colors.count() ) break; // format error
6282 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6283 if ( i+4 >= colors.count() ) break; // format error
6284 int delta = colors[i+4].toInt( &bOk );
6285 if ( !bOk ) break; // format error
6286 volumeColor.setRgbF( r, g, b );
6290 else if ( type == "edge" ) {
6291 // edge color is set by 3 values r:g:b, where
6292 // - r,g,b - is rgb color components
6293 if ( i+1 >= colors.count() ) break; // format error
6294 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6295 if ( i+2 >= colors.count() ) break; // format error
6296 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6297 if ( i+3 >= colors.count() ) break; // format error
6298 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6299 edgeColor.setRgbF( r, g, b );
6302 else if ( type == "node" ) {
6303 // node color is set by 3 values r:g:b, where
6304 // - r,g,b - is rgb color components
6305 if ( i+1 >= colors.count() ) break; // format error
6306 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6307 if ( i+2 >= colors.count() ) break; // format error
6308 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6309 if ( i+3 >= colors.count() ) break; // format error
6310 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6311 nodeColor.setRgbF( r, g, b );
6314 else if ( type == "elem0d" ) {
6315 // 0d element color is set by 3 values r:g:b, where
6316 // - r,g,b - is rgb color components
6317 if ( i+1 >= colors.count() ) break; // format error
6318 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6319 if ( i+2 >= colors.count() ) break; // format error
6320 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6321 if ( i+3 >= colors.count() ) break; // format error
6322 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6323 elem0dColor.setRgbF( r, g, b );
6326 else if ( type == "ball" ) {
6327 // ball color is set by 3 values r:g:b, where
6328 // - r,g,b - is rgb color components
6329 if ( i+1 >= colors.count() ) break; // format error
6330 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6331 if ( i+2 >= colors.count() ) break; // format error
6332 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6333 if ( i+3 >= colors.count() ) break; // format error
6334 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6335 ballColor.setRgbF( r, g, b );
6338 else if ( type == "outline" ) {
6339 // outline color is set by 3 values r:g:b, where
6340 // - r,g,b - is rgb color components
6341 if ( i+1 >= colors.count() ) break; // format error
6342 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6343 if ( i+2 >= colors.count() ) break; // format error
6344 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6345 if ( i+3 >= colors.count() ) break; // format error
6346 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6347 outlineColor.setRgbF( r, g, b );
6350 else if ( type == "orientation" ) {
6351 // orientation color is set by 3 values r:g:b, where
6352 // - r,g,b - is rgb color components
6353 if ( i+1 >= colors.count() ) break; // format error
6354 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6355 if ( i+2 >= colors.count() ) break; // format error
6356 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6357 if ( i+3 >= colors.count() ) break; // format error
6358 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6359 orientationColor.setRgbF( r, g, b );
6364 if ( nodeColor.isValid() )
6365 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6367 if ( edgeColor.isValid() )
6368 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6370 if ( faceColor.isValid() )
6371 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6373 if ( volumeColor.isValid() )
6374 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6375 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6376 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6378 if ( elem0dColor.isValid() )
6379 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6381 if ( ballColor.isValid() )
6382 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6384 if ( outlineColor.isValid() )
6385 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6386 // orientation color
6387 if ( orientationColor.isValid() )
6388 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6391 else if (paramNameStr == "Sizes") {
6392 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6395 int outlineWidth = -1;
6396 int elem0dSize = -1;
6398 double ballScale = -1.0;
6399 double shrinkSize = -1;
6400 double orientationSize = -1;
6401 bool orientation3d = false;
6402 for ( int i = 0; i < sizes.count(); i++ ) {
6403 QString type = sizes[i];
6404 if ( type == "line" ) {
6405 // line (wireframe) width is given as single integer value
6406 if ( i+1 >= sizes.count() ) break; // format error
6407 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6411 if ( type == "outline" ) {
6412 // outline width is given as single integer value
6413 if ( i+1 >= sizes.count() ) break; // format error
6414 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6418 else if ( type == "elem0d" ) {
6419 // 0d element size is given as single integer value
6420 if ( i+1 >= sizes.count() ) break; // format error
6421 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6425 else if ( type == "ball" ) {
6426 // balls are specified by two values: size:scale, where
6427 // - size - is a integer value specifying size
6428 // - scale - is a double value specifying scale factor
6429 if ( i+1 >= sizes.count() ) break; // format error
6430 int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6431 if ( i+2 >= sizes.count() ) break; // format error
6432 double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6437 else if ( type == "shrink" ) {
6438 // shrink factor is given as single floating point value
6439 if ( i+1 >= sizes.count() ) break; // format error
6440 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6444 else if ( type == "orientation" ) {
6445 // orientation vectors are specified by two values size:3d, where
6446 // - size - is a floating point value specifying scale factor
6447 // - 3d - is a boolean
6448 if ( i+1 >= sizes.count() ) break; // format error
6449 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6450 if ( i+2 >= sizes.count() ) break; // format error
6451 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6452 orientationSize = v1;
6453 orientation3d = (bool)v2;
6457 // line (wireframe) width
6458 if ( lineWidth > 0 )
6459 aSmeshActor->SetLineWidth( lineWidth );
6461 if ( outlineWidth > 0 )
6462 aSmeshActor->SetOutlineWidth( outlineWidth );
6463 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6464 aSmeshActor->SetOutlineWidth( lineWidth );
6466 if ( elem0dSize > 0 )
6467 aSmeshActor->Set0DSize( elem0dSize );
6470 aSmeshActor->SetBallSize( ballSize );
6472 if ( ballScale > 0.0 )
6473 aSmeshActor->SetBallScale( ballScale );
6475 if ( shrinkSize > 0 )
6476 aSmeshActor->SetShrinkFactor( shrinkSize );
6477 // orientation vectors
6478 if ( orientationSize > 0 ) {
6479 aSmeshActor->SetFacesOrientationScale( orientationSize );
6480 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6484 else if (paramNameStr == "PointMarker") {
6485 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6486 if( data.count() >= 2 ) {
6488 int aParam1 = data[1].toInt( &ok );
6490 if( data[0] == "std" && data.count() == 3 ) {
6491 int aParam2 = data[2].toInt( &ok );
6492 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6494 else if( data[0] == "custom" ) {
6495 VTK::MarkerMap::const_iterator markerIt = aMarkerMap.find( aParam1 );
6496 if( markerIt != aMarkerMap.end() ) {
6497 VTK::MarkerData aMarkerData = markerIt->second;
6498 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6505 else if (paramNameStr == "Opacity") {
6506 aSmeshActor->SetOpacity(val.toFloat());
6509 else if (paramNameStr.startsWith("ClippingPlane")) {
6510 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6511 // old format - val looks like "Off" or "1:0:0:0.5:0:0"
6512 // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
6513 // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
6514 // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
6515 // new format - val looks like "Off" or "0" (plane id)
6516 // (note: in new format "Off" value is used only for consistency,
6517 // so it is processed together with values in old format)
6518 bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
6519 if( anIsOldFormat ) {
6520 if (paramNameStr == "ClippingPlane1" || val == "Off")
6521 aSmeshActor->RemoveAllClippingPlanes();
6523 QList<SUIT_ViewManager*> lst;
6524 getApp()->viewManagers(viewerTypStr, lst);
6525 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6526 if (viewIndex >= 0 && viewIndex < lst.count()) {
6527 SUIT_ViewManager* vman = lst.at(viewIndex);
6528 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6530 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6532 SMESH::TActorList anActorList;
6533 anActorList.push_back( aSmeshActor );
6534 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
6535 aPlane->myViewWindow = vtkView;
6536 SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
6537 aPlane->PlaneMode = aMode;
6538 bool isOpenGLClipping = ( bool )vals[1].toInt();
6539 aPlane->IsOpenGLClipping = isOpenGLClipping;
6540 if ( aMode == SMESH::Absolute ) {
6541 aPlane->myAbsoluteOrientation = vals[2].toInt();
6542 aPlane->X = vals[3].toFloat();
6543 aPlane->Y = vals[4].toFloat();
6544 aPlane->Z = vals[5].toFloat();
6545 aPlane->Dx = vals[6].toFloat();
6546 aPlane->Dy = vals[7].toFloat();
6547 aPlane->Dz = vals[8].toFloat();
6549 else if ( aMode == SMESH::Relative ) {
6550 aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
6551 aPlane->myDistance = vals[3].toFloat();
6552 aPlane->myAngle[0] = vals[4].toFloat();
6553 aPlane->myAngle[1] = vals[5].toFloat();
6557 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6558 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6559 aClippingPlaneInfo.Plane = aPlane;
6560 aClippingPlaneInfo.ActorList = anActorList;
6561 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6569 int aPlaneId = val.toInt( &ok );
6570 if( ok && aPlaneId >= 0 ) {
6571 bool anIsDefinedPlane = false;
6572 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6573 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6574 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6575 TPlaneInfo& aPlaneInfo = *anIter;
6576 if( aPlaneInfo.PlaneId == aPlaneId ) {
6577 aPlaneInfo.ActorList.push_back( aSmeshActor );
6578 anIsDefinedPlane = true;
6582 if( !anIsDefinedPlane ) {
6583 TPlaneInfo aPlaneInfo;
6584 aPlaneInfo.PlaneId = aPlaneId;
6585 aPlaneInfo.ActorList.push_back( aSmeshActor );
6586 aPlaneInfo.ViewManager = vman;
6588 // to make the list sorted by plane id
6589 anIter = aPlaneInfoList.begin();
6590 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6591 const TPlaneInfo& aPlaneInfoRef = *anIter;
6592 if( aPlaneInfoRef.PlaneId > aPlaneId )
6595 aPlaneInfoList.insert( anIter, aPlaneInfo );
6600 } // if (aSmeshActor)
6601 } // other parameters than Visibility
6603 } // for names/parameters iterator
6604 } // for entries iterator
6606 // take into account planes with empty list of actors referred to them
6607 QList<SUIT_ViewManager*> aVMList;
6608 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6610 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6611 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6612 int aViewId = aPlaneDataIter->first;
6613 if( aViewId >= 0 && aViewId < aVMList.count() ) {
6614 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6616 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6618 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6619 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6620 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6621 const TPlaneData& aPlaneData = *anIter2;
6622 int aPlaneId = aPlaneData.Id;
6624 bool anIsFound = false;
6625 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6626 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6627 const TPlaneInfo& aPlaneInfo = *anIter3;
6628 if( aPlaneInfo.PlaneId == aPlaneId ) {
6635 TPlaneInfo aPlaneInfo; // ActorList field is empty
6636 aPlaneInfo.PlaneId = aPlaneId;
6637 aPlaneInfo.ViewManager = aViewManager;
6639 // to make the list sorted by plane id
6640 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6641 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6642 const TPlaneInfo& aPlaneInfoRef = *anIter4;
6643 if( aPlaneInfoRef.PlaneId > aPlaneId )
6646 aPlaneInfoList.insert( anIter4, aPlaneInfo );
6652 // add clipping planes to actors according to the restored parameters
6653 // and update the clipping plane map
6654 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6655 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6656 int aViewId = anIter1->first;
6657 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6659 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6660 if( anIter2 == aPlaneDataMap.end() )
6662 const TPlaneDataList& aPlaneDataList = anIter2->second;
6664 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6665 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6666 const TPlaneInfo& aPlaneInfo = *anIter3;
6667 int aPlaneId = aPlaneInfo.PlaneId;
6668 const TActorList& anActorList = aPlaneInfo.ActorList;
6669 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6673 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6677 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6679 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6680 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6681 const TPlaneData& aPlaneData = *anIter4;
6682 if( aPlaneData.Id == aPlaneId ) {
6683 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
6684 aPlane->myViewWindow = aViewWindow;
6685 aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
6686 aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
6687 if ( aPlane->PlaneMode == SMESH::Absolute ) {
6688 aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
6689 aPlane->X = aPlaneData.X;
6690 aPlane->Y = aPlaneData.Y;
6691 aPlane->Z = aPlaneData.Z;
6692 aPlane->Dx = aPlaneData.Dx;
6693 aPlane->Dy = aPlaneData.Dy;
6694 aPlane->Dz = aPlaneData.Dz;
6696 else if ( aPlane->PlaneMode == SMESH::Relative ) {
6697 aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
6698 aPlane->myDistance = aPlaneData.Distance;
6699 aPlane->myAngle[0] = aPlaneData.Angle[0];
6700 aPlane->myAngle[1] = aPlaneData.Angle[1];
6703 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6704 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6705 aClippingPlaneInfo.Plane = aPlane;
6706 aClippingPlaneInfo.ActorList = anActorList;
6707 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6718 // update all VTK views
6719 QList<SUIT_ViewManager*> lst;
6720 getApp()->viewManagers(lst);
6721 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6722 SUIT_ViewModel* vmodel = (*it)->getViewModel();
6723 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6724 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6725 // set OpenGL clipping planes
6726 VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
6727 vtkActorCollection* anAllActors = aCopy.GetActors();
6728 anAllActors->InitTraversal();
6729 while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
6730 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
6731 anActor->SetOpenGLClippingPlane();
6733 vtkView->getRenderer()->ResetCameraClippingRange();
6740 \brief Adds preferences for dfont of VTK viewer
6742 \param pIf group identifier
6743 \param param parameter
6744 \return identifier of preferences
6746 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
6748 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6750 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6753 fam.append( tr( "SMESH_FONT_ARIAL" ) );
6754 fam.append( tr( "SMESH_FONT_COURIER" ) );
6755 fam.append( tr( "SMESH_FONT_TIMES" ) );
6757 setPreferenceProperty( tfont, "fonts", fam );
6759 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6760 if ( needSize ) f = f | QtxFontEdit::Size;
6761 setPreferenceProperty( tfont, "features", f );
6767 \brief Actions after hypothesis edition
6768 Updates object browser after hypothesis edition
6770 void SMESHGUI::onHypothesisEdit( int result )
6773 SMESHGUI::Modified();
6774 updateObjBrowser( true );
6779 \brief Signal handler closing(SUIT_ViewWindow*) of a view
6780 \param pview view being closed
6782 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
6783 #ifndef DISABLE_PLOT2DVIEWER
6784 //Crear all Plot2d Viewers if need.
6785 SMESH::ClearPlot2Viewers(pview);
6789 void SMESHGUI::message( const QString& msg )
6792 QStringList data = msg.split("/");
6793 if ( data.count() > 0 ) {
6794 if ( data.first() == "mesh_loading" ) {
6796 QString entry = data.count() > 1 ? data[1] : QString();
6797 if ( entry.isEmpty() )
6800 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
6802 _PTR(SObject) obj = study->FindObjectID( entry.toLatin1().constData() );
6805 name = SMESH::fromUtf8(obj->GetName());
6806 if ( name.isEmpty() )
6809 if ( data.last() == "stop" )
6810 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
6812 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
6813 QApplication::processEvents();
6819 \brief Connects or disconnects signals about activating and cloning view on the module slots
6820 \param pview view which is connected/disconnected
6822 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
6826 SUIT_ViewManager* viewMgr = pview->getViewManager();
6828 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6829 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6831 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6832 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6837 \brief Return \c true if object can be renamed
6839 bool SMESHGUI::renameAllowed( const QString& entry) const {
6840 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6844 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6848 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
6853 if(appStudy->isComponent(entry) || obj->isReference())
6856 // check type to prevent renaming of inappropriate objects
6857 int aType = SMESHGUI_Selection::type(qPrintable(entry), SMESH::GetActiveStudyDocument());
6858 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6859 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6860 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6861 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6862 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
6869 Rename object by entry.
6870 \param entry entry of the object
6871 \param name new name of the object
6872 \brief Return \c true if rename operation finished successfully, \c false otherwise.
6874 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
6876 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6880 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6885 _PTR(Study) aStudy = appStudy->studyDS();
6890 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
6892 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
6897 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
6898 _PTR(GenericAttribute) anAttr;
6899 _PTR(AttributeName) aName;
6901 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
6903 // check type to prevent renaming of inappropriate objects
6904 int aType = SMESHGUI_Selection::type( qPrintable(entry), SMESH::GetActiveStudyDocument() );
6905 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6906 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6907 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6908 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6909 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
6910 if ( !name.isEmpty() ) {
6911 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
6913 // update name of group object and its actor
6914 Handle(SALOME_InteractiveObject) IObject =
6915 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
6917 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
6918 if( !aGroupObject->_is_nil() ) {
6919 aGroupObject->SetName( qPrintable(name) );
6920 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
6921 anActor->setName( qPrintable(name) );
6931 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
6933 static QList<QColor> colors;
6935 if ( colors.isEmpty() ) {
6937 for (int s = 0; s < 2 ; s++)
6939 for (int v = 100; v >= 40; v = v - 20)
6941 for (int h = 0; h < 359 ; h = h + 60)
6943 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
6948 static int currentColor = randomize( colors.size() );
6950 SALOMEDS::Color color;
6951 color.R = (double)colors[currentColor].red() / 255.0;
6952 color.G = (double)colors[currentColor].green() / 255.0;
6953 color.B = (double)colors[currentColor].blue() / 255.0;
6955 currentColor = (currentColor+1) % colors.count();