1 // Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
3 // Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
6 // This library is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU Lesser General Public
8 // License as published by the Free Software Foundation; either
9 // version 2.1 of the License, or (at your option) any later version.
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 // Lesser General Public License for more details.
16 // You should have received a copy of the GNU Lesser General Public
17 // License along with this library; if not, write to the Free Software
18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
22 // File : SMESHGUI.cxx
23 // Author : Nicolas REJNERI, Open CASCADE S.A.S.
25 #include <Standard_math.hxx> // E.A. must be included before Python.h to fix compilation on windows
27 #undef HAVE_FINITE // VSR: avoid compilation warning on Linux : "HAVE_FINITE" redefined
33 #include "SMESHGUI_Add0DElemsOnAllNodesDlg.h"
34 #include "SMESHGUI_AddMeshElementDlg.h"
35 #include "SMESHGUI_AddQuadraticElementDlg.h"
36 #include "SMESHGUI_BuildCompoundDlg.h"
37 #include "SMESHGUI_ClippingDlg.h"
38 #include "SMESHGUI_ComputeDlg.h"
39 #include "SMESHGUI_ConvToQuadOp.h"
40 #include "SMESHGUI_CopyMeshDlg.h"
41 #include "SMESHGUI_CreatePolyhedralVolumeDlg.h"
42 #include "SMESHGUI_DeleteGroupDlg.h"
43 #include "SMESHGUI_Displayer.h"
44 #include "SMESHGUI_DuplicateNodesDlg.h"
45 #include "SMESHGUI_ExtrusionAlongPathDlg.h"
46 #include "SMESHGUI_ExtrusionDlg.h"
47 #include "SMESHGUI_FieldSelectorWdg.h"
48 #include "SMESHGUI_FileInfoDlg.h"
49 #include "SMESHGUI_FileValidator.h"
50 #include "SMESHGUI_FilterDlg.h"
51 #include "SMESHGUI_FilterLibraryDlg.h"
52 #include "SMESHGUI_FindElemByPointDlg.h"
53 #include "SMESHGUI_GroupDlg.h"
54 #include "SMESHGUI_GroupOnShapeDlg.h"
55 #include "SMESHGUI_GroupOpDlg.h"
56 #include "SMESHGUI_Hypotheses.h"
57 #include "SMESHGUI_Make2DFrom3DOp.h"
58 #include "SMESHGUI_MakeNodeAtPointDlg.h"
59 #include "SMESHGUI_Measurements.h"
60 #include "SMESHGUI_MergeDlg.h"
61 #include "SMESHGUI_MeshInfo.h"
62 #include "SMESHGUI_MeshOp.h"
63 #include "SMESHGUI_MeshOrderOp.h"
64 #include "SMESHGUI_MeshPatternDlg.h"
65 #include "SMESHGUI_MultiEditDlg.h"
66 #include "SMESHGUI_NodesDlg.h"
67 #include "SMESHGUI_Operations.h"
68 #include "SMESHGUI_Preferences_ScalarBarDlg.h"
69 #include "SMESHGUI_PropertiesDlg.h"
70 #include "SMESHGUI_RemoveElementsDlg.h"
71 #include "SMESHGUI_RemoveNodesDlg.h"
72 #include "SMESHGUI_RenumberingDlg.h"
73 #include "SMESHGUI_ReorientFacesDlg.h"
74 #include "SMESHGUI_RevolutionDlg.h"
75 #include "SMESHGUI_RotationDlg.h"
76 #include "SMESHGUI_ScaleDlg.h"
77 #include "SMESHGUI_Selection.h"
78 #include "SMESHGUI_SewingDlg.h"
79 #include "SMESHGUI_SingleEditDlg.h"
80 #include "SMESHGUI_SmoothingDlg.h"
81 #include "SMESHGUI_SymmetryDlg.h"
82 #include "SMESHGUI_TranslationDlg.h"
83 #include "SMESHGUI_TransparencyDlg.h"
84 #include "SMESHGUI_DisplayEntitiesDlg.h"
85 #include "SMESHGUI_SplitBiQuad.h"
87 #include "SMESHGUI_FilterUtils.h"
88 #include "SMESHGUI_GEOMGenUtils.h"
89 #include "SMESHGUI_GroupUtils.h"
90 #include "SMESHGUI_HypothesesUtils.h"
91 #include "SMESHGUI_MeshUtils.h"
92 #include "SMESHGUI_PatternUtils.h"
93 #include "SMESHGUI_Utils.h"
94 #include "SMESHGUI_VTKUtils.h"
96 #include "SMESH_version.h"
98 #include "SMESH_ControlsDef.hxx"
99 #include "SMESH_Actor.h"
100 #include "SMESH_ActorUtils.h"
101 #include "SMESH_Client.hxx"
102 #include "SMESH_ScalarBarActor.h"
103 #include "SMESH_TypeFilter.hxx"
105 // SALOME GUI includes
106 #include <SalomeApp_Application.h>
107 #include <SalomeApp_CheckFileDlg.h>
108 #include <SalomeApp_DataObject.h>
109 #include <SalomeApp_Study.h>
110 #include <SalomeApp_Tools.h>
112 #include <LightApp_DataOwner.h>
113 #include <LightApp_NameDlg.h>
114 #include <LightApp_Preferences.h>
115 #include <LightApp_SelectionMgr.h>
116 #include <LightApp_UpdateFlags.h>
118 #include <SVTK_ViewManager.h>
119 #include <SVTK_ViewModel.h>
120 #include <SVTK_ViewWindow.h>
122 #include <VTKViewer_Algorithm.h>
124 #include <SUIT_Desktop.h>
125 #include <SUIT_FileDlg.h>
126 #include <SUIT_MessageBox.h>
127 #include <SUIT_OverrideCursor.h>
128 #include <SUIT_ResourceMgr.h>
129 #include <SUIT_Session.h>
131 #include <QtxPopupMgr.h>
132 #include <QtxFontEdit.h>
134 #include <SALOME_ListIO.hxx>
136 #ifndef DISABLE_PLOT2DVIEWER
137 #include <SPlot2d_ViewModel.h>
138 #include <SPlot2d_Histogram.h>
142 #include <SALOMEconfig.h>
143 #include CORBA_CLIENT_HEADER(SALOMEDS_Attributes)
144 #include CORBA_CLIENT_HEADER(SMESH_MeshEditor)
145 #include CORBA_CLIENT_HEADER(SMESH_Measurements)
148 // #define INCLUDE_MENUITEM_DEF // VSR commented ????????
149 #include <QApplication>
151 #include <QTextStream>
156 #include <boost/shared_ptr.hpp>
159 #include <vtkCallbackCommand.h>
160 #include <vtkCamera.h>
161 #include <vtkLookupTable.h>
162 #include <vtkPlane.h>
163 #include <vtkRenderer.h>
165 // SALOME KERNEL includes
166 #include <SALOMEDSClient_ClientFactory.hxx>
167 #include <SALOMEDSClient_IParameters.hxx>
168 #include <SALOMEDSClient_SComponent.hxx>
169 #include <SALOMEDSClient_StudyBuilder.hxx>
170 #include <SALOMEDS_Study.hxx>
171 #include <SALOMEDS_SObject.hxx>
172 #include "utilities.h"
175 #include <Standard_ErrorHandler.hxx>
176 #include <NCollection_DataMap.hxx>
177 #include <NCollection_DoubleMap.hxx>
179 #include <Basics_Utils.hxx>
181 // Below macro, when uncommented, switches on simplified (more performant) algorithm
182 // of auto-color picking up
183 #define SIMPLE_AUTOCOLOR
188 //=============================================================
189 void ImportMeshesFromFile(SMESH::SMESH_Gen_ptr theComponentMesh,
192 void ExportMeshToFile(int theCommandID);
194 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap);
196 void SetDisplayEntity(int theCommandID);
198 int ActionToControl( int theID, bool theReversed = false );
200 void Control( int theCommandID );
203 //================================================================================
205 * \brief Reads meshes from file
207 //================================================================================
209 void ImportMeshesFromFile( SMESH::SMESH_Gen_ptr theComponentMesh,
213 std::string myExtension;
215 if ( theCommandID == SMESHOp::OpImportMED ) {
216 filter.append( QObject::tr( "MED_FILES_FILTER" ) + " (*.*med)" );
217 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
219 else if ( theCommandID == SMESHOp::OpImportUNV ) {
220 filter.append( QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)" );
222 else if ( theCommandID == SMESHOp::OpImportDAT ) {
223 filter.append( QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)" );
225 else if ( theCommandID == SMESHOp::OpImportSTL ) {
226 filter.append( QObject::tr( "STL_FILES_FILTER" ) + " (*.stl)" );
229 else if ( theCommandID == SMESHOp::OpImportCGNS ) {
230 filter.append( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
233 else if ( theCommandID == SMESHOp::OpImportSAUV ) {
234 filter.append( QObject::tr( "SAUV files (*.sauv*)" ) );
235 filter.append( QObject::tr( "All files (*)" ) );
237 else if ( theCommandID == SMESHOp::OpImportGMF ) {
238 filter.append( QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" );
239 filter.append( QObject::tr( "GMF_BINARY_FILES_FILTER") + " (*.meshb)" );
242 QString anInitialPath = "";
243 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
244 anInitialPath = QDir::currentPath();
246 QStringList filenames;
247 bool toCreateGroups = true;
249 // if ( theCommandID == SMESHOp::OpImportGMF ) { // GMF
250 // SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg
251 // ( SMESHGUI::desktop(), true, QObject::tr("SMESH_REQUIRED_GROUPS"), true, true );
252 // fd->setWindowTitle( QObject::tr( "SMESH_IMPORT_MESH" ) );
253 // fd->setNameFilters( filter );
254 // fd->SetChecked( true );
256 // filenames << fd->selectedFile();
257 // toCreateGroups = fd->IsChecked();
263 filenames = SUIT_FileDlg::getOpenFileNames( SMESHGUI::desktop(),
266 QObject::tr( "SMESH_IMPORT_MESH" ) );
268 if ( filenames.count() > 0 )
270 SUIT_OverrideCursor wc;
271 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
274 QStringList anEntryList;
275 bool isEmpty = false;
276 for ( QStringList::ConstIterator it = filenames.begin(); it != filenames.end(); ++it )
278 QString filename = *it;
279 SMESH::mesh_array_var aMeshes = new SMESH::mesh_array;
281 switch ( theCommandID ) {
282 case SMESHOp::OpImportDAT:
284 // DAT format (currently unsupported)
285 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
286 arg( QObject::tr( "SMESH_ERR_NOT_SUPPORTED_FORMAT" ) ) );
289 case SMESHOp::OpImportUNV:
292 aMeshes->length( 1 );
293 aMeshes[0] = theComponentMesh->CreateMeshesFromUNV( filename.toUtf8().constData() );
294 if ( aMeshes[0]->_is_nil() )
295 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
296 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
299 case SMESHOp::OpImportMED:
302 SMESH::DriverMED_ReadStatus res;
303 aMeshes = theComponentMesh->CreateMeshesFromMED( filename.toUtf8().constData(), res );
304 if ( res != SMESH::DRS_OK ) {
305 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
306 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
310 case SMESHOp::OpImportSTL:
313 aMeshes->length( 1 );
314 aMeshes[0] = theComponentMesh->CreateMeshesFromSTL( filename.toUtf8().constData() );
315 if ( aMeshes[0]->_is_nil() ) {
316 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
317 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
322 case SMESHOp::OpImportCGNS:
325 SMESH::DriverMED_ReadStatus res;
326 aMeshes = theComponentMesh->CreateMeshesFromCGNS( filename.toUtf8().constData(), res );
327 if ( res != SMESH::DRS_OK ) {
328 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
329 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
334 case SMESHOp::OpImportSAUV:
337 SMESH::DriverMED_ReadStatus res;
338 aMeshes = theComponentMesh->CreateMeshesFromSAUV( filename.toUtf8().constData(), res );
339 if ( res != SMESH::DRS_OK ) {
340 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
341 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
345 case SMESHOp::OpImportGMF:
348 SMESH::ComputeError_var res;
349 aMeshes->length( 1 );
350 aMeshes[0] = theComponentMesh->CreateMeshesFromGMF( filename.toUtf8().constData(),
353 if ( res->code != SMESH::DRS_OK ) {
354 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
355 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res->code ).toLatin1().data() ) ) );
356 if ( strlen( res->comment.in() ) > 0 ) {
357 errors.back() += ": ";
358 errors.back() += res->comment.in();
365 catch ( const SALOME::SALOME_Exception& S_ex ) {
366 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
367 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
370 for ( int i = 0, iEnd = aMeshes->length(); i < iEnd; i++ )
372 _PTR(SObject) aMeshSO = SMESH::FindSObject( aMeshes[i] );
374 _PTR(StudyBuilder) aBuilder = aStudy->NewBuilder();
375 _PTR(AttributePixMap) aPixmap = aBuilder->FindOrCreateAttribute( aMeshSO, "AttributePixMap" );
376 aPixmap->SetPixMap( "ICON_SMESH_TREE_MESH_IMPORTED" );
377 if ( theCommandID == SMESHOp::OpImportUNV ) // mesh names aren't taken from the file for UNV import
378 SMESH::SetName( aMeshSO, QFileInfo(filename).fileName() );
380 anEntryList.append( aMeshSO->GetID().c_str() );
388 // update Object browser
389 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
391 // browse to the published meshes
392 if( LightApp_Application* anApp =
393 dynamic_cast<LightApp_Application*>( SUIT_Session::session()->activeApplication() ) )
394 anApp->browseObjects( anEntryList );
396 // show Error message box if there were errors
397 if ( errors.count() > 0 ) {
398 SUIT_MessageBox::critical( SMESHGUI::desktop(),
399 QObject::tr( "SMESH_ERROR" ),
400 QObject::tr( "SMESH_IMPORT_ERRORS" ) + "\n" + errors.join( "\n" ) );
403 // show warning message box, if some imported mesh is empty
405 SUIT_MessageBox::warning( SMESHGUI::desktop(),
406 QObject::tr( "SMESH_WRN_WARNING" ),
407 QObject::tr( "SMESH_DRS_SOME_EMPTY" ) );
412 //================================================================================
414 * \brief Export selected meshes or groups into a file
416 //================================================================================
418 void ExportMeshToFile( int theCommandID )
420 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
421 SALOME_ListIO selected;
423 aSel->selectedObjects( selected );
425 const bool isDAT = ( theCommandID == SMESHOp::OpExportDAT ||
426 theCommandID == SMESHOp::OpPopupExportDAT );
427 const bool isMED = ( theCommandID == SMESHOp::OpExportMED ||
428 theCommandID == SMESHOp::OpPopupExportMED );
429 const bool isUNV = ( theCommandID == SMESHOp::OpExportUNV ||
430 theCommandID == SMESHOp::OpPopupExportUNV );
431 const bool isSTL = ( theCommandID == SMESHOp::OpExportSTL ||
432 theCommandID == SMESHOp::OpPopupExportSTL );
434 const bool isCGNS= ( theCommandID == SMESHOp::OpExportCGNS ||
435 theCommandID == SMESHOp::OpPopupExportCGNS );
437 const bool isCGNS= false;
439 const bool isSAUV= ( theCommandID == SMESHOp::OpExportSAUV ||
440 theCommandID == SMESHOp::OpPopupExportSAUV );
441 const bool isGMF = ( theCommandID == SMESHOp::OpExportGMF ||
442 theCommandID == SMESHOp::OpPopupExportGMF );
444 const bool multiMeshSupported = ( isMED || isCGNS ); // file can hold several meshes
445 if ( selected.Extent() == 0 || ( selected.Extent() > 1 && !multiMeshSupported ))
448 // get mesh object from selection and check duplication of their names
449 bool hasDuplicatedMeshNames = false;
450 QList< QPair< SMESH::SMESH_IDSource_var, QString > > aMeshList;
451 QList< QPair< SMESH::SMESH_IDSource_var, QString > >::iterator aMeshIter;
452 SALOME_ListIteratorOfListIO It( selected );
453 for( ; It.More(); It.Next() )
455 Handle(SALOME_InteractiveObject) anIObject = It.Value();
456 SMESH::SMESH_IDSource_var aMeshItem =
457 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIObject);
458 if ( aMeshItem->_is_nil() ) {
459 SUIT_MessageBox::warning( SMESHGUI::desktop(),
460 QObject::tr( "SMESH_WRN_WARNING" ),
461 QObject::tr( "SMESH_BAD_MESH_SELECTION" ));
465 QString aMeshName = anIObject->getName();
467 // check for name duplications
468 if ( !hasDuplicatedMeshNames )
469 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
470 if( aMeshName == (*aMeshIter).second ) {
471 hasDuplicatedMeshNames = true;
476 aMeshList.append( QPair< SMESH::SMESH_IDSource_var, QString >( aMeshItem, aMeshName ) );
479 if( hasDuplicatedMeshNames && isMED ) {
480 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
481 QObject::tr("SMESH_WRN_WARNING"),
482 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_MESH_NAMES"),
483 QObject::tr("SMESH_BUT_YES"),
484 QObject::tr("SMESH_BUT_NO"), 0, 1);
489 aMeshIter = aMeshList.begin();
490 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
491 SMESH::SMESH_Mesh_var aMesh = aMeshOrGroup->GetMesh();
492 QString aMeshName = (*aMeshIter).second;
494 if ( isMED || isCGNS || isSAUV ) // formats where group names must be unique
496 // check for equal group names within each mesh
497 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
498 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
499 if ( !aMeshItem->_is_nil() && aMeshItem->HasDuplicatedGroupNamesMED()) {
500 int aRet = SUIT_MessageBox::warning
501 (SMESHGUI::desktop(),
502 QObject::tr("SMESH_WRN_WARNING"),
503 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_GRP").arg((*aMeshIter).second),
504 QObject::tr("SMESH_BUT_YES"),
505 QObject::tr("SMESH_BUT_NO"), 0, 1);
512 // Warn the user about presence of not supported elements
514 std::vector< SMESH::EntityType > notSupportedElemTypes, presentNotSupported;
518 notSupportedElemTypes.push_back( SMESH::Entity_0D );
519 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
524 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
525 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
526 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
527 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
528 notSupportedElemTypes.push_back( SMESH::Entity_Pyramid );
529 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
530 notSupportedElemTypes.push_back( SMESH::Entity_0D );
531 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
536 notSupportedElemTypes.push_back( SMESH::Entity_Edge );
537 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Edge );
538 notSupportedElemTypes.push_back( SMESH::Entity_0D );
539 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
544 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
549 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
550 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Triangle );
551 notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Quadrangle );
552 notSupportedElemTypes.push_back( SMESH::Entity_TriQuad_Hexa );
553 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
554 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
555 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
556 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
561 notSupportedElemTypes.push_back( SMESH::Entity_0D );
562 notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
563 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
564 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Pyramid );
565 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Penta );
566 notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
567 notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
568 notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polyhedra );
569 notSupportedElemTypes.push_back( SMESH::Entity_Ball );
571 if ( ! notSupportedElemTypes.empty() )
573 SMESH::long_array_var nbElems = aMeshOrGroup->GetMeshInfo();
574 for ( size_t iType = 0; iType < notSupportedElemTypes.size(); ++iType )
575 if ( nbElems[ notSupportedElemTypes[ iType ]] > 0 )
576 presentNotSupported.push_back( notSupportedElemTypes[ iType ]);
578 if ( !presentNotSupported.empty() )
581 const char* typeMsg[] = {
582 "SMESH_NODES", "SMESH_ELEMS0D","SMESH_EDGES","SMESH_QUADRATIC_EDGES",
583 "SMESH_TRIANGLES", "SMESH_QUADRATIC_TRIANGLES", "SMESH_BIQUADRATIC_TRIANGLES",
584 "SMESH_QUADRANGLES","SMESH_QUADRATIC_QUADRANGLES", "SMESH_BIQUADRATIC_QUADRANGLES",
585 "SMESH_POLYGONS","SMESH_QUADRATIC_POLYGONS",
586 "SMESH_TETRAHEDRA","SMESH_QUADRATIC_TETRAHEDRONS","SMESH_PYRAMIDS",
587 "SMESH_QUADRATIC_PYRAMIDS","SMESH_HEXAHEDRA","SMESH_QUADRATIC_HEXAHEDRONS",
588 "SMESH_TRIQUADRATIC_HEXAHEDRONS","SMESH_PENTAHEDRA","SMESH_QUADRATIC_PENTAHEDRONS",
589 "SMESH_OCTAHEDRA","SMESH_POLYEDRONS","SMESH_QUADRATIC_POLYEDRONS","SMESH_BALLS"
591 // is typeMsg complete? (compilation failure mains that enum SMDSAbs_EntityType changed)
592 const int nbTypes = sizeof( typeMsg ) / sizeof( const char* );
593 int _assert[( nbTypes == SMESH::Entity_Last ) ? 2 : -1 ]; _assert[0]=_assert[1];
595 QString andStr = " " + QObject::tr("SMESH_AND") + " ", comma(", ");
596 for ( size_t iType = 0; iType < presentNotSupported.size(); ++iType ) {
597 typeNames += QObject::tr( typeMsg[ presentNotSupported[ iType ]]);
598 if ( iType != presentNotSupported.size() - 1 )
599 typeNames += ( iType == presentNotSupported.size() - 2 ) ? andStr : comma;
601 int aRet = SUIT_MessageBox::warning
602 (SMESHGUI::desktop(),
603 QObject::tr("SMESH_WRN_WARNING"),
604 QObject::tr("EXPORT_NOT_SUPPORTED").arg(aMeshName).arg(format).arg(typeNames),
605 QObject::tr("SMESH_BUT_YES"),
606 QObject::tr("SMESH_BUT_NO"), 0, 1);
611 // Get parameters of export operation
614 SMESH::MED_VERSION aFormat = SMESH::MED_V2_2;
615 // Init the parameters with the default values
616 bool aIsASCII_STL = true;
617 bool toCreateGroups = false;
618 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
620 toCreateGroups = resMgr->booleanValue( "SMESH", "auto_groups", false );
621 bool toOverwrite = true;
622 bool toFindOutDim = true;
624 QString aFilter, aTitle = QObject::tr("SMESH_EXPORT_MESH");
625 QString anInitialPath = "";
626 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
627 anInitialPath = QDir::currentPath();
629 QList< QPair< GEOM::ListOfFields_var, QString > > aFieldList;
631 // Get a file name to write in and additional otions
632 if ( isUNV || isDAT || isGMF ) // Export w/o options
635 aFilter = QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)";
637 aFilter = QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)";
639 aFilter = QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" +
640 ";;" + QObject::tr( "GMF_BINARY_FILES_FILTER" ) + " (*.meshb)";
641 if ( anInitialPath.isEmpty() ) anInitialPath = SUIT_FileDlg::getLastVisitedPath();
642 aFilename = SUIT_FileDlg::getFileName(SMESHGUI::desktop(),
643 anInitialPath + QString("/") + aMeshName,
644 aFilter, aTitle, false);
646 else if ( isCGNS )// Export to CGNS
648 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
649 fd->setWindowTitle( aTitle );
650 fd->setNameFilter( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
651 if ( !anInitialPath.isEmpty() )
652 fd->setDirectory( anInitialPath );
653 fd->selectFile(aMeshName);
654 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
655 fd->setValidator( fv );
658 aFilename = fd->selectedFile();
659 toOverwrite = fv->isOverwrite();
663 else if ( isSTL ) // Export to STL
665 QMap<QString, int> aFilterMap;
666 aFilterMap.insert( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)", 1 );
667 aFilterMap.insert( QObject::tr( "STL_BIN_FILES_FILTER" ) + " (*.stl)", 0 );
670 QMap<QString, int>::const_iterator it = aFilterMap.begin();
671 for ( ; it != aFilterMap.end(); ++it )
672 filters.push_back( it.key() );
674 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
675 fd->setWindowTitle( aTitle );
676 fd->setNameFilters( filters );
677 fd->selectNameFilter( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
678 if ( !anInitialPath.isEmpty() )
679 fd->setDirectory( anInitialPath );
680 fd->selectFile(aMeshName);
684 aFilename = fd->selectedFile();
685 aIsASCII_STL = (aFilterMap[fd->selectedNameFilter()]) == 1 ? true: false;
690 else if ( isMED || isSAUV ) // Export to MED or SAUV
692 QMap<QString, SMESH::MED_VERSION> aFilterMap;
693 //QString v21 (aMesh->GetVersionString(SMESH::MED_V2_1, 2));
695 QString v22 (aMesh->GetVersionString(SMESH::MED_V2_2, 2));
696 //aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v21 ) + " (*.med)", SMESH::MED_V2_1 );
697 aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v22 ) + " (*.med)", SMESH::MED_V2_2 );
700 aFilterMap.insert("All files (*)", SMESH::MED_V2_1 );
701 aFilterMap.insert("SAUV files (*.sauv)", SMESH::MED_V2_2 );
702 aFilterMap.insert("SAUV files (*.sauve)", SMESH::MED_V2_1 );
706 QString aDefaultFilter;
707 QMap<QString, SMESH::MED_VERSION>::const_iterator it = aFilterMap.begin();
708 for ( ; it != aFilterMap.end(); ++it ) {
709 filters.push_back( it.key() );
710 if (it.value() == SMESH::MED_V2_2)
711 aDefaultFilter = it.key();
713 QStringList checkBoxes;
714 checkBoxes << QObject::tr("SMESH_AUTO_GROUPS") << QObject::tr("SMESH_AUTO_DIM");
716 SMESHGUI_FieldSelectorWdg* fieldSelWdg = new SMESHGUI_FieldSelectorWdg();
717 QList< QWidget* > wdgList;
718 if ( fieldSelWdg->GetAllFeilds( aMeshList, aFieldList ))
719 wdgList.append( fieldSelWdg );
721 SalomeApp_CheckFileDlg* fd =
722 new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true, wdgList );
723 fd->setWindowTitle( aTitle );
724 fd->setNameFilters( filters );
725 fd->selectNameFilter( aDefaultFilter );
726 fd->SetChecked( toCreateGroups, 0 );
727 fd->SetChecked( toFindOutDim, 1 );
728 if ( !anInitialPath.isEmpty() )
729 fd->setDirectory( anInitialPath );
730 fd->selectFile(aMeshName);
733 QListView *lview = fd->findChild<QListView*>("listView");
735 lview->setMinimumHeight(200);
737 QTreeView *tview = fd->findChild<QTreeView*>("treeView");
739 tview->setMinimumHeight(200);
742 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
743 fd->setValidator( fv );
748 aFilename = fd->selectedFile();
750 aFilename = QString::null;
753 aFormat = aFilterMap[fd->selectedNameFilter()];
754 toOverwrite = fv->isOverwrite();
756 if ( !aFilename.isEmpty() ) {
757 // med-2.1 does not support poly elements
758 if ( aFormat==SMESH::MED_V2_1 )
759 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
760 SMESH::SMESH_IDSource_var aMeshItem = (*aMeshIter).first;
761 SMESH::long_array_var nbElems = aMeshItem->GetMeshInfo();
762 if ( nbElems[ SMESH::Entity_Polygon ] + nbElems[ SMESH::Entity_Quad_Polygon ] +
763 nbElems[ SMESH::Entity_Polyhedra ] + nbElems[ SMESH::Entity_Quad_Polyhedra ])
765 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
766 QObject::tr("SMESH_WRN_WARNING"),
767 QObject::tr("SMESH_EXPORT_MED_V2_1").arg((*aMeshIter).second),
768 QObject::tr("SMESH_BUT_YES"),
769 QObject::tr("SMESH_BUT_NO"), 0, 1);
777 // can't append to an existing using other format
778 SMESH::MED_VERSION aVersion = SMESH::MED_V2_1;
779 bool isVersionOk = SMESHGUI::GetSMESHGen()->GetMEDVersion( aFilename.toUtf8().constData(), aVersion );
780 if( !isVersionOk || aVersion != aFormat ) {
781 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
782 QObject::tr("SMESH_WRN_WARNING"),
783 QObject::tr("SMESH_EXPORT_MED_VERSION_COLLISION").arg(aFilename),
784 QObject::tr("SMESH_BUT_YES"),
785 QObject::tr("SMESH_BUT_NO"), 0, 1);
792 QStringList aMeshNamesCollisionList;
793 SMESH::string_array_var aMeshNames = SMESHGUI::GetSMESHGen()->GetMeshNames( aFilename.toUtf8().constData() );
794 for( int i = 0, n = aMeshNames->length(); i < n; i++ ) {
795 QString anExistingMeshName( aMeshNames[ i ] );
796 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
797 QString anExportMeshName = (*aMeshIter).second;
798 if( anExportMeshName == anExistingMeshName ) {
799 aMeshNamesCollisionList.append( anExportMeshName );
804 if( !aMeshNamesCollisionList.isEmpty() ) {
805 QString aMeshNamesCollisionString = aMeshNamesCollisionList.join( ", " );
806 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
807 QObject::tr("SMESH_WRN_WARNING"),
808 QObject::tr("SMESH_EXPORT_MED_MESH_NAMES_COLLISION").arg(aMeshNamesCollisionString),
809 QObject::tr("SMESH_BUT_YES"),
810 QObject::tr("SMESH_BUT_NO"),
811 QObject::tr("SMESH_BUT_CANCEL"), 0, 2);
820 toCreateGroups = fd->IsChecked(0);
821 toFindOutDim = fd->IsChecked(1);
822 fieldSelWdg->GetSelectedFeilds();
823 if ( !fieldSelWdg->parent() )
834 if ( !aFilename.isEmpty() ) {
835 // Check whether the file already exists and delete it if yes
836 QFile aFile( aFilename );
837 if ( aFile.exists() && toOverwrite )
839 SUIT_OverrideCursor wc;
842 // Renumbering is not needed since SMDS redesign in V6.2.0 (Nov 2010)
843 // bool Renumber = false;
844 // // PAL 14172 : Check of we have to renumber or not from the preferences before export
846 // Renumber= resMgr->booleanValue("renumbering");
848 // SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
849 // aMeshEditor->RenumberNodes();
850 // aMeshEditor->RenumberElements();
851 // if ( SMESHGUI::automaticUpdate() )
852 // SMESH::UpdateView();
856 aMeshIter = aMeshList.begin();
857 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
859 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
860 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
861 const GEOM::ListOfFields& fields = aFieldList[ aMeshIndex ].first.in();
862 const QString& geoAssFields = aFieldList[ aMeshIndex ].second;
863 const bool hasFields = ( fields.length() || !geoAssFields.isEmpty() );
864 if ( !hasFields && aMeshOrGroup->_is_equivalent( aMeshItem ))
865 aMeshItem->ExportToMEDX( aFilename.toUtf8().data(), toCreateGroups,
866 aFormat, toOverwrite && aMeshIndex == 0, toFindOutDim );
868 aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups,
869 aFormat, toOverwrite && aMeshIndex == 0, toFindOutDim,
870 fields, geoAssFields.toLatin1().data() );
875 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ )
877 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
878 if( !aMeshItem->_is_nil() )
879 aMeshItem->ExportSAUV( aFilename.toUtf8().data(), toCreateGroups );
884 if ( aMeshOrGroup->_is_equivalent( aMesh ))
885 aMesh->ExportDAT( aFilename.toUtf8().data() );
887 aMesh->ExportPartToDAT( aMeshOrGroup, aFilename.toUtf8().data() );
891 if ( aMeshOrGroup->_is_equivalent( aMesh ))
892 aMesh->ExportUNV( aFilename.toUtf8().data() );
894 aMesh->ExportPartToUNV( aMeshOrGroup, aFilename.toUtf8().data() );
898 if ( aMeshOrGroup->_is_equivalent( aMesh ))
899 aMesh->ExportSTL( aFilename.toUtf8().data(), aIsASCII_STL );
901 aMesh->ExportPartToSTL( aMeshOrGroup, aFilename.toUtf8().data(), aIsASCII_STL );
905 aMeshIter = aMeshList.begin();
906 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
908 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
909 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
910 aMeshItem->ExportCGNS( aMeshOrGroup,
911 aFilename.toUtf8().data(),
912 toOverwrite && aMeshIndex == 0 );
917 toCreateGroups = true;
918 aMesh->ExportGMF( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups );
921 catch (const SALOME::SALOME_Exception& S_ex){
923 SUIT_MessageBox::warning(SMESHGUI::desktop(),
924 QObject::tr("SMESH_WRN_WARNING"),
925 QObject::tr("SMESH_EXPORT_FAILED"));
931 inline void InverseEntityMode(unsigned int& theOutputMode,
932 unsigned int theMode)
934 bool anIsNotPresent = ~theOutputMode & theMode;
936 theOutputMode |= theMode;
938 theOutputMode &= ~theMode;
941 void SetDisplayEntity(int theCommandID)
943 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
944 SALOME_ListIO selected;
946 aSel->selectedObjects( selected );
948 if ( selected.Extent() >= 1 ) {
949 SALOME_ListIteratorOfListIO It( selected );
950 for( ; It.More(); It.Next()){
951 Handle(SALOME_InteractiveObject) IObject = It.Value();
952 if(IObject->hasEntry()){
953 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
954 unsigned int aMode = anActor->GetEntityMode();
955 switch(theCommandID){
956 case SMESHOp::OpDE0DElements: InverseEntityMode(aMode,SMESH_Actor::e0DElements); break;
957 case SMESHOp::OpDEEdges: InverseEntityMode(aMode,SMESH_Actor::eEdges); break;
958 case SMESHOp::OpDEFaces: InverseEntityMode(aMode,SMESH_Actor::eFaces); break;
959 case SMESHOp::OpDEVolumes: InverseEntityMode(aMode,SMESH_Actor::eVolumes); break;
960 case SMESHOp::OpDEBalls: InverseEntityMode(aMode,SMESH_Actor::eBallElem); break;
961 case SMESHOp::OpDEAllEntity: aMode = SMESH_Actor::eAllEntity; break;
964 anActor->SetEntityMode(aMode);
973 SalomeApp_Application* app =
974 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
978 LightApp_SelectionMgr* aSel = app->selectionMgr();
979 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
980 if ( !aSel || !appStudy )
983 SALOME_ListIO selected;
984 aSel->selectedObjects( selected );
985 if ( selected.IsEmpty() )
988 Handle(SALOME_InteractiveObject) anIObject = selected.First();
990 _PTR(Study) aStudy = appStudy->studyDS();
991 _PTR(SObject) aMainSObject = aStudy->FindObjectID( anIObject->getEntry() );
992 SMESH::SMESH_Mesh_var aMainObject = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
993 if ( aMainObject->_is_nil() )
996 SUIT_OverrideCursor wc;
998 aMainObject->SetAutoColor( true ); // mesh groups are re-colored here
1000 QList<SALOMEDS::Color> aReservedColors;
1002 SMESH::ListOfGroups aListOfGroups = *aMainObject->GetGroups();
1003 for ( int i = 0, n = aListOfGroups.length(); i < n; i++ )
1005 SMESH::SMESH_GroupBase_var aGroupObject = aListOfGroups[i];
1007 #ifdef SIMPLE_AUTOCOLOR // simplified algorithm for auto-colors
1008 SALOMEDS::Color aColor = SMESHGUI::getPredefinedUniqueColor();
1009 #else // old algorithm for auto-colors
1010 SALOMEDS::Color aColor = SMESHGUI::getUniqueColor( aReservedColors );
1011 aReservedColors.append( aColor );
1012 #endif // SIMPLE_AUTOCOLOR
1013 aGroupObject->SetColor( aColor );
1015 _PTR(SObject) aGroupSObject = SMESH::FindSObject(aGroupObject);
1016 if ( aGroupSObject ) {
1019 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry(aGroupSObject->GetID().c_str())) {
1020 switch ( aGroupObject->GetType ()) {
1022 anActor->SetNodeColor( aColor.R, aColor.G, aColor.B ); break;
1024 anActor->SetEdgeColor( aColor.R, aColor.G, aColor.B ); break;
1026 anActor->Set0DColor( aColor.R, aColor.G, aColor.B ); break;
1028 anActor->SetBallColor( aColor.R, aColor.G, aColor.B ); break;
1030 SMESH::GetColor("SMESH", "volume_color", c, delta, "255,0,170|-100");
1031 anActor->SetVolumeColor( aColor.R, aColor.G, aColor.B, delta ); break;
1034 SMESH::GetColor("SMESH", "fill_color", c, delta, "0,170,255|-100");
1035 anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B, delta );
1041 SMESH::RepaintCurrentView();
1044 void OverallMeshQuality()
1046 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1047 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1048 SALOME_ListIO selected;
1050 aSel->selectedObjects( selected );
1052 if ( selected.IsEmpty() ) return;
1053 SALOME_ListIteratorOfListIO It( selected );
1054 for ( ; It.More(); It.Next() ) {
1055 SMESHGUI_CtrlInfoDlg* ctrlDlg = new SMESHGUI_CtrlInfoDlg( SMESHGUI::desktop() );
1056 ctrlDlg->showInfo( It.Value() );
1061 QString functorToString( SMESH::Controls::FunctorPtr f )
1063 QString type = QObject::tr( "UNKNOWN_CONTROL" );
1064 if ( dynamic_cast< SMESH::Controls::Volume* >( f.get() ) )
1065 type = QObject::tr( "VOLUME_3D_ELEMENTS" );
1066 else if ( dynamic_cast< SMESH::Controls::MaxElementLength2D* >( f.get() ) )
1067 type = QObject::tr( "MAX_ELEMENT_LENGTH_2D" );
1068 else if ( dynamic_cast< SMESH::Controls::MaxElementLength3D* >( f.get() ) )
1069 type = QObject::tr( "MAX_ELEMENT_LENGTH_3D" );
1070 else if ( dynamic_cast< SMESH::Controls::MinimumAngle* >( f.get() ) )
1071 type = QObject::tr( "MINIMUMANGLE_ELEMENTS" );
1072 else if ( dynamic_cast< SMESH::Controls::AspectRatio* >( f.get() ) )
1073 type = QObject::tr( "ASPECTRATIO_ELEMENTS" );
1074 else if ( dynamic_cast< SMESH::Controls::AspectRatio3D* >( f.get() ) )
1075 type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" );
1076 else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) )
1077 type = QObject::tr( "WARP_ELEMENTS" );
1078 else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) )
1079 type = QObject::tr( "TAPER_ELEMENTS" );
1080 else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) )
1081 type = QObject::tr( "SKEW_ELEMENTS" );
1082 else if ( dynamic_cast< SMESH::Controls::Area* >( f.get() ) )
1083 type = QObject::tr( "AREA_ELEMENTS" );
1084 else if ( dynamic_cast< SMESH::Controls::Length* >( f.get() ) )
1085 type = QObject::tr( "LENGTH_EDGES" );
1086 else if ( dynamic_cast< SMESH::Controls::Length2D* >( f.get() ) )
1087 type = QObject::tr( "LENGTH2D_EDGES" );
1088 else if ( dynamic_cast< SMESH::Controls::MultiConnection* >( f.get() ) )
1089 type = QObject::tr( "MULTI_BORDERS" );
1090 else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) )
1091 type = QObject::tr( "MULTI2D_BORDERS" );
1092 else if ( dynamic_cast< SMESH::Controls::FreeNodes* >( f.get() ) )
1093 type = QObject::tr( "FREE_NODES" );
1094 else if ( dynamic_cast< SMESH::Controls::FreeEdges* >( f.get() ) )
1095 type = QObject::tr( "FREE_EDGES" );
1096 else if ( dynamic_cast< SMESH::Controls::FreeBorders* >( f.get() ) )
1097 type = QObject::tr( "FREE_BORDERS" );
1098 else if ( dynamic_cast< SMESH::Controls::FreeFaces* >( f.get() ) )
1099 type = QObject::tr( "FREE_FACES" );
1100 else if ( dynamic_cast< SMESH::Controls::BareBorderVolume* >( f.get() ) )
1101 type = QObject::tr( "BARE_BORDER_VOLUME" );
1102 else if ( dynamic_cast< SMESH::Controls::BareBorderFace* >( f.get() ) )
1103 type = QObject::tr( "BARE_BORDER_FACE" );
1104 else if ( dynamic_cast< SMESH::Controls::OverConstrainedVolume* >( f.get() ) )
1105 type = QObject::tr( "OVER_CONSTRAINED_VOLUME" );
1106 else if ( dynamic_cast< SMESH::Controls::OverConstrainedFace* >( f.get() ) )
1107 type = QObject::tr( "OVER_CONSTRAINED_FACE" );
1108 else if ( dynamic_cast< SMESH::Controls::CoincidentNodes* >( f.get() ) )
1109 type = QObject::tr( "EQUAL_NODE" );
1110 else if ( dynamic_cast< SMESH::Controls::CoincidentElements1D* >( f.get() ) )
1111 type = QObject::tr( "EQUAL_EDGE" );
1112 else if ( dynamic_cast< SMESH::Controls::CoincidentElements2D* >( f.get() ) )
1113 type = QObject::tr( "EQUAL_FACE" );
1114 else if ( dynamic_cast< SMESH::Controls::CoincidentElements3D* >( f.get() ) )
1115 type = QObject::tr( "EQUAL_VOLUME" );
1119 void SaveDistribution()
1121 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1122 SALOME_ListIO selected;
1124 aSel->selectedObjects( selected );
1126 if ( selected.Extent() == 1 ) {
1127 Handle(SALOME_InteractiveObject) anIO = selected.First();
1128 if ( anIO->hasEntry() ) {
1129 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1131 anActor->GetScalarBarActor() &&
1132 anActor->GetControlMode() != SMESH_Actor::eNone )
1134 SMESH_ScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor();
1135 SMESH::Controls::FunctorPtr aFunctor = anActor->GetFunctor();
1136 if ( aScalarBarActor && aFunctor ) {
1137 SMESH::Controls::NumericalFunctor* aNumFun =
1138 dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
1140 std::vector<int> elements;
1141 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
1142 if ( mesh->_is_nil() ) {
1143 SMESH::SMESH_IDSource_var idSource =
1144 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
1145 if ( !idSource->_is_nil() )
1147 SMESH::long_array_var ids = idSource->GetIDs();
1148 elements.resize( ids->length() );
1149 for ( unsigned i = 0; i < elements.size(); ++i )
1150 elements[i] = ids[i];
1153 int nbIntervals = aScalarBarActor->GetMaximumNumberOfColors();
1154 vtkLookupTable* lookupTable =
1155 static_cast<vtkLookupTable*>(aScalarBarActor->GetLookupTable());
1156 double * minmax = lookupTable->GetRange();
1157 bool isLogarithmic = lookupTable->GetScale() == VTK_SCALE_LOG10;
1158 std::vector<int> nbEvents;
1159 std::vector<double> funValues;
1160 aNumFun->GetHistogram( nbIntervals, nbEvents, funValues,
1161 elements, minmax, isLogarithmic );
1162 QString anInitialPath = "";
1163 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
1164 anInitialPath = QDir::currentPath();
1165 QString aMeshName = anIO->getName();
1167 filter.append( QObject::tr( "TEXT_FILES_FILTER" ) + " (*.txt)" );
1168 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
1169 QString aFilename = anInitialPath + "/" + aMeshName + "_" +
1170 functorToString( aFunctor ).toLower().simplified().replace( QRegExp( " |-" ), "_" ) + ".txt";
1171 aFilename = SUIT_FileDlg::getFileName( SMESHGUI::desktop(),
1174 QObject::tr( "SMESH_SAVE_DISTRIBUTION" ),
1176 if ( !aFilename.isEmpty() ) {
1177 QFile f( aFilename );
1178 if ( f.open( QFile::WriteOnly | QFile::Truncate ) ) {
1179 QTextStream out( &f );
1180 out << "# Mesh: " << aMeshName << endl;
1181 out << "# Control: " << functorToString( aFunctor ) << endl;
1183 out.setFieldWidth( 10 );
1184 for ( int i = 0; i < (int)qMin( nbEvents.size(), funValues.size()-1 ); i++ )
1185 out << funValues[i] << "\t" << funValues[i+1] << "\t" << nbEvents[i] << endl;
1196 void ShowElement( int theCommandID )
1198 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1199 SALOME_ListIO selected;
1201 aSel->selectedObjects( selected );
1203 if ( selected.Extent() == 1 ) {
1204 Handle(SALOME_InteractiveObject) anIO = selected.First();
1205 if ( anIO->hasEntry() ) {
1206 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1208 anActor->GetScalarBarActor() &&
1209 anActor->GetControlMode() != SMESH_Actor::eNone )
1211 SMESH_ScalarBarActor *aScalarBarActor = anActor->GetScalarBarActor();
1212 if ( theCommandID == SMESHOp::OpShowDistribution ) {
1213 aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility());
1215 else if ( theCommandID == SMESHOp::OpShowScalarBar ) {
1216 aScalarBarActor->SetVisibility( !aScalarBarActor->GetVisibility());
1223 #ifndef DISABLE_PLOT2DVIEWER
1224 void PlotDistribution()
1226 SalomeApp_Application* app =
1227 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1231 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1232 SALOME_ListIO selected;
1234 aSel->selectedObjects( selected );
1236 if ( selected.Extent() == 1 ) {
1237 Handle(SALOME_InteractiveObject) anIO = selected.First();
1238 if ( anIO->hasEntry() ) {
1239 //Find Actor by entry before getting Plot2d viewer,
1240 //because after call getViewManager( Plot2d_Viewer::Type(), true ) active window is Plot2d Viewer
1241 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1243 SUIT_ViewManager* aViewManager =
1244 app->getViewManager( Plot2d_Viewer::Type(), true ); // create if necessary
1248 SPlot2d_Viewer* aView = dynamic_cast<SPlot2d_Viewer*>(aViewManager->getViewModel());
1252 Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
1256 if ( anActor && anActor->GetControlMode() != SMESH_Actor::eNone )
1258 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1259 QString functorName = functorToString( anActor->GetFunctor());
1260 QString aHistogramName("%1 : %2");
1261 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1262 aHistogram->setName(aHistogramName);
1263 aHistogram->setHorTitle(functorName);
1264 aHistogram->setVerTitle(QObject::tr("DISTRIBUTION_NB_ENT"));
1265 aPlot->displayObject(aHistogram, true);
1270 #endif //DISABLE_PLOT2DVIEWER
1272 void DisableAutoColor()
1274 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1275 SALOME_ListIO selected;
1277 aSel->selectedObjects( selected );
1279 if ( selected.Extent() ) {
1280 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1281 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1282 if ( !aMesh->_is_nil() ) {
1283 aMesh->SetAutoColor( false );
1290 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1291 SALOME_ListIO selected;
1293 aSel->selectedObjects( selected );
1294 if ( selected.Extent() )
1296 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1297 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1298 _PTR(SObject) aSObj = aStudy->FindObjectID(anIObject->getEntry());
1300 if ( aStudy->GetUseCaseBuilder()->SortChildren( aSObj, true/*AscendingOrder*/ ) ) {
1301 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1308 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap)
1310 SALOME_ListIO selected;
1311 SalomeApp_Application* app =
1312 dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1316 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1317 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1318 if ( !aSel || !appStudy )
1321 if ( theCommandID == SMESHOp::OpClipping ) { // Clipping dialog can be activated without selection
1322 if ( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
1323 aModule->EmitSignalDeactivateDialog();
1324 if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
1325 (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
1330 _PTR(Study) aStudy = appStudy->studyDS();
1332 aSel->selectedObjects( selected );
1334 if ( selected.Extent() >= 1 )
1336 switch ( theCommandID ) {
1337 case SMESHOp::OpTransparency:
1339 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1340 (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
1343 case SMESHOp::OpProperties:
1346 QColor faceColor, edgeColor, nodeColor, elem0dColor, ballColor;
1347 QColor orientationColor, outlineColor, volumeColor;
1348 int deltaF = 0, deltaV = 0;
1351 double ballScale = 1.0;
1353 int outlineWidth = 1;
1354 double shrinkCoef = 0.0;
1355 double orientationScale = 0.0;
1356 bool orientation3d = false;
1357 VTK::MarkerType markerType = VTK::MT_NONE;
1358 VTK::MarkerScale markerScale = VTK::MS_NONE;
1360 bool hasNodes = false;
1361 int presentEntities = 0;
1362 bool firstTime = true;
1364 SALOME_ListIteratorOfListIO It( selected );
1365 for ( ; It.More(); It.Next() ) {
1366 Handle(SALOME_InteractiveObject) IObject = It.Value();
1367 if ( !IObject->hasEntry() ) continue;
1368 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1369 if ( !anActor || !anActor->GetObject() ) continue;
1372 // nodes: color, marker
1373 anActor->GetNodeColor( color[0], color[1], color[2] );
1374 nodeColor.setRgbF( color[0], color[1], color[2] );
1375 markerType = anActor->GetMarkerType();
1376 markerScale = anActor->GetMarkerScale();
1377 markerId = anActor->GetMarkerTexture();
1378 // edges: color, width
1379 anActor->GetEdgeColor( color[0], color[1], color[2] );
1380 edgeColor.setRgbF( color[0], color[1], color[2] );
1381 edgeWidth = qMax( (int)anActor->GetLineWidth(), 1 ); // minimum allowed width is 1
1382 // faces: front color, back color (delta)
1383 anActor->GetSufaceColor( color[0], color[1], color[2], deltaF );
1384 faceColor.setRgbF( color[0], color[1], color[2] );
1385 // faces: front color, back color (delta)
1386 anActor->GetVolumeColor( color[0], color[1], color[2], deltaV );
1387 volumeColor.setRgbF( color[0], color[1], color[2] );
1388 // 0d elements: color, size
1389 anActor->Get0DColor( color[0], color[1], color[2] );
1390 elem0dColor.setRgbF( color[0], color[1], color[2] );
1391 elem0dSize = qMax( (int)anActor->Get0DSize(), 1 ); // minimum allowed size is 1
1392 // balls: color, size
1393 anActor->GetBallColor( color[0], color[1], color[2] );
1394 ballColor.setRgbF( color[0], color[1], color[2] );
1395 //ballSize = qMax( (int)anActor->GetBallSize(), 1 ); // minimum allowed size is 1
1396 ballScale = qMax( (double)anActor->GetBallScale(), 1e-2 ); // minimum allowed scale is 1e-2
1398 anActor->GetOutlineColor( color[0], color[1], color[2] );
1399 outlineColor.setRgbF( color[0], color[1], color[2] );
1400 outlineWidth = qMax( (int)anActor->GetOutlineWidth(), 1 ); // minimum allowed width is 1
1401 // orientation vectors: color, scale, 3d flag
1402 anActor->GetFacesOrientationColor( color[0], color[1], color[2] );
1403 orientationColor.setRgbF( color[0], color[1], color[2] );
1404 orientationScale = anActor->GetFacesOrientationScale();
1405 orientation3d = anActor->GetFacesOrientation3DVectors();
1407 shrinkCoef = anActor->GetShrinkFactor();
1410 firstTime = false; // we only take properties from first object (for performance reasons)
1413 hasNodes = anActor->GetObject()->GetNbEntities( SMDSAbs_Node );
1414 if ( !(presentEntities & SMESH_Actor::eEdges) && anActor->GetObject()->GetNbEntities( SMDSAbs_Edge ) )
1415 presentEntities = presentEntities | SMESH_Actor::eEdges;
1416 if ( !(presentEntities & SMESH_Actor::eFaces) && anActor->GetObject()->GetNbEntities( SMDSAbs_Face ) )
1417 presentEntities = presentEntities | SMESH_Actor::eFaces;
1418 if ( !(presentEntities & SMESH_Actor::eVolumes) && anActor->GetObject()->GetNbEntities( SMDSAbs_Volume ) )
1419 presentEntities = presentEntities | SMESH_Actor::eVolumes;
1420 if ( !(presentEntities & SMESH_Actor::e0DElements) && anActor->GetObject()->GetNbEntities( SMDSAbs_0DElement ) )
1421 presentEntities = presentEntities | SMESH_Actor::e0DElements;
1422 if ( !(presentEntities & SMESH_Actor::eBallElem) && anActor->GetObject()->GetNbEntities( SMDSAbs_Ball ) )
1423 presentEntities = presentEntities | SMESH_Actor::eBallElem;
1425 // as we know that all types of elements are present, we can exit the loop
1426 if ( presentEntities == SMESH_Actor::eAllEntity )
1430 SMESHGUI_PropertiesDlg dlg( theMarkerMap[ aStudy->StudyId() ], SMESHGUI::desktop() );
1431 // nodes: color, marker
1432 dlg.setNodeColor( nodeColor );
1433 if( markerType != VTK::MT_USER )
1434 dlg.setNodeMarker( markerType, markerScale );
1436 dlg.setNodeCustomMarker( markerId );
1437 // edges: color, line width
1438 dlg.setEdgeColor( edgeColor );
1439 dlg.setEdgeWidth( edgeWidth );
1440 // faces: front color, back color
1441 dlg.setFaceColor( faceColor, deltaF );
1442 // volumes: normal color, reversed color
1443 dlg.setVolumeColor( volumeColor, deltaV );
1444 // outlines: color, line width
1445 dlg.setOutlineColor( outlineColor );
1446 dlg.setOutlineWidth( outlineWidth );
1447 // 0d elements: color, size
1448 dlg.setElem0dColor( elem0dColor );
1449 dlg.setElem0dSize( elem0dSize );
1450 // balls: color, size
1451 dlg.setBallColor( ballColor );
1452 //dlg.setBallSize( ballSize );
1453 dlg.setBallScale( ballScale );
1454 // orientation: color, scale, 3d flag
1455 dlg.setOrientationColor( orientationColor );
1456 dlg.setOrientationSize( int( orientationScale * 100. ) );
1457 dlg.setOrientation3d( orientation3d );
1458 // shrink: scale factor
1459 dlg.setShrinkCoef( int( shrinkCoef * 100. ) );
1460 // hide unused controls
1461 dlg.showControls( presentEntities, hasNodes );
1464 nodeColor = dlg.nodeColor();
1465 markerType = dlg.nodeMarkerType();
1466 markerScale = dlg.nodeMarkerScale();
1467 markerId = dlg.nodeMarkerId();
1468 edgeColor = dlg.edgeColor();
1469 edgeWidth = dlg.edgeWidth();
1470 faceColor = dlg.faceColor();
1471 deltaF = dlg.faceColorDelta();
1472 volumeColor = dlg.volumeColor();
1473 deltaV = dlg.volumeColorDelta();
1474 outlineColor = dlg.outlineColor();
1475 outlineWidth = dlg.outlineWidth();
1476 elem0dColor = dlg.elem0dColor();
1477 elem0dSize = dlg.elem0dSize();
1478 ballColor = dlg.ballColor();
1479 // ballSize = dlg.ballSize();
1480 ballScale = dlg.ballScale();
1481 orientationColor = dlg.orientationColor();
1482 orientationScale = dlg.orientationSize() / 100.;
1483 orientation3d = dlg.orientation3d();
1484 shrinkCoef = dlg.shrinkCoef() / 100.;
1486 // store point markers map that might be changed by the user
1487 theMarkerMap[ aStudy->StudyId() ] = dlg.customMarkers();
1489 // set properties from dialog box to the presentations
1490 SALOME_ListIteratorOfListIO It( selected );
1491 for ( ; It.More(); It.Next() ) {
1492 Handle(SALOME_InteractiveObject) IObject = It.Value();
1493 if ( !IObject->hasEntry() ) continue;
1494 SMESH_Actor* anActor = SMESH::FindActorByEntry( IObject->getEntry() );
1495 if ( !anActor ) continue;
1497 // nodes: color, marker
1498 anActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
1499 if ( markerType != VTK::MT_USER ) {
1500 anActor->SetMarkerStd( markerType, markerScale );
1503 const VTK::MarkerMap& markerMap = theMarkerMap[ aStudy->StudyId() ];
1504 VTK::MarkerMap::const_iterator iter = markerMap.find( markerId );
1505 if ( iter != markerMap.end() )
1506 anActor->SetMarkerTexture( markerId, iter->second.second );
1508 // volumes: normal color, reversed color (delta)
1509 anActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
1510 // faces: front color, back color (delta)
1511 anActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
1512 // edges: color, width
1513 anActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
1514 anActor->SetLineWidth( edgeWidth );
1516 anActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
1517 anActor->SetOutlineWidth( outlineWidth );
1518 // 0D elements: color, size
1519 anActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
1520 anActor->Set0DSize( elem0dSize );
1521 // balls: color, size
1522 anActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
1523 // anActor->SetBallSize( ballSize );
1524 anActor->SetBallScale( ballScale );
1525 // orientation: color, scale, 3d flag
1526 anActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
1527 anActor->SetFacesOrientationScale( orientationScale );
1528 anActor->SetFacesOrientation3DVectors( orientation3d );
1530 anActor->SetShrinkFactor( shrinkCoef );
1532 // for groups, set also proper color
1533 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1534 if ( !aGroupObject->_is_nil() ) {
1535 SMESH::ElementType anElementType = aGroupObject->GetType();
1537 switch( anElementType ) {
1539 aColor = nodeColor; break;
1541 aColor = edgeColor; break;
1543 aColor = faceColor; break;
1545 aColor = volumeColor; break;
1547 aColor = elem0dColor; break;
1549 aColor = ballColor; break;
1553 if ( aColor.isValid() ) {
1554 SALOMEDS::Color aGroupColor;
1555 aGroupColor.R = aColor.redF();
1556 aGroupColor.G = aColor.greenF();
1557 aGroupColor.B = aColor.blueF();
1558 aGroupObject->SetColor( aGroupColor );
1560 } // if ( !aGroupObject->_is_nil() )
1561 } // for ( ; It.More(); It.Next() )
1562 SMESH::RepaintCurrentView();
1563 } // if ( dlg.exec() )
1565 } // case SMESHOp::OpProperties:
1566 } // switch(theCommandID)
1567 SALOME_ListIteratorOfListIO It( selected );
1568 for( ; It.More(); It.Next()){
1569 Handle(SALOME_InteractiveObject) IObject = It.Value();
1570 if(IObject->hasEntry()){
1571 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1572 switch(theCommandID){
1573 case SMESHOp::OpDMWireframe:
1574 anActor->SetRepresentation(SMESH_Actor::eEdge);
1576 case SMESHOp::OpDMShading:
1577 anActor->SetRepresentation(SMESH_Actor::eSurface);
1579 case SMESHOp::OpDMShrink:
1580 if(anActor->IsShrunk())
1581 anActor->UnShrink();
1583 anActor->SetShrink();
1585 case SMESHOp::OpDMNodes:
1586 anActor->SetRepresentation(SMESH_Actor::ePoint);
1588 case SMESHOp::OpRepresentationLines:
1589 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1590 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1592 case SMESHOp::OpRepresentationArcs:
1593 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1594 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1600 SMESH::RepaintCurrentView();
1604 int ActionToControl( int theID, bool theReversed )
1606 NCollection_DoubleMap<int,int> ActionControl;
1607 ActionControl.Bind( 0, SMESH_Actor::eNone );
1608 ActionControl.Bind( SMESHOp::OpFreeNode, SMESH_Actor::eFreeNodes );
1609 ActionControl.Bind( SMESHOp::OpEqualNode, SMESH_Actor::eCoincidentNodes );
1610 ActionControl.Bind( SMESHOp::OpFreeEdge, SMESH_Actor::eFreeEdges );
1611 ActionControl.Bind( SMESHOp::OpFreeBorder, SMESH_Actor::eFreeBorders );
1612 ActionControl.Bind( SMESHOp::OpLength, SMESH_Actor::eLength );
1613 ActionControl.Bind( SMESHOp::OpConnection, SMESH_Actor::eMultiConnection );
1614 ActionControl.Bind( SMESHOp::OpEqualEdge, SMESH_Actor::eCoincidentElems1D );
1615 ActionControl.Bind( SMESHOp::OpFreeFace, SMESH_Actor::eFreeFaces );
1616 ActionControl.Bind( SMESHOp::OpBareBorderFace, SMESH_Actor::eBareBorderFace );
1617 ActionControl.Bind( SMESHOp::OpOverConstrainedFace, SMESH_Actor::eOverConstrainedFace );
1618 ActionControl.Bind( SMESHOp::OpLength2D, SMESH_Actor::eLength2D );
1619 ActionControl.Bind( SMESHOp::OpConnection2D, SMESH_Actor::eMultiConnection2D );
1620 ActionControl.Bind( SMESHOp::OpArea, SMESH_Actor::eArea );
1621 ActionControl.Bind( SMESHOp::OpTaper, SMESH_Actor::eTaper );
1622 ActionControl.Bind( SMESHOp::OpAspectRatio, SMESH_Actor::eAspectRatio );
1623 ActionControl.Bind( SMESHOp::OpMinimumAngle, SMESH_Actor::eMinimumAngle );
1624 ActionControl.Bind( SMESHOp::OpWarpingAngle, SMESH_Actor::eWarping );
1625 ActionControl.Bind( SMESHOp::OpSkew, SMESH_Actor::eSkew );
1626 ActionControl.Bind( SMESHOp::OpMaxElementLength2D, SMESH_Actor::eMaxElementLength2D );
1627 ActionControl.Bind( SMESHOp::OpEqualFace, SMESH_Actor::eCoincidentElems2D );
1628 ActionControl.Bind( SMESHOp::OpAspectRatio3D, SMESH_Actor::eAspectRatio3D );
1629 ActionControl.Bind( SMESHOp::OpVolume, SMESH_Actor::eVolume3D );
1630 ActionControl.Bind( SMESHOp::OpMaxElementLength3D, SMESH_Actor::eMaxElementLength3D );
1631 ActionControl.Bind( SMESHOp::OpBareBorderVolume, SMESH_Actor::eBareBorderVolume );
1632 ActionControl.Bind( SMESHOp::OpOverConstrainedVolume, SMESH_Actor::eOverConstrainedVolume );
1633 ActionControl.Bind( SMESHOp::OpEqualVolume, SMESH_Actor::eCoincidentElems3D );
1635 return theReversed ? ActionControl.Find2( theID ) : ActionControl.Find1( theID );
1638 void Control( int theCommandID )
1640 SMESH_Actor::eControl aControl = SMESH_Actor::eControl( ActionToControl( theCommandID ));
1641 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1643 SALOME_ListIO selected;
1644 if ( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
1645 aSel->selectedObjects( selected );
1647 if ( !selected.IsEmpty() ) {
1648 SALOME_ListIteratorOfListIO It(selected);
1649 for ( ; It.More(); It.Next())
1651 Handle(SALOME_InteractiveObject) anIO = It.Value();
1652 if ( !anIO.IsNull() ) {
1653 _PTR(SObject) SO = aStudy->FindObjectID( It.Value()->getEntry() );
1655 CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
1656 SMESH::SMESH_IDSource_var anIDSrc = SMESH::SMESH_IDSource::_narrow( aObject );
1657 if ( !anIDSrc->_is_nil() ) {
1658 SMESH_Actor *anActor = SMESH::FindActorByEntry( anIO->getEntry());
1659 if (( !anActor && selected.Extent() == 1 ) &&
1660 ( anActor = SMESH::CreateActor( aStudy, anIO->getEntry() )))
1662 anActor->SetControlMode( aControl );
1663 SMESH::DisplayActor( SMESH::GetCurrentVtkView(), anActor );
1664 SMESH::UpdateView ( SMESH::eDisplay, anIO->getEntry() );
1668 if ( anActor->GetControlMode() != aControl )
1669 anActor->SetControlMode( aControl );
1670 QString functorName = functorToString( anActor->GetFunctor() );
1671 anActor->GetScalarBarActor()->SetTitle( functorName.toLatin1().constData() );
1672 SMESH::RepaintCurrentView();
1673 #ifndef DISABLE_PLOT2DVIEWER
1674 if ( anActor->GetPlot2Histogram() ) {
1675 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1676 QString aHistogramName("%1 : %2");
1677 aHistogramName = aHistogramName.arg( anIO->getName() ).arg( functorName );
1678 aHistogram->setName( aHistogramName );
1679 aHistogram->setHorTitle( functorName );
1680 SMESH::ProcessIn2DViewers( anActor );
1692 bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1693 SMESH::MeshObjectType theType,
1694 const QString theInTypeName,
1695 QString & theOutTypeName)
1697 SMESH_TypeFilter aTypeFilter( theType );
1699 if ( !theIO.IsNull() )
1701 entry = theIO->getEntry();
1702 LightApp_DataOwner owner( entry );
1703 if ( aTypeFilter.isOk( &owner )) {
1704 theOutTypeName = theInTypeName;
1712 QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1714 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1715 _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1717 _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1718 CORBA::String_var anID = aSComp->GetID().c_str();
1719 if ( !strcmp(anID.in(),theIO->getEntry()) )
1725 CheckOIType ( theIO, SMESH::HYPOTHESIS, "Hypothesis", aTypeName ) ||
1726 CheckOIType ( theIO, SMESH::ALGORITHM, "Algorithm", aTypeName ) ||
1727 CheckOIType ( theIO, SMESH::MESH, "Mesh", aTypeName ) ||
1728 CheckOIType ( theIO, SMESH::SUBMESH, "SubMesh", aTypeName ) ||
1729 CheckOIType ( theIO, SMESH::GROUP, "Group", aTypeName )
1737 // QString CheckHomogeneousSelection()
1739 // LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1740 // SALOME_ListIO selected;
1742 // aSel->selectedObjects( selected );
1744 // QString RefType = CheckTypeObject(selected.First());
1745 // SALOME_ListIteratorOfListIO It(selected);
1746 // for ( ; It.More(); It.Next())
1748 // Handle(SALOME_InteractiveObject) IObject = It.Value();
1749 // QString Type = CheckTypeObject(IObject);
1750 // if ( Type.compare(RefType) != 0 )
1751 // return "Heterogeneous Selection";
1757 uint randomize( uint size )
1759 static bool initialized = false;
1760 if ( !initialized ) {
1761 qsrand( QDateTime::currentDateTime().toTime_t() );
1765 v = uint( (double)( v ) / RAND_MAX * size );
1766 v = qMax( uint(0), qMin ( v, size-1 ) );
1772 void SMESHGUI::OnEditDelete()
1774 // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1775 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1776 SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1778 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1779 _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1780 _PTR(GenericAttribute) anAttr;
1781 _PTR(AttributeIOR) anIOR;
1783 int objectCount = 0;
1785 QString aParentComponent = QString::null;
1786 Handle(SALOME_InteractiveObject) anIO;
1787 for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1789 anIO = anIt.Value();
1790 QString cur = anIO->getComponentDataType();
1791 _PTR(SObject) aSO = aStudy->FindObjectID(anIO->getEntry());
1793 // check if object is reference
1794 _PTR(SObject) aRefSObj;
1795 aNameList.append("\n - ");
1796 if ( aSO->ReferencedObject( aRefSObj ) ) {
1797 QString aRefName = QString::fromStdString ( aRefSObj->GetName() );
1798 aNameList.append( aRefName );
1799 cur = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1802 aNameList.append(anIO->getName());
1806 if( aParentComponent.isNull() )
1807 aParentComponent = cur;
1808 else if( !aParentComponent.isEmpty() && aParentComponent!=cur )
1809 aParentComponent = "";
1812 if ( objectCount == 0 )
1813 return; // No Valid Objects Selected
1815 if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
1816 SUIT_MessageBox::warning( SMESHGUI::desktop(),
1817 QObject::tr("ERR_ERROR"),
1818 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
1821 // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
1822 if (SUIT_MessageBox::warning
1823 (SMESHGUI::desktop(),
1824 QObject::tr("SMESH_WRN_WARNING"),
1825 QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
1826 SUIT_MessageBox::Yes | SUIT_MessageBox::No,
1827 SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
1830 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1832 // Put the whole hierarchy of sub-objects of the selected SO's into a list and
1833 // then treat them all starting from the deepest objects (at list back)
1834 std::list< _PTR(SObject) > listSO;
1835 SALOME_ListIteratorOfListIO It(selected);
1836 for( ; It.More(); It.Next()) // loop on selected IO's
1838 Handle(SALOME_InteractiveObject) IObject = It.Value();
1839 if(IObject->hasEntry()) {
1840 _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
1842 // disable removal of "SMESH" component object
1843 if(aSO->FindAttribute(anAttr, "AttributeIOR")){
1845 if ( engineIOR() == anIOR->Value().c_str() )
1848 //Check the referenced object
1849 _PTR(SObject) aRefSObject;
1850 if ( aSO && aSO->ReferencedObject( aRefSObject ) )
1851 aSO = aRefSObject; // Delete main Object instead of reference
1853 listSO.push_back( aSO );
1854 std::list< _PTR(SObject) >::iterator itSO = --listSO.end();
1855 for ( ; itSO != listSO.end(); ++itSO ) {
1856 _PTR(ChildIterator) it = aStudy->NewChildIterator( *itSO );
1857 for (it->InitEx(false); it->More(); it->Next())
1858 listSO.push_back( it->Value() );
1862 // Check if none of objects to delete is referred from outside
1863 std::list< _PTR(SObject) >::reverse_iterator ritSO;
1864 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1866 _PTR(SObject) SO = *ritSO;
1867 if ( !SO ) continue;
1868 std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( *ritSO );
1869 for (size_t i = 0; i < aReferences.size(); i++) {
1870 _PTR(SComponent) aComponent = aReferences[i]->GetFatherComponent();
1871 std::string type = aComponent->ComponentDataType();
1872 if ( type != "SMESH" )
1874 SUIT_MessageBox::warning( anApp->desktop(),
1875 QObject::tr("WRN_WARNING"),
1876 QObject::tr("DEP_OBJECT") );
1877 return; // outside SMESH, there is an object depending on a SMESH object
1882 // Call mesh->Clear() to prevent loading mesh from file caused by hypotheses removal
1883 for( It.Initialize( selected ); It.More(); It.Next()) // loop on selected IO's
1885 Handle(SALOME_InteractiveObject) IObject = It.Value();
1886 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface< SMESH::SMESH_Mesh >( IObject );
1887 if ( !mesh->_is_nil() )
1891 // Treat SO's in the list starting from the back
1892 aStudyBuilder->NewCommand(); // There is a transaction
1893 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1895 _PTR(SObject) SO = *ritSO;
1896 if ( !SO ) continue;
1897 std::string anEntry = SO->GetID();
1899 /** Erase graphical object and remove all its data **/
1900 if(SO->FindAttribute(anAttr, "AttributeIOR")) {
1901 SMESH::RemoveVisualObjectWithActors( anEntry.c_str(), true);
1903 /** Remove an object from data structures **/
1904 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
1905 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
1906 if ( !aGroup->_is_nil() ) { // DELETE GROUP
1907 SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
1908 aMesh->RemoveGroup( aGroup );
1910 else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
1911 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
1912 aMesh->RemoveSubMesh( aSubMesh );
1914 _PTR(SObject) aMeshSO = SMESH::FindSObject(aMesh);
1916 SMESH::ModifiedMesh(aMeshSO, false, aMesh->NbNodes()==0);
1919 Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
1920 ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
1921 QString objType = CheckTypeObject(IObject);
1922 if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
1923 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
1924 aStudyBuilder->RemoveObjectWithChildren( SO );
1926 else {// default action: remove SObject from the study
1927 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
1928 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
1930 aStudyBuilder->RemoveObjectWithChildren( SO );
1934 } /* listSO back loop */
1936 aStudyBuilder->CommitCommand();
1938 /* Clear any previous selection */
1940 aSel->setSelectedObjects( l1 );
1942 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1946 SMESHGUI_EXPORT CAM_Module* createModule()
1948 return new SMESHGUI();
1951 SMESHGUI_EXPORT char* getModuleVersion() {
1952 return (char*)SMESH_VERSION_STR;
1956 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
1958 //=============================================================================
1962 //=============================================================================
1963 SMESHGUI::SMESHGUI() :
1964 SalomeApp_Module( "SMESH" )
1966 if ( CORBA::is_nil( myComponentSMESH ) )
1968 CORBA::Boolean anIsEmbeddedMode;
1969 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
1970 //MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
1972 // 0019923: EDF 765 SMESH : default values of hypothesis
1973 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
1974 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
1975 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
1976 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
1977 myComponentSMESH->SetDefaultNbSegments( nbSeg );
1979 const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif", "default_grp_color" };
1980 for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
1981 if ( aResourceMgr->hasValue( "SMESH", options[i] ))
1983 QString val = aResourceMgr->stringValue( "SMESH", options[i] );
1984 myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
1988 myActiveDialogBox = 0;
1989 myFilterLibraryDlg = 0;
1993 myEventCallbackCommand = vtkCallbackCommand::New();
1994 myEventCallbackCommand->Delete();
1995 myEventCallbackCommand->SetClientData( this );
1996 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
1999 /* load resources for all available meshers */
2000 SMESH::InitAvailableHypotheses();
2003 //=============================================================================
2007 //=============================================================================
2008 SMESHGUI::~SMESHGUI()
2012 //=============================================================================
2016 //=============================================================================
2017 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
2019 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2021 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
2026 //=============================================================================
2030 //=============================================================================
2031 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
2033 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2037 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2038 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2039 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2040 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2041 return autoUpdate && !exceeded;
2044 //=============================================================================
2048 //=============================================================================
2049 bool SMESHGUI::automaticUpdate( SMESH::SMESH_IDSource_ptr theMesh,
2050 int* entities, bool* limitExceeded, int* hidden, long* nbElements )
2052 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
2056 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
2057 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
2058 bool incrementalLimit = resMgr->booleanValue( "SMESH", "incremental_limit", false );
2060 SMESH::long_array_var info = theMesh->GetMeshInfo();
2061 long nbOdElems = info[SMDSEntity_0D];
2062 long nbEdges = info[SMDSEntity_Edge] + info[SMDSEntity_Quad_Edge];
2063 long nbFaces = info[SMDSEntity_Triangle] + info[SMDSEntity_Quad_Triangle] + info[SMDSEntity_BiQuad_Triangle] +
2064 info[SMDSEntity_Quadrangle] + info[SMDSEntity_Quad_Quadrangle] + info[SMDSEntity_BiQuad_Quadrangle] +
2065 info[SMDSEntity_Polygon] + info[SMDSEntity_Quad_Polygon];
2066 long nbVolumes = info[SMDSEntity_Tetra] + info[SMDSEntity_Quad_Tetra] +
2067 info[SMDSEntity_Hexa] + info[SMDSEntity_Quad_Hexa] + info[SMDSEntity_TriQuad_Hexa] +
2068 info[SMDSEntity_Pyramid] + info[SMDSEntity_Quad_Pyramid] +
2069 info[SMDSEntity_Penta] + info[SMDSEntity_Quad_Penta] +
2070 info[SMDSEntity_Polyhedra] +
2071 info[SMDSEntity_Hexagonal_Prism];
2072 long nbBalls = info[SMDSEntity_Ball];
2074 long requestedSize = nbOdElems + nbBalls + nbEdges + nbFaces + nbVolumes;
2075 *nbElements = requestedSize;
2077 *entities = SMESH_Actor::eAllEntity;
2080 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
2082 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
2084 if ( incrementalLimit ) {
2087 if ( nbOdElems > 0 ) {
2088 if ( total + nbOdElems > updateLimit ) {
2089 *entities = *entities & ~SMESH_Actor::e0DElements;
2090 *hidden = *hidden | SMESH_Actor::e0DElements;
2097 if ( nbEdges > 0 ) {
2098 if ( total + nbEdges > updateLimit ) {
2099 *entities = *entities & ~SMESH_Actor::eEdges;
2100 *hidden = *hidden | SMESH_Actor::eEdges;
2107 if ( nbFaces > 0 ) {
2108 if ( total + nbFaces > updateLimit ) {
2109 *entities = *entities & ~SMESH_Actor::eFaces;
2110 *hidden = *hidden | SMESH_Actor::eFaces;
2117 if ( nbVolumes > 0 ) {
2118 if ( total + nbVolumes > updateLimit ) {
2119 *entities = *entities & ~SMESH_Actor::eVolumes;
2120 *hidden = *hidden | SMESH_Actor::eVolumes;
2127 if ( nbBalls > 0 ) {
2128 if ( total + nbBalls > updateLimit ) {
2129 *entities = *entities & ~SMESH_Actor::eBallElem;
2130 *hidden = *hidden | SMESH_Actor::eBallElem;
2138 return autoUpdate && !exceeded;
2141 //=============================================================================
2145 //=============================================================================
2146 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
2148 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
2151 //=============================================================================
2155 //=============================================================================
2156 SMESHGUI* SMESHGUI::GetSMESHGUI()
2158 SMESHGUI* smeshMod = 0;
2159 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
2162 CAM_Module* module = app->module( "Mesh" );
2163 smeshMod = dynamic_cast<SMESHGUI*>( module );
2166 if ( smeshMod && smeshMod->application() && smeshMod->application()->activeStudy() )
2168 SalomeApp_Study* study = dynamic_cast<SalomeApp_Study*>( smeshMod->application()->activeStudy() );
2171 _PTR(Study) aStudy = study->studyDS();
2173 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
2182 Standard_EXPORT SMESHGUI* GetComponentGUI()
2184 return SMESHGUI::GetSMESHGUI();
2188 //=============================================================================
2192 //=============================================================================
2193 void SMESHGUI::SetState(int aState)
2198 //=============================================================================
2202 //=============================================================================
2203 void SMESHGUI::ResetState()
2208 //=============================================================================
2212 //=============================================================================
2213 void SMESHGUI::EmitSignalDeactivateDialog()
2215 emit SignalDeactivateActiveDialog();
2218 //=============================================================================
2222 //=============================================================================
2223 void SMESHGUI::EmitSignalStudyFrameChanged()
2225 emit SignalStudyFrameChanged();
2228 //=============================================================================
2232 //=============================================================================
2233 void SMESHGUI::EmitSignalCloseAllDialogs()
2235 emit SignalCloseAllDialogs();
2238 //=============================================================================
2242 //=============================================================================
2243 void SMESHGUI::EmitSignalVisibilityChanged()
2245 emit SignalVisibilityChanged();
2248 //=============================================================================
2252 //=============================================================================
2253 void SMESHGUI::EmitSignalCloseView()
2255 emit SignalCloseView();
2258 //=============================================================================
2262 //=============================================================================
2263 void SMESHGUI::EmitSignalActivatedViewManager()
2265 emit SignalActivatedViewManager();
2268 //=============================================================================
2272 //=============================================================================
2273 QDialog *SMESHGUI::GetActiveDialogBox()
2275 return myActiveDialogBox;
2278 //=============================================================================
2282 //=============================================================================
2283 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
2285 myActiveDialogBox = (QDialog *) aDlg;
2289 //=============================================================================
2293 //=============================================================================
2294 SUIT_Desktop* SMESHGUI::desktop()
2296 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
2298 return app->desktop();
2303 //=============================================================================
2307 //=============================================================================
2308 SalomeApp_Study* SMESHGUI::activeStudy()
2310 SUIT_Application* app = SUIT_Session::session()->activeApplication();
2312 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
2317 //=============================================================================
2321 //=============================================================================
2322 void SMESHGUI::Modified( bool theIsUpdateActions )
2324 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
2325 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
2326 appStudy->Modified();
2327 if( theIsUpdateActions )
2328 app->updateActions();
2333 //=============================================================================
2337 //=============================================================================
2338 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
2340 /* Here the position is on the bottom right corner - 10 */
2341 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
2343 SUIT_Desktop *PP = desktop();
2344 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
2345 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
2349 //=============================================================================
2353 //=============================================================================
2354 static int isStudyLocked(_PTR(Study) theStudy){
2355 return theStudy->GetProperties()->IsLocked();
2358 static bool checkLock(_PTR(Study) theStudy) {
2359 if (isStudyLocked(theStudy)) {
2360 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2361 QObject::tr("WRN_WARNING"),
2362 QObject::tr("WRN_STUDY_LOCKED") );
2368 //=======================================================================
2369 //function : CheckActiveStudyLocked
2371 //=======================================================================
2373 bool SMESHGUI::isActiveStudyLocked()
2375 _PTR(Study) aStudy = activeStudy()->studyDS();
2376 return checkLock( aStudy );
2379 //=============================================================================
2383 //=============================================================================
2384 bool SMESHGUI::OnGUIEvent( int theCommandID )
2386 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2390 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
2391 SUIT_ResourceMgr* mgr = resourceMgr();
2395 if (CORBA::is_nil(GetSMESHGen()->GetCurrentStudy())) {
2396 GetSMESHGen()->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
2399 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2400 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2402 //QAction* act = action( theCommandID );
2404 switch (theCommandID) {
2405 case SMESHOp::OpDelete:
2406 if(checkLock(aStudy)) break;
2409 case SMESHOp::OpImportDAT:
2410 case SMESHOp::OpImportUNV:
2411 case SMESHOp::OpImportMED:
2412 case SMESHOp::OpImportSTL:
2414 case SMESHOp::OpImportCGNS:
2416 case SMESHOp::OpImportSAUV:
2417 case SMESHOp::OpImportGMF:
2419 if(checkLock(aStudy)) break;
2420 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2424 case SMESHOp::OpFileInformation:
2426 SALOME_ListIO selected;
2427 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2429 aSel->selectedObjects( selected );
2430 if( selected.Extent() )
2432 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2433 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2434 if ( !aMesh->_is_nil() )
2436 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2442 case SMESHOp::OpExportDAT:
2443 case SMESHOp::OpExportMED:
2444 case SMESHOp::OpExportUNV:
2445 case SMESHOp::OpExportSTL:
2447 case SMESHOp::OpExportCGNS:
2449 case SMESHOp::OpExportSAUV:
2450 case SMESHOp::OpExportGMF:
2451 case SMESHOp::OpPopupExportDAT:
2452 case SMESHOp::OpPopupExportMED:
2453 case SMESHOp::OpPopupExportUNV:
2454 case SMESHOp::OpPopupExportSTL:
2456 case SMESHOp::OpPopupExportCGNS:
2458 case SMESHOp::OpPopupExportSAUV:
2459 case SMESHOp::OpPopupExportGMF:
2461 ::ExportMeshToFile(theCommandID);
2465 case SMESHOp::OpReset: // SCALAR BAR
2467 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2468 SALOME_ListIO selected;
2470 aSel->selectedObjects( selected );
2472 SALOME_ListIteratorOfListIO it(selected);
2473 for( ; it.More(); it.Next()) {
2474 Handle(SALOME_InteractiveObject) anIO = it.Value();
2475 if( anIO->hasEntry() ) {
2476 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2477 anActor->SetControlMode( SMESH_Actor::eNone );
2478 #ifndef DISABLE_PLOT2DVIEWER
2479 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2484 SMESH::UpdateView();
2487 case SMESHOp::OpScalarBarProperties:
2489 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2492 case SMESHOp::OpShowScalarBar:
2494 // show/hide scalar bar
2495 ::ShowElement(theCommandID);
2498 case SMESHOp::OpSaveDistribution:
2500 // dump control distribution data to the text file
2501 ::SaveDistribution();
2505 case SMESHOp::OpShowDistribution:
2507 // show/hide distribution
2508 ::ShowElement(theCommandID);
2512 #ifndef DISABLE_PLOT2DVIEWER
2513 case SMESHOp::OpPlotDistribution:
2515 // plot distribution
2516 ::PlotDistribution();
2522 case SMESHOp::OpAutoColor:
2526 case SMESHOp::OpDisableAutoColor:
2527 ::DisableAutoColor();
2530 case SMESHOp::OpClipping:
2531 case SMESHOp::OpTransparency:
2532 case SMESHOp::OpProperties: // Display preferences (colors, shrink size, line width, ...)
2535 case SMESHOp::OpDMWireframe:
2536 case SMESHOp::OpDMShading:
2537 case SMESHOp::OpDMNodes:
2538 case SMESHOp::OpDMShrink:
2539 ::SetDisplayMode(theCommandID, myMarkerMap);
2542 //2D quadratic representation
2543 case SMESHOp::OpRepresentationLines:
2544 case SMESHOp::OpRepresentationArcs:
2545 ::SetDisplayMode(theCommandID, myMarkerMap);
2549 case SMESHOp::OpDE0DElements:
2550 case SMESHOp::OpDEEdges:
2551 case SMESHOp::OpDEFaces:
2552 case SMESHOp::OpDEVolumes:
2553 case SMESHOp::OpDEBalls:
2554 case SMESHOp::OpDEAllEntity:
2555 ::SetDisplayEntity(theCommandID);
2558 // Choose entities to be displayed
2559 case SMESHOp::OpDEChoose:
2561 ( new SMESHGUI_DisplayEntitiesDlg( SMESHGUI::desktop() ) )->exec();
2565 case SMESHOp::OpOrientationOnFaces:
2567 LightApp_SelectionMgr* mgr = selectionMgr();
2568 SALOME_ListIO selected; mgr->selectedObjects( selected );
2570 SALOME_ListIteratorOfListIO it(selected);
2571 for( ; it.More(); it.Next()) {
2572 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2573 if(anIObject->hasEntry()) {
2574 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2575 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2582 case SMESHOp::OpUpdate:
2584 if(checkLock(aStudy)) break;
2585 SUIT_OverrideCursor wc;
2587 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2590 SMESH::UpdateView();
2592 catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2593 SMESH::OnVisuException();
2595 catch (...) { // PAL16774 (Crash after display of many groups)
2596 SMESH::OnVisuException();
2600 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2601 aSel->selectedObjects( l );
2602 aSel->setSelectedObjects( l );
2606 case SMESHOp::OpHide:
2607 case SMESHOp::OpShow:
2608 case SMESHOp::OpShowOnly:
2610 SUIT_OverrideCursor wc;
2611 SMESH::EDisplaing anAction;
2612 switch (theCommandID) {
2613 case SMESHOp::OpHide: anAction = SMESH::eErase; break;
2614 case SMESHOp::OpShow: anAction = SMESH::eDisplay; break;
2615 case SMESHOp::OpShowOnly: anAction = SMESH::eDisplayOnly; break;
2618 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2619 SALOME_ListIO sel_objects, to_process;
2621 aSel->selectedObjects( sel_objects );
2623 if ( theCommandID==SMESHOp::OpShowOnly )
2625 //MESSAGE("anAction = SMESH::eDisplayOnly");
2626 startOperation( myEraseAll );
2629 extractContainers( sel_objects, to_process );
2632 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2636 SALOME_ListIteratorOfListIO It( to_process );
2637 for ( ; It.More(); It.Next())
2639 Handle(SALOME_InteractiveObject) IOS = It.Value();
2640 if ( IOS->hasEntry() )
2642 if ( !SMESH::UpdateView( anAction, IOS->getEntry() )) {
2643 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2644 break; // PAL16774 (Crash after display of many groups)
2646 if (anAction == SMESH::eDisplayOnly)
2647 anAction = SMESH::eDisplay;
2652 // PAL13338 + PAL15161 -->
2653 if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !checkLock(aStudy)) {
2654 SMESH::UpdateView();
2655 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2657 // PAL13338 + PAL15161 <--
2659 catch (...) { // PAL16774 (Crash after display of many groups)
2660 SMESH::OnVisuException();
2663 if (anAction == SMESH::eErase) {
2665 aSel->setSelectedObjects( l1 );
2668 aSel->setSelectedObjects( to_process );
2673 case SMESHOp::OpNode:
2675 if(checkLock(aStudy)) break;
2678 EmitSignalDeactivateDialog();
2680 ( new SMESHGUI_NodesDlg( this ) )->show();
2683 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"),tr("SMESH_WRN_VIEWER_VTK"));
2688 case SMESHOp::OpCreateMesh:
2689 case SMESHOp::OpCreateSubMesh:
2690 case SMESHOp::OpEditMeshOrSubMesh:
2691 case SMESHOp::OpCompute:
2692 case SMESHOp::OpPreCompute:
2693 case SMESHOp::OpEvaluate:
2694 case SMESHOp::OpMeshOrder:
2695 startOperation( theCommandID );
2697 case SMESHOp::OpCopyMesh:
2699 if (checkLock(aStudy)) break;
2700 EmitSignalDeactivateDialog();
2701 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2704 case SMESHOp::OpBuildCompoundMesh:
2706 if (checkLock(aStudy)) break;
2707 EmitSignalDeactivateDialog();
2708 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2712 case SMESHOp::OpDiagonalInversion:
2713 case SMESHOp::OpUnionOfTwoTriangle:
2717 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2721 if ( checkLock( aStudy ) )
2724 /*Standard_Boolean aRes;
2725 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2726 if ( aMesh->_is_nil() )
2728 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2729 tr( "SMESH_BAD_SELECTION" ) );
2733 EmitSignalDeactivateDialog();
2734 if ( theCommandID == SMESHOp::OpDiagonalInversion )
2735 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2737 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2740 case SMESHOp::OpOrientation:
2741 case SMESHOp::OpUnionOfTriangles:
2742 case SMESHOp::OpCuttingOfQuadrangles:
2743 case SMESHOp::OpSplitVolumes:
2747 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
2751 if ( checkLock( aStudy ) )
2754 EmitSignalDeactivateDialog();
2755 SMESHGUI_MultiEditDlg* aDlg = NULL;
2756 if ( theCommandID == SMESHOp::OpOrientation )
2757 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2758 else if ( theCommandID == SMESHOp::OpUnionOfTriangles )
2759 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2760 else if ( theCommandID == SMESHOp::OpSplitVolumes )
2761 aDlg = new SMESHGUI_SplitVolumesDlg(this);
2763 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2768 case SMESHOp::OpSmoothing:
2770 if(checkLock(aStudy)) break;
2772 EmitSignalDeactivateDialog();
2773 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2776 SUIT_MessageBox::warning(desktop(), tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2780 case SMESHOp::OpExtrusion:
2782 if (checkLock(aStudy)) break;
2784 EmitSignalDeactivateDialog();
2785 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2787 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2791 case SMESHOp::OpExtrusionAlongAPath:
2793 if (checkLock(aStudy)) break;
2795 EmitSignalDeactivateDialog();
2796 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2798 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2802 case SMESHOp::OpRevolution:
2804 if(checkLock(aStudy)) break;
2806 EmitSignalDeactivateDialog();
2807 ( new SMESHGUI_RevolutionDlg( this ) )->show();
2810 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2814 case SMESHOp::OpPatternMapping:
2816 if ( checkLock( aStudy ) )
2820 EmitSignalDeactivateDialog();
2821 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2824 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2828 case SMESHOp::OpSplitBiQuadratic:
2829 case SMESHOp::OpConvertMeshToQuadratic:
2830 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
2831 case SMESHOp::OpReorientFaces:
2832 case SMESHOp::OpCreateGeometryGroup:
2834 startOperation( theCommandID );
2837 case SMESHOp::OpCreateGroup:
2841 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2845 if(checkLock(aStudy)) break;
2846 EmitSignalDeactivateDialog();
2847 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2849 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2850 SALOME_ListIO selected;
2852 aSel->selectedObjects( selected );
2854 int nbSel = selected.Extent();
2856 // check if mesh is selected
2857 aMesh = SMESH::GetMeshByIO( selected.First() );
2859 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2864 case SMESHOp::OpConstructGroup:
2868 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2872 if(checkLock(aStudy)) break;
2873 EmitSignalDeactivateDialog();
2875 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2876 SALOME_ListIO selected;
2878 aSel->selectedObjects( selected );
2880 int nbSel = selected.Extent();
2882 // check if submesh is selected
2883 Handle(SALOME_InteractiveObject) IObject = selected.First();
2884 if (IObject->hasEntry()) {
2885 _PTR(SObject) aSObj = aStudy->FindObjectID(IObject->getEntry());
2887 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2888 if (!aSubMesh->_is_nil()) {
2890 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2891 // get submesh elements list by types
2892 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2893 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2894 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2895 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2896 // create group for each type o elements
2897 QString aName = IObject->getName();
2898 QStringList anEntryList;
2899 if (aNodes->length() > 0) {
2900 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2901 aGroup->Add(aNodes.inout());
2902 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2903 anEntryList.append( aSObject->GetID().c_str() );
2905 if (aEdges->length() > 0) {
2906 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2907 aGroup->Add(aEdges.inout());
2908 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2909 anEntryList.append( aSObject->GetID().c_str() );
2911 if (aFaces->length() > 0) {
2912 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2913 aGroup->Add(aFaces.inout());
2914 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2915 anEntryList.append( aSObject->GetID().c_str() );
2917 if (aVolumes->length() > 0) {
2918 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2919 aGroup->Add(aVolumes.inout());
2920 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2921 anEntryList.append( aSObject->GetID().c_str() );
2924 anApp->browseObjects( anEntryList );
2926 catch(const SALOME::SALOME_Exception & S_ex){
2927 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2934 SUIT_MessageBox::warning(desktop(),
2935 tr("SMESH_WRN_WARNING"),
2936 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
2941 case SMESHOp::OpEditGroup:
2945 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
2949 if(checkLock(aStudy)) break;
2950 EmitSignalDeactivateDialog();
2952 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2953 SALOME_ListIO selected;
2955 aSel->selectedObjects( selected );
2957 SALOME_ListIteratorOfListIO It (selected);
2958 int nbSelectedGroups = 0;
2959 for ( ; It.More(); It.Next() )
2961 SMESH::SMESH_GroupBase_var aGroup =
2962 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
2963 if (!aGroup->_is_nil()) {
2965 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
2969 if (nbSelectedGroups == 0)
2971 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
2977 case SMESHOp::OpAddElemGroupPopup: // Add elements to group
2979 if(checkLock(aStudy)) break;
2980 if (myState == 800) {
2981 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2982 if (aDlg) aDlg->onAdd();
2987 case SMESHOp::OpRemoveElemGroupPopup: // Remove elements from group
2989 if(checkLock(aStudy)) break;
2990 if (myState == 800) {
2991 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2992 if (aDlg) aDlg->onRemove();
2997 case SMESHOp::OpEditGeomGroupAsGroup:
3001 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3005 if(checkLock(aStudy)) break;
3006 EmitSignalDeactivateDialog();
3008 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3009 SALOME_ListIO selected;
3011 aSel->selectedObjects( selected );
3013 SALOME_ListIteratorOfListIO It (selected);
3014 for ( ; It.More(); It.Next() )
3016 SMESH::SMESH_GroupOnGeom_var aGroup =
3017 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
3018 if (!aGroup->_is_nil()) {
3019 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3024 SMESH::SMESH_GroupOnFilter_var aGroup =
3025 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
3026 if (!aGroup->_is_nil()) {
3027 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
3035 case SMESHOp::OpUnionGroups:
3036 case SMESHOp::OpIntersectGroups:
3037 case SMESHOp::OpCutGroups:
3041 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3045 if ( checkLock( aStudy ) )
3048 EmitSignalDeactivateDialog();
3050 SMESHGUI_GroupOpDlg* aDlg = 0;
3051 if ( theCommandID == SMESHOp::OpUnionGroups )
3052 aDlg = new SMESHGUI_UnionGroupsDlg( this );
3053 else if ( theCommandID == SMESHOp::OpIntersectGroups )
3054 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
3056 aDlg = new SMESHGUI_CutGroupsDlg( this );
3063 case SMESHOp::OpGroupUnderlyingElem: // Create groups of entities from existing groups of superior dimensions
3065 if ( checkLock( aStudy ) )
3068 EmitSignalDeactivateDialog();
3069 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
3075 case SMESHOp::OpDeleteGroup: // Delete groups with their contents
3079 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
3083 if ( checkLock( aStudy ) )
3086 EmitSignalDeactivateDialog();
3088 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
3092 case SMESHOp::OpMeshInformation:
3093 case SMESHOp::OpWhatIs:
3095 int page = theCommandID == SMESHOp::OpMeshInformation ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
3096 EmitSignalDeactivateDialog();
3097 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3098 SALOME_ListIO selected;
3100 aSel->selectedObjects( selected );
3102 if ( selected.Extent() > 1 ) { // a dlg for each IO
3103 SALOME_ListIteratorOfListIO It( selected );
3104 for ( ; It.More(); It.Next() ) {
3105 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3106 dlg->showInfo( It.Value() );
3111 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
3117 case SMESHOp::OpFindElementByPoint:
3119 startOperation( theCommandID );
3123 case SMESHOp::OpEditHypothesis:
3125 if(checkLock(aStudy)) break;
3127 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3128 SALOME_ListIO selected;
3130 aSel->selectedObjects( selected );
3132 int nbSel = selected.Extent();
3135 Handle(SALOME_InteractiveObject) anIObject = selected.First();
3136 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
3138 if ( !aHypothesis->_is_nil() )
3140 SMESHGUI_GenericHypothesisCreator* aCreator =
3141 SMESH::GetHypothesisCreator( SMESH::toQStr( aHypothesis->GetName() ));
3144 // set geometry of mesh and sub-mesh to aCreator
3145 aSel->selectedObjects( selected, "", /*convertReferences=*/false);
3146 if ( selected.Extent() == 1 )
3148 QString subGeomID, meshGeomID;
3149 Handle(SALOME_InteractiveObject) hypIO = selected.First();
3150 if ( SMESH::GetGeomEntries( hypIO, subGeomID, meshGeomID ))
3152 if ( subGeomID.isEmpty() ) subGeomID = meshGeomID;
3153 aCreator->setShapeEntry( subGeomID );
3154 aCreator->setMainShapeEntry( meshGeomID );
3158 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
3168 case SMESHOp::OpUnassign: // REMOVE HYPOTHESIS / ALGORITHMS
3170 if(checkLock(aStudy)) break;
3171 SUIT_OverrideCursor wc;
3173 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
3174 SALOME_ListIO selected;
3176 aSel->selectedObjects( selected, QString::null, false );
3178 SALOME_ListIteratorOfListIO It(selected);
3179 for (int i = 0; It.More(); It.Next(), i++) {
3180 Handle(SALOME_InteractiveObject) IObject = It.Value();
3181 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
3184 aSel->setSelectedObjects( l1 );
3189 case SMESHOp::OpElem0D:
3190 case SMESHOp::OpBall:
3191 case SMESHOp::OpEdge:
3192 case SMESHOp::OpTriangle:
3193 case SMESHOp::OpQuadrangle:
3194 case SMESHOp::OpPolygon:
3195 case SMESHOp::OpTetrahedron:
3196 case SMESHOp::OpHexahedron:
3197 case SMESHOp::OpPentahedron:
3198 case SMESHOp::OpPyramid:
3199 case SMESHOp::OpHexagonalPrism:
3201 if(checkLock(aStudy)) break;
3203 EmitSignalDeactivateDialog();
3204 SMDSAbs_EntityType type = SMDSEntity_Edge;
3205 switch (theCommandID) {
3206 case SMESHOp::OpElem0D: type = SMDSEntity_0D; break;
3207 case SMESHOp::OpBall: type = SMDSEntity_Ball; break;
3208 case SMESHOp::OpTriangle: type = SMDSEntity_Triangle; break;
3209 case SMESHOp::OpQuadrangle: type = SMDSEntity_Quadrangle; break;
3210 case SMESHOp::OpTetrahedron: type = SMDSEntity_Tetra; break;
3211 case SMESHOp::OpPolygon: type = SMDSEntity_Polygon; break;
3212 case SMESHOp::OpHexahedron: type = SMDSEntity_Hexa; break;
3213 case SMESHOp::OpPentahedron: type = SMDSEntity_Penta; break;
3214 case SMESHOp::OpPyramid: type = SMDSEntity_Pyramid; break;
3215 case SMESHOp::OpHexagonalPrism: type = SMDSEntity_Hexagonal_Prism; break;
3218 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
3221 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3225 case SMESHOp::OpPolyhedron:
3227 if(checkLock(aStudy)) break;
3229 EmitSignalDeactivateDialog();
3230 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
3233 SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3237 case SMESHOp::OpQuadraticEdge:
3238 case SMESHOp::OpQuadraticTriangle:
3239 case SMESHOp::OpBiQuadraticTriangle:
3240 case SMESHOp::OpQuadraticQuadrangle:
3241 case SMESHOp::OpBiQuadraticQuadrangle:
3242 case SMESHOp::OpQuadraticPolygon:
3243 case SMESHOp::OpQuadraticTetrahedron:
3244 case SMESHOp::OpQuadraticPyramid:
3245 case SMESHOp::OpQuadraticPentahedron:
3246 case SMESHOp::OpQuadraticHexahedron:
3247 case SMESHOp::OpTriQuadraticHexahedron:
3249 if(checkLock(aStudy)) break;
3251 EmitSignalDeactivateDialog();
3252 SMDSAbs_EntityType type = SMDSEntity_Last;
3254 switch (theCommandID) {
3255 case SMESHOp::OpQuadraticEdge: type = SMDSEntity_Quad_Edge; break;
3256 case SMESHOp::OpQuadraticTriangle: type = SMDSEntity_Quad_Triangle; break;
3257 case SMESHOp::OpBiQuadraticTriangle: type = SMDSEntity_BiQuad_Triangle; break;
3258 case SMESHOp::OpQuadraticQuadrangle: type = SMDSEntity_Quad_Quadrangle; break;
3259 case SMESHOp::OpBiQuadraticQuadrangle: type = SMDSEntity_BiQuad_Quadrangle; break;
3260 case SMESHOp::OpQuadraticPolygon: type = SMDSEntity_Quad_Polygon; break;
3261 case SMESHOp::OpQuadraticTetrahedron: type = SMDSEntity_Quad_Tetra; break;
3262 case SMESHOp::OpQuadraticPyramid: type = SMDSEntity_Quad_Pyramid; break;
3263 case SMESHOp::OpQuadraticPentahedron: type = SMDSEntity_Quad_Penta; break;
3264 case SMESHOp::OpQuadraticHexahedron: type = SMDSEntity_Quad_Hexa; break;
3265 case SMESHOp::OpTriQuadraticHexahedron: type = SMDSEntity_TriQuad_Hexa; break;
3268 if ( type != SMDSEntity_Last )
3269 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
3272 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3273 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3277 case SMESHOp::OpRemoveNodes:
3279 if(checkLock(aStudy)) break;
3281 EmitSignalDeactivateDialog();
3282 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
3285 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3286 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3290 case SMESHOp::OpRemoveElements: // REMOVES ELEMENTS
3292 if(checkLock(aStudy)) break;
3294 EmitSignalDeactivateDialog();
3295 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
3299 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3300 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3304 case SMESHOp::OpClearMesh: {
3306 if(checkLock(aStudy)) break;
3308 SALOME_ListIO selected;
3309 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3310 aSel->selectedObjects( selected );
3312 SUIT_OverrideCursor wc;
3313 SALOME_ListIteratorOfListIO It (selected);
3314 for ( ; It.More(); It.Next() )
3316 Handle(SALOME_InteractiveObject) IOS = It.Value();
3317 SMESH::SMESH_Mesh_var aMesh =
3318 SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
3319 if ( aMesh->_is_nil()) continue;
3321 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3323 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3324 SMESH::ModifiedMesh( aMeshSObj, false, true);
3325 // hide groups and submeshes
3326 _PTR(ChildIterator) anIter =
3327 SMESH::GetActiveStudyDocument()->NewChildIterator( aMeshSObj );
3328 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3330 _PTR(SObject) so = anIter->Value();
3331 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3334 catch (const SALOME::SALOME_Exception& S_ex){
3336 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3340 SMESH::UpdateView();
3344 case SMESHOp::OpRemoveOrphanNodes:
3346 if(checkLock(aStudy)) break;
3347 SALOME_ListIO selected;
3348 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3349 aSel->selectedObjects( selected );
3350 if ( selected.Extent() == 1 ) {
3351 Handle(SALOME_InteractiveObject) anIO = selected.First();
3352 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3353 if ( !aMesh->_is_nil() ) {
3354 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3355 tr( "SMESH_WARNING" ),
3356 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3357 SUIT_MessageBox::Yes |
3358 SUIT_MessageBox::No,
3359 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3362 SUIT_OverrideCursor wc;
3363 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3364 int removed = aMeshEditor->RemoveOrphanNodes();
3365 SUIT_MessageBox::information(SMESHGUI::desktop(),
3366 tr("SMESH_INFORMATION"),
3367 tr("NB_NODES_REMOVED").arg(removed));
3368 if ( removed > 0 ) {
3369 SMESH::UpdateView();
3370 SMESHGUI::Modified();
3373 catch (const SALOME::SALOME_Exception& S_ex) {
3374 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3383 case SMESHOp::OpRenumberingNodes:
3385 if(checkLock(aStudy)) break;
3387 EmitSignalDeactivateDialog();
3388 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3392 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3393 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3397 case SMESHOp::OpRenumberingElements:
3399 if(checkLock(aStudy)) break;
3401 EmitSignalDeactivateDialog();
3402 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3406 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3407 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3411 case SMESHOp::OpTranslation:
3413 if(checkLock(aStudy)) break;
3415 EmitSignalDeactivateDialog();
3416 ( new SMESHGUI_TranslationDlg( this ) )->show();
3419 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3420 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3424 case SMESHOp::OpRotation:
3426 if(checkLock(aStudy)) break;
3428 EmitSignalDeactivateDialog();
3429 ( new SMESHGUI_RotationDlg( this ) )->show();
3432 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3433 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3437 case SMESHOp::OpSymmetry:
3439 if(checkLock(aStudy)) break;
3441 EmitSignalDeactivateDialog();
3442 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3445 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3446 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3450 case SMESHOp::OpScale:
3452 if(checkLock(aStudy)) break;
3454 EmitSignalDeactivateDialog();
3455 ( new SMESHGUI_ScaleDlg( this ) )->show();
3458 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3459 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3464 case SMESHOp::OpSewing:
3466 if(checkLock(aStudy)) break;
3468 EmitSignalDeactivateDialog();
3469 ( new SMESHGUI_SewingDlg( this ) )->show();
3472 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3473 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3477 case SMESHOp::OpMergeNodes:
3479 if(checkLock(aStudy)) break;
3481 EmitSignalDeactivateDialog();
3482 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3485 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3486 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3490 case SMESHOp::OpMergeElements:
3492 if (checkLock(aStudy)) break;
3494 EmitSignalDeactivateDialog();
3495 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3497 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3498 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3503 case SMESHOp::OpMoveNode: // MAKE MESH PASS THROUGH POINT
3504 startOperation( SMESHOp::OpMoveNode );
3507 case SMESHOp::OpDuplicateNodes:
3509 if(checkLock(aStudy)) break;
3511 EmitSignalDeactivateDialog();
3512 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3515 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3516 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3521 case SMESHOp::OpElem0DOnElemNodes: // 0D_ON_ALL_NODES
3522 startOperation( SMESHOp::OpElem0DOnElemNodes );
3525 case SMESHOp::OpSelectFiltersLibrary: // Library of selection filters
3527 static QList<int> aTypes;
3528 if ( aTypes.isEmpty() )
3530 aTypes.append( SMESH::NODE );
3531 aTypes.append( SMESH::EDGE );
3532 aTypes.append( SMESH::FACE );
3533 aTypes.append( SMESH::VOLUME );
3535 if (!myFilterLibraryDlg)
3536 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3537 else if (myFilterLibraryDlg->isHidden())
3538 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3539 myFilterLibraryDlg->raise();
3543 case SMESHOp::OpFreeNode:
3544 case SMESHOp::OpEqualNode:
3545 case SMESHOp::OpFreeEdge:
3546 case SMESHOp::OpFreeBorder:
3547 case SMESHOp::OpLength:
3548 case SMESHOp::OpConnection:
3549 case SMESHOp::OpEqualEdge:
3550 case SMESHOp::OpFreeFace:
3551 case SMESHOp::OpBareBorderFace:
3552 case SMESHOp::OpOverConstrainedFace:
3553 case SMESHOp::OpLength2D:
3554 case SMESHOp::OpConnection2D:
3555 case SMESHOp::OpArea:
3556 case SMESHOp::OpTaper:
3557 case SMESHOp::OpAspectRatio:
3558 case SMESHOp::OpMinimumAngle:
3559 case SMESHOp::OpWarpingAngle:
3560 case SMESHOp::OpSkew:
3561 case SMESHOp::OpMaxElementLength2D:
3562 case SMESHOp::OpEqualFace:
3563 case SMESHOp::OpAspectRatio3D:
3564 case SMESHOp::OpVolume:
3565 case SMESHOp::OpMaxElementLength3D:
3566 case SMESHOp::OpBareBorderVolume:
3567 case SMESHOp::OpOverConstrainedVolume:
3568 case SMESHOp::OpEqualVolume:
3571 LightApp_SelectionMgr* mgr = selectionMgr();
3572 SALOME_ListIO selected; mgr->selectedObjects( selected );
3574 if( !selected.IsEmpty() ) {
3575 SUIT_OverrideCursor wc;
3576 ::Control( theCommandID );
3579 SUIT_MessageBox::warning(desktop(),
3580 tr( "SMESH_WRN_WARNING" ),
3581 tr( "SMESH_BAD_SELECTION" ) );
3585 SUIT_MessageBox::warning(desktop(),
3586 tr( "SMESH_WRN_WARNING" ),
3587 tr( "NOT_A_VTK_VIEWER" ) );
3590 case SMESHOp::OpOverallMeshQuality:
3591 OverallMeshQuality();
3593 case SMESHOp::OpNumberingNodes:
3595 SUIT_OverrideCursor wc;
3596 LightApp_SelectionMgr* mgr = selectionMgr();
3597 SALOME_ListIO selected; mgr->selectedObjects( selected );
3599 SALOME_ListIteratorOfListIO it(selected);
3600 for( ; it.More(); it.Next()) {
3601 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3602 if(anIObject->hasEntry()) {
3603 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3604 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3610 case SMESHOp::OpNumberingElements:
3612 SUIT_OverrideCursor wc;
3613 LightApp_SelectionMgr* mgr = selectionMgr();
3614 SALOME_ListIO selected; mgr->selectedObjects( selected );
3616 SALOME_ListIteratorOfListIO it(selected);
3617 for( ; it.More(); it.Next()) {
3618 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3619 if(anIObject->hasEntry())
3620 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3621 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3626 case SMESHOp::OpPropertiesLength:
3627 case SMESHOp::OpPropertiesArea:
3628 case SMESHOp::OpPropertiesVolume:
3629 case SMESHOp::OpMinimumDistance:
3630 case SMESHOp::OpBoundingBox:
3632 int page = SMESHGUI_MeasureDlg::MinDistance;
3633 if ( theCommandID == SMESHOp::OpBoundingBox )
3634 page = SMESHGUI_MeasureDlg::BoundingBox;
3635 else if ( theCommandID == SMESHOp::OpPropertiesLength )
3636 page = SMESHGUI_MeasureDlg::Length;
3637 else if ( theCommandID == SMESHOp::OpPropertiesArea )
3638 page = SMESHGUI_MeasureDlg::Area;
3639 else if ( theCommandID == SMESHOp::OpPropertiesVolume )
3640 page = SMESHGUI_MeasureDlg::Volume;
3642 EmitSignalDeactivateDialog();
3643 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3647 case SMESHOp::OpSortChild:
3653 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3654 //updateObjBrowser();
3658 //=============================================================================
3662 //=============================================================================
3663 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3668 //=============================================================================
3672 //=============================================================================
3673 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3678 //=============================================================================
3682 //=============================================================================
3683 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3688 //=============================================================================
3689 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3690 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3692 //=============================================================================
3693 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3694 SUIT_ViewWindow* wnd )
3696 if(theIO->hasEntry()){
3697 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3698 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3702 //=======================================================================
3703 // function : createSMESHAction
3705 //=======================================================================
3706 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3707 const int key, const bool toggle, const QString& shortcutAction )
3710 QWidget* parent = application()->desktop();
3711 SUIT_ResourceMgr* resMgr = resourceMgr();
3713 if ( !icon_id.isEmpty() )
3714 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3716 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3717 if ( !pix.isNull() )
3718 icon = QIcon( pix );
3720 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3721 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3722 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3724 createAction( id, tooltip, icon, menu, status_bar, key, parent,
3725 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3728 //=======================================================================
3729 // function : createPopupItem
3731 //=======================================================================
3732 void SMESHGUI::createPopupItem( const int id,
3733 const QString& clients,
3734 const QString& types,
3735 const QString& theRule,
3738 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3739 popupMgr()->insert( action( id ), pId, 0 );
3741 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3742 QString dc = "selcount"; // VSR : insetad of QtxPopupSelection::defSelCountParam()
3743 QString rule = "(%1) and (%2) and (%3)";
3744 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3745 if( clients.isEmpty() )
3746 rule = rule.arg( QString( "true" ) );
3748 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3749 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3752 bool cont = myRules.contains( id );
3754 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3756 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3757 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3760 //=======================================================================
3761 // function : initialize
3763 //=======================================================================
3764 void SMESHGUI::initialize( CAM_Application* app )
3766 SalomeApp_Module::initialize( app );
3768 // SUIT_ResourceMgr* mgr = app->resourceMgr();
3770 /* Automatic Update flag */
3771 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3773 // ----- create actions --------------
3775 //createSMESHAction( SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
3776 createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_I) );
3777 createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
3778 //createSMESHAction( 114, "NUM" );
3779 createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL" );
3781 createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
3783 createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
3784 createSMESHAction( SMESHOp::OpImportGMF, "IMPORT_GMF" );
3785 createSMESHAction( SMESHOp::OpExportDAT, "DAT" );
3786 createSMESHAction( SMESHOp::OpExportMED, "MED" );
3787 createSMESHAction( SMESHOp::OpExportUNV, "UNV" );
3788 createSMESHAction( SMESHOp::OpExportSTL, "STL" );
3790 createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
3792 createSMESHAction( SMESHOp::OpExportSAUV, "SAUV");
3793 createSMESHAction( SMESHOp::OpExportGMF, "GMF" );
3794 createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
3795 createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
3796 createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
3797 createSMESHAction( SMESHOp::OpPopupExportSTL, "STL" );
3799 createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
3801 createSMESHAction( SMESHOp::OpPopupExportSAUV, "SAUV");
3802 createSMESHAction( SMESHOp::OpPopupExportGMF, "GMF" );
3803 createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
3804 createSMESHAction( SMESHOp::OpDelete, "DELETE", "ICON_DELETE", Qt::Key_Delete );
3805 createSMESHAction( SMESHOp::OpSelectFiltersLibrary, "SEL_FILTER_LIB" );
3806 createSMESHAction( SMESHOp::OpCreateMesh, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
3807 createSMESHAction( SMESHOp::OpCreateSubMesh, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
3808 createSMESHAction( SMESHOp::OpEditMeshOrSubMesh, "EDIT_MESHSUBMESH", "ICON_DLG_EDIT_MESH" );
3809 createSMESHAction( SMESHOp::OpBuildCompoundMesh, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
3810 createSMESHAction( SMESHOp::OpCopyMesh, "COPY_MESH", "ICON_COPY_MESH" );
3811 createSMESHAction( SMESHOp::OpCompute, "COMPUTE", "ICON_COMPUTE" );
3812 createSMESHAction( SMESHOp::OpPreCompute, "PRECOMPUTE", "ICON_PRECOMPUTE" );
3813 createSMESHAction( SMESHOp::OpEvaluate, "EVALUATE", "ICON_EVALUATE" );
3814 createSMESHAction( SMESHOp::OpMeshOrder, "MESH_ORDER", "ICON_MESH_ORDER");
3815 createSMESHAction( SMESHOp::OpCreateGroup, "CREATE_GROUP", "ICON_CREATE_GROUP" );
3816 createSMESHAction( SMESHOp::OpCreateGeometryGroup, "CREATE_GEO_GROUP", "ICON_CREATE_GEO_GROUP" );
3817 createSMESHAction( SMESHOp::OpConstructGroup, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
3818 createSMESHAction( SMESHOp::OpEditGroup, "EDIT_GROUP", "ICON_EDIT_GROUP" );
3819 createSMESHAction( SMESHOp::OpEditGeomGroupAsGroup, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3820 createSMESHAction( SMESHOp::OpUnionGroups, "UN_GROUP", "ICON_UNION" );
3821 createSMESHAction( SMESHOp::OpIntersectGroups, "INT_GROUP", "ICON_INTERSECT" );
3822 createSMESHAction( SMESHOp::OpCutGroups, "CUT_GROUP", "ICON_CUT" );
3823 createSMESHAction( SMESHOp::OpGroupUnderlyingElem, "UNDERLYING_ELEMS", "ICON_UNDERLYING_ELEMS" );
3824 createSMESHAction( SMESHOp::OpAddElemGroupPopup, "ADD" );
3825 createSMESHAction( SMESHOp::OpRemoveElemGroupPopup, "REMOVE" );
3826 createSMESHAction( SMESHOp::OpDeleteGroup, "DEL_GROUP", "ICON_DEL_GROUP" );
3827 createSMESHAction( SMESHOp::OpMeshInformation , "ADV_INFO", "ICON_ADV_INFO" );
3828 //createSMESHAction( SMESHOp::OpStdInfo, "STD_INFO", "ICON_STD_INFO" );
3829 //createSMESHAction( SMESHOp::OpWhatIs, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3830 createSMESHAction( SMESHOp::OpFindElementByPoint, "FIND_ELEM", "ICON_FIND_ELEM" );
3832 createSMESHAction( SMESHOp::OpFreeNode, "FREE_NODE", "ICON_FREE_NODE", 0, true );
3833 createSMESHAction( SMESHOp::OpEqualNode, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
3834 createSMESHAction( SMESHOp::OpFreeEdge, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
3835 createSMESHAction( SMESHOp::OpFreeBorder, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
3836 createSMESHAction( SMESHOp::OpLength, "LENGTH", "ICON_LENGTH", 0, true );
3837 createSMESHAction( SMESHOp::OpConnection, "CONNECTION", "ICON_CONNECTION", 0, true );
3838 createSMESHAction( SMESHOp::OpEqualEdge, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
3839 createSMESHAction( SMESHOp::OpFreeFace, "FREE_FACES", "ICON_FREE_FACES", 0, true );
3840 createSMESHAction( SMESHOp::OpBareBorderFace, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
3841 createSMESHAction( SMESHOp::OpOverConstrainedFace, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
3842 createSMESHAction( SMESHOp::OpLength2D, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
3843 createSMESHAction( SMESHOp::OpConnection2D, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
3844 createSMESHAction( SMESHOp::OpArea, "AREA", "ICON_AREA", 0, true );
3845 createSMESHAction( SMESHOp::OpTaper, "TAPER", "ICON_TAPER", 0, true );
3846 createSMESHAction( SMESHOp::OpAspectRatio, "ASPECT", "ICON_ASPECT", 0, true );
3847 createSMESHAction( SMESHOp::OpMinimumAngle, "MIN_ANG", "ICON_ANGLE", 0, true );
3848 createSMESHAction( SMESHOp::OpWarpingAngle, "WARP", "ICON_WARP", 0, true );
3849 createSMESHAction( SMESHOp::OpSkew, "SKEW", "ICON_SKEW", 0, true );
3850 createSMESHAction( SMESHOp::OpMaxElementLength2D, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
3851 createSMESHAction( SMESHOp::OpEqualFace, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
3852 createSMESHAction( SMESHOp::OpAspectRatio3D, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
3853 createSMESHAction( SMESHOp::OpVolume, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
3854 createSMESHAction( SMESHOp::OpMaxElementLength3D, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
3855 createSMESHAction( SMESHOp::OpBareBorderVolume, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
3856 createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
3857 createSMESHAction( SMESHOp::OpEqualVolume, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
3858 createSMESHAction( SMESHOp::OpOverallMeshQuality, "OVERALL_MESH_QUALITY" );
3860 createSMESHAction( SMESHOp::OpNode, "NODE", "ICON_DLG_NODE" );
3861 createSMESHAction( SMESHOp::OpElem0D, "ELEM0D", "ICON_DLG_ELEM0D" );
3862 createSMESHAction( SMESHOp::OpElem0DOnElemNodes, "0D_ON_ALL_NODES", "ICON_0D_ON_ALL_NODES" );
3863 createSMESHAction( SMESHOp::OpBall, "BALL", "ICON_DLG_BALL" );
3864 createSMESHAction( SMESHOp::OpEdge, "EDGE", "ICON_DLG_EDGE" );
3865 createSMESHAction( SMESHOp::OpTriangle, "TRIANGLE", "ICON_DLG_TRIANGLE" );
3866 createSMESHAction( SMESHOp::OpQuadrangle, "QUAD", "ICON_DLG_QUADRANGLE" );
3867 createSMESHAction( SMESHOp::OpPolygon, "POLYGON", "ICON_DLG_POLYGON" );
3868 createSMESHAction( SMESHOp::OpTetrahedron, "TETRA", "ICON_DLG_TETRAS" );
3869 createSMESHAction( SMESHOp::OpHexahedron, "HEXA", "ICON_DLG_HEXAS" );
3870 createSMESHAction( SMESHOp::OpPentahedron, "PENTA", "ICON_DLG_PENTA" );
3871 createSMESHAction( SMESHOp::OpPyramid , "PYRAMID", "ICON_DLG_PYRAMID" );
3872 createSMESHAction( SMESHOp::OpHexagonalPrism, "OCTA", "ICON_DLG_OCTA" );
3873 createSMESHAction( SMESHOp::OpPolyhedron, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
3874 createSMESHAction( SMESHOp::OpQuadraticEdge, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
3875 createSMESHAction( SMESHOp::OpQuadraticTriangle, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
3876 createSMESHAction( SMESHOp::OpBiQuadraticTriangle, "BIQUADRATIC_TRIANGLE", "ICON_DLG_BIQUADRATIC_TRIANGLE" );
3877 createSMESHAction( SMESHOp::OpQuadraticQuadrangle, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
3878 createSMESHAction( SMESHOp::OpBiQuadraticQuadrangle, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
3879 createSMESHAction( SMESHOp::OpQuadraticPolygon, "QUADRATIC_POLYGON", "ICON_DLG_QUADRATIC_POLYGON" );
3880 createSMESHAction( SMESHOp::OpQuadraticTetrahedron, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
3881 createSMESHAction( SMESHOp::OpQuadraticPyramid, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
3882 createSMESHAction( SMESHOp::OpQuadraticPentahedron, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
3883 createSMESHAction( SMESHOp::OpQuadraticHexahedron, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
3884 createSMESHAction( SMESHOp::OpTriQuadraticHexahedron, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
3886 createSMESHAction( SMESHOp::OpRemoveNodes, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
3887 createSMESHAction( SMESHOp::OpRemoveElements, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
3888 createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
3889 createSMESHAction( SMESHOp::OpClearMesh, "CLEAR_MESH", "ICON_CLEAR_MESH" );
3891 //createSMESHAction( SMESHOp::OpRenumberingNodes, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
3892 //createSMESHAction( SMESHOp::OpRenumberingElements, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
3894 createSMESHAction( SMESHOp::OpTranslation, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
3895 createSMESHAction( SMESHOp::OpRotation, "ROT", "ICON_DLG_MESH_ROTATION" );
3896 createSMESHAction( SMESHOp::OpSymmetry, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
3897 createSMESHAction( SMESHOp::OpScale, "SCALE", "ICON_DLG_MESH_SCALE" );
3898 createSMESHAction( SMESHOp::OpSewing, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
3899 createSMESHAction( SMESHOp::OpMergeNodes, "MERGE", "ICON_SMESH_MERGE_NODES" );
3900 createSMESHAction( SMESHOp::OpMergeElements, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
3901 createSMESHAction( SMESHOp::OpMoveNode, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
3902 createSMESHAction( SMESHOp::OpDuplicateNodes, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
3903 createSMESHAction( SMESHOp::OpDiagonalInversion, "INV", "ICON_DLG_MESH_DIAGONAL" );
3904 createSMESHAction( SMESHOp::OpUnionOfTwoTriangle, "UNION2", "ICON_UNION2TRI" );
3905 createSMESHAction( SMESHOp::OpOrientation, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
3906 createSMESHAction( SMESHOp::OpReorientFaces, "REORIENT_2D", "ICON_REORIENT_2D" );
3907 createSMESHAction( SMESHOp::OpUnionOfTriangles, "UNION", "ICON_UNIONTRI" );
3908 createSMESHAction( SMESHOp::OpCuttingOfQuadrangles, "CUT", "ICON_CUTQUAD" );
3909 createSMESHAction( SMESHOp::OpSplitVolumes, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
3910 createSMESHAction( SMESHOp::OpSplitBiQuadratic, "SPLIT_BIQUAD", "ICON_SPLIT_BIQUAD" );
3911 createSMESHAction( SMESHOp::OpSmoothing, "SMOOTH", "ICON_DLG_SMOOTHING" );
3912 createSMESHAction( SMESHOp::OpExtrusion, "EXTRUSION", "ICON_EXTRUSION" );
3913 createSMESHAction( SMESHOp::OpExtrusionAlongAPath, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
3914 createSMESHAction( SMESHOp::OpRevolution, "REVOLUTION", "ICON_REVOLUTION" );
3915 createSMESHAction( SMESHOp::OpPatternMapping, "MAP", "ICON_MAP" );
3916 createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
3917 createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D", "ICON_2D_FROM_3D" );
3919 createSMESHAction( SMESHOp::OpReset, "RESET" );
3920 createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
3921 createSMESHAction( SMESHOp::OpShowScalarBar, "SHOW_SCALAR_BAR","",0, true );
3922 createSMESHAction( SMESHOp::OpSaveDistribution, "SAVE_DISTRIBUTION" );
3923 createSMESHAction( SMESHOp::OpShowDistribution, "SHOW_DISTRIBUTION","",0, true );
3924 #ifndef DISABLE_PLOT2DVIEWER
3925 createSMESHAction( SMESHOp::OpPlotDistribution, "PLOT_DISTRIBUTION" );
3927 createSMESHAction( SMESHOp::OpDMWireframe, "WIRE", "ICON_WIRE", 0, true );
3928 createSMESHAction( SMESHOp::OpDMShading, "SHADE", "ICON_SHADE", 0, true );
3929 createSMESHAction( SMESHOp::OpDMNodes, "NODES", "ICON_POINTS", 0, true );
3930 createSMESHAction( SMESHOp::OpDMShrink, "SHRINK", "ICON_SHRINK", 0, true );
3931 createSMESHAction( SMESHOp::OpUpdate, "UPDATE", "ICON_UPDATE" );
3932 createSMESHAction( SMESHOp::OpDE0DElements, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
3933 createSMESHAction( SMESHOp::OpDEEdges, "EDGES", "ICON_DLG_EDGE", 0, true );
3934 createSMESHAction( SMESHOp::OpDEFaces, "FACES", "ICON_DLG_TRIANGLE", 0, true );
3935 createSMESHAction( SMESHOp::OpDEVolumes, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
3936 createSMESHAction( SMESHOp::OpDEBalls, "BALLS", "ICON_DLG_BALL", 0, true );
3937 createSMESHAction( SMESHOp::OpDEChoose, "CHOOSE", "ICON_DLG_CHOOSE", 0, false );
3938 createSMESHAction( SMESHOp::OpDEAllEntity, "ALL", "ICON_DLG_CHOOSE_ALL", 0, false );
3939 createSMESHAction( SMESHOp::OpOrientationOnFaces, "FACE_ORIENTATION", "", 0, true );
3941 createSMESHAction( SMESHOp::OpRepresentationLines, "LINE_REPRESENTATION", "", 0, true );
3942 createSMESHAction( SMESHOp::OpRepresentationArcs, "ARC_REPRESENTATION", "", 0, true );
3944 createSMESHAction( SMESHOp::OpEditHypothesis, "EDIT_HYPO" );
3945 createSMESHAction( SMESHOp::OpUnassign, "UNASSIGN" );
3946 createSMESHAction( SMESHOp::OpNumberingNodes, "NUM_NODES", "", 0, true );
3947 createSMESHAction( SMESHOp::OpNumberingElements, "NUM_ELEMENTS", "", 0, true );
3948 createSMESHAction( SMESHOp::OpProperties, "COLORS" );
3949 createSMESHAction( SMESHOp::OpTransparency, "TRANSP" );
3950 createSMESHAction( SMESHOp::OpClipping, "CLIP" );
3951 createSMESHAction( SMESHOp::OpAutoColor, "AUTO_COLOR" );
3952 createSMESHAction( SMESHOp::OpDisableAutoColor, "DISABLE_AUTO_COLOR" );
3954 createSMESHAction( SMESHOp::OpMinimumDistance, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
3955 createSMESHAction( SMESHOp::OpBoundingBox, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
3956 createSMESHAction( SMESHOp::OpPropertiesLength, "MEASURE_LENGTH", "ICON_MEASURE_LENGTH" );
3957 createSMESHAction( SMESHOp::OpPropertiesArea, "MEASURE_AREA", "ICON_MEASURE_AREA" );
3958 createSMESHAction( SMESHOp::OpPropertiesVolume, "MEASURE_VOLUME", "ICON_MEASURE_VOLUME" );
3960 createSMESHAction( SMESHOp::OpHide, "HIDE" );
3961 createSMESHAction( SMESHOp::OpShow, "SHOW" );
3962 createSMESHAction( SMESHOp::OpShowOnly, "DISPLAY_ONLY" );
3964 createSMESHAction( SMESHOp::OpSortChild, "SORT_CHILD_ITEMS" );
3966 QList<int> aCtrlActions;
3967 aCtrlActions << SMESHOp::OpFreeNode << SMESHOp::OpEqualNode // node controls
3968 << SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
3969 << SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge // edge controls
3970 << SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
3971 << SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
3972 << SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
3973 << SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
3974 << SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace // face controls
3975 << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
3976 << SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
3977 << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume; // volume controls
3978 QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
3979 aCtrlGroup->setExclusive( true );
3980 for( int i = 0; i < aCtrlActions.size(); i++ )
3981 aCtrlGroup->addAction( action( aCtrlActions[i] ) );
3983 // ----- create menu --------------
3984 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
3985 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
3986 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
3987 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
3988 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
3989 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
3990 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
3991 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
3993 createMenu( separator(), fileId );
3995 QMenu* nodeMenu = new QMenu(); QMenu* edgeMenu = new QMenu();
3996 QMenu* faceMenu = new QMenu(); QMenu* volumeMenu = new QMenu();
3997 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
3998 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
3999 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10, -1, nodeMenu ),
4000 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10, -1, edgeMenu ),
4001 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10, -1, faceMenu ),
4002 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10, -1, volumeMenu ),
4003 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
4004 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
4005 //renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
4006 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
4007 basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
4009 //createMenu( SMESHOp::OpImportDAT, importId, -1 );
4010 createMenu( SMESHOp::OpImportUNV, importId, -1 );
4011 createMenu( SMESHOp::OpImportMED, importId, -1 );
4012 createMenu( SMESHOp::OpImportSTL, importId, -1 );
4014 createMenu( SMESHOp::OpImportCGNS, importId, -1 );
4016 createMenu( SMESHOp::OpImportSAUV, importId, -1 );
4017 createMenu( SMESHOp::OpImportGMF, importId, -1 );
4018 createMenu( SMESHOp::OpExportDAT, exportId, -1 );
4019 createMenu( SMESHOp::OpExportMED, exportId, -1 );
4020 createMenu( SMESHOp::OpExportUNV, exportId, -1 );
4021 createMenu( SMESHOp::OpExportSTL, exportId, -1 );
4023 createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
4025 createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
4026 createMenu( SMESHOp::OpExportGMF, exportId, -1 );
4027 createMenu( separator(), fileId, 10 );
4029 createMenu( SMESHOp::OpDelete, editId, -1 );
4031 createMenu( SMESHOp::OpSelectFiltersLibrary, toolsId, -1 );
4033 createMenu( SMESHOp::OpCreateMesh, meshId, -1 ); // "Mesh" menu
4034 createMenu( SMESHOp::OpCreateSubMesh, meshId, -1 );
4035 createMenu( SMESHOp::OpEditMeshOrSubMesh, meshId, -1 );
4036 createMenu( SMESHOp::OpBuildCompoundMesh, meshId, -1 );
4037 createMenu( SMESHOp::OpCopyMesh, meshId, -1 );
4038 createMenu( separator(), meshId, -1 );
4039 createMenu( SMESHOp::OpCompute, meshId, -1 );
4040 createMenu( SMESHOp::OpPreCompute, meshId, -1 );
4041 createMenu( SMESHOp::OpEvaluate, meshId, -1 );
4042 createMenu( SMESHOp::OpMeshOrder, meshId, -1 );
4043 createMenu( separator(), meshId, -1 );
4044 createMenu( SMESHOp::OpCreateGroup, meshId, -1 );
4045 createMenu( SMESHOp::OpCreateGeometryGroup, meshId, -1 );
4046 createMenu( SMESHOp::OpConstructGroup, meshId, -1 );
4047 createMenu( SMESHOp::OpEditGroup, meshId, -1 );
4048 createMenu( SMESHOp::OpEditGeomGroupAsGroup, meshId, -1 );
4049 createMenu( separator(), meshId, -1 );
4050 createMenu( SMESHOp::OpUnionGroups, meshId, -1 );
4051 createMenu( SMESHOp::OpIntersectGroups, meshId, -1 );
4052 createMenu( SMESHOp::OpCutGroups, meshId, -1 );
4053 createMenu( separator(), meshId, -1 );
4054 createMenu( SMESHOp::OpGroupUnderlyingElem, meshId, -1 );
4055 createMenu( separator(), meshId, -1 );
4056 createMenu( SMESHOp::OpMeshInformation, meshId, -1 );
4057 //createMenu( SMESHOp::OpStdInfo, meshId, -1 );
4058 //createMenu( SMESHOp::OpWhatIs, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4059 createMenu( SMESHOp::OpFindElementByPoint, meshId, -1 );
4060 createMenu( separator(), meshId, -1 );
4062 createMenu( SMESHOp::OpFreeNode, nodeId, -1 );
4063 createMenu( SMESHOp::OpEqualNode, nodeId, -1 );
4064 createMenu( SMESHOp::OpFreeBorder, edgeId, -1 );
4065 createMenu( SMESHOp::OpLength, edgeId, -1 );
4066 createMenu( SMESHOp::OpConnection, edgeId, -1 );
4067 createMenu( SMESHOp::OpEqualEdge, edgeId, -1 );
4068 createMenu( SMESHOp::OpFreeEdge, faceId, -1 );
4069 createMenu( SMESHOp::OpFreeFace, faceId, -1 );
4070 createMenu( SMESHOp::OpBareBorderFace, faceId, -1 );
4071 createMenu( SMESHOp::OpOverConstrainedFace, faceId, -1 );
4072 createMenu( SMESHOp::OpLength2D, faceId, -1 );
4073 createMenu( SMESHOp::OpConnection2D, faceId, -1 );
4074 createMenu( SMESHOp::OpArea, faceId, -1 );
4075 createMenu( SMESHOp::OpTaper, faceId, -1 );
4076 createMenu( SMESHOp::OpAspectRatio, faceId, -1 );
4077 createMenu( SMESHOp::OpMinimumAngle, faceId, -1 );
4078 createMenu( SMESHOp::OpWarpingAngle, faceId, -1 );
4079 createMenu( SMESHOp::OpSkew, faceId, -1 );
4080 createMenu( SMESHOp::OpMaxElementLength2D, faceId, -1 );
4081 createMenu( SMESHOp::OpEqualFace, faceId, -1 );
4082 createMenu( SMESHOp::OpAspectRatio3D, volumeId, -1 );
4083 createMenu( SMESHOp::OpVolume, volumeId, -1 );
4084 createMenu( SMESHOp::OpMaxElementLength3D, volumeId, -1 );
4085 createMenu( SMESHOp::OpBareBorderVolume, volumeId, -1 );
4086 createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
4087 createMenu( SMESHOp::OpEqualVolume, volumeId, -1 );
4088 createMenu( separator(), ctrlId, -1 );
4089 createMenu( SMESHOp::OpReset, ctrlId, -1 );
4090 createMenu( separator(), ctrlId, -1 );
4091 createMenu( SMESHOp::OpOverallMeshQuality, ctrlId, -1 );
4093 createMenu( SMESHOp::OpNode, addId, -1 );
4094 createMenu( SMESHOp::OpElem0D, addId, -1 );
4095 createMenu( SMESHOp::OpElem0DOnElemNodes, addId, -1 );
4096 createMenu( SMESHOp::OpBall, addId, -1 );
4097 createMenu( SMESHOp::OpEdge, addId, -1 );
4098 createMenu( SMESHOp::OpTriangle, addId, -1 );
4099 createMenu( SMESHOp::OpQuadrangle, addId, -1 );
4100 createMenu( SMESHOp::OpPolygon, addId, -1 );
4101 createMenu( SMESHOp::OpTetrahedron, addId, -1 );
4102 createMenu( SMESHOp::OpHexahedron, addId, -1 );
4103 createMenu( SMESHOp::OpPentahedron, addId, -1 );
4104 createMenu( SMESHOp::OpPyramid, addId, -1 );
4105 createMenu( SMESHOp::OpHexagonalPrism, addId, -1 );
4106 createMenu( SMESHOp::OpPolyhedron, addId, -1 );
4107 createMenu( separator(), addId, -1 );
4108 createMenu( SMESHOp::OpQuadraticEdge, addId, -1 );
4109 createMenu( SMESHOp::OpQuadraticTriangle, addId, -1 );
4110 createMenu( SMESHOp::OpBiQuadraticTriangle , addId, -1 );
4111 createMenu( SMESHOp::OpQuadraticQuadrangle, addId, -1 );
4112 createMenu( SMESHOp::OpBiQuadraticQuadrangle, addId, -1 );
4113 createMenu( SMESHOp::OpQuadraticPolygon, addId, -1 );
4114 createMenu( SMESHOp::OpQuadraticTetrahedron, addId, -1 );
4115 createMenu( SMESHOp::OpQuadraticPyramid, addId, -1 );
4116 createMenu( SMESHOp::OpQuadraticPentahedron, addId, -1 );
4117 createMenu( SMESHOp::OpQuadraticHexahedron, addId, -1 );
4118 createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
4120 createMenu( SMESHOp::OpRemoveNodes, removeId, -1 );
4121 createMenu( SMESHOp::OpRemoveElements, removeId, -1 );
4122 createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
4123 createMenu( separator(), removeId, -1 );
4124 createMenu( SMESHOp::OpDeleteGroup, removeId, -1 );
4125 createMenu( separator(), removeId, -1 );
4126 createMenu( SMESHOp::OpClearMesh, removeId, -1 );
4128 //createMenu( SMESHOp::OpRenumberingNodes, renumId, -1 );
4129 //createMenu( SMESHOp::OpRenumberingElements, renumId, -1 );
4131 createMenu( SMESHOp::OpTranslation, transfId, -1 );
4132 createMenu( SMESHOp::OpRotation, transfId, -1 );
4133 createMenu( SMESHOp::OpSymmetry, transfId, -1 );
4134 createMenu( SMESHOp::OpScale, transfId, -1 );
4135 createMenu( SMESHOp::OpSewing, transfId, -1 );
4136 createMenu( SMESHOp::OpMergeNodes, transfId, -1 );
4137 createMenu( SMESHOp::OpMergeElements, transfId, -1 );
4138 createMenu( SMESHOp::OpDuplicateNodes, transfId, -1 );
4140 createMenu( SMESHOp::OpMoveNode, modifyId, -1 );
4141 createMenu( SMESHOp::OpDiagonalInversion, modifyId, -1 );
4142 createMenu( SMESHOp::OpUnionOfTwoTriangle, modifyId, -1 );
4143 createMenu( SMESHOp::OpOrientation, modifyId, -1 );
4144 createMenu( SMESHOp::OpReorientFaces, modifyId, -1 );
4145 createMenu( SMESHOp::OpUnionOfTriangles, modifyId, -1 );
4146 createMenu( SMESHOp::OpCuttingOfQuadrangles, modifyId, -1 );
4147 createMenu( SMESHOp::OpSplitVolumes, modifyId, -1 );
4148 createMenu( SMESHOp::OpSplitBiQuadratic, modifyId, -1 );
4149 createMenu( SMESHOp::OpSmoothing, modifyId, -1 );
4150 createMenu( SMESHOp::OpExtrusion, modifyId, -1 );
4151 createMenu( SMESHOp::OpExtrusionAlongAPath , modifyId, -1 );
4152 createMenu( SMESHOp::OpRevolution, modifyId, -1 );
4153 createMenu( SMESHOp::OpPatternMapping, modifyId, -1 );
4154 createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
4155 createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
4157 createMenu( SMESHOp::OpMinimumDistance, measureId, -1 );
4158 createMenu( SMESHOp::OpBoundingBox, measureId, -1 );
4159 createMenu( SMESHOp::OpPropertiesLength, basicPropId, -1 );
4160 createMenu( SMESHOp::OpPropertiesArea, basicPropId, -1 );
4161 createMenu( SMESHOp::OpPropertiesVolume, basicPropId, -1 );
4162 createMenu( SMESHOp::OpUpdate, viewId, -1 );
4164 connect( nodeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4165 connect( edgeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4166 connect( faceMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4167 connect( volumeMenu, SIGNAL( aboutToShow() ), this, SLOT( onUpdateControlActions() ) );
4169 // ----- create toolbars --------------
4170 int meshTb = createTool( tr( "TB_MESH" ), QString( "SMESHMeshToolbar" ) ),
4171 info = createTool( tr( "TB_INFO" ), QString( "SMESHInformationToolbar" ) ),
4172 groupTb = createTool( tr( "TB_GROUP" ), QString( "SMESHGroupToolbar" ) ),
4173 ctrl0dTb = createTool( tr( "TB_CTRL0D" ), QString( "SMESHNodeControlsToolbar" ) ),
4174 ctrl1dTb = createTool( tr( "TB_CTRL1D" ), QString( "SMESHEdgeControlsToolbar" ) ),
4175 ctrl2dTb = createTool( tr( "TB_CTRL2D" ), QString( "SMESHFaceControlsToolbar" ) ),
4176 ctrl3dTb = createTool( tr( "TB_CTRL3D" ), QString( "SMESHVolumeControlsToolbar" ) ),
4177 addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ),
4178 addNonElemTb = createTool( tr( "TB_ADDNON" ), QString( "SMESHAddElementToolbar" ) ),
4179 remTb = createTool( tr( "TB_REM" ), QString( "SMESHRemoveToolbar" ) ),
4180 //renumbTb = createTool( tr( "TB_RENUMBER" ), QString( "SMESHRenumberingToolbar" ) ),
4181 transformTb = createTool( tr( "TB_TRANSFORM" ), QString( "SMESHTransformationToolbar" ) ),
4182 modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ),
4183 measuremTb = createTool( tr( "TB_MEASUREM" ), QString( "SMESHMeasurementsToolbar" ) ),
4184 dispModeTb = createTool( tr( "TB_DISP_MODE" ), QString( "SMESHDisplayModeToolbar" ) );
4186 createTool( SMESHOp::OpCreateMesh, meshTb );
4187 createTool( SMESHOp::OpCreateSubMesh, meshTb );
4188 createTool( SMESHOp::OpEditMeshOrSubMesh, meshTb );
4189 createTool( SMESHOp::OpBuildCompoundMesh, meshTb );
4190 createTool( SMESHOp::OpCopyMesh, meshTb );
4191 createTool( separator(), meshTb );
4192 createTool( SMESHOp::OpCompute, meshTb );
4193 createTool( SMESHOp::OpPreCompute, meshTb );
4194 createTool( SMESHOp::OpEvaluate, meshTb );
4195 createTool( SMESHOp::OpMeshOrder, meshTb );
4197 createTool( SMESHOp::OpCreateGroup, groupTb );
4198 createTool( SMESHOp::OpCreateGeometryGroup, groupTb );
4199 createTool( SMESHOp::OpConstructGroup, groupTb );
4200 createTool( SMESHOp::OpEditGroup, groupTb );
4202 createTool( SMESHOp::OpMeshInformation, info );
4203 //createTool( SMESHOp::OpStdInfo, meshTb );
4204 //createTool( SMESHOp::OpWhatIs, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
4205 createTool( SMESHOp::OpFindElementByPoint, info );
4207 createTool( SMESHOp::OpFreeNode, ctrl0dTb );
4208 createTool( SMESHOp::OpEqualNode, ctrl0dTb );
4210 createTool( SMESHOp::OpFreeBorder, ctrl1dTb );
4211 createTool( SMESHOp::OpLength, ctrl1dTb );
4212 createTool( SMESHOp::OpConnection, ctrl1dTb );
4213 createTool( SMESHOp::OpEqualEdge, ctrl1dTb );
4215 createTool( SMESHOp::OpFreeEdge, ctrl2dTb );
4216 createTool( SMESHOp::OpFreeFace, ctrl2dTb );
4217 createTool( SMESHOp::OpBareBorderFace, ctrl2dTb );
4218 createTool( SMESHOp::OpOverConstrainedFace, ctrl2dTb );
4219 createTool( SMESHOp::OpLength2D, ctrl2dTb );
4220 createTool( SMESHOp::OpConnection2D, ctrl2dTb );
4221 createTool( SMESHOp::OpArea, ctrl2dTb );
4222 createTool( SMESHOp::OpTaper, ctrl2dTb );
4223 createTool( SMESHOp::OpAspectRatio, ctrl2dTb );
4224 createTool( SMESHOp::OpMinimumAngle, ctrl2dTb );
4225 createTool( SMESHOp::OpWarpingAngle, ctrl2dTb );
4226 createTool( SMESHOp::OpSkew, ctrl2dTb );
4227 createTool( SMESHOp::OpMaxElementLength2D, ctrl2dTb );
4228 createTool( SMESHOp::OpEqualFace, ctrl2dTb );
4230 createTool( SMESHOp::OpAspectRatio3D, ctrl3dTb );
4231 createTool( SMESHOp::OpVolume, ctrl3dTb );
4232 createTool( SMESHOp::OpMaxElementLength3D, ctrl3dTb );
4233 createTool( SMESHOp::OpBareBorderVolume, ctrl3dTb );
4234 createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
4235 createTool( SMESHOp::OpEqualVolume, ctrl3dTb );
4237 createTool( SMESHOp::OpNode, addElemTb );
4238 createTool( SMESHOp::OpElem0D, addElemTb );
4239 createTool( SMESHOp::OpElem0DOnElemNodes, addElemTb );
4240 createTool( SMESHOp::OpBall, addElemTb );
4241 createTool( SMESHOp::OpEdge, addElemTb );
4242 createTool( SMESHOp::OpTriangle, addElemTb );
4243 createTool( SMESHOp::OpQuadrangle, addElemTb );
4244 createTool( SMESHOp::OpPolygon, addElemTb );
4245 createTool( SMESHOp::OpTetrahedron, addElemTb );
4246 createTool( SMESHOp::OpHexahedron, addElemTb );
4247 createTool( SMESHOp::OpPentahedron, addElemTb );
4248 createTool( SMESHOp::OpPyramid, addElemTb );
4249 createTool( SMESHOp::OpHexagonalPrism, addElemTb );
4250 createTool( SMESHOp::OpPolyhedron, addElemTb );
4252 createTool( SMESHOp::OpQuadraticEdge, addNonElemTb );
4253 createTool( SMESHOp::OpQuadraticTriangle, addNonElemTb );
4254 createTool( SMESHOp::OpBiQuadraticTriangle, addNonElemTb );
4255 createTool( SMESHOp::OpQuadraticQuadrangle, addNonElemTb );
4256 createTool( SMESHOp::OpBiQuadraticQuadrangle, addNonElemTb );
4257 createTool( SMESHOp::OpQuadraticPolygon, addNonElemTb );
4258 createTool( SMESHOp::OpQuadraticTetrahedron, addNonElemTb );
4259 createTool( SMESHOp::OpQuadraticPyramid, addNonElemTb );
4260 createTool( SMESHOp::OpQuadraticPentahedron, addNonElemTb );
4261 createTool( SMESHOp::OpQuadraticHexahedron, addNonElemTb );
4262 createTool( SMESHOp::OpTriQuadraticHexahedron, addNonElemTb );
4264 createTool( SMESHOp::OpRemoveNodes, remTb );
4265 createTool( SMESHOp::OpRemoveElements, remTb );
4266 createTool( SMESHOp::OpRemoveOrphanNodes, remTb );
4267 createTool( SMESHOp::OpClearMesh, remTb );
4269 //createTool( SMESHOp::OpRenumberingNodes, renumbTb );
4270 //createTool( SMESHOp::OpRenumberingElements, renumbTb );
4272 createTool( SMESHOp::OpTranslation, transformTb );
4273 createTool( SMESHOp::OpRotation, transformTb );
4274 createTool( SMESHOp::OpSymmetry, transformTb );
4275 createTool( SMESHOp::OpScale, transformTb );
4276 createTool( SMESHOp::OpSewing, transformTb );
4277 createTool( SMESHOp::OpMergeNodes, transformTb );
4278 createTool( SMESHOp::OpMergeElements, transformTb );
4279 createTool( SMESHOp::OpDuplicateNodes, transformTb );
4281 createTool( SMESHOp::OpMoveNode, modifyTb );
4282 createTool( SMESHOp::OpDiagonalInversion, modifyTb );
4283 createTool( SMESHOp::OpUnionOfTwoTriangle, modifyTb );
4284 createTool( SMESHOp::OpOrientation, modifyTb );
4285 createTool( SMESHOp::OpReorientFaces, modifyTb );
4286 createTool( SMESHOp::OpUnionOfTriangles, modifyTb );
4287 createTool( SMESHOp::OpCuttingOfQuadrangles, modifyTb );
4288 createTool( SMESHOp::OpSplitVolumes, modifyTb );
4289 createTool( SMESHOp::OpSplitBiQuadratic, modifyTb );
4290 createTool( SMESHOp::OpSmoothing, modifyTb );
4291 createTool( SMESHOp::OpExtrusion, modifyTb );
4292 createTool( SMESHOp::OpExtrusionAlongAPath, modifyTb );
4293 createTool( SMESHOp::OpRevolution, modifyTb );
4294 createTool( SMESHOp::OpPatternMapping, modifyTb );
4295 createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
4296 createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
4298 createTool( SMESHOp::OpMinimumDistance, measuremTb );
4300 createTool( SMESHOp::OpUpdate, dispModeTb );
4302 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
4303 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
4306 QString OB = "'ObjectBrowser'",
4307 View = "'" + SVTK_Viewer::Type() + "'",
4309 mesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::MESH ) ),
4310 group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
4311 hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
4312 algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
4313 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
4314 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
4315 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
4316 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_FACE ) ).
4317 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_SOLID ) ).
4318 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_COMPOUND ) ).
4319 arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH ) ),
4321 mesh_part = mesh + " " + subMesh + " " + group,
4322 mesh_group = mesh + " " + group,
4323 hyp_alg = hypo + " " + algo;
4325 // popup for object browser
4327 isInvisible("not( isVisible )"),
4328 isEmpty("numberOfNodes = 0"),
4329 isNotEmpty("numberOfNodes <> 0"),
4331 // has nodes, edges, etc in VISIBLE! actor
4332 hasNodes("(numberOfNodes > 0 )"),//&& isVisible)"),
4333 hasElems("(count( elemTypes ) > 0)"),
4334 hasDifferentElems("(count( elemTypes ) > 1)"),
4335 hasBalls("({'BallElem'} in elemTypes)"),
4336 hasElems0d("({'Elem0d'} in elemTypes)"),
4337 hasEdges("({'Edge'} in elemTypes)"),
4338 hasFaces("({'Face'} in elemTypes)"),
4339 hasVolumes("({'Volume'} in elemTypes)"),
4340 hasFacesOrVolumes("(({'Face'} in elemTypes) || ({'Volume'} in elemTypes)) ");
4342 createPopupItem( SMESHOp::OpFileInformation, OB, mesh, "&& selcount=1 && isImported" );
4343 createPopupItem( SMESHOp::OpCreateSubMesh, OB, mesh, "&& hasGeomReference");
4344 createPopupItem( SMESHOp::OpEditMeshOrSubMesh, OB, mesh );
4345 createPopupItem( SMESHOp::OpEditMeshOrSubMesh, OB, subMesh, "&& hasGeomReference" );
4346 createPopupItem( SMESHOp::OpEditGroup, OB, group );
4347 createPopupItem( SMESHOp::OpEditGeomGroupAsGroup, OB, group, "&& groupType != 'Group'" );
4349 popupMgr()->insert( separator(), -1, 0 );
4350 createPopupItem( SMESHOp::OpCompute, OB, mesh, "&& isComputable" );
4351 createPopupItem( SMESHOp::OpPreCompute, OB, mesh, "&& isPreComputable" );
4352 createPopupItem( SMESHOp::OpEvaluate, OB, mesh, "&& isComputable" );
4353 createPopupItem( SMESHOp::OpMeshOrder, OB, mesh, "&& isComputable && hasGeomReference" );
4354 createPopupItem( SMESHOp::OpUpdate, OB, mesh_part );
4355 createPopupItem( SMESHOp::OpMeshInformation, OB, mesh_part );
4356 createPopupItem( SMESHOp::OpFindElementByPoint, OB, mesh_group );
4357 createPopupItem( SMESHOp::OpOverallMeshQuality, OB, mesh_part );
4358 popupMgr()->insert( separator(), -1, 0 );
4359 createPopupItem( SMESHOp::OpCreateGroup, OB, mesh );
4360 createPopupItem( SMESHOp::OpCreateGeometryGroup, OB, mesh, "&& hasGeomReference" );
4361 createPopupItem( SMESHOp::OpConstructGroup, OB, subMesh );
4362 popupMgr()->insert( separator(), -1, 0 );
4363 createPopupItem( SMESHOp::OpEditHypothesis, OB, hypo, "&& isEditableHyp");
4364 createPopupItem( SMESHOp::OpUnassign, OB, hyp_alg ); // REMOVE HYPOTHESIS / ALGORITHMS
4365 popupMgr()->insert( separator(), -1, 0 );
4366 createPopupItem( SMESHOp::OpConvertMeshToQuadratic, OB, mesh + " " + subMesh ); // convert to quadratic
4367 createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh + " " + group, // create 2D mesh from 3D
4369 popupMgr()->insert( separator(), -1, 0 );
4370 createPopupItem( SMESHOp::OpClearMesh, OB, mesh );
4371 popupMgr()->insert( separator(), -1, 0 );
4373 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
4374 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
4375 QString only_one_2D = only_one_non_empty + " && dim>1";
4377 int anId = popupMgr()->insert( tr( "MEN_EXPORT" ), -1, -1 ); // EXPORT submenu
4378 createPopupItem( SMESHOp::OpPopupExportMED, OB, mesh_group, multiple_non_empty, anId );
4379 createPopupItem( SMESHOp::OpPopupExportUNV, OB, mesh_group, only_one_non_empty, anId );
4380 createPopupItem( SMESHOp::OpPopupExportSTL, OB, mesh_group, only_one_2D, anId );
4382 createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
4384 createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, only_one_non_empty, anId );
4385 createPopupItem( SMESHOp::OpPopupExportGMF, OB, mesh_group, only_one_non_empty, anId );
4386 createPopupItem( SMESHOp::OpPopupExportDAT, OB, mesh_group, only_one_non_empty, anId );
4387 createPopupItem( SMESHOp::OpDelete, OB, mesh_part + " " + hyp_alg );
4388 createPopupItem( SMESHOp::OpDeleteGroup, OB, group );
4389 popupMgr()->insert( separator(), -1, 0 );
4392 createPopupItem( SMESHOp::OpEditGroup, View, group );
4393 createPopupItem( SMESHOp::OpAddElemGroupPopup, View, elems );
4394 createPopupItem( SMESHOp::OpRemoveElemGroupPopup, View, elems );
4396 popupMgr()->insert( separator(), -1, 0 );
4397 createPopupItem( SMESHOp::OpUpdate, View, mesh_part );
4398 createPopupItem( SMESHOp::OpMeshInformation, View, mesh_part );
4399 createPopupItem( SMESHOp::OpOverallMeshQuality, View, mesh_part );
4400 createPopupItem( SMESHOp::OpFindElementByPoint, View, mesh );
4401 popupMgr()->insert( separator(), -1, 0 );
4403 createPopupItem( SMESHOp::OpAutoColor, OB + " " + View, mesh, "&& (not isAutoColor)" );
4404 createPopupItem( SMESHOp::OpDisableAutoColor, OB + " " + View, mesh, "&& isAutoColor" );
4405 popupMgr()->insert( separator(), -1, 0 );
4407 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
4408 QString aType = QString( "%1type in {%2}" ).arg( lc );
4409 aType = aType.arg( mesh_part );
4410 QString aMeshInVTK = aClient + "&&" + aType;
4412 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
4413 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
4414 QString aSelCount = QString( "%1 > 0" ).arg( dc );
4416 //-------------------------------------------------
4418 //-------------------------------------------------
4419 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
4421 popupMgr()->insert( action( SMESHOp::OpNumberingNodes ), anId, -1 );
4422 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
4423 popupMgr()->setRule( action( SMESHOp::OpNumberingNodes ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4425 popupMgr()->insert( action( SMESHOp::OpNumberingElements ), anId, -1 );
4426 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4427 popupMgr()->setRule( action( SMESHOp::OpNumberingElements ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4429 popupMgr()->insert( separator(), -1, -1 );
4431 //-------------------------------------------------
4433 //-------------------------------------------------
4434 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4436 popupMgr()->insert( action( SMESHOp::OpDMWireframe ), anId, -1 );
4437 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4438 popupMgr()->setRule( action( SMESHOp::OpDMWireframe ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4440 popupMgr()->insert( action( SMESHOp::OpDMShading ), anId, -1 );
4441 popupMgr()->setRule( action( SMESHOp::OpDMShading ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4442 popupMgr()->setRule( action( SMESHOp::OpDMShading ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4444 popupMgr()->insert( action( SMESHOp::OpDMNodes ), anId, -1 );
4445 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), aMeshInVTK + "&&" + hasNodes, QtxPopupMgr::VisibleRule );
4446 popupMgr()->setRule( action( SMESHOp::OpDMNodes ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4448 popupMgr()->insert( separator(), anId, -1 );
4450 popupMgr()->insert( action( SMESHOp::OpDMShrink ), anId, -1 );
4451 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4452 popupMgr()->setRule( action( SMESHOp::OpDMShrink ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4454 //-------------------------------------------------
4456 //-------------------------------------------------
4457 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4459 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4461 popupMgr()->insert( action( SMESHOp::OpDE0DElements ), anId, -1 );
4462 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4463 popupMgr()->setRule( action( SMESHOp::OpDE0DElements ), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4465 popupMgr()->insert( action( SMESHOp::OpDEEdges ), anId, -1 );
4466 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4467 popupMgr()->setRule( action( SMESHOp::OpDEEdges ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4469 popupMgr()->insert( action( SMESHOp::OpDEFaces ), anId, -1 );
4470 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4471 popupMgr()->setRule( action( SMESHOp::OpDEFaces ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4473 popupMgr()->insert( action( SMESHOp::OpDEVolumes ), anId, -1 );
4474 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4475 popupMgr()->setRule( action( SMESHOp::OpDEVolumes ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4477 popupMgr()->insert( action( SMESHOp::OpDEBalls ), anId, -1 );
4478 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), aDiffElemsInVTK + "&& isVisible &&" + hasBalls, QtxPopupMgr::VisibleRule );
4479 popupMgr()->setRule( action( SMESHOp::OpDEBalls ), "{'BallElem'} in entityMode", QtxPopupMgr::ToggleRule );
4481 popupMgr()->insert( separator(), anId, -1 );
4483 popupMgr()->insert( action( SMESHOp::OpDEChoose ), anId, -1 );
4484 popupMgr()->setRule( action( SMESHOp::OpDEChoose ), aClient + "&&" + aType + "&&" + isNotEmpty, QtxPopupMgr::VisibleRule );
4486 popupMgr()->insert( separator(), anId, -1 );
4488 popupMgr()->insert( action( SMESHOp::OpDEAllEntity ), anId, -1 );
4489 popupMgr()->setRule( action( SMESHOp::OpDEAllEntity ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4492 //-------------------------------------------------
4493 // Representation of the 2D Quadratic elements
4494 //-------------------------------------------------
4495 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4496 popupMgr()->insert( action( SMESHOp::OpRepresentationLines ), anId, -1 );
4497 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), aMeshInVTK + "&& isVisible && isQuadratic",QtxPopupMgr::VisibleRule );
4498 popupMgr()->setRule( action( SMESHOp::OpRepresentationLines ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4500 popupMgr()->insert( action( SMESHOp::OpRepresentationArcs ), anId, -1 );
4501 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), aMeshInVTK + "&& isVisible && isQuadratic", QtxPopupMgr::VisibleRule );
4502 popupMgr()->setRule( action( SMESHOp::OpRepresentationArcs ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4504 //-------------------------------------------------
4505 // Orientation of faces
4506 //-------------------------------------------------
4507 popupMgr()->insert( action( SMESHOp::OpOrientationOnFaces ), -1, -1 );
4508 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4509 popupMgr()->setRule( action( SMESHOp::OpOrientationOnFaces ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4511 //-------------------------------------------------
4513 //-------------------------------------------------
4514 popupMgr()->insert( action( SMESHOp::OpProperties ), -1, -1 );
4515 popupMgr()->setRule( action( SMESHOp::OpProperties ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4517 //-------------------------------------------------
4519 //-------------------------------------------------
4520 popupMgr()->insert( action( SMESHOp::OpTransparency ), -1, -1 );
4521 popupMgr()->setRule( action( SMESHOp::OpTransparency ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4523 //-------------------------------------------------
4525 //-------------------------------------------------
4527 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4528 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4529 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4530 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4532 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4534 popupMgr()->insert( action( SMESHOp::OpReset ), anId, -1 ); // RESET
4535 popupMgr()->setRule( action( SMESHOp::OpReset ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4537 popupMgr()->insert( separator(), anId, -1 );
4539 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4541 popupMgr()->insert( action( SMESHOp::OpFreeNode ), aSubId, -1 );
4542 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4543 popupMgr()->setRule( action( SMESHOp::OpFreeNode ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4545 popupMgr()->insert ( action( SMESHOp::OpEqualNode ), aSubId, -1 );
4546 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4547 popupMgr()->setRule( action( SMESHOp::OpEqualNode ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4549 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4551 popupMgr()->insert( action( SMESHOp::OpFreeBorder ), aSubId, -1 );
4552 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), aMeshInVTK + "&&" + hasEdges + "&&" + hasFacesOrVolumes, QtxPopupMgr::VisibleRule );
4553 popupMgr()->setRule( action( SMESHOp::OpFreeBorder ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4555 popupMgr()->insert( action( SMESHOp::OpLength ), aSubId, -1 );
4556 popupMgr()->setRule( action( SMESHOp::OpLength ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4557 popupMgr()->setRule( action( SMESHOp::OpLength ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4559 popupMgr()->insert( action( SMESHOp::OpConnection ), aSubId, -1 );
4560 popupMgr()->setRule( action( SMESHOp::OpConnection ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4561 popupMgr()->setRule( action( SMESHOp::OpConnection ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4562 popupMgr()->insert ( action( SMESHOp::OpEqualEdge ), aSubId, -1 ); // EQUAL_EDGE
4563 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4564 popupMgr()->setRule( action( SMESHOp::OpEqualEdge ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4566 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4568 popupMgr()->insert( action( SMESHOp::OpFreeEdge ), aSubId, -1 );
4569 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4570 popupMgr()->setRule( action( SMESHOp::OpFreeEdge ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4572 popupMgr()->insert ( action( SMESHOp::OpFreeFace ), aSubId, -1 );
4573 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4574 QtxPopupMgr::VisibleRule );
4575 popupMgr()->setRule( action( SMESHOp::OpFreeFace ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4577 popupMgr()->insert ( action( SMESHOp::OpLength2D ), aSubId, -1 );
4578 popupMgr()->setRule( action( SMESHOp::OpLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4579 popupMgr()->setRule( action( SMESHOp::OpLength2D ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4581 popupMgr()->insert ( action( SMESHOp::OpConnection2D ), aSubId, -1 );
4582 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4583 popupMgr()->setRule( action( SMESHOp::OpConnection2D ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4585 popupMgr()->insert ( action( SMESHOp::OpArea ), aSubId, -1 );
4586 popupMgr()->setRule( action( SMESHOp::OpArea ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4587 popupMgr()->setRule( action( SMESHOp::OpArea ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4589 popupMgr()->insert ( action( SMESHOp::OpTaper ), aSubId, -1 );
4590 popupMgr()->setRule( action( SMESHOp::OpTaper ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4591 popupMgr()->setRule( action( SMESHOp::OpTaper ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4593 popupMgr()->insert ( action( SMESHOp::OpAspectRatio ), aSubId, -1 );
4594 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4595 popupMgr()->setRule( action( SMESHOp::OpAspectRatio ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4597 popupMgr()->insert ( action( SMESHOp::OpMinimumAngle ), aSubId, -1 );
4598 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4599 popupMgr()->setRule( action( SMESHOp::OpMinimumAngle ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4601 popupMgr()->insert ( action( SMESHOp::OpWarpingAngle ), aSubId, -1 );
4602 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4603 popupMgr()->setRule( action( SMESHOp::OpWarpingAngle ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4605 popupMgr()->insert ( action( SMESHOp::OpSkew ), aSubId, -1 );
4606 popupMgr()->setRule( action( SMESHOp::OpSkew ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4607 popupMgr()->setRule( action( SMESHOp::OpSkew ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4609 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength2D ), aSubId, -1 );
4610 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4611 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength2D ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4613 popupMgr()->insert ( action( SMESHOp::OpBareBorderFace ), aSubId, -1 );
4614 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4615 popupMgr()->setRule( action( SMESHOp::OpBareBorderFace ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4617 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
4618 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4619 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4620 popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
4621 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4622 popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4624 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4626 popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D ), aSubId, -1 );
4627 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4628 popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4630 popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
4631 popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4632 popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4634 popupMgr()->insert ( action( SMESHOp::OpMaxElementLength3D ), aSubId, -1 );
4635 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4636 popupMgr()->setRule( action( SMESHOp::OpMaxElementLength3D ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4638 popupMgr()->insert ( action( SMESHOp::OpBareBorderVolume ), aSubId, -1 );
4639 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4640 popupMgr()->setRule( action( SMESHOp::OpBareBorderVolume ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4642 popupMgr()->insert ( action( SMESHOp::OpOverConstrainedVolume ), aSubId, -1 );
4643 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4644 popupMgr()->setRule( action( SMESHOp::OpOverConstrainedVolume ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4646 popupMgr()->insert ( action( SMESHOp::OpEqualVolume ), aSubId, -1 );
4647 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4648 popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4650 popupMgr()->insert( separator(), anId, -1 );
4652 popupMgr()->insert( action( SMESHOp::OpShowScalarBar ), anId, -1 );
4653 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4654 popupMgr()->setRule( action( SMESHOp::OpShowScalarBar ), aMeshInVTK + "&& controlMode <> 'eNone' && isScalarBarVisible", QtxPopupMgr::ToggleRule );
4655 popupMgr()->insert( action( SMESHOp::OpScalarBarProperties ), anId, -1 );
4656 popupMgr()->setRule( action( SMESHOp::OpScalarBarProperties ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4658 popupMgr()->insert( separator(), anId, -1 );
4660 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4662 popupMgr()->insert( action( SMESHOp::OpSaveDistribution ), aSubId, -1 );
4663 popupMgr()->setRule( action( SMESHOp::OpSaveDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4665 popupMgr()->insert( action( SMESHOp::OpShowDistribution ), aSubId, -1 );
4666 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4667 popupMgr()->setRule( action( SMESHOp::OpShowDistribution ), aMeshInVTK + "&& isNumFunctor && isScalarBarVisible && isDistributionVisible", QtxPopupMgr::ToggleRule);
4669 #ifndef DISABLE_PLOT2DVIEWER
4670 popupMgr()->insert( action( SMESHOp::OpPlotDistribution ), aSubId, -1 );
4671 popupMgr()->setRule( action( SMESHOp::OpPlotDistribution ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4674 //-------------------------------------------------
4676 //-------------------------------------------------
4677 popupMgr()->insert( separator(), -1, -1 );
4678 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4679 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4680 popupMgr()->insert( action( SMESHOp::OpShow ), -1, -1 );
4681 popupMgr()->setRule( action( SMESHOp::OpShow ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4683 popupMgr()->insert( action( SMESHOp::OpHide ), -1, -1 );
4684 popupMgr()->setRule( action( SMESHOp::OpHide ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4686 popupMgr()->insert( action( SMESHOp::OpShowOnly ), -1, -1 );
4687 popupMgr()->setRule( action( SMESHOp::OpShowOnly ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4689 popupMgr()->insert( separator(), -1, -1 );
4691 //-------------------------------------------------
4693 //-------------------------------------------------
4694 popupMgr()->insert( action( SMESHOp::OpClipping ), -1, -1 );
4695 popupMgr()->setRule( action( SMESHOp::OpClipping ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4697 popupMgr()->insert( separator(), -1, -1 );
4699 popupMgr()->insert( action( SMESHOp::OpSortChild ), -1, -1 );
4700 popupMgr()->setRule( action( SMESHOp::OpSortChild ), "$component={'SMESH'} and client='ObjectBrowser' and isContainer and nbChildren>1", QtxPopupMgr::VisibleRule );
4701 popupMgr()->insert( separator(), -1, -1 );
4703 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4704 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4706 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4707 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4710 //================================================================================
4712 * \brief Return true if SMESH or GEOM objects are selected.
4713 * Is called form LightApp_Module::activateModule() which clear selection if
4714 * not isSelectionCompatible()
4716 //================================================================================
4718 bool SMESHGUI::isSelectionCompatible()
4720 bool isCompatible = true;
4721 SALOME_ListIO selected;
4722 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4723 Sel->selectedObjects( selected );
4725 SALOME_ListIteratorOfListIO It( selected );
4726 for ( ; isCompatible && It.More(); It.Next())
4728 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4729 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4731 return isCompatible;
4735 bool SMESHGUI::reusableOperation( const int id )
4737 // compute, evaluate and precompute are not reusable operations
4738 return ( id == SMESHOp::OpCompute || id == SMESHOp::OpPreCompute || id == SMESHOp::OpEvaluate ) ? false : SalomeApp_Module::reusableOperation( id );
4741 bool SMESHGUI::activateModule( SUIT_Study* study )
4743 bool res = SalomeApp_Module::activateModule( study );
4745 setMenuShown( true );
4746 setToolShown( true );
4748 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4749 PyGILState_STATE gstate = PyGILState_Ensure();
4750 PyObject* pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4751 if ( !pluginsmanager ) {
4755 PyObject* result = PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toUtf8().data(),tr("SMESH_PLUGINS_OTHER").toUtf8().data());
4760 PyGILState_Release(gstate);
4761 // end of SMESH plugins loading
4763 // Reset actions accelerator keys
4764 action(SMESHOp::OpDelete)->setEnabled(true); // Delete: Key_Delete
4766 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4767 GetSMESHGen()->SetCurrentStudy(SALOMEDS::Study::_nil());
4768 if ( SalomeApp_Study* s = dynamic_cast<SalomeApp_Study*>( study )) {
4769 if ( _PTR(Study) aStudy = s->studyDS() )
4770 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
4773 // get all view currently opened in the study and connect their signals to
4774 // the corresponding slots of the class.
4775 SUIT_Desktop* aDesk = study->application()->desktop();
4777 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4778 SUIT_ViewWindow* wnd;
4779 foreach ( wnd, wndList )
4783 Py_XDECREF(pluginsmanager);
4787 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4789 setMenuShown( false );
4790 setToolShown( false );
4792 EmitSignalCloseAllDialogs();
4794 // Unset actions accelerator keys
4795 action(SMESHOp::OpDelete)->setEnabled(false); // Delete: Key_Delete
4797 return SalomeApp_Module::deactivateModule( study );
4800 void SMESHGUI::studyClosed( SUIT_Study* s )
4804 SMESH::RemoveVisuData( s->id() );
4805 SalomeApp_Module::studyClosed( s );
4808 void SMESHGUI::OnGUIEvent()
4810 const QObject* obj = sender();
4811 if ( !obj || !obj->inherits( "QAction" ) )
4813 int id = actionId((QAction*)obj);
4818 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4820 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
4821 if ( CORBA::is_nil( myComponentSMESH ) )
4823 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4825 aGUI.myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4826 return aGUI.myComponentSMESH;
4829 myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4830 return myComponentSMESH;
4833 QString SMESHGUI::engineIOR() const
4835 CORBA::ORB_var anORB = getApp()->orb();
4836 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4837 return QString( anIOR.in() );
4840 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4842 SalomeApp_Module::contextMenuPopup( client, menu, title );
4844 selectionMgr()->selectedObjects( lst );
4845 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4846 Handle(SALOME_InteractiveObject) io = lst.First();
4847 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4848 _PTR(Study) study = appStudy->studyDS();
4849 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4851 QString aName = QString( SMESH::fromUtf8(obj->GetName()) );
4852 while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4853 aName.remove( (aName.length() - 1), 1 );
4859 LightApp_Selection* SMESHGUI::createSelection() const
4861 return new SMESHGUI_Selection();
4864 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4866 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4867 aMap.insert( SalomeApp_Application::WT_NoteBook, Qt::LeftDockWidgetArea );
4868 #ifndef DISABLE_PYCONSOLE
4869 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4873 void SMESHGUI::viewManagers( QStringList& list ) const
4875 list.append( SVTK_Viewer::Type() );
4878 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4880 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4881 SMESH::UpdateSelectionProp( this );
4883 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
4884 for(int i = 0; i < aViews.count() ; i++){
4885 SUIT_ViewWindow *sf = aViews[i];
4888 EmitSignalActivatedViewManager();
4892 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
4894 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
4895 myClippingPlaneInfoMap.erase( theViewManager );
4898 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
4900 theActor->AddObserver( SMESH::DeleteActorEvent,
4901 myEventCallbackCommand.GetPointer(),
4905 void SMESHGUI::ProcessEvents( vtkObject* theObject,
4906 unsigned long theEvent,
4907 void* theClientData,
4910 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
4911 if( theObject && (int) theEvent == SMESH::DeleteActorEvent ) {
4912 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
4913 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
4914 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
4915 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
4916 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
4917 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
4918 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
4919 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
4920 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
4921 SMESH::TActorList::iterator anIter3 = anActorList.begin();
4922 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
4923 if( anActor == *anIter3 ) {
4924 anActorList.erase( anIter3 );
4935 void SMESHGUI::createPreferences()
4937 // General tab ------------------------------------------------------------------------
4938 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
4940 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
4941 setPreferenceProperty( autoUpdate, "columns", 2 );
4942 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
4943 setPreferenceProperty( lim, "min", 0 );
4944 setPreferenceProperty( lim, "max", 100000000 );
4945 setPreferenceProperty( lim, "step", 1000 );
4946 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4947 addPreference( tr( "PREF_INCREMENTAL_LIMIT" ), autoUpdate, LightApp_Preferences::Bool, "SMESH", "incremental_limit" );
4949 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
4950 setPreferenceProperty( qaGroup, "columns", 2 );
4951 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
4952 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
4953 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
4954 setPreferenceProperty( prec, "min", 0 );
4955 setPreferenceProperty( prec, "max", 100 );
4956 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
4957 setPreferenceProperty( doubleNodesTol, "precision", 10 );
4958 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
4959 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
4960 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
4962 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE_GROUP" ), genTab );
4963 setPreferenceProperty( dispgroup, "columns", 2 );
4964 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
4966 modes.append( tr("MEN_WIRE") );
4967 modes.append( tr("MEN_SHADE") );
4968 modes.append( tr("MEN_NODES") );
4969 modes.append( tr("MEN_SHRINK") );
4970 QList<QVariant> indices;
4971 indices.append( 0 );
4972 indices.append( 1 );
4973 indices.append( 2 );
4974 indices.append( 3 );
4975 setPreferenceProperty( dispmode, "strings", modes );
4976 setPreferenceProperty( dispmode, "indexes", indices );
4978 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE_GROUP" ), genTab );
4979 setPreferenceProperty( arcgroup, "columns", 2 );
4980 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
4981 QStringList quadraticModes;
4982 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
4983 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
4985 indices.append( 0 );
4986 indices.append( 1 );
4987 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
4988 setPreferenceProperty( quadraticmode, "indexes", indices );
4990 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
4991 "SMESH", "max_angle" );
4992 setPreferenceProperty( maxAngle, "min", 1 );
4993 setPreferenceProperty( maxAngle, "max", 90 );
4997 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
4998 setPreferenceProperty( exportgroup, "columns", 2 );
4999 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
5000 //addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
5002 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
5003 setPreferenceProperty( computeGroup, "columns", 2 );
5004 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
5006 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
5007 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
5008 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
5010 indices.append( 0 );
5011 indices.append( 1 );
5012 indices.append( 2 );
5013 setPreferenceProperty( notifyMode, "strings", modes );
5014 setPreferenceProperty( notifyMode, "indexes", indices );
5016 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
5017 setPreferenceProperty( infoGroup, "columns", 2 );
5018 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
5020 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
5021 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
5023 indices.append( 0 );
5024 indices.append( 1 );
5025 setPreferenceProperty( elemInfo, "strings", modes );
5026 setPreferenceProperty( elemInfo, "indexes", indices );
5027 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
5028 setPreferenceProperty( nodesLim, "min", 0 );
5029 setPreferenceProperty( nodesLim, "max", 10000000 );
5030 setPreferenceProperty( nodesLim, "step", 10000 );
5031 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5032 int ctrlLim = addPreference( tr( "PREF_CTRL_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_controls_limit" );
5033 setPreferenceProperty( ctrlLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
5034 setPreferenceProperty( ctrlLim, "min", 0 );
5035 setPreferenceProperty( ctrlLim, "max", 10000000 );
5036 setPreferenceProperty( ctrlLim, "step", 1000 );
5037 addPreference( tr( "PREF_ELEM_INFO_GRP_DETAILS" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "elem_info_grp_details" );
5038 addPreference( tr( "PREF_DUMP_BASE_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_base" );
5039 addPreference( tr( "PREF_DUMP_ELEM_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_elem" );
5040 addPreference( tr( "PREF_DUMP_ADD_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_add" );
5041 addPreference( tr( "PREF_DUMP_CTRL_INFO" ), infoGroup, LightApp_Preferences::Bool, "SMESH", "info_dump_ctrl" );
5043 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
5044 setPreferenceProperty( segGroup, "columns", 2 );
5045 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
5046 "SMESH", "segmentation" );
5047 setPreferenceProperty( segLen, "min", 1 );
5048 setPreferenceProperty( segLen, "max", 10000000 );
5049 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
5050 "SMESH", "nb_segments_per_edge" );
5051 setPreferenceProperty( nbSeg, "min", 1 );
5052 setPreferenceProperty( nbSeg, "max", 10000000 );
5054 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
5055 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
5056 "SMESH", "forget_mesh_on_hyp_modif" );
5059 // Quantities with individual precision settings
5060 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
5061 setPreferenceProperty( precGroup, "columns", 2 );
5063 const int nbQuantities = 6;
5064 int precs[nbQuantities], ii = 0;
5065 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
5066 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
5067 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
5068 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
5069 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
5070 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
5071 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
5072 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
5073 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
5074 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
5075 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
5076 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
5078 // Set property for precision value for spinboxes
5079 for ( ii = 0; ii < nbQuantities; ii++ ){
5080 setPreferenceProperty( precs[ii], "min", -14 );
5081 setPreferenceProperty( precs[ii], "max", 14 );
5082 setPreferenceProperty( precs[ii], "precision", 2 );
5085 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
5086 setPreferenceProperty( previewGroup, "columns", 2 );
5087 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
5088 setPreferenceProperty( chunkSize, "min", 1 );
5089 setPreferenceProperty( chunkSize, "max", 1000 );
5090 setPreferenceProperty( chunkSize, "step", 50 );
5092 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
5093 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
5095 // Mesh tab ------------------------------------------------------------------------
5096 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
5097 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
5098 setPreferenceProperty( nodeGroup, "columns", 3 );
5100 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
5102 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
5104 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5105 QList<QVariant> aMarkerTypeIndicesList;
5106 QList<QVariant> aMarkerTypeIconsList;
5107 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
5108 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
5109 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
5110 aMarkerTypeIndicesList << i;
5111 aMarkerTypeIconsList << pixmap;
5113 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
5114 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
5116 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
5118 QList<QVariant> aMarkerScaleIndicesList;
5119 QStringList aMarkerScaleValuesList;
5120 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
5121 aMarkerScaleIndicesList << i;
5122 //aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
5123 aMarkerScaleValuesList << QString::number( i );
5125 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
5126 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
5128 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
5129 //setPreferenceProperty( elemGroup, "columns", 2 );
5131 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
5132 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
5133 ColorId = addPreference( tr( "PREF_VOLUME" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "volume_color" );
5134 setPreferenceProperty( ColorId, "text", tr("PREF_REVERSEDVOLUME") );
5135 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
5136 addPreference( tr( "PREF_BALL_COLOR" ), elemGroup, LightApp_Preferences::Color, "SMESH", "ball_elem_color" );
5137 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
5138 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
5139 addPreference( tr( "PREF_PREVIEW_COLOR" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "preview_color" );
5142 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
5143 setPreferenceProperty( grpGroup, "columns", 2 );
5145 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
5146 addPreference( tr( "PREF_GRP_DEF_COLOR" ), grpGroup, LightApp_Preferences::Color, "SMESH", "default_grp_color" );
5148 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
5149 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
5150 /* int ballSize = addPreference(tr("PREF_BALL_SIZE"), elemGroup,
5151 LightApp_Preferences::IntSpin, "SMESH", "ball_elem_size"); */
5152 double ballDiameter = addPreference(tr("PREF_BALL_DIAMETER"), elemGroup,
5153 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_diameter");
5154 double ballScale = addPreference(tr("PREF_BALL_SCALE"), elemGroup,
5155 LightApp_Preferences::DblSpin, "SMESH", "ball_elem_scale");
5156 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
5157 LightApp_Preferences::IntSpin, "SMESH", "element_width");
5158 int outW = addPreference(tr("PREF_OUTLINE_WIDTH"), elemGroup,
5159 LightApp_Preferences::IntSpin, "SMESH", "outline_width");
5160 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
5161 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
5163 setPreferenceProperty( size0d, "min", 1 );
5164 setPreferenceProperty( size0d, "max", 10 );
5166 // setPreferenceProperty( ballSize, "min", 1 );
5167 // setPreferenceProperty( ballSize, "max", 10 );
5169 setPreferenceProperty( ballDiameter, "min", 1e-7 );
5170 setPreferenceProperty( ballDiameter, "max", 1e9 );
5171 setPreferenceProperty( ballDiameter, "step", 0.1 );
5173 setPreferenceProperty( ballScale, "min", 1e-2 );
5174 setPreferenceProperty( ballScale, "max", 1e7 );
5175 setPreferenceProperty( ballScale, "step", 0.5 );
5177 setPreferenceProperty( elemW, "min", 1 );
5178 setPreferenceProperty( elemW, "max", 5 );
5180 setPreferenceProperty( outW, "min", 1 );
5181 setPreferenceProperty( outW, "max", 5 );
5183 setPreferenceProperty( shrink, "min", 0 );
5184 setPreferenceProperty( shrink, "max", 100 );
5186 int numGroup = addPreference( tr( "PREF_GROUP_NUMBERING" ), meshTab );
5187 setPreferenceProperty( numGroup, "columns", 2 );
5189 addPreference( tr( "PREF_NUMBERING_NODE" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_node_color" );
5190 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_node_font", true );
5192 addPreference( tr( "PREF_NUMBERING_ELEM" ), numGroup, LightApp_Preferences::Color, "SMESH", "numbering_elem_color" );
5193 addVtkFontPref( tr( "PREF_NUMBERING_FONT" ), numGroup, "numbering_elem_font", true );
5195 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
5196 setPreferenceProperty( orientGroup, "columns", 1 );
5198 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
5199 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
5201 setPreferenceProperty( orientScale, "min", 0.05 );
5202 setPreferenceProperty( orientScale, "max", 0.5 );
5203 setPreferenceProperty( orientScale, "step", 0.05 );
5205 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
5207 // Selection tab ------------------------------------------------------------------------
5208 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
5210 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
5211 setPreferenceProperty( selGroup, "columns", 2 );
5213 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
5214 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
5216 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
5217 setPreferenceProperty( preGroup, "columns", 2 );
5219 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
5221 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
5222 setPreferenceProperty( precSelGroup, "columns", 2 );
5224 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
5225 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
5226 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
5228 // Scalar Bar tab ------------------------------------------------------------------------
5229 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
5230 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
5231 setPreferenceProperty( fontGr, "columns", 2 );
5233 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
5234 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
5236 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
5237 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
5239 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
5240 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
5242 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
5243 setPreferenceProperty( numcol, "min", 2 );
5244 setPreferenceProperty( numcol, "max", 256 );
5246 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
5247 setPreferenceProperty( numlab, "min", 2 );
5248 setPreferenceProperty( numlab, "max", 65 );
5250 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
5251 setPreferenceProperty( orientGr, "columns", 2 );
5252 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
5253 QStringList orients;
5254 orients.append( tr( "SMESH_VERTICAL" ) );
5255 orients.append( tr( "SMESH_HORIZONTAL" ) );
5256 indices.clear(); indices.append( 0 ); indices.append( 1 );
5257 setPreferenceProperty( orient, "strings", orients );
5258 setPreferenceProperty( orient, "indexes", indices );
5260 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
5261 setPreferenceProperty( posVSizeGr, "columns", 2 );
5262 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
5263 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
5264 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
5265 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
5266 setPreferenceProperty( xv, "step", 0.1 );
5267 setPreferenceProperty( xv, "min", 0.0 );
5268 setPreferenceProperty( xv, "max", 1.0 );
5269 setPreferenceProperty( yv, "step", 0.1 );
5270 setPreferenceProperty( yv, "min", 0.0 );
5271 setPreferenceProperty( yv, "max", 1.0 );
5272 setPreferenceProperty( wv, "step", 0.1 );
5273 setPreferenceProperty( wv, "min", 0.0 );
5274 setPreferenceProperty( wv, "max", 1.0 );
5275 setPreferenceProperty( hv, "min", 0.0 );
5276 setPreferenceProperty( hv, "max", 1.0 );
5277 setPreferenceProperty( hv, "step", 0.1 );
5279 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
5280 setPreferenceProperty( posHSizeGr, "columns", 2 );
5281 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
5282 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
5283 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
5284 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
5285 setPreferenceProperty( xv, "min", 0.0 );
5286 setPreferenceProperty( xv, "max", 1.0 );
5287 setPreferenceProperty( xv, "step", 0.1 );
5288 setPreferenceProperty( xh, "min", 0.0 );
5289 setPreferenceProperty( xh, "max", 1.0 );
5290 setPreferenceProperty( xh, "step", 0.1 );
5291 setPreferenceProperty( yh, "min", 0.0 );
5292 setPreferenceProperty( yh, "max", 1.0 );
5293 setPreferenceProperty( yh, "step", 0.1 );
5294 setPreferenceProperty( wh, "min", 0.0 );
5295 setPreferenceProperty( wh, "max", 1.0 );
5296 setPreferenceProperty( wh, "step", 0.1 );
5297 setPreferenceProperty( hh, "min", 0.0 );
5298 setPreferenceProperty( hh, "max", 1.0 );
5299 setPreferenceProperty( hh, "step", 0.1 );
5301 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
5302 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
5303 setPreferenceProperty( distributionGr, "columns", 3 );
5305 types.append( tr( "SMESH_MONOCOLOR" ) );
5306 types.append( tr( "SMESH_MULTICOLOR" ) );
5307 indices.clear(); indices.append( 0 ); indices.append( 1 );
5308 setPreferenceProperty( coloringType, "strings", types );
5309 setPreferenceProperty( coloringType, "indexes", indices );
5310 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
5314 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
5316 if ( sect=="SMESH" ) {
5317 float sbX1 = 0.01, sbY1 = 0.01, sbW = 0.08, sbH = 0.08;
5318 float aTol = 1.00000009999999;
5319 std::string aWarning;
5320 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
5322 if ( name== "selection_object_color" ||
5323 name=="selection_element_color" ||
5324 name== "highlight_color" ||
5325 name=="selection_precision_node" ||
5326 name=="selection_precision_element" ||
5327 name=="selection_precision_object" )
5329 SMESH::UpdateSelectionProp( this );
5331 else if (name == "scalar_bar_vertical_x" || name == "scalar_bar_vertical_width")
5333 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
5334 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
5335 if ( sbX1+sbW > aTol ) {
5336 aWarning = "Origin and Size Vertical: X+Width > 1\n";
5339 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
5340 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
5343 else if (name == "scalar_bar_vertical_y" || name == "scalar_bar_vertical_height" )
5345 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
5346 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
5347 if ( sbY1 + sbH > aTol ) {
5348 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
5349 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
5350 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
5353 else if (name == "scalar_bar_horizontal_x" || name == "scalar_bar_horizontal_width")
5355 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5356 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
5357 if ( sbX1 + sbW > aTol ) {
5358 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
5361 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
5362 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
5365 else if (name == "scalar_bar_horizontal_y" || name == "scalar_bar_horizontal_height")
5367 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5368 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
5369 if ( sbY1 + sbH > aTol ) {
5370 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
5373 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
5374 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
5377 else if ( name == "segmentation" )
5379 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
5380 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
5382 else if ( name == "nb_segments_per_edge" )
5384 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
5385 myComponentSMESH->SetDefaultNbSegments( nbSeg );
5387 else if ( name == "historical_python_dump" || name == "forget_mesh_on_hyp_modif" || name == "default_grp_color" )
5389 QString val = aResourceMgr->stringValue( "SMESH", name );
5390 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
5392 else if ( name == "numbering_node_color" || name == "numbering_node_font" )
5394 SMESH::UpdateFontProp( this );
5396 else if ( name == "numbering_elem_color" || name == "numbering_elem_font" )
5398 SMESH::UpdateFontProp( this );
5401 if ( aWarning.size() != 0 ) {
5402 aWarning += "The default values are applied instead.";
5403 SUIT_MessageBox::warning(SMESHGUI::desktop(),
5404 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
5405 QObject::tr(aWarning.c_str()));
5410 //================================================================================
5412 * \brief Update something in accordance with update flags
5413 * \param theFlags - update flags
5415 * Update viewer or/and object browser etc. in accordance with update flags ( see
5416 * LightApp_UpdateFlags enumeration ).
5418 //================================================================================
5419 void SMESHGUI::update( const int flags )
5421 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
5422 SMESH::UpdateView();
5424 SalomeApp_Module::update( flags );
5427 //================================================================================
5429 * \brief Set default selection mode
5431 * SLOT called when operation commited. Sets default selection mode
5433 //================================================================================
5434 void SMESHGUI::onOperationCommited( SUIT_Operation* )
5436 SVTK_ViewWindow* vtkWnd =
5437 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5439 vtkWnd->SetSelectionMode( ActorSelection );
5442 //================================================================================
5444 * \brief Set default selection mode
5446 * SLOT called when operation aborted. Sets default selection mode
5448 //================================================================================
5449 void SMESHGUI::onOperationAborted( SUIT_Operation* )
5451 SVTK_ViewWindow* vtkWnd =
5452 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
5454 vtkWnd->SetSelectionMode( ActorSelection );
5457 //================================================================================
5459 * \brief Creates operation with given identifier
5460 * \param id - identifier of operation to be started
5461 * \return Pointer on created operation or NULL if operation is not created
5463 * Virtual method redefined from the base class creates operation with given id.
5464 * It is called called automatically from startOperation method of base class.
5466 //================================================================================
5467 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
5469 LightApp_Operation* op = 0;
5470 // to do : create operation here
5473 case SMESHOp::OpSplitBiQuadratic:
5474 op = new SMESHGUI_SplitBiQuadOp();
5476 case SMESHOp::OpConvertMeshToQuadratic:
5477 op = new SMESHGUI_ConvToQuadOp();
5479 case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
5480 op = new SMESHGUI_Make2DFrom3DOp();
5482 case SMESHOp::OpReorientFaces:
5483 op = new SMESHGUI_ReorientFacesOp();
5485 case SMESHOp::OpCreateMesh:
5486 op = new SMESHGUI_MeshOp( true, true );
5488 case SMESHOp::OpCreateSubMesh:
5489 op = new SMESHGUI_MeshOp( true, false );
5491 case SMESHOp::OpEditMeshOrSubMesh:
5492 op = new SMESHGUI_MeshOp( false );
5494 case SMESHOp::OpCompute:
5495 op = new SMESHGUI_ComputeOp();
5497 case SMESHOp::OpPreCompute:
5498 op = new SMESHGUI_PrecomputeOp();
5500 case SMESHOp::OpEvaluate:
5501 op = new SMESHGUI_EvaluateOp();
5503 case SMESHOp::OpMeshOrder:
5504 op = new SMESHGUI_MeshOrderOp();
5506 case SMESHOp::OpCreateGeometryGroup:
5507 op = new SMESHGUI_GroupOnShapeOp();
5509 case SMESHOp::OpFindElementByPoint:
5510 op = new SMESHGUI_FindElemByPointOp();
5512 case SMESHOp::OpMoveNode: // Make mesh pass through point
5513 op = new SMESHGUI_MakeNodeAtPointOp();
5515 case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
5516 op = new SMESHGUI_Add0DElemsOnAllNodesOp();
5523 op = SalomeApp_Module::createOperation( id );
5527 //================================================================================
5529 * \brief Stops current operations and starts a given one
5530 * \param id - The id of the operation to start
5532 //================================================================================
5534 void SMESHGUI::switchToOperation(int id)
5536 if ( _PTR(Study) aStudy = SMESH::GetActiveStudyDocument() )
5537 activeStudy()->abortAllOperations();
5538 startOperation( id );
5541 LightApp_Displayer* SMESHGUI::displayer()
5544 myDisplayer = new SMESHGUI_Displayer( getApp() );
5548 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5551 int aTolerance = 64;
5552 int anIterations = 0;
5558 if( anIterations % aPeriod == 0 )
5561 if( aTolerance < 1 )
5565 aHue = (int)( 360.0 * rand() / RAND_MAX );
5568 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5569 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5570 for( ; it != itEnd; ++it )
5572 SALOMEDS::Color anAutoColor = *it;
5573 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5576 aQColor.getHsv( &h, &s, &v );
5577 if( abs( h - aHue ) < aTolerance )
5589 aColor.setHsv( aHue, 255, 255 );
5591 SALOMEDS::Color aSColor;
5592 aSColor.R = aColor.redF();
5593 aSColor.G = aColor.greenF();
5594 aSColor.B = aColor.blueF();
5599 const char* gSeparator = "_"; // character used to separate parameter names
5600 const char* gDigitsSep = ":"; // character used to separate numeric parameter values (color = r:g:b)
5601 const char* gPathSep = "|"; // character used to separate paths
5604 * \brief Store visual parameters
5606 * This method is called just before the study document is saved.
5607 * Store visual parameters in AttributeParameter attribue(s)
5609 void SMESHGUI::storeVisualParameters (int savePoint)
5612 Kernel_Utils::Localizer loc;
5614 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5615 if (!appStudy || !appStudy->studyDS())
5617 _PTR(Study) studyDS = appStudy->studyDS();
5619 // componentName is used for encoding of entries when storing them in IParameters
5620 std::string componentName = myComponentSMESH->ComponentDataType();
5621 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5622 //if (!aSComponent) return;
5625 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5626 componentName.c_str(),
5628 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5630 // store map of custom markers
5631 const VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5632 if( !aMarkerMap.empty() )
5634 VTK::MarkerMap::const_iterator anIter = aMarkerMap.begin();
5635 for( ; anIter != aMarkerMap.end(); anIter++ )
5637 int anId = anIter->first;
5638 VTK::MarkerData aMarkerData = anIter->second;
5639 std::string aMarkerFileName = aMarkerData.first;
5640 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5641 if( aMarkerTexture.size() < 3 )
5642 continue; // should contain at least width, height and the first value
5644 QString aPropertyName( "texture" );
5645 aPropertyName += gSeparator;
5646 aPropertyName += QString::number( anId );
5648 QString aPropertyValue = aMarkerFileName.c_str();
5649 aPropertyValue += gPathSep;
5651 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5652 ushort aWidth = *aTextureIter++;
5653 ushort aHeight = *aTextureIter++;
5654 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5655 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5656 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5657 aPropertyValue += QString::number( *aTextureIter );
5659 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5663 // viewers counters are used for storing view_numbers in IParameters
5666 // main cycle to store parameters of displayed objects
5667 QList<SUIT_ViewManager*> lst;
5668 QList<SUIT_ViewManager*>::Iterator it;
5669 getApp()->viewManagers(lst);
5670 for (it = lst.begin(); it != lst.end(); it++)
5672 SUIT_ViewManager* vman = *it;
5673 QString vType = vman->getType();
5675 // saving VTK actors properties
5676 if (vType == SVTK_Viewer::Type())
5678 // store the clipping planes attached to the view manager
5679 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5680 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5681 if( anIter != myClippingPlaneInfoMap.end() )
5682 aClippingPlaneInfoList = anIter->second;
5684 if( !aClippingPlaneInfoList.empty() ) {
5685 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5686 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5688 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5689 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5691 QString aPropertyName( "ClippingPlane" );
5692 aPropertyName += gSeparator;
5693 aPropertyName += QString::number( vtkViewers );
5694 aPropertyName += gSeparator;
5695 aPropertyName += QString::number( anId );
5697 QString aPropertyValue = QString::number( (int)aPlane->PlaneMode ).toLatin1().constData();
5698 aPropertyValue += gDigitsSep;
5699 aPropertyValue += QString::number( aPlane->IsOpenGLClipping ).toLatin1().constData();
5700 aPropertyValue += gDigitsSep;
5701 if ( aPlane->PlaneMode == SMESH::Absolute ) {
5702 aPropertyValue += QString::number( aPlane->myAbsoluteOrientation ).toLatin1().constData();
5703 aPropertyValue += gDigitsSep;
5704 aPropertyValue += QString::number( aPlane->X ).toLatin1().constData();
5705 aPropertyValue += gDigitsSep;
5706 aPropertyValue += QString::number( aPlane->Y ).toLatin1().constData();
5707 aPropertyValue += gDigitsSep;
5708 aPropertyValue += QString::number( aPlane->Z ).toLatin1().constData();
5709 aPropertyValue += gDigitsSep;
5710 aPropertyValue += QString::number( aPlane->Dx ).toLatin1().constData();
5711 aPropertyValue += gDigitsSep;
5712 aPropertyValue += QString::number( aPlane->Dy ).toLatin1().constData();
5713 aPropertyValue += gDigitsSep;
5714 aPropertyValue += QString::number( aPlane->Dz ).toLatin1().constData();
5716 else if ( aPlane->PlaneMode == SMESH::Relative ) {
5717 aPropertyValue += QString::number( (int)aPlane->myRelativeOrientation ).toLatin1().constData();
5718 aPropertyValue += gDigitsSep;
5719 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5720 aPropertyValue += gDigitsSep;
5721 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5722 aPropertyValue += gDigitsSep;
5723 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5726 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5730 QVector<SUIT_ViewWindow*> views = vman->getViews();
5731 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5733 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5735 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5736 vtkActorCollection* allActors = aCopy.GetActors();
5737 allActors->InitTraversal();
5738 while (vtkActor* actor = allActors->GetNextActor())
5740 if (actor->GetVisibility()) // store only visible actors
5742 SMESH_Actor* aSmeshActor = 0;
5743 if (actor->IsA("SMESH_Actor"))
5744 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5745 if (aSmeshActor && aSmeshActor->hasIO())
5747 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5750 // entry is "encoded" = it does NOT contain component adress,
5751 // since it is a subject to change on next component loading
5752 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5754 std::string param, vtkParam = vType.toLatin1().data();
5755 vtkParam += gSeparator;
5756 vtkParam += QString::number(vtkViewers).toLatin1().data();
5757 vtkParam += gSeparator;
5760 param = vtkParam + "Visibility";
5761 ip->setParameter(entry, param, "On");
5764 param = vtkParam + "Representation";
5765 ip->setParameter(entry, param, QString::number
5766 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5769 param = vtkParam + "IsShrunk";
5770 ip->setParameter(entry, param, QString::number
5771 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5773 // Displayed entities
5774 unsigned int aMode = aSmeshActor->GetEntityMode();
5775 bool isE = aMode & SMESH_Actor::eEdges;
5776 bool isF = aMode & SMESH_Actor::eFaces;
5777 bool isV = aMode & SMESH_Actor::eVolumes;
5778 bool is0d = aMode & SMESH_Actor::e0DElements;
5779 bool isB = aMode & SMESH_Actor::eBallElem;
5781 QString modeStr ("e");
5782 modeStr += gDigitsSep; modeStr += QString::number(isE);
5783 modeStr += gDigitsSep; modeStr += "f";
5784 modeStr += gDigitsSep; modeStr += QString::number(isF);
5785 modeStr += gDigitsSep; modeStr += "v";
5786 modeStr += gDigitsSep; modeStr += QString::number(isV);
5787 modeStr += gDigitsSep; modeStr += "0d";
5788 modeStr += gDigitsSep; modeStr += QString::number(is0d);
5789 modeStr += gDigitsSep; modeStr += "b";
5790 modeStr += gDigitsSep; modeStr += QString::number(isB);
5792 param = vtkParam + "Entities";
5793 ip->setParameter(entry, param, modeStr.toLatin1().data());
5799 aSmeshActor->GetSufaceColor(r, g, b, delta);
5800 QStringList colorStr;
5801 colorStr << "surface";
5802 colorStr << QString::number(r);
5803 colorStr << QString::number(g);
5804 colorStr << QString::number(b);
5806 colorStr << "backsurface";
5807 colorStr << QString::number(delta);
5809 aSmeshActor->GetVolumeColor(r, g, b, delta);
5810 colorStr << "volume";
5811 colorStr << QString::number(r);
5812 colorStr << QString::number(g);
5813 colorStr << QString::number(b);
5814 colorStr << QString::number(delta);
5816 aSmeshActor->GetEdgeColor(r, g, b);
5818 colorStr << QString::number(r);
5819 colorStr << QString::number(g);
5820 colorStr << QString::number(b);
5822 aSmeshActor->GetNodeColor(r, g, b);
5824 colorStr << QString::number(r);
5825 colorStr << QString::number(g);
5826 colorStr << QString::number(b);
5828 aSmeshActor->GetOutlineColor(r, g, b);
5829 colorStr << "outline";
5830 colorStr << QString::number(r);
5831 colorStr << QString::number(g);
5832 colorStr << QString::number(b);
5834 aSmeshActor->Get0DColor(r, g, b);
5835 colorStr << "elem0d";
5836 colorStr << QString::number(r);
5837 colorStr << QString::number(g);
5838 colorStr << QString::number(b);
5840 aSmeshActor->GetBallColor(r, g, b);
5842 colorStr << QString::number(r);
5843 colorStr << QString::number(g);
5844 colorStr << QString::number(b);
5846 aSmeshActor->GetFacesOrientationColor(r, g, b);
5847 colorStr << "orientation";
5848 colorStr << QString::number(r);
5849 colorStr << QString::number(g);
5850 colorStr << QString::number(b);
5852 param = vtkParam + "Colors";
5853 ip->setParameter(entry, param, qPrintable(colorStr.join(gDigitsSep)));
5856 QStringList sizeStr;
5858 sizeStr << QString::number((int)aSmeshActor->GetLineWidth());
5859 sizeStr << "outline";
5860 sizeStr << QString::number((int)aSmeshActor->GetOutlineWidth());
5861 sizeStr << "elem0d";
5862 sizeStr << QString::number((int)aSmeshActor->Get0DSize());
5864 //sizeStr << QString::number((int)aSmeshActor->GetBallSize());
5865 sizeStr << QString::number((double)aSmeshActor->GetBallSize());
5866 sizeStr << QString::number((double)aSmeshActor->GetBallScale());
5867 sizeStr << "shrink";
5868 sizeStr << QString::number(aSmeshActor->GetShrinkFactor());
5869 sizeStr << "orientation";
5870 sizeStr << QString::number(aSmeshActor->GetFacesOrientationScale());
5871 sizeStr << QString::number(aSmeshActor->GetFacesOrientation3DVectors());
5873 param = vtkParam + "Sizes";
5874 ip->setParameter(entry, param, qPrintable(sizeStr.join(gDigitsSep)));
5879 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5880 if( aMarkerType == VTK::MT_USER ) {
5881 markerStr += "custom";
5882 markerStr += gDigitsSep;
5883 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
5887 markerStr += gDigitsSep;
5888 markerStr += QString::number( (int)aMarkerType );
5889 markerStr += gDigitsSep;
5890 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
5893 param = vtkParam + "PointMarker";
5894 ip->setParameter(entry, param, markerStr.toLatin1().data());
5897 param = vtkParam + "Opacity";
5898 ip->setParameter(entry, param,
5899 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
5902 param = vtkParam + "ClippingPlane";
5904 if( !aClippingPlaneInfoList.empty() ) {
5905 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
5906 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
5908 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
5909 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
5910 SMESH::TActorList::iterator anIter2 = anActorList.begin();
5911 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
5912 if( aSmeshActor == *anIter2 ) {
5913 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
5914 QString::number( anId ).toLatin1().constData() );
5921 ip->setParameter( entry, param, "Off" );
5922 } // if (io->hasEntry())
5923 } // SMESH_Actor && hasIO
5925 } // while.. actors traversal
5929 } // if (SVTK view model)
5930 } // for (viewManagers)
5933 // data structures for clipping planes processing
5937 bool isOpenGLClipping;
5938 vtkIdType RelativeOrientation;
5941 int AbsoluteOrientation;
5942 double X, Y, Z, Dx, Dy, Dz;
5944 typedef std::list<TPlaneData> TPlaneDataList;
5945 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
5947 typedef std::list<vtkActor*> TActorList;
5950 TActorList ActorList;
5951 SUIT_ViewManager* ViewManager;
5953 typedef std::list<TPlaneInfo> TPlaneInfoList;
5954 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
5957 * \brief Restore visual parameters
5959 * This method is called after the study document is opened.
5960 * Restore visual parameters from AttributeParameter attribue(s)
5962 void SMESHGUI::restoreVisualParameters (int savePoint)
5965 Kernel_Utils::Localizer loc;
5967 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5968 if (!appStudy || !appStudy->studyDS())
5970 _PTR(Study) studyDS = appStudy->studyDS();
5972 // componentName is used for encoding of entries when storing them in IParameters
5973 std::string componentName = myComponentSMESH->ComponentDataType();
5974 //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
5975 //if (!aSComponent) return;
5978 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5979 componentName.c_str(),
5981 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5983 // restore map of custom markers and map of clipping planes
5984 VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5985 TPlaneDataMap aPlaneDataMap;
5987 std::vector<std::string> properties = ip->getProperties();
5988 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
5990 std::string property = *propIt;
5991 QString aPropertyName( property.c_str() );
5992 QString aPropertyValue( ip->getProperty( property ).c_str() );
5994 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
5995 if( aPropertyNameList.isEmpty() )
5998 QString aPropertyType = aPropertyNameList[0];
5999 if( aPropertyType == "texture" )
6001 if( aPropertyNameList.size() != 2 )
6005 int anId = aPropertyNameList[1].toInt( &ok );
6006 if( !ok || anId < 1 )
6009 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
6010 if( aPropertyValueList.size() != 2 )
6013 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
6014 QString aMarkerTextureString = aPropertyValueList[1];
6015 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
6016 if( aMarkerTextureStringList.size() != 3 )
6020 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
6025 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
6029 VTK::MarkerTexture aMarkerTexture;
6030 aMarkerTexture.push_back( aWidth );
6031 aMarkerTexture.push_back( aHeight );
6033 QString aMarkerTextureData = aMarkerTextureStringList[2];
6034 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
6036 QChar aChar = aMarkerTextureData.at( i );
6037 if( aChar.isDigit() )
6038 aMarkerTexture.push_back( aChar.digitValue() );
6041 aMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
6043 else if( aPropertyType == "ClippingPlane" )
6045 if( aPropertyNameList.size() != 3 )
6049 int aViewId = aPropertyNameList[1].toInt( &ok );
6050 if( !ok || aViewId < 0 )
6054 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
6055 if( !ok || aClippingPlaneId < 0 )
6058 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
6059 if( aPropertyValueList.size() != 6 && aPropertyValueList.size() != 9 )
6062 TPlaneData aPlaneData;
6063 aPlaneData.AbsoluteOrientation = false;
6064 aPlaneData.RelativeOrientation = 0;
6065 aPlaneData.Distance = aPlaneData.Angle[0] = aPlaneData.Angle[1] = 0;
6066 aPlaneData.X = aPlaneData.Y = aPlaneData.Z = 0;
6067 aPlaneData.Dx = aPlaneData.Dy = aPlaneData.Dz = 0;
6069 aPlaneData.Id = aClippingPlaneId;
6072 aPlaneData.Mode = aPropertyValueList[0].toInt( &ok );
6077 aPlaneData.isOpenGLClipping = aPropertyValueList[1].toInt( &ok );
6081 if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Absolute )
6084 aPlaneData.AbsoluteOrientation = aPropertyValueList[2].toInt( &ok );
6089 aPlaneData.X = aPropertyValueList[3].toDouble( &ok );
6094 aPlaneData.Y = aPropertyValueList[4].toDouble( &ok );
6099 aPlaneData.Z = aPropertyValueList[5].toDouble( &ok );
6104 aPlaneData.Dx = aPropertyValueList[6].toDouble( &ok );
6109 aPlaneData.Dy = aPropertyValueList[7].toDouble( &ok );
6114 aPlaneData.Dz = aPropertyValueList[8].toDouble( &ok );
6118 else if ( (SMESH::Mode)aPlaneData.Mode == SMESH::Relative ) {
6120 aPlaneData.RelativeOrientation = aPropertyValueList[2].toInt( &ok );
6125 aPlaneData.Distance = aPropertyValueList[3].toDouble( &ok );
6130 aPlaneData.Angle[0] = aPropertyValueList[4].toDouble( &ok );
6135 aPlaneData.Angle[1] = aPropertyValueList[5].toDouble( &ok );
6140 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
6141 aPlaneDataList.push_back( aPlaneData );
6145 TPlaneInfoMap aPlaneInfoMap;
6147 std::vector<std::string> entries = ip->getEntries();
6149 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
6151 // entry is a normal entry - it should be "decoded" (setting base adress of component)
6152 QString entry (ip->decodeEntry(*entIt).c_str());
6154 // Check that the entry corresponds to a real object in the Study
6155 // as the object may be deleted or modified after the visual state is saved.
6156 _PTR(SObject) so = studyDS->FindObjectID(entry.toLatin1().data());
6157 if (!so) continue; //Skip the not existent entry
6159 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
6160 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
6162 std::vector<std::string>::iterator namesIt = paramNames.begin();
6163 std::vector<std::string>::iterator valuesIt = paramValues.begin();
6165 // actors are stored in a map after displaying of them for
6166 // quicker access in the future: map < viewID to actor >
6167 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
6169 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
6171 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
6172 // '_' is used as separator and should not be used in viewer type or parameter names.
6173 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
6174 if (lst.size() != 3)
6177 QString viewerTypStr = lst[0];
6178 QString viewIndexStr = lst[1];
6179 QString paramNameStr = lst[2];
6182 int viewIndex = viewIndexStr.toUInt(&ok);
6183 if (!ok) // bad conversion of view index to integer
6187 if (viewerTypStr == SVTK_Viewer::Type())
6189 SMESH_Actor* aSmeshActor = 0;
6190 if (vtkActors.IsBound(viewIndex))
6191 aSmeshActor = vtkActors.Find(viewIndex);
6193 QList<SUIT_ViewManager*> lst;
6194 getApp()->viewManagers(viewerTypStr, lst);
6196 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6197 SUIT_ViewManager* vman = NULL;
6198 if (viewIndex >= 0 && viewIndex < lst.count())
6199 vman = lst.at(viewIndex);
6201 if (paramNameStr == "Visibility")
6203 if (!aSmeshActor && displayer() && vman)
6205 SUIT_ViewModel* vmodel = vman->getViewModel();
6206 // SVTK view model can be casted to SALOME_View
6207 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
6209 // store displayed actor in a temporary map for quicker
6210 // access later when restoring other parameters
6211 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6212 vtkRenderer* Renderer = vtkView->getRenderer();
6213 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
6214 vtkActorCollection* theActors = aCopy.GetActors();
6215 theActors->InitTraversal();
6216 bool isFound = false;
6217 vtkActor *ac = theActors->GetNextActor();
6218 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
6219 if (ac->IsA("SMESH_Actor")) {
6220 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
6221 if (aGeomAc->hasIO()) {
6222 Handle(SALOME_InteractiveObject) io =
6223 Handle(SALOME_InteractiveObject)::DownCast(aGeomAc->getIO());
6224 if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) {
6226 vtkActors.Bind(viewIndex, aGeomAc);
6232 } // if (paramNameStr == "Visibility")
6235 // the rest properties "work" with SMESH_Actor
6238 QString val ((*valuesIt).c_str());
6241 if (paramNameStr == "Representation") {
6242 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
6245 else if (paramNameStr == "IsShrunk") {
6247 if (!aSmeshActor->IsShrunk())
6248 aSmeshActor->SetShrink();
6251 if (aSmeshActor->IsShrunk())
6252 aSmeshActor->UnShrink();
6255 // Displayed entities
6256 else if (paramNameStr == "Entities") {
6257 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
6258 int aEntityMode = SMESH_Actor::eAllEntity;
6259 for ( int i = 0; i < mode.count(); i+=2 ) {
6260 if ( i < mode.count()-1 ) {
6261 QString type = mode[i];
6262 bool val = mode[i+1].toInt();
6263 if ( type == "e" && !val )
6264 aEntityMode = aEntityMode & ~SMESH_Actor::eEdges;
6265 else if ( type == "f" && !val )
6266 aEntityMode = aEntityMode & ~SMESH_Actor::eFaces;
6267 else if ( type == "v" && !val )
6268 aEntityMode = aEntityMode & ~SMESH_Actor::eVolumes;
6269 else if ( type == "0d" && !val )
6270 aEntityMode = aEntityMode & ~SMESH_Actor::e0DElements;
6271 else if ( type == "b" && !val )
6272 aEntityMode = aEntityMode & ~SMESH_Actor::eBallElem;
6275 aSmeshActor->SetEntityMode( aEntityMode );
6278 else if (paramNameStr == "Colors") {
6279 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
6286 QColor outlineColor;
6287 QColor orientationColor;
6293 // below lines are required to get default values for delta coefficients
6294 // of backface color for faces and color of reversed volumes
6295 SMESH::GetColor( "SMESH", "fill_color", c, deltaF, "0,170,255|-100" );
6296 SMESH::GetColor( "SMESH", "volume_color", c, deltaV, "255,0,170|-100" );
6297 for ( int i = 0; i < colors.count(); i++ ) {
6298 QString type = colors[i];
6299 if ( type == "surface" ) {
6300 // face color is set by 3 values r:g:b, where
6301 // - r,g,b - is rgb color components
6302 if ( i+1 >= colors.count() ) break; // format error
6303 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6304 if ( i+2 >= colors.count() ) break; // format error
6305 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6306 if ( i+3 >= colors.count() ) break; // format error
6307 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6308 faceColor.setRgbF( r, g, b );
6311 else if ( type == "backsurface" ) {
6312 // backface color can be defined in several ways
6313 // - in old versions, it is set as rgb triple r:g:b - this was is unsupported now
6314 // - in latest versions, it is set as delta coefficient
6315 bool rgbOk = false, deltaOk;
6316 if ( i+1 >= colors.count() ) break; // format error
6317 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6318 int delta = colors[i+1].toInt( &deltaOk );
6320 if ( i+1 < colors.count() ) // index is shifted to 1
6321 g = colors[i+1].toDouble( &rgbOk );
6322 if ( rgbOk ) i++; // shift index
6323 if ( rgbOk && i+1 < colors.count() ) // index is shifted to 2
6324 b = colors[i+1].toDouble( &rgbOk );
6326 // - as currently there's no way to set directly backsurface color as it was before,
6327 // we ignore old dump where r,g,b triple was set
6328 // - also we check that delta parameter is set properly
6329 if ( !rgbOk && deltaOk )
6332 else if ( type == "volume" ) {
6333 // volume color is set by 4 values r:g:b:delta, where
6334 // - r,g,b - is a normal volume rgb color components
6335 // - delta - is a reversed volume color delta coefficient
6336 if ( i+1 >= colors.count() ) break; // format error
6337 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6338 if ( i+2 >= colors.count() ) break; // format error
6339 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6340 if ( i+3 >= colors.count() ) break; // format error
6341 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6342 if ( i+4 >= colors.count() ) break; // format error
6343 int delta = colors[i+4].toInt( &bOk );
6344 if ( !bOk ) break; // format error
6345 volumeColor.setRgbF( r, g, b );
6349 else if ( type == "edge" ) {
6350 // edge color is set by 3 values r:g:b, where
6351 // - r,g,b - is rgb color components
6352 if ( i+1 >= colors.count() ) break; // format error
6353 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6354 if ( i+2 >= colors.count() ) break; // format error
6355 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6356 if ( i+3 >= colors.count() ) break; // format error
6357 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6358 edgeColor.setRgbF( r, g, b );
6361 else if ( type == "node" ) {
6362 // node color is set by 3 values r:g:b, where
6363 // - r,g,b - is rgb color components
6364 if ( i+1 >= colors.count() ) break; // format error
6365 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6366 if ( i+2 >= colors.count() ) break; // format error
6367 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6368 if ( i+3 >= colors.count() ) break; // format error
6369 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6370 nodeColor.setRgbF( r, g, b );
6373 else if ( type == "elem0d" ) {
6374 // 0d element color is set by 3 values r:g:b, where
6375 // - r,g,b - is rgb color components
6376 if ( i+1 >= colors.count() ) break; // format error
6377 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6378 if ( i+2 >= colors.count() ) break; // format error
6379 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6380 if ( i+3 >= colors.count() ) break; // format error
6381 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6382 elem0dColor.setRgbF( r, g, b );
6385 else if ( type == "ball" ) {
6386 // ball color is set by 3 values r:g:b, where
6387 // - r,g,b - is rgb color components
6388 if ( i+1 >= colors.count() ) break; // format error
6389 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6390 if ( i+2 >= colors.count() ) break; // format error
6391 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6392 if ( i+3 >= colors.count() ) break; // format error
6393 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6394 ballColor.setRgbF( r, g, b );
6397 else if ( type == "outline" ) {
6398 // outline color is set by 3 values r:g:b, where
6399 // - r,g,b - is rgb color components
6400 if ( i+1 >= colors.count() ) break; // format error
6401 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6402 if ( i+2 >= colors.count() ) break; // format error
6403 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6404 if ( i+3 >= colors.count() ) break; // format error
6405 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6406 outlineColor.setRgbF( r, g, b );
6409 else if ( type == "orientation" ) {
6410 // orientation color is set by 3 values r:g:b, where
6411 // - r,g,b - is rgb color components
6412 if ( i+1 >= colors.count() ) break; // format error
6413 r = colors[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6414 if ( i+2 >= colors.count() ) break; // format error
6415 g = colors[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6416 if ( i+3 >= colors.count() ) break; // format error
6417 b = colors[i+3].toDouble( &bOk ); if ( !bOk ) break; // format error
6418 orientationColor.setRgbF( r, g, b );
6423 if ( nodeColor.isValid() )
6424 aSmeshActor->SetNodeColor( nodeColor.redF(), nodeColor.greenF(), nodeColor.blueF() );
6426 if ( edgeColor.isValid() )
6427 aSmeshActor->SetEdgeColor( edgeColor.redF(), edgeColor.greenF(), edgeColor.blueF() );
6429 if ( faceColor.isValid() )
6430 aSmeshActor->SetSufaceColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6432 if ( volumeColor.isValid() )
6433 aSmeshActor->SetVolumeColor( volumeColor.redF(), volumeColor.greenF(), volumeColor.blueF(), deltaV );
6434 else if ( faceColor.isValid() ) // backward compatibility (no separate color for volumes)
6435 aSmeshActor->SetVolumeColor( faceColor.redF(), faceColor.greenF(), faceColor.blueF(), deltaF );
6437 if ( elem0dColor.isValid() )
6438 aSmeshActor->Set0DColor( elem0dColor.redF(), elem0dColor.greenF(), elem0dColor.blueF() );
6440 if ( ballColor.isValid() )
6441 aSmeshActor->SetBallColor( ballColor.redF(), ballColor.greenF(), ballColor.blueF() );
6443 if ( outlineColor.isValid() )
6444 aSmeshActor->SetOutlineColor( outlineColor.redF(), outlineColor.greenF(), outlineColor.blueF() );
6445 // orientation color
6446 if ( orientationColor.isValid() )
6447 aSmeshActor->SetFacesOrientationColor( orientationColor.redF(), orientationColor.greenF(), orientationColor.blueF() );
6450 else if (paramNameStr == "Sizes") {
6451 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
6454 int outlineWidth = -1;
6455 int elem0dSize = -1;
6456 //int ballSize = -1;
6457 double ballDiameter = -1.0;
6458 double ballScale = -1.0;
6459 double shrinkSize = -1;
6460 double orientationSize = -1;
6461 bool orientation3d = false;
6462 for ( int i = 0; i < sizes.count(); i++ ) {
6463 QString type = sizes[i];
6464 if ( type == "line" ) {
6465 // line (wireframe) width is given as single integer value
6466 if ( i+1 >= sizes.count() ) break; // format error
6467 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6471 if ( type == "outline" ) {
6472 // outline width is given as single integer value
6473 if ( i+1 >= sizes.count() ) break; // format error
6474 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6478 else if ( type == "elem0d" ) {
6479 // 0d element size is given as single integer value
6480 if ( i+1 >= sizes.count() ) break; // format error
6481 int v = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6485 else if ( type == "ball" ) {
6486 // balls are specified by two values: size:scale, where
6487 // - size - is a integer value specifying size
6488 // - scale - is a double value specifying scale factor
6489 if ( i+1 >= sizes.count() ) break; // format error
6490 //int v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6491 double v1 = sizes[i+1].toInt( &bOk ); if ( !bOk ) break; // format error
6492 if ( i+2 >= sizes.count() ) break; // format error
6493 double v2 = sizes[i+2].toDouble( &bOk ); if ( !bOk ) break; // format error
6499 else if ( type == "shrink" ) {
6500 // shrink factor is given as single floating point value
6501 if ( i+1 >= sizes.count() ) break; // format error
6502 double v = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6506 else if ( type == "orientation" ) {
6507 // orientation vectors are specified by two values size:3d, where
6508 // - size - is a floating point value specifying scale factor
6509 // - 3d - is a boolean
6510 if ( i+1 >= sizes.count() ) break; // format error
6511 double v1 = sizes[i+1].toDouble( &bOk ); if ( !bOk ) break; // format error
6512 if ( i+2 >= sizes.count() ) break; // format error
6513 int v2 = sizes[i+2].toInt( &bOk ); if ( !bOk ) break; // format error
6514 orientationSize = v1;
6515 orientation3d = (bool)v2;
6519 // line (wireframe) width
6520 if ( lineWidth > 0 )
6521 aSmeshActor->SetLineWidth( lineWidth );
6523 if ( outlineWidth > 0 )
6524 aSmeshActor->SetOutlineWidth( outlineWidth );
6525 else if ( lineWidth > 0 ) // backward compatibility (no separate width for outlines)
6526 aSmeshActor->SetOutlineWidth( lineWidth );
6528 if ( elem0dSize > 0 )
6529 aSmeshActor->Set0DSize( elem0dSize );
6531 /*if ( ballSize > 0 )
6532 aSmeshActor->SetBallSize( ballSize );*/
6534 if ( ballDiameter > 0 )
6535 aSmeshActor->SetBallSize( ballDiameter );
6537 if ( ballScale > 0.0 )
6538 aSmeshActor->SetBallScale( ballScale );
6540 if ( shrinkSize > 0 )
6541 aSmeshActor->SetShrinkFactor( shrinkSize );
6542 // orientation vectors
6543 if ( orientationSize > 0 ) {
6544 aSmeshActor->SetFacesOrientationScale( orientationSize );
6545 aSmeshActor->SetFacesOrientation3DVectors( orientation3d );
6549 else if (paramNameStr == "PointMarker") {
6550 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
6551 if( data.count() >= 2 ) {
6553 int aParam1 = data[1].toInt( &ok );
6555 if( data[0] == "std" && data.count() == 3 ) {
6556 int aParam2 = data[2].toInt( &ok );
6557 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
6559 else if( data[0] == "custom" ) {
6560 VTK::MarkerMap::const_iterator markerIt = aMarkerMap.find( aParam1 );
6561 if( markerIt != aMarkerMap.end() ) {
6562 VTK::MarkerData aMarkerData = markerIt->second;
6563 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
6570 else if (paramNameStr == "Opacity") {
6571 aSmeshActor->SetOpacity(val.toFloat());
6574 else if (paramNameStr.startsWith("ClippingPlane")) {
6575 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
6576 // old format - val looks like "Off" or "1:0:0:0.5:0:0"
6577 // (mode(relative), is OpenGL clipping plane, orientation, distance, two angles)
6578 // or "0:1:1:10.5:1.0:1.0:15.0:10.0:10.0"
6579 // (mode(absolute), is OpenGL clipping plane, orientation, base point(x, y, z), direction (dx, dy, dz))
6580 // new format - val looks like "Off" or "0" (plane id)
6581 // (note: in new format "Off" value is used only for consistency,
6582 // so it is processed together with values in old format)
6583 bool anIsOldFormat = ( vals.count() == 6 || vals.count() == 9 || val == "Off" );
6584 if( anIsOldFormat ) {
6585 if (paramNameStr == "ClippingPlane1" || val == "Off")
6586 aSmeshActor->RemoveAllClippingPlanes();
6588 QList<SUIT_ViewManager*> lst;
6589 getApp()->viewManagers(viewerTypStr, lst);
6590 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
6591 if (viewIndex >= 0 && viewIndex < lst.count()) {
6592 SUIT_ViewManager* vman = lst.at(viewIndex);
6593 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
6595 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
6597 SMESH::TActorList anActorList;
6598 anActorList.push_back( aSmeshActor );
6599 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( vtkView );
6600 aPlane->myViewWindow = vtkView;
6601 SMESH::Mode aMode = ( SMESH::Mode )vals[0].toInt();
6602 aPlane->PlaneMode = aMode;
6603 bool isOpenGLClipping = ( bool )vals[1].toInt();
6604 aPlane->IsOpenGLClipping = isOpenGLClipping;
6605 if ( aMode == SMESH::Absolute ) {
6606 aPlane->myAbsoluteOrientation = vals[2].toInt();
6607 aPlane->X = vals[3].toFloat();
6608 aPlane->Y = vals[4].toFloat();
6609 aPlane->Z = vals[5].toFloat();
6610 aPlane->Dx = vals[6].toFloat();
6611 aPlane->Dy = vals[7].toFloat();
6612 aPlane->Dz = vals[8].toFloat();
6614 else if ( aMode == SMESH::Relative ) {
6615 aPlane->myRelativeOrientation = (SMESH::Orientation)vals[2].toInt();
6616 aPlane->myDistance = vals[3].toFloat();
6617 aPlane->myAngle[0] = vals[4].toFloat();
6618 aPlane->myAngle[1] = vals[5].toFloat();
6622 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6623 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6624 aClippingPlaneInfo.Plane = aPlane;
6625 aClippingPlaneInfo.ActorList = anActorList;
6626 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6634 int aPlaneId = val.toInt( &ok );
6635 if( ok && aPlaneId >= 0 ) {
6636 bool anIsDefinedPlane = false;
6637 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
6638 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
6639 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6640 TPlaneInfo& aPlaneInfo = *anIter;
6641 if( aPlaneInfo.PlaneId == aPlaneId ) {
6642 aPlaneInfo.ActorList.push_back( aSmeshActor );
6643 anIsDefinedPlane = true;
6647 if( !anIsDefinedPlane ) {
6648 TPlaneInfo aPlaneInfo;
6649 aPlaneInfo.PlaneId = aPlaneId;
6650 aPlaneInfo.ActorList.push_back( aSmeshActor );
6651 aPlaneInfo.ViewManager = vman;
6653 // to make the list sorted by plane id
6654 anIter = aPlaneInfoList.begin();
6655 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
6656 const TPlaneInfo& aPlaneInfoRef = *anIter;
6657 if( aPlaneInfoRef.PlaneId > aPlaneId )
6660 aPlaneInfoList.insert( anIter, aPlaneInfo );
6665 } // if (aSmeshActor)
6666 } // other parameters than Visibility
6668 } // for names/parameters iterator
6669 } // for entries iterator
6671 // take into account planes with empty list of actors referred to them
6672 QList<SUIT_ViewManager*> aVMList;
6673 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
6675 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
6676 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
6677 int aViewId = aPlaneDataIter->first;
6678 if( aViewId >= 0 && aViewId < aVMList.count() ) {
6679 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
6681 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
6683 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
6684 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
6685 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
6686 const TPlaneData& aPlaneData = *anIter2;
6687 int aPlaneId = aPlaneData.Id;
6689 bool anIsFound = false;
6690 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6691 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6692 const TPlaneInfo& aPlaneInfo = *anIter3;
6693 if( aPlaneInfo.PlaneId == aPlaneId ) {
6700 TPlaneInfo aPlaneInfo; // ActorList field is empty
6701 aPlaneInfo.PlaneId = aPlaneId;
6702 aPlaneInfo.ViewManager = aViewManager;
6704 // to make the list sorted by plane id
6705 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
6706 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
6707 const TPlaneInfo& aPlaneInfoRef = *anIter4;
6708 if( aPlaneInfoRef.PlaneId > aPlaneId )
6711 aPlaneInfoList.insert( anIter4, aPlaneInfo );
6717 // add clipping planes to actors according to the restored parameters
6718 // and update the clipping plane map
6719 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
6720 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
6721 int aViewId = anIter1->first;
6722 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
6724 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
6725 if( anIter2 == aPlaneDataMap.end() )
6727 const TPlaneDataList& aPlaneDataList = anIter2->second;
6729 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
6730 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
6731 const TPlaneInfo& aPlaneInfo = *anIter3;
6732 int aPlaneId = aPlaneInfo.PlaneId;
6733 const TActorList& anActorList = aPlaneInfo.ActorList;
6734 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
6738 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
6742 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
6744 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
6745 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
6746 const TPlaneData& aPlaneData = *anIter4;
6747 if( aPlaneData.Id == aPlaneId ) {
6748 SMESH::OrientedPlane* aPlane = SMESH::OrientedPlane::New( aViewWindow );
6749 aPlane->myViewWindow = aViewWindow;
6750 aPlane->PlaneMode = (SMESH::Mode)aPlaneData.Mode;
6751 aPlane->IsOpenGLClipping = aPlaneData.isOpenGLClipping;
6752 if ( aPlane->PlaneMode == SMESH::Absolute ) {
6753 aPlane->myAbsoluteOrientation = aPlaneData.AbsoluteOrientation;
6754 aPlane->X = aPlaneData.X;
6755 aPlane->Y = aPlaneData.Y;
6756 aPlane->Z = aPlaneData.Z;
6757 aPlane->Dx = aPlaneData.Dx;
6758 aPlane->Dy = aPlaneData.Dy;
6759 aPlane->Dz = aPlaneData.Dz;
6761 else if ( aPlane->PlaneMode == SMESH::Relative ) {
6762 aPlane->myRelativeOrientation = (SMESH::Orientation)aPlaneData.RelativeOrientation;
6763 aPlane->myDistance = aPlaneData.Distance;
6764 aPlane->myAngle[0] = aPlaneData.Angle[0];
6765 aPlane->myAngle[1] = aPlaneData.Angle[1];
6768 if ( SMESHGUI_ClippingDlg::AddPlane( anActorList, aPlane ) ) {
6769 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
6770 aClippingPlaneInfo.Plane = aPlane;
6771 aClippingPlaneInfo.ActorList = anActorList;
6772 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
6783 // update all VTK views
6784 QList<SUIT_ViewManager*> lst;
6785 getApp()->viewManagers(lst);
6786 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
6787 SUIT_ViewModel* vmodel = (*it)->getViewModel();
6788 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
6789 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
6790 // set OpenGL clipping planes
6791 VTK::ActorCollectionCopy aCopy( vtkView->getRenderer()->GetActors() );
6792 vtkActorCollection* anAllActors = aCopy.GetActors();
6793 anAllActors->InitTraversal();
6794 while( vtkActor* aVTKActor = anAllActors->GetNextActor() )
6795 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( aVTKActor ) )
6796 anActor->SetOpenGLClippingPlane();
6798 vtkView->getRenderer()->ResetCameraClippingRange();
6805 \brief Adds preferences for dfont of VTK viewer
6807 \param pIf group identifier
6808 \param param parameter
6809 \return identifier of preferences
6811 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param, const bool needSize )
6813 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
6815 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
6818 fam.append( tr( "SMESH_FONT_ARIAL" ) );
6819 fam.append( tr( "SMESH_FONT_COURIER" ) );
6820 fam.append( tr( "SMESH_FONT_TIMES" ) );
6822 setPreferenceProperty( tfont, "fonts", fam );
6824 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
6825 if ( needSize ) f = f | QtxFontEdit::Size;
6826 setPreferenceProperty( tfont, "features", f );
6832 \brief Actions after hypothesis edition
6833 Updates object browser after hypothesis edition
6835 void SMESHGUI::onHypothesisEdit( int result )
6838 SMESHGUI::Modified();
6839 updateObjBrowser( true );
6843 \brief Actions after choosing menu of control modes
6844 Updates control mode actions according to current selection
6846 void SMESHGUI::onUpdateControlActions()
6848 SALOME_ListIO selected;
6849 if ( LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr() )
6850 aSel->selectedObjects( selected );
6852 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
6853 if ( selected.Extent() ) {
6854 if ( selected.First()->hasEntry() ) {
6855 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( selected.First()->getEntry() )) {
6856 aControl = anActor->GetControlMode();
6857 SALOME_ListIteratorOfListIO it(selected);
6858 for ( it.Next(); it.More(); it.Next() ) {
6859 Handle(SALOME_InteractiveObject) anIO = it.Value();
6860 if ( anIO->hasEntry() ) {
6861 if ( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
6862 if ( aControl != anActor->GetControlMode() ) {
6863 aControl = SMESH_Actor::eNone;
6873 int anAction = ActionToControl( aControl, true );
6875 action( anAction )->setChecked( true );
6877 QMenu* send = (QMenu*)sender();
6878 QList<QAction*> actions = send->actions();
6879 for ( int i = 0; i < actions.size(); i++ )
6880 actions[i]->setChecked( false );
6886 \brief Signal handler closing(SUIT_ViewWindow*) of a view
6887 \param pview view being closed
6889 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
6890 #ifndef DISABLE_PLOT2DVIEWER
6891 //Crear all Plot2d Viewers if need.
6892 SMESH::ClearPlot2Viewers(pview);
6894 EmitSignalCloseView();
6897 void SMESHGUI::message( const QString& msg )
6900 QStringList data = msg.split("/");
6901 if ( data.count() > 0 ) {
6902 if ( data.first() == "mesh_loading" ) {
6904 QString entry = data.count() > 1 ? data[1] : QString();
6905 if ( entry.isEmpty() )
6908 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
6910 _PTR(SObject) obj = study->FindObjectID( entry.toLatin1().constData() );
6913 name = SMESH::fromUtf8(obj->GetName());
6914 if ( name.isEmpty() )
6917 if ( data.last() == "stop" )
6918 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
6920 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
6921 QApplication::processEvents();
6927 \brief Connects or disconnects signals about activating and cloning view on the module slots
6928 \param pview view which is connected/disconnected
6930 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
6934 SUIT_ViewManager* viewMgr = pview->getViewManager();
6936 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6937 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6939 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6940 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6945 \brief Return \c true if object can be renamed
6947 bool SMESHGUI::renameAllowed( const QString& entry) const {
6948 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6952 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6956 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
6961 if(appStudy->isComponent(entry) || obj->isReference())
6964 // check type to prevent renaming of inappropriate objects
6965 int aType = SMESHGUI_Selection::type(qPrintable(entry), SMESH::GetActiveStudyDocument());
6966 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
6967 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
6968 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
6969 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
6970 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM)
6977 Rename object by entry.
6978 \param entry entry of the object
6979 \param name new name of the object
6980 \brief Return \c true if rename operation finished successfully, \c false otherwise.
6982 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
6984 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6988 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6993 _PTR(Study) aStudy = appStudy->studyDS();
6998 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
7000 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
7005 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
7006 _PTR(GenericAttribute) anAttr;
7007 _PTR(AttributeName) aName;
7009 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
7011 // check type to prevent renaming of inappropriate objects
7012 int aType = SMESHGUI_Selection::type( qPrintable(entry), SMESH::GetActiveStudyDocument() );
7013 if (aType == SMESH::MESH || aType == SMESH::GROUP ||
7014 aType == SMESH::SUBMESH || aType == SMESH::SUBMESH_COMPOUND ||
7015 aType == SMESH::SUBMESH_SOLID || aType == SMESH::SUBMESH_FACE ||
7016 aType == SMESH::SUBMESH_EDGE || aType == SMESH::SUBMESH_VERTEX ||
7017 aType == SMESH::HYPOTHESIS || aType == SMESH::ALGORITHM) {
7018 if ( !name.isEmpty() ) {
7019 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
7021 // update name of group object and its actor
7022 Handle(SALOME_InteractiveObject) IObject =
7023 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
7025 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
7026 if( !aGroupObject->_is_nil() ) {
7027 aGroupObject->SetName( qPrintable(name) );
7028 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
7029 anActor->setName( qPrintable(name) );
7039 SALOMEDS::Color SMESHGUI::getPredefinedUniqueColor()
7041 static QList<QColor> colors;
7043 if ( colors.isEmpty() ) {
7045 for (int s = 0; s < 2 ; s++)
7047 for (int v = 100; v >= 40; v = v - 20)
7049 for (int h = 0; h < 359 ; h = h + 60)
7051 colors.append(QColor::fromHsv(h, 255 - s * 127, v * 255 / 100));
7056 static int currentColor = randomize( colors.size() );
7058 SALOMEDS::Color color;
7059 color.R = (double)colors[currentColor].red() / 255.0;
7060 color.G = (double)colors[currentColor].green() / 255.0;
7061 color.B = (double)colors[currentColor].blue() / 255.0;
7063 currentColor = (currentColor+1) % colors.count();