1 // Copyright (C) 2007-2012 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.
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
32 #include "SMESHGUI_AddMeshElementDlg.h"
33 #include "SMESHGUI_AddQuadraticElementDlg.h"
34 #include "SMESHGUI_BuildCompoundDlg.h"
35 #include "SMESHGUI_ClippingDlg.h"
36 #include "SMESHGUI_ComputeDlg.h"
37 #include "SMESHGUI_ConvToQuadOp.h"
38 #include "SMESHGUI_CreatePolyhedralVolumeDlg.h"
39 #include "SMESHGUI_DeleteGroupDlg.h"
40 #include "SMESHGUI_Displayer.h"
41 #include "SMESHGUI_MergeDlg.h"
42 #include "SMESHGUI_ExtrusionAlongPathDlg.h"
43 #include "SMESHGUI_ExtrusionDlg.h"
44 #include "SMESHGUI_FileInfoDlg.h"
45 #include "SMESHGUI_FileValidator.h"
46 #include "SMESHGUI_FilterDlg.h"
47 #include "SMESHGUI_FilterLibraryDlg.h"
48 #include "SMESHGUI_FindElemByPointDlg.h"
49 #include "SMESHGUI_GroupDlg.h"
50 #include "SMESHGUI_GroupOnShapeDlg.h"
51 #include "SMESHGUI_GroupOpDlg.h"
52 #include "SMESHGUI_Hypotheses.h"
53 #include "SMESHGUI_Make2DFrom3DOp.h"
54 #include "SMESHGUI_MakeNodeAtPointDlg.h"
55 #include "SMESHGUI_Measurements.h"
56 #include "SMESHGUI_MeshInfo.h"
57 #include "SMESHGUI_MeshOp.h"
58 #include "SMESHGUI_MeshOrderOp.h"
59 #include "SMESHGUI_MeshPatternDlg.h"
60 #include "SMESHGUI_MultiEditDlg.h"
61 #include "SMESHGUI_NodesDlg.h"
62 #include "SMESHGUI_Preferences_ColorDlg.h"
63 #include "SMESHGUI_Preferences_ScalarBarDlg.h"
64 #include "SMESHGUI_RemoveElementsDlg.h"
65 #include "SMESHGUI_RemoveNodesDlg.h"
66 #include "SMESHGUI_RenumberingDlg.h"
67 #include "SMESHGUI_RevolutionDlg.h"
68 #include "SMESHGUI_RotationDlg.h"
69 #include "SMESHGUI_Selection.h"
70 #include "SMESHGUI_SewingDlg.h"
71 #include "SMESHGUI_SingleEditDlg.h"
72 #include "SMESHGUI_SmoothingDlg.h"
73 #include "SMESHGUI_SymmetryDlg.h"
74 #include "SMESHGUI_TranslationDlg.h"
75 #include "SMESHGUI_ScaleDlg.h"
76 #include "SMESHGUI_TransparencyDlg.h"
77 #include "SMESHGUI_DuplicateNodesDlg.h"
78 #include "SMESHGUI_CopyMeshDlg.h"
80 #include "SMESHGUI_Utils.h"
81 #include "SMESHGUI_MeshUtils.h"
82 #include "SMESHGUI_GroupUtils.h"
83 #include "SMESHGUI_FilterUtils.h"
84 #include "SMESHGUI_PatternUtils.h"
85 #include "SMESHGUI_VTKUtils.h"
86 #include "SMESHGUI_HypothesesUtils.h"
88 #include <SMESH_version.h>
90 #include <SMESH_Client.hxx>
91 #include <SMESH_Actor.h>
92 #include <SMESH_ScalarBarActor.h>
93 #include <SMESH_ActorUtils.h>
94 #include <SMESH_TypeFilter.hxx>
95 #include "SMESH_ControlsDef.hxx"
97 // SALOME GUI includes
98 #include <SalomeApp_Tools.h>
99 #include <SalomeApp_Study.h>
100 #include <SalomeApp_Application.h>
101 #include <SalomeApp_CheckFileDlg.h>
102 #include <SalomeApp_DataObject.h>
104 #include <LightApp_DataOwner.h>
105 #include <LightApp_Preferences.h>
106 #include <LightApp_SelectionMgr.h>
107 #include <LightApp_UpdateFlags.h>
108 #include <LightApp_NameDlg.h>
110 #include <SVTK_ViewWindow.h>
111 #include <SVTK_ViewModel.h>
112 #include <SVTK_ViewManager.h>
114 #include <VTKViewer_Algorithm.h>
116 #include <SUIT_MessageBox.h>
117 #include <SUIT_ResourceMgr.h>
118 #include <SUIT_FileDlg.h>
119 #include <SUIT_Desktop.h>
120 #include <SUIT_OverrideCursor.h>
121 #include <SUIT_Session.h>
123 #include <QtxPopupMgr.h>
124 #include <QtxFontEdit.h>
126 #include <SALOME_ListIO.hxx>
127 #include <SALOME_ListIteratorOfListIO.hxx>
129 #ifndef DISABLE_PLOT2DVIEWER
130 #include <SPlot2d_ViewModel.h>
131 #include <SPlot2d_Histogram.h>
135 #include <SALOMEconfig.h>
136 #include CORBA_CLIENT_HEADER(SALOMEDS_Attributes)
137 #include CORBA_CLIENT_HEADER(SMESH_MeshEditor)
138 #include CORBA_CLIENT_HEADER(SMESH_Measurements)
141 // #define INCLUDE_MENUITEM_DEF // VSR commented ????????
142 #include <QApplication>
144 #include <QTextStream>
147 #include <boost/shared_ptr.hpp>
150 #include <vtkCamera.h>
151 #include <vtkRenderer.h>
152 #include <vtkPlane.h>
153 #include <vtkCallbackCommand.h>
154 #include <vtkLookupTable.h>
156 // SALOME KERNEL includes
157 #include <SALOMEDS_Study.hxx>
158 #include <SALOMEDSClient_StudyBuilder.hxx>
159 #include <SALOMEDSClient_SComponent.hxx>
160 #include <SALOMEDSClient_ClientFactory.hxx>
161 #include <SALOMEDSClient_IParameters.hxx>
164 #include <Standard_ErrorHandler.hxx>
165 #include <NCollection_DataMap.hxx>
167 //To disable automatic genericobj management, the following line should be commented.
168 //Otherwise, it should be uncommented. Refer to KERNEL_SRC/src/SALOMEDSImpl/SALOMEDSImpl_AttributeIOR.cxx
169 #define WITHGENERICOBJ
173 //=============================================================
174 void ImportMeshesFromFile(SMESH::SMESH_Gen_ptr theComponentMesh,
177 void ExportMeshToFile(int theCommandID);
179 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap);
181 void SetDisplayEntity(int theCommandID);
183 void Control( int theCommandID );
187 //=============================================================
188 void ImportMeshesFromFile( SMESH::SMESH_Gen_ptr theComponentMesh,
192 std::string myExtension;
194 if ( theCommandID == 113 ) {
195 filter.append( QObject::tr( "MED_FILES_FILTER" ) + " (*.med)" );
196 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
198 else if ( theCommandID == 112 ) {
199 filter.append( QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)" );
201 else if ( theCommandID == 111 ) {
202 filter.append( QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)" );
204 else if ( theCommandID == 115 ) {
205 filter.append( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
207 else if ( theCommandID == 116 ) {
208 filter.append( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
210 else if ( theCommandID == 117 ) {
211 filter.append( QObject::tr( "SAUV files (*.sauv*)" ) );
212 filter.append( QObject::tr( "All files (*)" ) );
215 QString anInitialPath = "";
216 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
217 anInitialPath = QDir::currentPath();
219 QStringList filenames = SUIT_FileDlg::getOpenFileNames( SMESHGUI::desktop(),
222 QObject::tr( "SMESH_IMPORT_MESH" ) );
223 if ( filenames.count() > 0 ) {
224 SUIT_OverrideCursor wc;
225 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
228 QStringList anEntryList;
229 bool isEmpty = false;
230 for ( QStringList::ConstIterator it = filenames.begin(); it != filenames.end(); ++it ) {
231 QString filename = *it;
232 SMESH::mesh_array_var aMeshes = new SMESH::mesh_array;
234 switch ( theCommandID ) {
237 // DAT format (currently unsupported)
238 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
239 arg( QObject::tr( "SMESH_ERR_NOT_SUPPORTED_FORMAT" ) ) );
245 aMeshes->length( 1 );
246 aMeshes[0] = theComponentMesh->CreateMeshesFromUNV( filename.toLatin1().constData() );
247 if ( aMeshes[0]->_is_nil() )
248 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
249 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
255 SMESH::DriverMED_ReadStatus res;
256 aMeshes = theComponentMesh->CreateMeshesFromMED( filename.toLatin1().constData(), res );
257 if ( res != SMESH::DRS_OK ) {
258 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
259 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
266 aMeshes->length( 1 );
267 aMeshes[0] = theComponentMesh->CreateMeshesFromSTL( filename.toLatin1().constData() );
268 if ( aMeshes[0]->_is_nil() ) {
269 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
270 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
277 SMESH::DriverMED_ReadStatus res;
278 aMeshes = theComponentMesh->CreateMeshesFromCGNS( filename.toLatin1().constData(), res );
279 if ( res != SMESH::DRS_OK ) {
280 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
281 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
288 SMESH::DriverMED_ReadStatus res;
289 aMeshes = theComponentMesh->CreateMeshesFromSAUV( filename.toLatin1().constData(), res );
290 if ( res != SMESH::DRS_OK ) {
291 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
292 arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
298 catch ( const SALOME::SALOME_Exception& S_ex ) {
299 errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
300 arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
303 for ( int i = 0, iEnd = aMeshes->length(); i < iEnd; i++ ) {
304 _PTR(SObject) aMeshSO = SMESH::FindSObject( aMeshes[i] );
306 _PTR(StudyBuilder) aBuilder = aStudy->NewBuilder();
307 _PTR(AttributePixMap) aPixmap = aBuilder->FindOrCreateAttribute( aMeshSO, "AttributePixMap" );
308 aPixmap->SetPixMap( "ICON_SMESH_TREE_MESH_IMPORTED" );
309 if ( theCommandID == 112 ) // mesh names aren't taken from the file for UNV import
310 SMESH::SetName( aMeshSO, QFileInfo(filename).fileName() );
312 anEntryList.append( aMeshSO->GetID().c_str() );
314 #ifdef WITHGENERICOBJ
315 // obj has been published in study. Its refcount has been incremented.
316 // It is safe to decrement its refcount
317 // so that it will be destroyed when the entry in study will be removed
318 aMeshes[i]->UnRegister();
327 // update Object browser
328 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
330 // browse to the published meshes
331 if( LightApp_Application* anApp =
332 dynamic_cast<LightApp_Application*>( SUIT_Session::session()->activeApplication() ) )
333 anApp->browseObjects( anEntryList );
335 // show Error message box if there were errors
336 if ( errors.count() > 0 ) {
337 SUIT_MessageBox::critical( SMESHGUI::desktop(),
338 QObject::tr( "SMESH_ERROR" ),
339 QObject::tr( "SMESH_IMPORT_ERRORS" ) + "\n" + errors.join( "\n" ) );
342 // show warning message box, if some imported mesh is empty
344 SUIT_MessageBox::warning( SMESHGUI::desktop(),
345 QObject::tr( "SMESH_WRN_WARNING" ),
346 QObject::tr( "SMESH_DRS_SOME_EMPTY" ) );
351 //================================================================================
353 * \brief Export selected meshes or groups into a file
355 //================================================================================
357 void ExportMeshToFile( int theCommandID )
359 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
360 SALOME_ListIO selected;
362 aSel->selectedObjects( selected );
364 const bool isMED = ( theCommandID == 122 || theCommandID == 125 );
365 const bool isDAT = ( theCommandID == 121 || theCommandID == 124 );
366 const bool isUNV = ( theCommandID == 123 || theCommandID == 126 );
367 const bool isSTL = ( theCommandID == 140 || theCommandID == 141 );
368 const bool isCGNS= ( theCommandID == 142 || theCommandID == 143 );
369 const bool isSAUV= ( theCommandID == 144 || theCommandID == 145 );
371 // actually, the following condition can't be met (added for insurance)
372 if( selected.Extent() == 0 ||
373 ( selected.Extent() > 1 && !isMED && !isSTL ))
376 // get mesh object from selection and check duplication of their names
377 bool hasDuplicatedMeshNames = false;
378 QList< QPair< SMESH::SMESH_IDSource_var, QString > > aMeshList;
379 QList< QPair< SMESH::SMESH_IDSource_var, QString > >::iterator aMeshIter;
380 SALOME_ListIteratorOfListIO It( selected );
381 for( ; It.More(); It.Next() )
383 Handle(SALOME_InteractiveObject) anIObject = It.Value();
384 SMESH::SMESH_IDSource_var aMeshItem = SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIObject);
385 if ( aMeshItem->_is_nil() ) {
386 SUIT_MessageBox::warning( SMESHGUI::desktop(),
387 QObject::tr( "SMESH_WRN_WARNING" ),
388 QObject::tr( "SMESH_BAD_MESH_SELECTION" ));
392 QString aMeshName = anIObject->getName();
394 // check for name duplications
395 if ( !hasDuplicatedMeshNames )
396 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
397 if( aMeshName == (*aMeshIter).second ) {
398 hasDuplicatedMeshNames = true;
403 aMeshList.append( QPair< SMESH::SMESH_IDSource_var, QString >( aMeshItem, aMeshName ) );
406 if( hasDuplicatedMeshNames && isMED ) {
407 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
408 QObject::tr("SMESH_WRN_WARNING"),
409 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_MESH_NAMES"),
410 QObject::tr("SMESH_BUT_YES"),
411 QObject::tr("SMESH_BUT_NO"), 0, 1);
416 aMeshIter = aMeshList.begin();
417 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
418 SMESH::SMESH_Mesh_var aMesh = aMeshOrGroup->GetMesh();
419 QString aMeshName = (*aMeshIter).second;
421 if ( isMED || isCGNS || isSAUV )
423 // check for equal group names within each mesh
424 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
425 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
426 if ( !aMeshItem->_is_nil() && aMeshItem->HasDuplicatedGroupNamesMED()) {
427 int aRet = SUIT_MessageBox::warning
428 (SMESHGUI::desktop(),
429 QObject::tr("SMESH_WRN_WARNING"),
430 QObject::tr("SMESH_EXPORT_MED_DUPLICATED_GRP").arg((*aMeshIter).second),
431 QObject::tr("SMESH_BUT_YES"),
432 QObject::tr("SMESH_BUT_NO"), 0, 1);
440 // warn the user about presence of not supported elements
441 SMESH::long_array_var nbElems = aMeshOrGroup->GetMeshInfo();
442 int nbNotSupported = ( nbElems[ SMESH::Entity_Pyramid ] +
443 nbElems[ SMESH::Entity_Quad_Pyramid ] +
444 nbElems[ SMESH::Entity_Hexagonal_Prism ] +
445 nbElems[ SMESH::Entity_Polygon ] +
446 nbElems[ SMESH::Entity_Polyhedra ] );
447 if ( nbNotSupported > 0 ) {
448 int aRet = SUIT_MessageBox::warning
449 (SMESHGUI::desktop(),
450 QObject::tr("SMESH_WRN_WARNING"),
451 QObject::tr("SMESH_EXPORT_UNV").arg(aMeshName),
452 QObject::tr("SMESH_BUT_YES"),
453 QObject::tr("SMESH_BUT_NO"), 0, 1);
459 // Get parameters of export operation
462 SMESH::MED_VERSION aFormat;
463 // Init the parameters with the default values
464 bool aIsASCII_STL = true;
465 bool toCreateGroups = false;
466 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
468 toCreateGroups = resMgr->booleanValue( "SMESH", "auto_groups", false );
469 bool toOverwrite = true;
471 QString aFilter, aTitle = QObject::tr("SMESH_EXPORT_MESH");
472 QString anInitialPath = "";
473 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
474 anInitialPath = QDir::currentPath();
476 if ( isUNV || isDAT )
479 aFilter = QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)";
481 aFilter = QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)";
482 if ( anInitialPath.isEmpty() ) anInitialPath = SUIT_FileDlg::getLastVisitedPath();
483 aFilename = SUIT_FileDlg::getFileName(SMESHGUI::desktop(),
484 anInitialPath + QString("/") + aMeshName,
485 aFilter, aTitle, false);
487 else if ( isCGNS )// Export to CGNS
489 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
490 fd->setWindowTitle( aTitle );
491 fd->setNameFilter( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
492 if ( !anInitialPath.isEmpty() )
493 fd->setDirectory( anInitialPath );
494 fd->selectFile(aMeshName);
495 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
496 fd->setValidator( fv );
499 aFilename = fd->selectedFile();
500 toOverwrite = fv->isOverwrite();
504 else if ( isSTL ) // Export to STL
506 QMap<QString, int> aFilterMap;
507 aFilterMap.insert( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)", 1 );
508 aFilterMap.insert( QObject::tr( "STL_BIN_FILES_FILTER" ) + " (*.stl)", 0 );
511 QMap<QString, int>::const_iterator it = aFilterMap.begin();
512 for ( ; it != aFilterMap.end(); ++it )
513 filters.push_back( it.key() );
515 SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
516 fd->setWindowTitle( aTitle );
517 fd->setNameFilters( filters );
518 fd->selectNameFilter( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
519 if ( !anInitialPath.isEmpty() )
520 fd->setDirectory( anInitialPath );
521 fd->selectFile(aMeshName);
525 aFilename = fd->selectedFile();
526 aIsASCII_STL = (aFilterMap[fd->selectedNameFilter()]) == 1 ? true: false;
531 else if ( isMED || isSAUV ) // Export to MED or SAUV
533 QMap<QString, SMESH::MED_VERSION> aFilterMap;
534 //QString v21 (aMesh->GetVersionString(SMESH::MED_V2_1, 2));
536 QString v22 (aMesh->GetVersionString(SMESH::MED_V2_2, 2));
537 //aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v21 ) + " (*.med)", SMESH::MED_V2_1 );
538 aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( v22 ) + " (*.med)", SMESH::MED_V2_2 );
541 aFilterMap.insert("All files (*)", SMESH::MED_V2_1 );
542 aFilterMap.insert("SAUV files (*.sauv)", SMESH::MED_V2_2 );
543 aFilterMap.insert("SAUV files (*.sauve)", SMESH::MED_V2_1 );
547 QString aDefaultFilter;
548 QMap<QString, SMESH::MED_VERSION>::const_iterator it = aFilterMap.begin();
549 for ( ; it != aFilterMap.end(); ++it ) {
550 filters.push_back( it.key() );
551 if (it.value() == SMESH::MED_V2_2)
552 aDefaultFilter = it.key();
555 SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg
556 ( SMESHGUI::desktop(), false, QObject::tr("SMESH_AUTO_GROUPS"), true, true );
557 fd->setWindowTitle( aTitle );
558 fd->setNameFilters( filters );
559 fd->selectNameFilter(aDefaultFilter);
560 fd->SetChecked(toCreateGroups);
561 if ( !anInitialPath.isEmpty() )
562 fd->setDirectory( anInitialPath );
563 fd->selectFile(aMeshName);
565 SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
566 fd->setValidator( fv );
571 aFilename = fd->selectedFile();
573 aFilename = QString::null;
576 aFormat = aFilterMap[fd->selectedNameFilter()];
577 toOverwrite = fv->isOverwrite();
579 if ( !aFilename.isEmpty() ) {
580 // med-2.1 does not support poly elements
581 if ( aFormat==SMESH::MED_V2_1 )
582 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
583 SMESH::SMESH_IDSource_var aMeshItem = (*aMeshIter).first;
584 SMESH::long_array_var nbElems = aMeshItem->GetMeshInfo();
585 if ( nbElems[ SMESH::Entity_Polygon ] + nbElems[ SMESH::Entity_Quad_Polygon ] +
586 nbElems[ SMESH::Entity_Polyhedra ] + nbElems[ SMESH::Entity_Quad_Polyhedra ])
588 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
589 QObject::tr("SMESH_WRN_WARNING"),
590 QObject::tr("SMESH_EXPORT_MED_V2_1").arg((*aMeshIter).second),
591 QObject::tr("SMESH_BUT_YES"),
592 QObject::tr("SMESH_BUT_NO"), 0, 1);
600 // can't append to an existing using other format
601 SMESH::MED_VERSION aVersion = SMESH::MED_V2_1;
602 bool isVersionOk = SMESHGUI::GetSMESHGen()->GetMEDVersion( aFilename.toLatin1().constData(), aVersion );
603 if( !isVersionOk || aVersion != aFormat ) {
604 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
605 QObject::tr("SMESH_WRN_WARNING"),
606 QObject::tr("SMESH_EXPORT_MED_VERSION_COLLISION").arg(aFilename),
607 QObject::tr("SMESH_BUT_YES"),
608 QObject::tr("SMESH_BUT_NO"), 0, 1);
615 QStringList aMeshNamesCollisionList;
616 SMESH::string_array_var aMeshNames = SMESHGUI::GetSMESHGen()->GetMeshNames( aFilename.toLatin1().constData() );
617 for( int i = 0, n = aMeshNames->length(); i < n; i++ ) {
618 QString anExistingMeshName( aMeshNames[ i ] );
619 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
620 QString anExportMeshName = (*aMeshIter).second;
621 if( anExportMeshName == anExistingMeshName ) {
622 aMeshNamesCollisionList.append( anExportMeshName );
627 if( !aMeshNamesCollisionList.isEmpty() ) {
628 QString aMeshNamesCollisionString = aMeshNamesCollisionList.join( ", " );
629 int aRet = SUIT_MessageBox::warning(SMESHGUI::desktop(),
630 QObject::tr("SMESH_WRN_WARNING"),
631 QObject::tr("SMESH_EXPORT_MED_MESH_NAMES_COLLISION").arg(aMeshNamesCollisionString),
632 QObject::tr("SMESH_BUT_YES"),
633 QObject::tr("SMESH_BUT_NO"),
634 QObject::tr("SMESH_BUT_CANCEL"), 0, 2);
643 toCreateGroups = fd->IsChecked();
653 if ( !aFilename.isEmpty() ) {
654 // Check whether the file already exists and delete it if yes
655 QFile aFile( aFilename );
656 if ( aFile.exists() && toOverwrite )
658 SUIT_OverrideCursor wc;
661 // Renumbering is not needed since SMDS redesign in V6.2.0 (Nov 2010)
662 // bool Renumber = false;
663 // // PAL 14172 : Check of we have to renumber or not from the preferences before export
665 // Renumber= resMgr->booleanValue("SMESH","renumbering");
667 // SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
668 // aMeshEditor->RenumberNodes();
669 // aMeshEditor->RenumberElements();
670 // if ( SMESHGUI::automaticUpdate() )
671 // SMESH::UpdateView();
675 aMeshIter = aMeshList.begin();
676 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
678 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
679 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
680 if ( aMeshOrGroup->_is_equivalent( aMeshItem ))
681 aMeshItem->ExportToMEDX( aFilename.toLatin1().data(), toCreateGroups,
682 aFormat, toOverwrite && aMeshIndex == 0 );
684 aMeshItem->ExportPartToMED( aMeshOrGroup, aFilename.toLatin1().data(), toCreateGroups,
685 aFormat, toOverwrite && aMeshIndex == 0 );
690 for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ )
692 SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
693 if( !aMeshItem->_is_nil() )
694 aMeshItem->ExportSAUV( aFilename.toLatin1().data(), toCreateGroups );
699 if ( aMeshOrGroup->_is_equivalent( aMesh ))
700 aMesh->ExportDAT( aFilename.toLatin1().data() );
702 aMesh->ExportPartToDAT( aMeshOrGroup, aFilename.toLatin1().data() );
706 if ( aMeshOrGroup->_is_equivalent( aMesh ))
707 aMesh->ExportUNV( aFilename.toLatin1().data() );
709 aMesh->ExportPartToUNV( aMeshOrGroup, aFilename.toLatin1().data() );
713 if ( aMeshOrGroup->_is_equivalent( aMesh ))
714 aMesh->ExportSTL( aFilename.toLatin1().data(), aIsASCII_STL );
716 aMesh->ExportPartToSTL( aMeshOrGroup, aFilename.toLatin1().data(), aIsASCII_STL );
720 aMeshIter = aMeshList.begin();
721 for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
723 SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
724 SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
725 aMeshItem->ExportCGNS( aMeshOrGroup,
726 aFilename.toLatin1().data(),
727 toOverwrite && aMeshIndex == 0 );
731 catch (const SALOME::SALOME_Exception& S_ex){
733 SUIT_MessageBox::warning(SMESHGUI::desktop(),
734 QObject::tr("SMESH_WRN_WARNING"),
735 QObject::tr("SMESH_EXPORT_FAILED"));
741 inline void InverseEntityMode(unsigned int& theOutputMode,
742 unsigned int theMode)
744 bool anIsNotPresent = ~theOutputMode & theMode;
746 theOutputMode |= theMode;
748 theOutputMode &= ~theMode;
751 void SetDisplayEntity(int theCommandID){
752 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
753 SALOME_ListIO selected;
755 aSel->selectedObjects( selected );
757 if(selected.Extent() >= 1){
758 SALOME_ListIteratorOfListIO It( selected );
759 for( ; It.More(); It.Next()){
760 Handle(SALOME_InteractiveObject) IObject = It.Value();
761 if(IObject->hasEntry()){
762 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
763 unsigned int aMode = anActor->GetEntityMode();
764 switch(theCommandID){
766 InverseEntityMode(aMode,SMESH_Actor::e0DElements);
769 InverseEntityMode(aMode,SMESH_Actor::eEdges);
772 InverseEntityMode(aMode,SMESH_Actor::eFaces);
775 InverseEntityMode(aMode,SMESH_Actor::eVolumes);
778 aMode = SMESH_Actor::eAllEntity;
782 anActor->SetEntityMode(aMode);
790 SALOME_ListIO selected;
791 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
795 LightApp_SelectionMgr* aSel = app->selectionMgr();
796 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
797 if( !aSel || !appStudy )
800 aSel->selectedObjects( selected );
801 if( selected.IsEmpty() )
804 Handle(SALOME_InteractiveObject) anIObject = selected.First();
806 _PTR(Study) aStudy = appStudy->studyDS();
807 _PTR(SObject) aMainSObject( aStudy->FindObjectID( anIObject->getEntry() ) );
808 SMESH::SMESH_Mesh_var aMainObject = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
809 if( aMainObject->_is_nil() )
812 aMainObject->SetAutoColor( true ); // mesh groups are re-colored here
814 SMESH::ListOfGroups aListOfGroups = *aMainObject->GetGroups();
815 for( int i = 0, n = aListOfGroups.length(); i < n; i++ )
817 SMESH::SMESH_GroupBase_var aGroupObject = aListOfGroups[i];
818 SALOMEDS::Color aColor = aGroupObject->GetColor();
819 _PTR(SObject) aGroupSObject = SMESH::FindSObject(aGroupObject);
821 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(aGroupSObject->GetID().c_str())) {
822 if( aGroupObject->GetType() == SMESH::NODE )
823 anActor->SetNodeColor( aColor.R, aColor.G, aColor.B );
824 else if( aGroupObject->GetType() == SMESH::EDGE )
825 anActor->SetEdgeColor( aColor.R, aColor.G, aColor.B );
826 else if( aGroupObject->GetType() == SMESH::ELEM0D )
827 anActor->Set0DColor( aColor.R, aColor.G, aColor.B );
831 SMESH::GetColor("SMESH", "fill_color", c, delta, "0,170,255|-100");
832 anActor->SetSufaceColor( aColor.R, aColor.G, aColor.B, delta );
838 SMESH::RepaintCurrentView();
841 QString functorToString( SMESH::Controls::FunctorPtr f )
843 QString type = QObject::tr( "UNKNOWN_CONTROL" );
844 if ( dynamic_cast< SMESH::Controls::Volume* >( f.get() ) )
845 type = QObject::tr( "VOLUME_3D_ELEMENTS" );
846 else if ( dynamic_cast< SMESH::Controls::MaxElementLength2D* >( f.get() ) )
847 type = QObject::tr( "MAX_ELEMENT_LENGTH_2D" );
848 else if ( dynamic_cast< SMESH::Controls::MaxElementLength3D* >( f.get() ) )
849 type = QObject::tr( "MAX_ELEMENT_LENGTH_3D" );
850 else if ( dynamic_cast< SMESH::Controls::MinimumAngle* >( f.get() ) )
851 type = QObject::tr( "MINIMUMANGLE_ELEMENTS" );
852 else if ( dynamic_cast< SMESH::Controls::AspectRatio* >( f.get() ) )
853 type = QObject::tr( "ASPECTRATIO_ELEMENTS" );
854 else if ( dynamic_cast< SMESH::Controls::AspectRatio3D* >( f.get() ) )
855 type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" );
856 else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) )
857 type = QObject::tr( "WARP_ELEMENTS" );
858 else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) )
859 type = QObject::tr( "TAPER_ELEMENTS" );
860 else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) )
861 type = QObject::tr( "SKEW_ELEMENTS" );
862 else if ( dynamic_cast< SMESH::Controls::Area* >( f.get() ) )
863 type = QObject::tr( "AREA_ELEMENTS" );
864 else if ( dynamic_cast< SMESH::Controls::Length* >( f.get() ) )
865 type = QObject::tr( "LENGTH_EDGES" );
866 else if ( dynamic_cast< SMESH::Controls::Length2D* >( f.get() ) )
867 type = QObject::tr( "LENGTH2D_EDGES" );
868 else if ( dynamic_cast< SMESH::Controls::MultiConnection* >( f.get() ) )
869 type = QObject::tr( "MULTI_BORDERS" );
870 else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) )
871 type = QObject::tr( "MULTI2D_BORDERS" );
872 else if ( dynamic_cast< SMESH::Controls::FreeNodes* >( f.get() ) )
873 type = QObject::tr( "FREE_NODES" );
874 else if ( dynamic_cast< SMESH::Controls::FreeEdges* >( f.get() ) )
875 type = QObject::tr( "FREE_EDGES" );
876 else if ( dynamic_cast< SMESH::Controls::FreeBorders* >( f.get() ) )
877 type = QObject::tr( "FREE_BORDERS" );
878 else if ( dynamic_cast< SMESH::Controls::FreeFaces* >( f.get() ) )
879 type = QObject::tr( "FREE_FACES" );
880 else if ( dynamic_cast< SMESH::Controls::BareBorderVolume* >( f.get() ) )
881 type = QObject::tr( "BARE_BORDER_VOLUME" );
882 else if ( dynamic_cast< SMESH::Controls::BareBorderFace* >( f.get() ) )
883 type = QObject::tr( "BARE_BORDER_FACE" );
884 else if ( dynamic_cast< SMESH::Controls::OverConstrainedVolume* >( f.get() ) )
885 type = QObject::tr( "OVER_CONSTRAINED_VOLUME" );
886 else if ( dynamic_cast< SMESH::Controls::OverConstrainedFace* >( f.get() ) )
887 type = QObject::tr( "OVER_CONSTRAINED_FACE" );
888 else if ( dynamic_cast< SMESH::Controls::CoincidentNodes* >( f.get() ) )
889 type = QObject::tr( "EQUAL_NODE" );
890 else if ( dynamic_cast< SMESH::Controls::CoincidentElements1D* >( f.get() ) )
891 type = QObject::tr( "EQUAL_EDGE" );
892 else if ( dynamic_cast< SMESH::Controls::CoincidentElements2D* >( f.get() ) )
893 type = QObject::tr( "EQUAL_FACE" );
894 else if ( dynamic_cast< SMESH::Controls::CoincidentElements3D* >( f.get() ) )
895 type = QObject::tr( "EQUAL_VOLUME" );
899 void SaveDistribution()
901 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
902 SALOME_ListIO selected;
904 aSel->selectedObjects( selected );
906 if ( selected.Extent() == 1 ) {
907 Handle(SALOME_InteractiveObject) anIO = selected.First();
908 if ( anIO->hasEntry() ) {
909 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
910 if ( anActor && anActor->GetScalarBarActor() && anActor->GetControlMode() != SMESH_Actor::eNone ) {
911 SMESH_ScalarBarActor* aScalarBarActor = anActor->GetScalarBarActor();
912 SMESH::Controls::FunctorPtr aFunctor = anActor->GetFunctor();
913 if ( aScalarBarActor && aFunctor ) {
914 SMESH::Controls::NumericalFunctor* aNumFun = dynamic_cast<SMESH::Controls::NumericalFunctor*>( aFunctor.get() );
916 std::vector<int> elements;
917 SMESH::SMESH_Mesh_var mesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIO);
918 if ( mesh->_is_nil() ) {
919 SMESH::SMESH_IDSource_var idSource =
920 SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(anIO);
921 if ( !idSource->_is_nil() )
923 SMESH::long_array_var ids = idSource->GetIDs();
924 elements.resize( ids->length() );
925 for ( unsigned i = 0; i < elements.size(); ++i )
926 elements[i] = ids[i];
929 int nbIntervals = aScalarBarActor->GetMaximumNumberOfColors();
930 vtkLookupTable* lookupTable =
931 static_cast<vtkLookupTable*>(aScalarBarActor->GetLookupTable());
932 double * minmax = lookupTable->GetRange();
933 std::vector<int> nbEvents;
934 std::vector<double> funValues;
935 aNumFun->GetHistogram( nbIntervals, nbEvents, funValues, elements, minmax );
936 QString anInitialPath = "";
937 if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
938 anInitialPath = QDir::currentPath();
939 QString aMeshName = anIO->getName();
941 filter.append( QObject::tr( "TEXT_FILES_FILTER" ) + " (*.txt)" );
942 filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
943 QString aFilename = anInitialPath + "/" + aMeshName + "_" +
944 functorToString( aFunctor ).toLower().simplified().replace( QRegExp( " |-" ), "_" ) + ".txt";
945 aFilename = SUIT_FileDlg::getFileName( SMESHGUI::desktop(),
948 QObject::tr( "SMESH_SAVE_DISTRIBUTION" ),
950 if ( !aFilename.isEmpty() ) {
951 QFile f( aFilename );
952 if ( f.open( QFile::WriteOnly | QFile::Truncate ) ) {
953 QTextStream out( &f );
954 out << "# Mesh: " << aMeshName << endl;
955 out << "# Control: " << functorToString( aFunctor ) << endl;
957 out.setFieldWidth( 10 );
958 for ( int i = 0; i < qMin( nbEvents.size(), funValues.size()-1 ); i++ )
959 out << funValues[i] << "\t" << funValues[i+1] << "\t" << nbEvents[i] << endl;
970 void ShowDistribution() {
971 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
972 SALOME_ListIO selected;
974 aSel->selectedObjects( selected );
976 if ( selected.Extent() == 1 ) {
977 Handle(SALOME_InteractiveObject) anIO = selected.First();
978 if ( anIO->hasEntry() ) {
979 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
980 if ( anActor && anActor->GetScalarBarActor() && anActor->GetControlMode() != SMESH_Actor::eNone ) {
981 SMESH_ScalarBarActor *aScalarBarActor = anActor->GetScalarBarActor();
982 aScalarBarActor->SetDistributionVisibility(!aScalarBarActor->GetDistributionVisibility());
988 #ifndef DISABLE_PLOT2DVIEWER
989 void PlotDistribution() {
990 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
994 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
995 SALOME_ListIO selected;
997 aSel->selectedObjects( selected );
999 if ( selected.Extent() == 1 ) {
1000 Handle(SALOME_InteractiveObject) anIO = selected.First();
1001 if ( anIO->hasEntry() ) {
1002 //Find Actor by entry before getting Plot2d viewer,
1003 //because after call getViewManager( Plot2d_Viewer::Type(), true ) active window is Plot2d Viewer
1004 SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() );
1006 SUIT_ViewManager* aViewManager = app->getViewManager( Plot2d_Viewer::Type(), true ); // create if necessary
1011 SPlot2d_Viewer* aView = dynamic_cast<SPlot2d_Viewer*>(aViewManager->getViewModel());
1015 Plot2d_ViewFrame* aPlot = aView->getActiveViewFrame();
1019 if ( anActor && anActor->GetControlMode() != SMESH_Actor::eNone ) {
1020 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1021 QString functorName = functorToString( anActor->GetFunctor());
1022 QString aHistogramName("%1 : %2");
1023 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1024 aHistogram->setName(aHistogramName);
1025 aHistogram->setHorTitle(functorName);
1026 aHistogram->setVerTitle(QObject::tr("DISTRIBUTION_NB_ENT"));
1027 aPlot->displayObject(aHistogram, true);
1032 #endif //DISABLE_PLOT2DVIEWER
1034 void DisableAutoColor(){
1035 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1036 SALOME_ListIO selected;
1038 aSel->selectedObjects( selected );
1040 if(selected.Extent()){
1041 Handle(SALOME_InteractiveObject) anIObject = selected.First();
1042 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
1043 if ( !aMesh->_is_nil() ) {
1044 aMesh->SetAutoColor( false );
1049 void SetDisplayMode(int theCommandID, SMESHGUI_StudyId2MarkerMap& theMarkerMap){
1050 SALOME_ListIO selected;
1051 SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
1055 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1056 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1057 if( !aSel || !appStudy )
1060 if( theCommandID == 1134 ) { // Clipping dialog can be activated without selection
1061 if( SMESHGUI* aModule = SMESHGUI::GetSMESHGUI() ) {
1062 aModule->EmitSignalDeactivateDialog();
1063 if( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aModule ) )
1064 (new SMESHGUI_ClippingDlg( aModule, aViewWindow ))->show();
1069 _PTR(Study) aStudy = appStudy->studyDS();
1071 aSel->selectedObjects( selected );
1073 if(selected.Extent() >= 1){
1074 switch(theCommandID){
1076 SMESHGUI::GetSMESHGUI()->EmitSignalDeactivateDialog();
1077 (new SMESHGUI_TransparencyDlg( SMESHGUI::GetSMESHGUI() ))->show();
1081 QColor c, e, b, n, c0D, o, outl, selection, preselection;
1085 vtkFloatingPointType Shrink = 0.0;
1086 vtkFloatingPointType faces_orientation_scale = 0.0;
1087 bool faces_orientation_3dvectors = false;
1089 VTK::MarkerType aMarkerTypeCurrent = VTK::MT_NONE;
1090 VTK::MarkerScale aMarkerScaleCurrent = VTK::MS_NONE;
1091 int aMarkerTextureCurrent = 0;
1093 SALOME_ListIteratorOfListIO It( selected );
1094 for( ; It.More(); It.Next()){
1095 Handle(SALOME_InteractiveObject) IObject = It.Value();
1096 if(IObject->hasEntry()){
1097 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1098 vtkFloatingPointType color[3];
1099 anActor->GetSufaceColor(color[0], color[1], color[2],delta);
1100 int c0 = int (color[0] * 255);
1101 int c1 = int (color[1] * 255);
1102 int c2 = int (color[2] * 255);
1103 c.setRgb(c0, c1, c2);
1105 vtkFloatingPointType edgecolor[3];
1106 anActor->GetEdgeColor(edgecolor[0], edgecolor[1], edgecolor[2]);
1107 c0 = int (edgecolor[0] * 255);
1108 c1 = int (edgecolor[1] * 255);
1109 c2 = int (edgecolor[2] * 255);
1110 e.setRgb(c0, c1, c2);
1112 vtkFloatingPointType nodecolor[3];
1113 anActor->GetNodeColor(nodecolor[0], nodecolor[1], nodecolor[2]);
1114 c0 = int (nodecolor[0] * 255);
1115 c1 = int (nodecolor[1] * 255);
1116 c2 = int (nodecolor[2] * 255);
1117 n.setRgb(c0, c1, c2);
1119 vtkFloatingPointType color0D[3];
1120 anActor->Get0DColor(color0D[0], color0D[1], color0D[2]);
1121 c0 = int (color0D[0] * 255);
1122 c1 = int (color0D[1] * 255);
1123 c2 = int (color0D[2] * 255);
1124 c0D.setRgb(c0, c1, c2);
1126 vtkFloatingPointType outlineColor[3];
1127 anActor->GetOutlineColor(outlineColor[0], outlineColor[1], outlineColor[2]);
1128 c0 = int (outlineColor[0] * 255);
1129 c1 = int (outlineColor[1] * 255);
1130 c2 = int (outlineColor[2] * 255);
1131 outl.setRgb(c0, c1, c2);
1133 vtkFloatingPointType hColor[3];
1134 anActor->GetHighlightColor(hColor[0], hColor[1], hColor[2]);
1135 c0 = int (hColor[0] * 255);
1136 c1 = int (hColor[1] * 255);
1137 c2 = int (hColor[2] * 255);
1138 selection.setRgb(c0, c1, c2);
1140 vtkFloatingPointType phColor[3];
1141 anActor->GetPreHighlightColor(phColor[0], phColor[1], phColor[2]);
1142 c0 = int (phColor[0] * 255);
1143 c1 = int (phColor[1] * 255);
1144 c2 = int (phColor[2] * 255);
1145 preselection.setRgb(c0, c1, c2);
1147 size0D = (int)anActor->Get0DSize();
1150 Edgewidth = (int)anActor->GetLineWidth();
1153 Shrink = anActor->GetShrinkFactor();
1155 vtkFloatingPointType faces_orientation_color[3];
1156 anActor->GetFacesOrientationColor(faces_orientation_color);
1157 c0 = int (faces_orientation_color[0] * 255);
1158 c1 = int (faces_orientation_color[1] * 255);
1159 c2 = int (faces_orientation_color[2] * 255);
1160 o.setRgb(c0, c1, c2);
1162 faces_orientation_scale = anActor->GetFacesOrientationScale();
1163 faces_orientation_3dvectors = anActor->GetFacesOrientation3DVectors();
1165 aMarkerTypeCurrent = anActor->GetMarkerType();
1166 aMarkerScaleCurrent = anActor->GetMarkerScale();
1167 aMarkerTextureCurrent = anActor->GetMarkerTexture();
1169 // even if there are multiple objects in the selection,
1170 // we need only the first one to get values for the dialog
1176 SMESHGUI_Preferences_ColorDlg *aDlg =
1177 new SMESHGUI_Preferences_ColorDlg( SMESHGUI::GetSMESHGUI() );
1178 aDlg->SetColor(1, c);
1179 aDlg->SetColor(2, e);
1180 aDlg->SetColor(3, n);
1181 aDlg->SetColor(4, outl);
1182 aDlg->SetDeltaBrightness(delta);
1183 aDlg->SetColor(5, c0D);
1184 aDlg->SetColor(6, o);
1185 aDlg->SetIntValue(1, Edgewidth);
1186 aDlg->SetIntValue(2, int(Shrink*100.));
1187 aDlg->SetIntValue(3, size0D);
1188 aDlg->SetDoubleValue(1, faces_orientation_scale);
1189 aDlg->SetBooleanValue(1, faces_orientation_3dvectors);
1190 aDlg->SetColor(7, selection);
1191 aDlg->SetColor(8, preselection);
1193 aDlg->setCustomMarkerMap( theMarkerMap[ aStudy->StudyId() ] );
1195 if( aMarkerTypeCurrent != VTK::MT_USER )
1196 aDlg->setStandardMarker( aMarkerTypeCurrent, aMarkerScaleCurrent );
1198 aDlg->setCustomMarker( aMarkerTextureCurrent );
1201 QColor color = aDlg->GetColor(1);
1202 QColor edgecolor = aDlg->GetColor(2);
1203 QColor nodecolor = aDlg->GetColor(3);
1204 QColor outlinecolor = aDlg->GetColor(4);
1205 QColor color0D = aDlg->GetColor(5);
1206 QColor faces_orientation_color = aDlg->GetColor(6);
1207 QColor selectioncolor = aDlg->GetColor(7);
1208 QColor preSelectioncolor = aDlg->GetColor(8);
1209 int delta = aDlg->GetDeltaBrightness();
1212 theMarkerMap[ aStudy->StudyId() ] = aDlg->getCustomMarkerMap();
1214 SALOME_ListIteratorOfListIO It( selected );
1215 for( ; It.More(); It.Next()){
1216 Handle(SALOME_InteractiveObject) IObject = It.Value();
1217 if(IObject->hasEntry()){
1218 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1219 /* actor color and backface color */
1220 anActor->SetSufaceColor(vtkFloatingPointType (color.red()) / 255.,
1221 vtkFloatingPointType (color.green()) / 255.,
1222 vtkFloatingPointType (color.blue()) / 255.,
1225 anActor->SetEdgeColor(vtkFloatingPointType (edgecolor.red()) / 255.,
1226 vtkFloatingPointType (edgecolor.green()) / 255.,
1227 vtkFloatingPointType (edgecolor.blue()) / 255.);
1229 anActor->SetOutlineColor(vtkFloatingPointType (outlinecolor.red()) / 255.,
1230 vtkFloatingPointType (outlinecolor.green()) / 255.,
1231 vtkFloatingPointType (outlinecolor.blue()) / 255.);
1234 anActor->SetHighlightColor(vtkFloatingPointType (selectioncolor.red()) / 255.,
1235 vtkFloatingPointType (selectioncolor.green()) / 255.,
1236 vtkFloatingPointType (selectioncolor.blue()) / 255.);
1238 anActor->SetPreHighlightColor(vtkFloatingPointType (preSelectioncolor.red()) / 255.,
1239 vtkFloatingPointType (preSelectioncolor.green()) / 255.,
1240 vtkFloatingPointType (preSelectioncolor.blue()) / 255.);
1243 /* Shrink factor and size edges */
1244 anActor->SetShrinkFactor(aDlg->GetIntValue(2) / 100.);
1245 anActor->SetLineWidth(aDlg->GetIntValue(1));
1247 /* Nodes color and size */
1248 anActor->SetNodeColor(vtkFloatingPointType (nodecolor.red()) / 255.,
1249 vtkFloatingPointType (nodecolor.green()) / 255.,
1250 vtkFloatingPointType (nodecolor.blue()) / 255.);
1253 anActor->Set0DColor(vtkFloatingPointType (color0D.red()) / 255.,
1254 vtkFloatingPointType (color0D.green()) / 255.,
1255 vtkFloatingPointType (color0D.blue()) / 255.);
1256 anActor->Set0DSize(aDlg->GetIntValue(3));
1258 /* Faces orientation */
1259 vtkFloatingPointType c[3] = {vtkFloatingPointType(faces_orientation_color.redF()),
1260 vtkFloatingPointType(faces_orientation_color.greenF()),
1261 vtkFloatingPointType(faces_orientation_color.blueF())};
1262 anActor->SetFacesOrientationColor(c);
1263 anActor->SetFacesOrientationScale(aDlg->GetDoubleValue(1));
1264 anActor->SetFacesOrientation3DVectors(aDlg->GetBooleanValue(1));
1266 VTK::MarkerType aMarkerTypeNew = aDlg->getMarkerType();
1267 VTK::MarkerScale aMarkerScaleNew = aDlg->getStandardMarkerScale();
1268 int aMarkerTextureNew = aDlg->getCustomMarkerID();
1269 if( aMarkerTypeNew != VTK::MT_USER )
1270 anActor->SetMarkerStd( aMarkerTypeNew, aMarkerScaleNew );
1272 const VTK::MarkerMap& aMarkerMap = theMarkerMap[ aStudy->StudyId() ];
1273 VTK::MarkerMap::const_iterator anIter = aMarkerMap.find( aMarkerTextureNew );
1274 if( anIter != aMarkerMap.end() )
1275 anActor->SetMarkerTexture( aMarkerTextureNew, anIter->second.second );
1278 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
1279 if( !aGroupObject->_is_nil() )
1281 SMESH::ElementType anElementType = aGroupObject->GetType();
1283 switch( anElementType )
1285 case SMESH::NODE: aColor = nodecolor; break;
1286 case SMESH::EDGE: aColor = edgecolor; break;
1287 default: aColor = color; break;
1290 SALOMEDS::Color aGroupColor;
1291 aGroupColor.R = (float)aColor.red() / 255.0;
1292 aGroupColor.G = (float)aColor.green() / 255.0;
1293 aGroupColor.B = (float)aColor.blue() / 255.0;
1294 aGroupObject->SetColor( aGroupColor );
1299 SMESH::RepaintCurrentView();
1305 SALOME_ListIteratorOfListIO It( selected );
1306 for( ; It.More(); It.Next()){
1307 Handle(SALOME_InteractiveObject) IObject = It.Value();
1308 if(IObject->hasEntry()){
1309 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(IObject->getEntry())){
1310 switch(theCommandID){
1312 anActor->SetRepresentation(SMESH_Actor::eEdge);
1315 anActor->SetRepresentation(SMESH_Actor::eSurface);
1318 if(anActor->IsShrunk())
1319 anActor->UnShrink();
1321 anActor->SetShrink();
1324 anActor->SetRepresentation(SMESH_Actor::ePoint);
1327 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eLines)
1328 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eLines);
1331 if(anActor->GetQuadratic2DRepresentation() != SMESH_Actor::eArcs)
1332 anActor->SetQuadratic2DRepresentation(SMESH_Actor::eArcs);
1338 SMESH::RepaintCurrentView();
1342 void Control( int theCommandID )
1344 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1345 SALOME_ListIO selected;
1347 aSel->selectedObjects( selected );
1349 if( !selected.IsEmpty() ){
1350 Handle(SALOME_InteractiveObject) anIO = selected.First();
1352 SMESH_Actor::eControl aControl = SMESH_Actor::eNone;
1353 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIO->getEntry())) {
1354 switch ( theCommandID ){
1356 aControl = SMESH_Actor::eLength;
1359 aControl = SMESH_Actor::eLength2D;
1362 aControl = SMESH_Actor::eFreeEdges;
1365 aControl = SMESH_Actor::eFreeBorders;
1368 aControl = SMESH_Actor::eMultiConnection;
1371 aControl = SMESH_Actor::eFreeNodes;
1374 aControl = SMESH_Actor::eMultiConnection2D;
1377 aControl = SMESH_Actor::eArea;
1380 aControl = SMESH_Actor::eTaper;
1383 aControl = SMESH_Actor::eAspectRatio;
1386 aControl = SMESH_Actor::eAspectRatio3D;
1389 aControl = SMESH_Actor::eMinimumAngle;
1392 aControl = SMESH_Actor::eWarping;
1395 aControl = SMESH_Actor::eSkew;
1398 aControl = SMESH_Actor::eVolume3D;
1401 aControl = SMESH_Actor::eFreeFaces;
1404 aControl = SMESH_Actor::eMaxElementLength2D;
1407 aControl = SMESH_Actor::eMaxElementLength3D;
1410 aControl = SMESH_Actor::eBareBorderVolume;
1413 aControl = SMESH_Actor::eBareBorderFace;
1416 aControl = SMESH_Actor::eOverConstrainedVolume;
1419 aControl = SMESH_Actor::eOverConstrainedFace;
1422 aControl = SMESH_Actor::eCoincidentNodes;
1425 aControl = SMESH_Actor::eCoincidentElems1D;
1428 aControl = SMESH_Actor:: eCoincidentElems2D;
1431 aControl = SMESH_Actor::eCoincidentElems3D;
1435 anActor->SetControlMode(aControl);
1436 anActor->GetScalarBarActor()->SetTitle( functorToString( anActor->GetFunctor() ).toLatin1().constData() );
1437 SMESH::RepaintCurrentView();
1438 #ifndef DISABLE_PLOT2DVIEWER
1439 if(anActor->GetPlot2Histogram()) {
1440 SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
1441 QString functorName = functorToString( anActor->GetFunctor());
1442 QString aHistogramName("%1 : %2");
1443 aHistogramName = aHistogramName.arg(anIO->getName()).arg(functorName);
1444 aHistogram->setName(aHistogramName);
1445 aHistogram->setHorTitle(functorName);
1446 SMESH::ProcessIn2DViewers(anActor);
1455 bool CheckOIType(const Handle(SALOME_InteractiveObject) & theIO,
1456 MeshObjectType theType,
1457 const QString theInTypeName,
1458 QString & theOutTypeName)
1460 SMESH_TypeFilter aTypeFilter( theType );
1462 if( !theIO.IsNull() )
1464 entry = theIO->getEntry();
1465 LightApp_DataOwner owner( entry );
1466 if ( aTypeFilter.isOk( &owner )) {
1467 theOutTypeName = theInTypeName;
1475 QString CheckTypeObject(const Handle(SALOME_InteractiveObject) & theIO)
1477 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1478 _PTR(SObject) aSObj = aStudy->FindObjectID(theIO->getEntry());
1480 _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
1481 CORBA::String_var anID = aSComp->GetID().c_str();
1482 if (!strcmp(anID.in(),theIO->getEntry()))
1488 CheckOIType ( theIO, HYPOTHESIS, "Hypothesis", aTypeName ) ||
1489 CheckOIType ( theIO, ALGORITHM, "Algorithm", aTypeName ) ||
1490 CheckOIType ( theIO, MESH, "Mesh", aTypeName ) ||
1491 CheckOIType ( theIO, SUBMESH, "SubMesh", aTypeName ) ||
1492 CheckOIType ( theIO, GROUP, "Group", aTypeName )
1500 QString CheckHomogeneousSelection()
1502 //SUIT_Study* aStudy = SMESH::GetActiveStudy();
1503 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
1504 SALOME_ListIO selected;
1506 aSel->selectedObjects( selected );
1508 QString RefType = CheckTypeObject(selected.First());
1509 SALOME_ListIteratorOfListIO It(selected);
1510 for ( ; It.More(); It.Next())
1512 Handle(SALOME_InteractiveObject) IObject = It.Value();
1513 QString Type = CheckTypeObject(IObject);
1514 if (Type.compare(RefType) != 0)
1515 return "Heterogeneous Selection";
1522 void SMESHGUI::OnEditDelete()
1524 // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
1525 LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
1526 SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );
1528 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
1529 _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1530 _PTR(GenericAttribute) anAttr;
1531 _PTR(AttributeIOR) anIOR;
1533 int objectCount = 0;
1535 QString aParentComponent = QString::null;
1536 Handle(SALOME_InteractiveObject) anIO;
1537 for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
1539 anIO = anIt.Value();
1540 QString cur = anIO->getComponentDataType();
1541 _PTR(SObject) aSO = aStudy->FindObjectID(anIO->getEntry());
1543 // check if object is reference
1544 _PTR(SObject) aRefSObj;
1545 aNameList.append("\n - ");
1546 if ( aSO->ReferencedObject( aRefSObj ) ) {
1547 QString aRefName = QString::fromStdString ( aRefSObj->GetName() );
1548 aNameList.append( aRefName );
1549 cur = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
1552 aNameList.append(anIO->getName());
1556 if( aParentComponent.isNull() )
1557 aParentComponent = cur;
1558 else if( !aParentComponent.isEmpty() && aParentComponent!=cur )
1559 aParentComponent = "";
1562 if ( objectCount == 0 )
1563 return; // No Valid Objects Selected
1565 if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() ) {
1566 SUIT_MessageBox::warning( SMESHGUI::desktop(),
1567 QObject::tr("ERR_ERROR"),
1568 QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
1571 // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
1572 if (SUIT_MessageBox::warning
1573 (SMESHGUI::desktop(),
1574 QObject::tr("SMESH_WRN_WARNING"),
1575 QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
1576 SUIT_MessageBox::Yes | SUIT_MessageBox::No,
1577 SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
1580 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1582 // Put the whole hierarchy of sub-objects of the selected SO's into a list and
1583 // then treat them all starting from the deepest objects (at list back)
1584 std::list< _PTR(SObject) > listSO;
1585 SALOME_ListIteratorOfListIO It(selected);
1586 for( ; It.More(); It.Next()) // loop on selected IO's
1588 Handle(SALOME_InteractiveObject) IObject = It.Value();
1589 if(IObject->hasEntry()) {
1590 _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
1592 // disable removal of "SMESH" component object
1593 if(aSO->FindAttribute(anAttr, "AttributeIOR")){
1595 if ( engineIOR() == anIOR->Value().c_str() )
1598 //Check the referenced object
1599 _PTR(SObject) aRefSObject;
1600 if ( aSO && aSO->ReferencedObject( aRefSObject ) )
1601 aSO = aRefSObject; // Delete main Object instead of reference
1603 listSO.push_back( aSO );
1604 std::list< _PTR(SObject) >::iterator itSO = listSO.begin();
1605 for ( ; itSO != listSO.end(); ++itSO ) {
1606 _PTR(ChildIterator) it = aStudy->NewChildIterator( *itSO );
1607 for (it->InitEx(false); it->More(); it->Next())
1608 listSO.push_back( it->Value() );
1612 // Check if none of objects to delete is referred from outside
1613 std::list< _PTR(SObject) >::reverse_iterator ritSO;
1614 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1616 _PTR(SObject) SO = *ritSO;
1617 if ( !SO ) continue;
1618 std::vector<_PTR(SObject)> aReferences = aStudy->FindDependances( *ritSO );
1619 for (size_t i = 0; i < aReferences.size(); i++) {
1620 _PTR(SComponent) aComponent = aReferences[i]->GetFatherComponent();
1621 std::string type = aComponent->ComponentDataType();
1622 if ( type != "SMESH" )
1624 SUIT_MessageBox::warning( anApp->desktop(),
1625 QObject::tr("WRN_WARNING"),
1626 QObject::tr("DEP_OBJECT") );
1627 return; // outside SMESH, there is an object depending on a SMESH object
1632 // Treat SO's in the list starting from the back
1633 aStudyBuilder->NewCommand(); // There is a transaction
1634 for ( ritSO = listSO.rbegin(); ritSO != listSO.rend(); ++ritSO )
1636 _PTR(SObject) SO = *ritSO;
1637 if ( !SO ) continue;
1638 std::string anEntry = SO->GetID();
1640 /** Erase graphical object **/
1641 if(SO->FindAttribute(anAttr, "AttributeIOR")){
1642 ViewManagerList aViewMenegers = anApp->viewManagers();
1643 ViewManagerList::const_iterator it = aViewMenegers.begin();
1644 for( ; it != aViewMenegers.end(); it++) {
1645 SUIT_ViewManager* vm = *it;
1646 int nbSf = vm ? vm->getViewsCount() : 0;
1648 QVector<SUIT_ViewWindow*> aViews = vm->getViews();
1649 for(int i = 0; i < nbSf; i++){
1650 SUIT_ViewWindow *sf = aViews[i];
1651 if(SMESH_Actor* anActor = SMESH::FindActorByEntry(sf,anEntry.c_str())){
1652 SMESH::RemoveActor(sf,anActor);
1658 /** Remove an object from data structures **/
1659 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
1660 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
1661 if ( !aGroup->_is_nil() ) { // DELETE GROUP
1662 SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
1663 aMesh->RemoveGroup( aGroup );
1665 else if ( !aSubMesh->_is_nil() ) { // DELETE SUBMESH
1666 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
1667 aMesh->RemoveSubMesh( aSubMesh );
1669 _PTR(SObject) aMeshSO = SMESH::FindSObject(aMesh);
1671 SMESH::ModifiedMesh(aMeshSO, false, aMesh->NbNodes()==0);
1674 Handle(SALOME_InteractiveObject) IObject = new SALOME_InteractiveObject
1675 ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
1676 QString objType = CheckTypeObject(IObject);
1677 if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
1678 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
1679 aStudyBuilder->RemoveObjectWithChildren( SO );
1681 else {// default action: remove SObject from the study
1682 // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
1683 //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
1685 aStudyBuilder->RemoveObjectWithChildren( SO );
1689 } /* listSO back loop */
1691 aStudyBuilder->CommitCommand();
1693 /* Clear any previous selection */
1695 aSel->setSelectedObjects( l1 );
1697 SMESHGUI::GetSMESHGUI()->updateObjBrowser();
1702 SMESHGUI_EXPORT CAM_Module* createModule()
1704 return new SMESHGUI();
1707 SMESHGUI_EXPORT char* getModuleVersion() {
1708 return (char*)SMESH_VERSION_STR;
1712 SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil();
1714 //=============================================================================
1718 //=============================================================================
1719 SMESHGUI::SMESHGUI() :
1720 SalomeApp_Module( "SMESH" ),
1721 LightApp_Module( "SMESH" )
1723 if ( CORBA::is_nil( myComponentSMESH ) )
1725 CORBA::Boolean anIsEmbeddedMode;
1726 myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
1727 MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
1729 // 0019923: EDF 765 SMESH : default values of hypothesis
1730 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
1731 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
1732 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
1733 nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
1734 myComponentSMESH->SetDefaultNbSegments( nbSeg );
1736 const char* options[] = { "historical_python_dump", "forget_mesh_on_hyp_modif" };
1737 for ( size_t i = 0; i < sizeof(options)/sizeof(char*); ++i )
1738 if ( aResourceMgr->hasValue( "SMESH", options[i] ))
1740 QString val = aResourceMgr->stringValue( "SMESH", options[i] );
1741 myComponentSMESH->SetOption( options[i], val.toLatin1().constData() );
1745 myActiveDialogBox = 0;
1746 myFilterLibraryDlg = 0;
1750 myEventCallbackCommand = vtkCallbackCommand::New();
1751 myEventCallbackCommand->Delete();
1752 myEventCallbackCommand->SetClientData( this );
1753 myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
1756 SMESH::GetFilterManager();
1757 SMESH::GetPattern();
1758 SMESH::GetMeasurements();
1760 /* load resources for all available meshers */
1761 SMESH::InitAvailableHypotheses();
1764 //=============================================================================
1768 //=============================================================================
1769 SMESHGUI::~SMESHGUI()
1771 #ifdef WITHGENERICOBJ
1772 SMESH::GetFilterManager()->UnRegister();
1773 SMESH::GetMeasurements()->UnRegister();
1775 SMESH::GetFilterManager() = SMESH::FilterManager::_nil();
1776 SMESH::GetMeasurements() = SMESH::Measurements::_nil();
1779 //=============================================================================
1783 //=============================================================================
1784 LightApp_SelectionMgr* SMESHGUI::selectionMgr()
1786 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1788 return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
1793 //=============================================================================
1797 //=============================================================================
1798 bool SMESHGUI::automaticUpdate(unsigned int requestedSize, bool* limitExceeded)
1800 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
1804 bool autoUpdate = resMgr->booleanValue( "SMESH", "auto_update", false );
1805 long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
1806 bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
1807 if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
1808 return autoUpdate && !exceeded;
1811 //=============================================================================
1815 //=============================================================================
1816 SUIT_ResourceMgr* SMESHGUI::resourceMgr()
1818 return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
1821 //=============================================================================
1825 //=============================================================================
1826 SMESHGUI* SMESHGUI::GetSMESHGUI()
1828 SMESHGUI* smeshMod = 0;
1829 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
1832 CAM_Module* module = app->module( "Mesh" );
1833 smeshMod = dynamic_cast<SMESHGUI*>( module );
1836 if ( smeshMod && smeshMod->application() && smeshMod->application()->activeStudy() )
1838 SalomeApp_Study* study = dynamic_cast<SalomeApp_Study*>( smeshMod->application()->activeStudy() );
1841 _PTR(Study) aStudy = study->studyDS();
1843 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
1852 Standard_EXPORT SMESHGUI* GetComponentGUI()
1854 return SMESHGUI::GetSMESHGUI();
1858 //=============================================================================
1862 //=============================================================================
1863 void SMESHGUI::SetState(int aState)
1868 //=============================================================================
1872 //=============================================================================
1873 void SMESHGUI::ResetState()
1878 //=============================================================================
1882 //=============================================================================
1883 void SMESHGUI::EmitSignalDeactivateDialog()
1885 emit SignalDeactivateActiveDialog();
1888 //=============================================================================
1892 //=============================================================================
1893 void SMESHGUI::EmitSignalStudyFrameChanged()
1895 emit SignalStudyFrameChanged();
1898 //=============================================================================
1902 //=============================================================================
1903 void SMESHGUI::EmitSignalCloseAllDialogs()
1905 emit SignalCloseAllDialogs();
1908 //=============================================================================
1912 //=============================================================================
1913 void SMESHGUI::EmitSignalVisibilityChanged()
1915 emit SignalVisibilityChanged();
1918 //=============================================================================
1922 //=============================================================================
1923 QDialog *SMESHGUI::GetActiveDialogBox()
1925 return myActiveDialogBox;
1928 //=============================================================================
1932 //=============================================================================
1933 void SMESHGUI::SetActiveDialogBox(QDialog * aDlg)
1935 myActiveDialogBox = (QDialog *) aDlg;
1939 //=============================================================================
1943 //=============================================================================
1944 SUIT_Desktop* SMESHGUI::desktop()
1946 SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
1948 return app->desktop();
1953 //=============================================================================
1957 //=============================================================================
1958 SalomeApp_Study* SMESHGUI::activeStudy()
1960 SUIT_Application* app = SUIT_Session::session()->activeApplication();
1962 return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
1967 //=============================================================================
1971 //=============================================================================
1972 void SMESHGUI::Modified( bool theIsUpdateActions )
1974 if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
1975 if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
1976 appStudy->Modified();
1977 if( theIsUpdateActions )
1978 app->updateActions();
1983 //=============================================================================
1987 //=============================================================================
1988 bool SMESHGUI::DefineDlgPosition(QWidget * aDlg, int &x, int &y)
1990 /* Here the position is on the bottom right corner - 10 */
1991 // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
1993 SUIT_Desktop *PP = desktop();
1994 x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
1995 y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
1999 //=============================================================================
2003 //=============================================================================
2004 static int isStudyLocked(_PTR(Study) theStudy){
2005 return theStudy->GetProperties()->IsLocked();
2008 static bool checkLock(_PTR(Study) theStudy) {
2009 if (isStudyLocked(theStudy)) {
2010 SUIT_MessageBox::warning( SMESHGUI::desktop(),
2011 QObject::tr("WRN_WARNING"),
2012 QObject::tr("WRN_STUDY_LOCKED") );
2018 //=======================================================================
2019 //function : CheckActiveStudyLocked
2021 //=======================================================================
2023 bool SMESHGUI::isActiveStudyLocked()
2025 _PTR(Study) aStudy = activeStudy()->studyDS();
2026 return checkLock( aStudy );
2029 //=============================================================================
2033 //=============================================================================
2034 bool SMESHGUI::OnGUIEvent( int theCommandID )
2036 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
2040 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
2041 SUIT_ResourceMgr* mgr = resourceMgr();
2045 if (CORBA::is_nil(GetSMESHGen()->GetCurrentStudy())) {
2046 GetSMESHGen()->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
2049 SUIT_ViewWindow* view = application()->desktop()->activeWindow();
2050 SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
2052 //QAction* act = action( theCommandID );
2054 switch (theCommandID) {
2056 if(checkLock(aStudy)) break;
2067 if(checkLock(aStudy)) break;
2068 ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
2072 case 150: //MED FILE INFORMATION
2074 SALOME_ListIO selected;
2075 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2077 aSel->selectedObjects( selected );
2078 if( selected.Extent() )
2080 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2081 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
2082 if ( !aMesh->_is_nil() )
2084 SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
2091 case 122: // EXPORT MED
2104 ::ExportMeshToFile(theCommandID);
2108 case 200: // SCALAR BAR
2110 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2111 SALOME_ListIO selected;
2113 aSel->selectedObjects( selected );
2115 if( selected.Extent() ) {
2116 Handle(SALOME_InteractiveObject) anIO = selected.First();
2117 if( anIO->hasEntry() ) {
2118 if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
2119 anActor->SetControlMode( SMESH_Actor::eNone );
2120 #ifndef DISABLE_PLOT2DVIEWER
2121 SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
2130 SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
2135 // dump control distribution data to the text file
2136 ::SaveDistribution();
2142 // show/ distribution
2143 ::ShowDistribution();
2147 #ifndef DISABLE_PLOT2DVIEWER
2150 // plot distribution
2151 ::PlotDistribution();
2162 ::DisableAutoColor();
2165 case 1134: // Clipping
2166 case 1133: // Tranparency
2167 case 1132: // Display preferences (colors, shrink size, line width, ...)
2174 ::SetDisplayMode(theCommandID, myMarkerMap);
2177 //2D quadratic representation
2180 ::SetDisplayMode(theCommandID, myMarkerMap);
2184 case 216: // 0D elements
2187 case 219: // Volumes
2188 case 220: // All Entity
2189 ::SetDisplayEntity(theCommandID);
2192 case 221: // Orientation of faces
2194 LightApp_SelectionMgr* mgr = selectionMgr();
2195 SALOME_ListIO selected; mgr->selectedObjects( selected );
2197 SALOME_ListIteratorOfListIO it(selected);
2198 for( ; it.More(); it.Next()) {
2199 Handle(SALOME_InteractiveObject) anIObject = it.Value();
2200 if(anIObject->hasEntry()) {
2201 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2202 anActor->SetFacesOriented( !anActor->GetFacesOriented() );
2211 if(checkLock(aStudy)) break;
2213 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2216 SMESH::UpdateView();
2218 catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
2219 SMESH::OnVisuException();
2221 catch (...) { // PAL16774 (Crash after display of many groups)
2222 SMESH::OnVisuException();
2226 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2227 aSel->selectedObjects( l );
2228 aSel->setSelectedObjects( l );
2233 case 301: // DISPLAY
2234 case 302: // DISPLAY ONLY
2236 SMESH::EDisplaing anAction;
2237 switch (theCommandID) {
2238 case 300: anAction = SMESH::eErase; break;
2239 case 301: anAction = SMESH::eDisplay; break;
2240 case 302: anAction = SMESH::eDisplayOnly; break;
2243 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2244 SALOME_ListIO sel_objects, to_process;
2246 aSel->selectedObjects( sel_objects );
2248 if( theCommandID==302 )
2250 MESSAGE("anAction = SMESH::eDisplayOnly");
2251 startOperation( myEraseAll );
2254 extractContainers( sel_objects, to_process );
2257 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
2261 SALOME_ListIteratorOfListIO It( to_process );
2262 for ( ; It.More(); It.Next()) {
2264 Handle(SALOME_InteractiveObject) IOS = It.Value();
2265 if (IOS->hasEntry()) {
2267 if (!SMESH::UpdateView(anAction, IOS->getEntry())) {
2268 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2269 break; // PAL16774 (Crash after display of many groups)
2271 if (anAction == SMESH::eDisplayOnly)
2273 MESSAGE("anAction = SMESH::eDisplayOnly");
2274 anAction = SMESH::eDisplay;
2280 // PAL13338 + PAL15161 -->
2281 if ( ( theCommandID==301 || theCommandID==302 ) && !checkLock(aStudy)) {
2282 MESSAGE("anAction = SMESH::eDisplayOnly");
2283 SMESH::UpdateView();
2284 SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
2286 // PAL13338 + PAL15161 <--
2288 catch (...) { // PAL16774 (Crash after display of many groups)
2289 SMESH::OnVisuException();
2292 if (anAction == SMESH::eErase) {
2293 MESSAGE("anAction == SMESH::eErase");
2295 aSel->setSelectedObjects( l1 );
2298 aSel->setSelectedObjects( to_process );
2305 if(checkLock(aStudy)) break;
2308 EmitSignalDeactivateDialog();
2310 ( new SMESHGUI_NodesDlg( this ) )->show();
2313 SUIT_MessageBox::warning(desktop(),
2314 tr("SMESH_WRN_WARNING"),
2315 tr("SMESH_WRN_VIEWER_VTK"));
2320 case 2151: // FILTER
2324 EmitSignalDeactivateDialog();
2325 ( new SMESHGUI_FilterDlg( this, SMESH::EDGE ) )->show();
2330 case 701: // COMPUTE MESH
2331 case 711: // PRECOMPUTE MESH
2332 case 712: // EVALUATE MESH
2333 case 713: // MESH ORDER
2335 if (checkLock(aStudy)) break;
2336 startOperation( theCommandID );
2340 case 702: // Create mesh
2341 case 703: // Create sub-mesh
2342 case 704: // Edit mesh/sub-mesh
2343 startOperation( theCommandID );
2345 case 705: // copy mesh
2347 if (checkLock(aStudy)) break;
2348 EmitSignalDeactivateDialog();
2349 ( new SMESHGUI_CopyMeshDlg( this ) )->show();
2352 case 710: // Build compound mesh
2354 if (checkLock(aStudy)) break;
2355 EmitSignalDeactivateDialog();
2356 ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
2360 case 407: // DIAGONAL INVERSION
2361 case 408: // Delete diagonal
2365 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2366 tr( "NOT_A_VTK_VIEWER" ) );
2370 if ( checkLock( aStudy ) )
2373 /*Standard_Boolean aRes;
2374 SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
2375 if ( aMesh->_is_nil() )
2377 SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
2378 tr( "SMESH_BAD_SELECTION" ) );
2382 EmitSignalDeactivateDialog();
2383 if ( theCommandID == 407 )
2384 ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
2386 ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
2389 case 409: // Change orientation
2390 case 410: // Union of triangles
2391 case 411: // Cutting of quadrangles
2392 case 419: // Splitting volumes into tetrahedra
2396 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2397 tr( "NOT_A_VTK_VIEWER" ) );
2401 if ( checkLock( aStudy ) )
2404 EmitSignalDeactivateDialog();
2405 SMESHGUI_MultiEditDlg* aDlg = NULL;
2406 if ( theCommandID == 409 )
2407 aDlg = new SMESHGUI_ChangeOrientationDlg(this);
2408 else if ( theCommandID == 410 )
2409 aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
2410 else if ( theCommandID == 419 )
2411 aDlg = new SMESHGUI_CuttingIntoTetraDlg(this);
2413 aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);
2418 case 412: // Smoothing
2420 if(checkLock(aStudy)) break;
2422 EmitSignalDeactivateDialog();
2423 ( new SMESHGUI_SmoothingDlg( this ) )->show();
2426 SUIT_MessageBox::warning(desktop(),
2427 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2431 case 413: // Extrusion
2433 if (checkLock(aStudy)) break;
2435 EmitSignalDeactivateDialog();
2436 ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
2438 SUIT_MessageBox::warning(desktop(),
2439 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2443 case 414: // Revolution
2445 if(checkLock(aStudy)) break;
2447 EmitSignalDeactivateDialog();
2448 ( new SMESHGUI_RevolutionDlg( this ) )->show();
2451 SUIT_MessageBox::warning(desktop(),
2452 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2456 case 415: // Pattern mapping
2458 if ( checkLock( aStudy ) )
2462 EmitSignalDeactivateDialog();
2463 ( new SMESHGUI_MeshPatternDlg( this ) )->show();
2466 SUIT_MessageBox::warning(desktop(),
2467 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2471 case 416: // Extrusion along a path
2473 if (checkLock(aStudy)) break;
2475 EmitSignalDeactivateDialog();
2476 ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
2478 SUIT_MessageBox::warning(desktop(),
2479 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2483 case 417: // Convert mesh to quadratic
2485 startOperation( 417 );
2486 /* if (checkLock(aStudy)) break;
2488 EmitSignalDeactivateDialog();
2489 new SMESHGUI_ConvToQuadDlg();
2491 SUIT_MessageBox::warning(desktop(),
2492 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2496 case 418: // create 2D mesh from 3D
2498 startOperation( 418 );
2501 case 806: // CREATE GEO GROUP
2503 startOperation( 806 );
2506 case 801: // CREATE GROUP
2510 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2511 tr( "NOT_A_VTK_VIEWER" ) );
2515 if(checkLock(aStudy)) break;
2516 EmitSignalDeactivateDialog();
2517 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();
2519 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2520 SALOME_ListIO selected;
2522 aSel->selectedObjects( selected );
2524 int nbSel = selected.Extent();
2526 // check if mesh is selected
2527 aMesh = SMESH::GetMeshByIO( selected.First() );
2529 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
2534 case 802: // CONSTRUCT GROUP
2538 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2539 tr( "NOT_A_VTK_VIEWER" ) );
2543 if(checkLock(aStudy)) break;
2544 EmitSignalDeactivateDialog();
2546 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2547 SALOME_ListIO selected;
2549 aSel->selectedObjects( selected );
2551 int nbSel = selected.Extent();
2553 // check if submesh is selected
2554 Handle(SALOME_InteractiveObject) IObject = selected.First();
2555 if (IObject->hasEntry()) {
2556 _PTR(SObject) aSObj = aStudy->FindObjectID(IObject->getEntry());
2558 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
2559 if (!aSubMesh->_is_nil()) {
2561 SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
2562 // get submesh elements list by types
2563 SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
2564 SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
2565 SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
2566 SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
2567 // create group for each type o elements
2568 QString aName = IObject->getName();
2569 QStringList anEntryList;
2570 if (aNodes->length() > 0) {
2571 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
2572 aGroup->Add(aNodes.inout());
2573 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2574 anEntryList.append( aSObject->GetID().c_str() );
2576 if (aEdges->length() > 0) {
2577 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
2578 aGroup->Add(aEdges.inout());
2579 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2580 anEntryList.append( aSObject->GetID().c_str() );
2582 if (aFaces->length() > 0) {
2583 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
2584 aGroup->Add(aFaces.inout());
2585 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2586 anEntryList.append( aSObject->GetID().c_str() );
2588 if (aVolumes->length() > 0) {
2589 SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
2590 aGroup->Add(aVolumes.inout());
2591 if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
2592 anEntryList.append( aSObject->GetID().c_str() );
2595 anApp->browseObjects( anEntryList );
2597 catch(const SALOME::SALOME_Exception & S_ex){
2598 SalomeApp_Tools::QtCatchCorbaException(S_ex);
2605 SUIT_MessageBox::warning(desktop(),
2606 tr("SMESH_WRN_WARNING"),
2607 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
2612 case 803: // EDIT GROUP
2616 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2617 tr( "NOT_A_VTK_VIEWER" ) );
2621 if(checkLock(aStudy)) break;
2622 EmitSignalDeactivateDialog();
2624 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2625 SALOME_ListIO selected;
2627 aSel->selectedObjects( selected );
2629 SALOME_ListIteratorOfListIO It (selected);
2630 int nbSelectedGroups = 0;
2631 for ( ; It.More(); It.Next() )
2633 SMESH::SMESH_GroupBase_var aGroup =
2634 SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
2635 if (!aGroup->_is_nil()) {
2637 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
2641 if (nbSelectedGroups == 0)
2643 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
2649 case 804: // Add elements to group
2651 if(checkLock(aStudy)) break;
2652 if (myState == 800) {
2653 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2654 if (aDlg) aDlg->onAdd();
2659 case 805: // Remove elements from group
2661 if(checkLock(aStudy)) break;
2662 if (myState == 800) {
2663 SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
2664 if (aDlg) aDlg->onRemove();
2669 case 815: // Edit GEOM GROUP as standalone
2673 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2674 tr( "NOT_A_VTK_VIEWER" ) );
2678 if(checkLock(aStudy)) break;
2679 EmitSignalDeactivateDialog();
2681 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2682 SALOME_ListIO selected;
2684 aSel->selectedObjects( selected );
2686 SALOME_ListIteratorOfListIO It (selected);
2687 for ( ; It.More(); It.Next() )
2689 SMESH::SMESH_GroupOnGeom_var aGroup =
2690 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
2691 if (!aGroup->_is_nil()) {
2692 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
2697 SMESH::SMESH_GroupOnFilter_var aGroup =
2698 SMESH::IObjectToInterface<SMESH::SMESH_GroupOnFilter>(It.Value());
2699 if (!aGroup->_is_nil()) {
2700 SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
2708 case 810: // Union Groups
2709 case 811: // Intersect groups
2710 case 812: // Cut groups
2714 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2715 tr( "NOT_A_VTK_VIEWER" ) );
2719 if ( checkLock( aStudy ) )
2722 EmitSignalDeactivateDialog();
2724 SMESHGUI_GroupOpDlg* aDlg = 0;
2725 if ( theCommandID == 810 )
2726 aDlg = new SMESHGUI_UnionGroupsDlg( this );
2727 else if ( theCommandID == 811 )
2728 aDlg = new SMESHGUI_IntersectGroupsDlg( this );
2730 aDlg = new SMESHGUI_CutGroupsDlg( this );
2737 case 814: // Create groups of entities from existing groups of superior dimensions
2739 if ( checkLock( aStudy ) )
2742 EmitSignalDeactivateDialog();
2743 SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
2749 case 813: // Delete groups with their contents
2753 SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
2754 tr( "NOT_A_VTK_VIEWER" ) );
2758 if ( checkLock( aStudy ) )
2761 EmitSignalDeactivateDialog();
2763 ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
2767 case 900: // MESH INFOS
2768 case 903: // WHAT IS
2770 int page = theCommandID == 900 ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
2771 EmitSignalDeactivateDialog();
2772 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2773 SALOME_ListIO selected;
2775 aSel->selectedObjects( selected );
2777 if ( selected.Extent() > 1 ) { // a dlg for each IO
2778 SALOME_ListIteratorOfListIO It( selected );
2779 for ( ; It.More(); It.Next() ) {
2780 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
2781 dlg->showInfo( It.Value() );
2786 SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
2792 case 904: // FIND ELEM
2794 startOperation( theCommandID );
2798 case 1100: // EDIT HYPOTHESIS
2800 if(checkLock(aStudy)) break;
2802 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2803 SALOME_ListIO selected;
2805 aSel->selectedObjects( selected );
2807 int nbSel = selected.Extent();
2810 Handle(SALOME_InteractiveObject) anIObject = selected.First();
2811 SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);
2813 /* Look for all mesh objects that have this hypothesis affected in order to flag as ModifiedMesh */
2814 /* At end below '...->updateObjBrowser(true)' will change icon of mesh objects */
2815 /* Warning : however by internal mechanism all subMeshes icons are changed ! */
2816 if ( !aHypothesis->_is_nil() )
2819 //SMESHGUI_GenericHypothesisCreator* aCreator = SMESH::GetHypothesisCreator(aHypothesis->GetName());
2820 SMESHGUI_GenericHypothesisCreator* aCreator = SMESH::GetHypothesisCreator(aHypothesis->GetName());
2822 aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
2832 case 1102: // REMOVE HYPOTHESIS / ALGORITHMS
2834 if(checkLock(aStudy)) break;
2835 SUIT_OverrideCursor wc;
2837 LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
2838 SALOME_ListIO selected;
2840 aSel->selectedObjects( selected, QString::null, false );
2842 SALOME_ListIteratorOfListIO It(selected);
2843 for (int i = 0; It.More(); It.Next(), i++) {
2844 Handle(SALOME_InteractiveObject) IObject = It.Value();
2845 SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
2848 aSel->setSelectedObjects( l1 );
2853 case 4009: // ELEM0D
2855 case 4021: // TRIANGLE
2857 case 4023: // POLYGON
2861 case 4134: // PYRAMID
2862 case 4135: // OCTA12
2864 if(checkLock(aStudy)) break;
2866 EmitSignalDeactivateDialog();
2867 SMDSAbs_EntityType type = SMDSEntity_Edge;
2868 switch (theCommandID) {
2870 type = SMDSEntity_0D; break;
2872 type = SMDSEntity_Triangle; break;
2874 type = SMDSEntity_Quadrangle; break;
2876 type = SMDSEntity_Tetra; break;
2878 type = SMDSEntity_Polygon; break;
2880 type = SMDSEntity_Hexa; break;
2882 type = SMDSEntity_Penta; break;
2884 type = SMDSEntity_Pyramid; break;
2886 type = SMDSEntity_Hexagonal_Prism; break;
2889 ( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
2892 SUIT_MessageBox::warning(desktop(),
2893 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2897 case 4033: // POLYHEDRON
2899 if(checkLock(aStudy)) break;
2901 EmitSignalDeactivateDialog();
2902 ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
2905 SUIT_MessageBox::warning(SMESHGUI::desktop(),
2906 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2910 case 4034: // QUADRATIC EDGE
2911 case 4035: // QUADRATIC TRIANGLE
2912 case 4036: // QUADRATIC QUADRANGLE
2913 case 4136: // BIQUADRATIC QUADRANGLE
2914 case 4037: // QUADRATIC TETRAHEDRON
2915 case 4038: // QUADRATIC PYRAMID
2916 case 4039: // QUADRATIC PENTAHEDRON
2917 case 4040: // QUADRATIC HEXAHEDRON
2918 case 4140: // TRIQUADRATIC HEXAHEDRON
2920 if(checkLock(aStudy)) break;
2922 EmitSignalDeactivateDialog();
2923 SMDSAbs_EntityType type;
2925 switch (theCommandID) {
2927 type = SMDSEntity_Quad_Edge; break;
2929 type = SMDSEntity_Quad_Triangle; break;
2931 type = SMDSEntity_Quad_Quadrangle; break;
2933 type = SMDSEntity_BiQuad_Quadrangle; break;
2935 type = SMDSEntity_Quad_Tetra; break;
2937 type = SMDSEntity_Quad_Pyramid; break;
2939 type = SMDSEntity_Quad_Penta; break;
2941 type = SMDSEntity_Quad_Hexa;
2943 type = SMDSEntity_TriQuad_Hexa;
2947 ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
2950 SUIT_MessageBox::warning(SMESHGUI::desktop(),
2951 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2955 case 4041: // REMOVES NODES
2957 if(checkLock(aStudy)) break;
2959 EmitSignalDeactivateDialog();
2960 ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
2963 SUIT_MessageBox::warning(SMESHGUI::desktop(),
2964 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2968 case 4042: // REMOVES ELEMENTS
2970 if(checkLock(aStudy)) break;
2972 EmitSignalDeactivateDialog();
2973 ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
2977 SUIT_MessageBox::warning(SMESHGUI::desktop(),
2978 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
2982 case 4043: { // CLEAR_MESH
2984 if(checkLock(aStudy)) break;
2986 SALOME_ListIO selected;
2987 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
2988 aSel->selectedObjects( selected );
2990 SUIT_OverrideCursor wc;
2991 SALOME_ListIteratorOfListIO It (selected);
2992 for ( ; It.More(); It.Next() )
2994 Handle(SALOME_InteractiveObject) IOS = It.Value();
2995 SMESH::SMESH_Mesh_var aMesh =
2996 SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
2997 if ( aMesh->_is_nil()) continue;
2999 SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
3001 _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
3002 SMESH::ModifiedMesh( aMeshSObj, false, true);
3003 // hide groups and submeshes
3004 _PTR(ChildIterator) anIter =
3005 SMESH::GetActiveStudyDocument()->NewChildIterator( aMeshSObj );
3006 for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
3008 _PTR(SObject) so = anIter->Value();
3009 SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
3012 catch (const SALOME::SALOME_Exception& S_ex){
3014 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3018 SMESH::UpdateView();
3022 case 4044: // REMOVE ORPHAN NODES
3024 if(checkLock(aStudy)) break;
3025 SALOME_ListIO selected;
3026 if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
3027 aSel->selectedObjects( selected );
3028 if ( selected.Extent() == 1 ) {
3029 Handle(SALOME_InteractiveObject) anIO = selected.First();
3030 SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
3031 if ( !aMesh->_is_nil() ) {
3032 bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
3033 tr( "SMESH_WARNING" ),
3034 tr( "REMOVE_ORPHAN_NODES_QUESTION"),
3035 SUIT_MessageBox::Yes |
3036 SUIT_MessageBox::No,
3037 SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
3040 SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
3041 int removed = aMeshEditor->RemoveOrphanNodes();
3042 SUIT_MessageBox::information(SMESHGUI::desktop(),
3043 tr("SMESH_INFORMATION"),
3044 tr("NB_NODES_REMOVED").arg(removed));
3045 if ( removed > 0 ) {
3046 SMESH::UpdateView();
3047 SMESHGUI::Modified();
3050 catch (const SALOME::SALOME_Exception& S_ex) {
3051 SalomeApp_Tools::QtCatchCorbaException(S_ex);
3060 case 4051: // RENUMBERING NODES
3062 if(checkLock(aStudy)) break;
3064 EmitSignalDeactivateDialog();
3065 ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
3069 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3070 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3074 case 4052: // RENUMBERING ELEMENTS
3076 if(checkLock(aStudy)) break;
3078 EmitSignalDeactivateDialog();
3079 ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
3083 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3084 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3088 case 4061: // TRANSLATION
3090 if(checkLock(aStudy)) break;
3092 EmitSignalDeactivateDialog();
3093 ( new SMESHGUI_TranslationDlg( this ) )->show();
3096 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3097 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3101 case 4062: // ROTATION
3103 if(checkLock(aStudy)) break;
3105 EmitSignalDeactivateDialog();
3106 ( new SMESHGUI_RotationDlg( this ) )->show();
3109 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3110 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3114 case 4063: // SYMMETRY
3116 if(checkLock(aStudy)) break;
3118 EmitSignalDeactivateDialog();
3119 ( new SMESHGUI_SymmetryDlg( this ) )->show();
3122 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3123 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3127 case 4064: // SEWING
3129 if(checkLock(aStudy)) break;
3131 EmitSignalDeactivateDialog();
3132 ( new SMESHGUI_SewingDlg( this ) )->show();
3135 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3136 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3140 case 4065: // MERGE NODES
3142 if(checkLock(aStudy)) break;
3144 EmitSignalDeactivateDialog();
3145 ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
3148 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3149 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3153 case 4066: // MERGE EQUAL ELEMENTS
3155 if (checkLock(aStudy)) break;
3157 EmitSignalDeactivateDialog();
3158 ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
3160 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3161 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3166 case 4067: // MAKE MESH PASS THROUGH POINT
3167 startOperation( 4067 );
3172 if(checkLock(aStudy)) break;
3174 EmitSignalDeactivateDialog();
3175 ( new SMESHGUI_ScaleDlg( this ) )->show();
3178 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3179 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3184 case 4069: // DUPLICATE NODES
3186 if(checkLock(aStudy)) break;
3188 EmitSignalDeactivateDialog();
3189 ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
3192 SUIT_MessageBox::warning(SMESHGUI::desktop(),
3193 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
3198 case 5105: // Library of selection filters
3200 static QList<int> aTypes;
3201 if ( aTypes.isEmpty() )
3203 aTypes.append( SMESH::NODE );
3204 aTypes.append( SMESH::EDGE );
3205 aTypes.append( SMESH::FACE );
3206 aTypes.append( SMESH::VOLUME );
3208 if (!myFilterLibraryDlg)
3209 myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3210 else if (myFilterLibraryDlg->isHidden())
3211 myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
3212 myFilterLibraryDlg->raise();
3216 case 6017: // CONTROLS
3244 LightApp_SelectionMgr* mgr = selectionMgr();
3245 SALOME_ListIO selected; mgr->selectedObjects( selected );
3247 if ( selected.Extent() == 1 && selected.First()->hasEntry() ) {
3248 _PTR(SObject) SO = aStudy->FindObjectID( selected.First()->getEntry() );
3250 CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
3251 SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_narrow( aObject );
3252 SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( aObject );
3253 SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( aObject );
3254 if ( !aMesh->_is_nil() || !aSubMesh->_is_nil() || !aGroup->_is_nil() ) {
3255 ::Control( theCommandID );
3260 SUIT_MessageBox::warning(desktop(),
3261 tr( "SMESH_WRN_WARNING" ),
3262 tr( "SMESH_BAD_SELECTION" ) );
3266 SUIT_MessageBox::warning(desktop(),
3267 tr( "SMESH_WRN_WARNING" ),
3268 tr( "NOT_A_VTK_VIEWER" ) );
3273 LightApp_SelectionMgr* mgr = selectionMgr();
3274 SALOME_ListIO selected; mgr->selectedObjects( selected );
3276 SALOME_ListIteratorOfListIO it(selected);
3277 for( ; it.More(); it.Next()) {
3278 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3279 if(anIObject->hasEntry()) {
3280 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3281 anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
3289 LightApp_SelectionMgr* mgr = selectionMgr();
3290 SALOME_ListIO selected; mgr->selectedObjects( selected );
3292 SALOME_ListIteratorOfListIO it(selected);
3293 for( ; it.More(); it.Next()) {
3294 Handle(SALOME_InteractiveObject) anIObject = it.Value();
3295 if(anIObject->hasEntry())
3296 if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
3297 anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
3305 int page = theCommandID == 501 ? SMESHGUI_MeasureDlg::MinDistance : SMESHGUI_MeasureDlg::BoundingBox;
3306 EmitSignalDeactivateDialog();
3307 SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
3313 anApp->updateActions(); //SRN: To update a Save button in the toolbar
3314 //updateObjBrowser();
3318 //=============================================================================
3322 //=============================================================================
3323 bool SMESHGUI::OnMousePress( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3328 //=============================================================================
3332 //=============================================================================
3333 bool SMESHGUI::OnMouseMove( QMouseEvent * pe, SUIT_ViewWindow * wnd )
3338 //=============================================================================
3342 //=============================================================================
3343 bool SMESHGUI::OnKeyPress( QKeyEvent * pe, SUIT_ViewWindow * wnd )
3348 //=============================================================================
3349 /*! Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO)
3350 * Purpose: ensures that the actor for the given <theIO> exists in the active VTK view
3352 //=============================================================================
3353 void SMESHGUI::BuildPresentation( const Handle(SALOME_InteractiveObject) & theIO,
3354 SUIT_ViewWindow* wnd )
3356 if(theIO->hasEntry()){
3357 //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
3358 SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
3362 //=======================================================================
3363 // function : createSMESHAction
3365 //=======================================================================
3366 void SMESHGUI::createSMESHAction( const int id, const QString& po_id, const QString& icon_id,
3367 const int key, const bool toggle, const QString& shortcutAction )
3370 QWidget* parent = application()->desktop();
3371 SUIT_ResourceMgr* resMgr = resourceMgr();
3373 if ( !icon_id.isEmpty() )
3374 pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
3376 pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
3377 if ( !pix.isNull() )
3378 icon = QIcon( pix );
3380 QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
3381 menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
3382 status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
3384 createAction( id, tooltip, icon, menu, status_bar, key, parent,
3385 toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
3388 //=======================================================================
3389 // function : createPopupItem
3391 //=======================================================================
3392 void SMESHGUI::createPopupItem( const int id,
3393 const QString& clients,
3394 const QString& types,
3395 const QString& theRule,
3400 parentId = popupMgr()->actionId( action( pId ) );
3402 if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
3403 popupMgr()->insert( action( id ), parentId, 0 );
3405 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3406 QString dc = "selcount"; // VSR : insetad of QtxPopupSelection::defSelCountParam()
3407 QString rule = "(%1) and (%2) and (%3)";
3408 rule = rule.arg( QString( "%1>0" ).arg( dc ) );
3409 if( clients.isEmpty() )
3410 rule = rule.arg( QString( "true" ) );
3412 rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
3413 rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
3416 bool cont = myRules.contains( id );
3418 rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );
3420 popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
3421 myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
3424 //=======================================================================
3425 // function : initialize
3427 //=======================================================================
3428 void SMESHGUI::initialize( CAM_Application* app )
3430 SalomeApp_Module::initialize( app );
3432 // SUIT_ResourceMgr* mgr = app->resourceMgr();
3434 /* Automatic Update flag */
3435 // myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );
3437 // ----- create actions --------------
3439 createSMESHAction( 111, "DAT", "", (Qt::CTRL+Qt::Key_B) );
3440 createSMESHAction( 112, "UNV", "", (Qt::CTRL+Qt::Key_U) );
3441 createSMESHAction( 113, "MED", "", (Qt::CTRL+Qt::Key_M) );
3442 createSMESHAction( 114, "NUM" );
3443 createSMESHAction( 115, "STL" );
3444 createSMESHAction( 116, "CGNS" );
3445 createSMESHAction( 117, "SAUV" );
3446 createSMESHAction( 121, "DAT" );
3447 createSMESHAction( 122, "MED" );
3448 createSMESHAction( 123, "UNV" );
3449 createSMESHAction( 140, "STL" );
3450 createSMESHAction( 142, "CGNS" );
3451 createSMESHAction( 144, "SAUV" );
3452 createSMESHAction( 124, "EXPORT_DAT" );
3453 createSMESHAction( 125, "EXPORT_MED" );
3454 createSMESHAction( 126, "EXPORT_UNV" );
3455 createSMESHAction( 141, "EXPORT_STL" );
3456 createSMESHAction( 143, "EXPORT_CGNS" );
3457 createSMESHAction( 145, "EXPORT_SAUV" );
3458 createSMESHAction( 150, "FILE_INFO" );
3459 createSMESHAction( 33, "DELETE", "ICON_DELETE", Qt::Key_Delete );
3460 createSMESHAction( 5105, "SEL_FILTER_LIB" );
3461 createSMESHAction( 701, "COMPUTE", "ICON_COMPUTE" );
3462 createSMESHAction( 702, "CREATE_MESH", "ICON_DLG_INIT_MESH" );
3463 createSMESHAction( 703, "CREATE_SUBMESH", "ICON_DLG_ADD_SUBMESH" );
3464 createSMESHAction( 704, "EDIT_MESHSUBMESH","ICON_DLG_EDIT_MESH" );
3465 createSMESHAction( 705, "COPY_MESH", "ICON_COPY_MESH" );
3466 createSMESHAction( 710, "BUILD_COMPOUND", "ICON_BUILD_COMPOUND" );
3467 createSMESHAction( 711, "PRECOMPUTE", "ICON_PRECOMPUTE" );
3468 createSMESHAction( 712, "EVALUATE", "ICON_COMPUTE" );
3469 createSMESHAction( 713, "MESH_ORDER", "ICON_COMPUTE" );
3470 createSMESHAction( 806, "CREATE_GEO_GROUP","ICON_CREATE_GEO_GROUP" );
3471 createSMESHAction( 801, "CREATE_GROUP", "ICON_CREATE_GROUP" );
3472 createSMESHAction( 802, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
3473 createSMESHAction( 803, "EDIT_GROUP", "ICON_EDIT_GROUP" );
3474 createSMESHAction( 815, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
3475 createSMESHAction( 804, "ADD" );
3476 createSMESHAction( 805, "REMOVE" );
3477 createSMESHAction( 810, "UN_GROUP", "ICON_UNION" );
3478 createSMESHAction( 811, "INT_GROUP", "ICON_INTERSECT" );
3479 createSMESHAction( 812, "CUT_GROUP", "ICON_CUT" );
3480 createSMESHAction( 814, "UNDERLYING_ELEMS","ICON_UNDERLYING_ELEMS" );
3481 createSMESHAction( 813, "DEL_GROUP", "ICON_DEL_GROUP" );
3482 createSMESHAction( 900, "ADV_INFO", "ICON_ADV_INFO" );
3483 //createSMESHAction( 902, "STD_INFO", "ICON_STD_INFO" );
3484 //createSMESHAction( 903, "WHAT_IS", "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3485 createSMESHAction( 904, "FIND_ELEM", "ICON_FIND_ELEM" );
3486 createSMESHAction( 6001, "LENGTH", "ICON_LENGTH", 0, true );
3487 createSMESHAction( 6002, "FREE_EDGE", "ICON_FREE_EDGE", 0, true );
3488 createSMESHAction( 6021, "FREE_FACES", "ICON_FREE_FACES", 0, true );
3489 createSMESHAction( 6022, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
3490 createSMESHAction( 6023, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
3491 createSMESHAction( 6024, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
3492 createSMESHAction( 6025, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
3493 createSMESHAction( 6026, "OVER_CONSTRAINED_VOLUME","ICON_OVER_CONSTRAINED_VOLUME", 0, true );
3494 createSMESHAction( 6027, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
3495 createSMESHAction( 6028, "EQUAL_NODE", "ICON_EQUAL_NODE", 0, true );
3496 createSMESHAction( 6029, "EQUAL_EDGE", "ICON_EQUAL_EDGE", 0, true );
3497 createSMESHAction( 6030, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
3498 createSMESHAction( 6031, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
3499 createSMESHAction( 6003, "FREE_BORDER", "ICON_FREE_EDGE_2D", 0, true );
3500 createSMESHAction( 6004, "CONNECTION", "ICON_CONNECTION", 0, true );
3501 createSMESHAction( 6005, "FREE_NODE", "ICON_FREE_NODE", 0, true );
3502 createSMESHAction( 6011, "AREA", "ICON_AREA", 0, true );
3503 createSMESHAction( 6012, "TAPER", "ICON_TAPER", 0, true );
3504 createSMESHAction( 6013, "ASPECT", "ICON_ASPECT", 0, true );
3505 createSMESHAction( 6014, "MIN_ANG", "ICON_ANGLE", 0, true );
3506 createSMESHAction( 6015, "WARP", "ICON_WARP", 0, true );
3507 createSMESHAction( 6016, "SKEW", "ICON_SKEW", 0, true );
3508 createSMESHAction( 6017, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
3509 createSMESHAction( 6018, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
3510 createSMESHAction( 6019, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
3511 createSMESHAction( 6009, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
3512 createSMESHAction( 4000, "NODE", "ICON_DLG_NODE" );
3513 createSMESHAction( 4009, "ELEM0D", "ICON_DLG_ELEM0D" );
3514 createSMESHAction( 4010, "EDGE", "ICON_DLG_EDGE" );
3515 createSMESHAction( 4021, "TRIANGLE", "ICON_DLG_TRIANGLE" );
3516 createSMESHAction( 4022, "QUAD", "ICON_DLG_QUADRANGLE" );
3517 createSMESHAction( 4023, "POLYGON", "ICON_DLG_POLYGON" );
3518 createSMESHAction( 4031, "TETRA", "ICON_DLG_TETRAS" );
3519 createSMESHAction( 4032, "HEXA", "ICON_DLG_HEXAS" );
3520 createSMESHAction( 4133, "PENTA", "ICON_DLG_PENTA" );
3521 createSMESHAction( 4134, "PYRAMID", "ICON_DLG_PYRAMID" );
3522 createSMESHAction( 4135, "OCTA", "ICON_DLG_OCTA" );
3523 createSMESHAction( 4033, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
3524 createSMESHAction( 4034, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
3525 createSMESHAction( 4035, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
3526 createSMESHAction( 4036, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
3527 createSMESHAction( 4136, "BIQUADRATIC_QUADRANGLE", "ICON_DLG_BIQUADRATIC_QUADRANGLE" );
3528 createSMESHAction( 4037, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
3529 createSMESHAction( 4038, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
3530 createSMESHAction( 4039, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
3531 createSMESHAction( 4040, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );
3532 createSMESHAction( 4140, "TRIQUADRATIC_HEXAHEDRON", "ICON_DLG_TRIQUADRATIC_HEXAHEDRON" );
3533 createSMESHAction( 4041, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
3534 createSMESHAction( 4042, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
3535 createSMESHAction( 4044, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
3536 createSMESHAction( 4043, "CLEAR_MESH" , "ICON_CLEAR_MESH" );
3537 createSMESHAction( 4051, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
3538 createSMESHAction( 4052, "RENUM_ELEMENTS", "ICON_DLG_RENUMBERING_ELEMENTS" );
3539 createSMESHAction( 4061, "TRANS", "ICON_SMESH_TRANSLATION_VECTOR" );
3540 createSMESHAction( 4062, "ROT", "ICON_DLG_MESH_ROTATION" );
3541 createSMESHAction( 4063, "SYM", "ICON_SMESH_SYMMETRY_PLANE" );
3542 createSMESHAction( 4064, "SEW", "ICON_SMESH_SEWING_FREEBORDERS" );
3543 createSMESHAction( 4065, "MERGE", "ICON_SMESH_MERGE_NODES" );
3544 createSMESHAction( 4066, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
3545 createSMESHAction( 4067, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
3546 createSMESHAction( 4068, "SCALE", "ICON_DLG_MESH_SCALE" );
3547 createSMESHAction( 4069, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
3548 createSMESHAction( 407, "INV", "ICON_DLG_MESH_DIAGONAL" );
3549 createSMESHAction( 408, "UNION2", "ICON_UNION2TRI" );
3550 createSMESHAction( 409, "ORIENT", "ICON_DLG_MESH_ORIENTATION" );
3551 createSMESHAction( 410, "UNION", "ICON_UNIONTRI" );
3552 createSMESHAction( 411, "CUT", "ICON_CUTQUAD" );
3553 createSMESHAction( 412, "SMOOTH", "ICON_DLG_SMOOTHING" );
3554 createSMESHAction( 413, "EXTRUSION", "ICON_EXTRUSION" );
3555 createSMESHAction( 414, "REVOLUTION", "ICON_REVOLUTION" );
3556 createSMESHAction( 415, "MAP", "ICON_MAP" );
3557 createSMESHAction( 416, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
3558 createSMESHAction( 417, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
3559 createSMESHAction( 418, "2D_FROM_3D", "ICON_2D_FROM_3D" );
3560 createSMESHAction( 419, "SPLIT_TO_TETRA", "ICON_SPLIT_TO_TETRA" );
3561 createSMESHAction( 200, "RESET" );
3562 createSMESHAction( 201, "SCALAR_BAR_PROP" );
3563 createSMESHAction( 2021, "SAVE_DISTRIBUTION" );
3564 createSMESHAction( 2022, "SHOW_DISTRIBUTION","",0, true );
3565 #ifndef DISABLE_PLOT2DVIEWER
3566 createSMESHAction( 2023, "PLOT_DISTRIBUTION" );
3568 createSMESHAction( 211, "WIRE", "ICON_WIRE", 0, true );
3569 createSMESHAction( 212, "SHADE", "ICON_SHADE", 0, true );
3570 createSMESHAction( 213, "SHRINK", "ICON_SHRINK", 0, true );
3571 createSMESHAction( 214, "UPDATE", "ICON_UPDATE" );
3572 createSMESHAction( 215, "NODES", "ICON_POINTS", 0, true );
3573 createSMESHAction( 216, "ELEMS0D", "ICON_DLG_ELEM0D", 0, true );
3574 createSMESHAction( 217, "EDGES", "ICON_DLG_EDGE", 0, true );
3575 createSMESHAction( 218, "FACES", "ICON_DLG_TRIANGLE", 0, true );
3576 createSMESHAction( 219, "VOLUMES", "ICON_DLG_TETRAS", 0, true );
3577 createSMESHAction( 220, "ALL" );
3578 createSMESHAction( 221, "FACE_ORIENTATION", "", 0, true );
3580 createSMESHAction( 231, "LINE_REPRESENTATION", "", 0, true );
3581 createSMESHAction( 232, "ARC_REPRESENTATION", "", 0, true );
3583 createSMESHAction( 1100, "EDIT_HYPO" );
3584 createSMESHAction( 1102, "UNASSIGN" );
3585 createSMESHAction( 9010, "NUM_NODES", "", 0, true );
3586 createSMESHAction( 9011, "NUM_ELEMENTS", "", 0, true );
3587 createSMESHAction( 1131, "DISPMODE" );
3588 createSMESHAction( 1132, "COLORS" );
3589 createSMESHAction( 1133, "TRANSP" );
3590 createSMESHAction( 1134, "CLIP" );
3591 createSMESHAction( 1135, "DISP_ENT" );
3592 createSMESHAction( 1136, "AUTO_COLOR" );
3593 createSMESHAction( 1137, "DISABLE_AUTO_COLOR" );
3594 createSMESHAction( 2000, "CTRL" );
3596 createSMESHAction( 501, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
3597 createSMESHAction( 502, "MEASURE_BND_BOX", "ICON_MEASURE_BND_BOX" );
3599 createSMESHAction( 300, "ERASE" );
3600 createSMESHAction( 301, "DISPLAY" );
3601 createSMESHAction( 302, "DISPLAY_ONLY" );
3603 // ----- create menu --------------
3604 int fileId = createMenu( tr( "MEN_FILE" ), -1, 1 ),
3605 editId = createMenu( tr( "MEN_EDIT" ), -1, 3 ),
3606 toolsId = createMenu( tr( "MEN_TOOLS" ), -1, 5, 50 ),
3607 meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
3608 ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
3609 modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
3610 measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
3611 viewId = createMenu( tr( "MEN_VIEW" ), -1, 2 );
3613 createMenu( separator(), fileId );
3615 int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
3616 exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
3617 nodeId = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10 ),
3618 edgeId = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10 ),
3619 faceId = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10 ),
3620 volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10 ),
3621 addId = createMenu( tr( "MEN_ADD" ), modifyId, 402 ),
3622 removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
3623 renumId = createMenu( tr( "MEN_RENUM" ), modifyId, 404 ),
3624 transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 );
3626 createMenu( 111, importId, -1 );
3627 createMenu( 112, importId, -1 );
3628 createMenu( 113, importId, -1 );
3629 createMenu( 115, importId, -1 );
3631 createMenu( 116, importId, -1 );
3633 createMenu( 117, importId, -1 );
3634 createMenu( 121, exportId, -1 );
3635 createMenu( 122, exportId, -1 );
3636 createMenu( 123, exportId, -1 );
3637 createMenu( 140, exportId, -1 ); // export to STL
3639 createMenu( 142, exportId, -1 ); // export to CGNS
3641 createMenu( 144, exportId, -1 ); // export to SAUV
3642 createMenu( separator(), fileId, 10 );
3644 createMenu( 33, editId, -1 );
3646 createMenu( 5105, toolsId, -1 );
3648 createMenu( 702, meshId, -1 ); // "Mesh" menu
3649 createMenu( 703, meshId, -1 );
3650 createMenu( 704, meshId, -1 );
3651 createMenu( 710, meshId, -1 );
3652 createMenu( 705, meshId, -1 );
3653 createMenu( separator(), meshId, -1 );
3654 createMenu( 701, meshId, -1 );
3655 createMenu( 711, meshId, -1 );
3656 createMenu( 712, meshId, -1 );
3657 createMenu( 713, meshId, -1 );
3658 createMenu( separator(), meshId, -1 );
3659 createMenu( 801, meshId, -1 );
3660 createMenu( 806, meshId, -1 );
3661 createMenu( 802, meshId, -1 );
3662 createMenu( 803, meshId, -1 );
3663 createMenu( 815, meshId, -1 );
3664 createMenu( separator(), meshId, -1 );
3665 createMenu( 810, meshId, -1 );
3666 createMenu( 811, meshId, -1 );
3667 createMenu( 812, meshId, -1 );
3668 createMenu( separator(), meshId, -1 );
3669 createMenu( 814, meshId, -1 );
3670 createMenu( separator(), meshId, -1 );
3671 createMenu( 900, meshId, -1 );
3672 //createMenu( 902, meshId, -1 );
3673 //createMenu( 903, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3674 createMenu( 904, meshId, -1 );
3675 createMenu( separator(), meshId, -1 );
3677 createMenu( 6005, nodeId, -1 );
3678 createMenu( 6028, nodeId, -1 );
3679 createMenu( 6002, edgeId, -1 );
3680 createMenu( 6003, edgeId, -1 );
3681 createMenu( 6001, edgeId, -1 );
3682 createMenu( 6004, edgeId, -1 );
3683 createMenu( 6029, edgeId, -1 );
3684 createMenu( 6021, faceId, -1 );
3685 createMenu( 6025, faceId, -1 );
3686 createMenu( 6027, faceId, -1 );
3687 createMenu( 6018, faceId, -1 );
3688 createMenu( 6019, faceId, -1 );
3689 createMenu( 6011, faceId, -1 );
3690 createMenu( 6012, faceId, -1 );
3691 createMenu( 6013, faceId, -1 );
3692 createMenu( 6014, faceId, -1 );
3693 createMenu( 6015, faceId, -1 );
3694 createMenu( 6016, faceId, -1 );
3695 createMenu( 6022, faceId, -1 );
3696 createMenu( 6030, faceId, -1 );
3697 createMenu( 6017, volumeId, -1 );
3698 createMenu( 6009, volumeId, -1 );
3699 createMenu( 6023, volumeId, -1 );
3700 createMenu( 6024, volumeId, -1 );
3701 createMenu( 6026, volumeId, -1 );
3702 createMenu( 6031, volumeId, -1 );
3704 createMenu( 4000, addId, -1 );
3705 createMenu( 4009, addId, -1 );
3706 createMenu( 4010, addId, -1 );
3707 createMenu( 4021, addId, -1 );
3708 createMenu( 4022, addId, -1 );
3709 createMenu( 4023, addId, -1 );
3710 createMenu( 4031, addId, -1 );
3711 createMenu( 4032, addId, -1 );
3712 createMenu( 4133, addId, -1 );
3713 createMenu( 4134, addId, -1 );
3714 createMenu( 4135, addId, -1 );
3715 createMenu( 4033, addId, -1 );
3716 createMenu( separator(), addId, -1 );
3717 createMenu( 4034, addId, -1 );
3718 createMenu( 4035, addId, -1 );
3719 createMenu( 4036, addId, -1 );
3720 createMenu( 4136, addId, -1 );
3721 createMenu( 4037, addId, -1 );
3722 createMenu( 4038, addId, -1 );
3723 createMenu( 4039, addId, -1 );
3724 createMenu( 4040, addId, -1 );
3725 createMenu( 4140, addId, -1 );
3727 createMenu( 4041, removeId, -1 );
3728 createMenu( 4042, removeId, -1 );
3729 createMenu( 4044, removeId, -1 );
3730 createMenu( separator(), removeId, -1 );
3731 createMenu( 813, removeId, -1 );
3732 createMenu( separator(), removeId, -1 );
3733 createMenu( 4043, removeId, -1 );
3735 createMenu( 4051, renumId, -1 );
3736 createMenu( 4052, renumId, -1 );
3738 createMenu( 4061, transfId, -1 );
3739 createMenu( 4062, transfId, -1 );
3740 createMenu( 4063, transfId, -1 );
3741 createMenu( 4068, transfId, -1 );
3742 createMenu( 4064, transfId, -1 );
3743 createMenu( 4065, transfId, -1 );
3744 createMenu( 4066, transfId, -1 );
3745 createMenu( 4069, transfId, -1 );
3747 createMenu( 4067,modifyId, -1 );
3748 createMenu( 407, modifyId, -1 );
3749 createMenu( 408, modifyId, -1 );
3750 createMenu( 409, modifyId, -1 );
3751 createMenu( 410, modifyId, -1 );
3752 createMenu( 411, modifyId, -1 );
3753 createMenu( 419, modifyId, -1 );
3754 createMenu( 412, modifyId, -1 );
3755 createMenu( 413, modifyId, -1 );
3756 createMenu( 416, modifyId, -1 );
3757 createMenu( 414, modifyId, -1 );
3758 createMenu( 415, modifyId, -1 );
3759 createMenu( 417, modifyId, -1 );
3760 createMenu( 418, modifyId, -1 );
3762 createMenu( 501, measureId, -1 );
3763 createMenu( 502, measureId, -1 );
3764 createMenu( 214, viewId, -1 );
3766 // ----- create toolbars --------------
3767 int meshTb = createTool( tr( "TB_MESH" ) ),
3768 ctrlTb = createTool( tr( "TB_CTRL" ) ),
3769 addRemTb = createTool( tr( "TB_ADD_REMOVE" ) ),
3770 modifyTb = createTool( tr( "TB_MODIFY" ) ),
3771 dispModeTb = createTool( tr( "TB_DISP_MODE" ) );
3773 createTool( 702, meshTb );
3774 createTool( 703, meshTb );
3775 createTool( 704, meshTb );
3776 createTool( 710, meshTb );
3777 createTool( 705, meshTb );
3778 createTool( separator(), meshTb );
3779 createTool( 701, meshTb );
3780 createTool( 711, meshTb );
3781 createTool( 712, meshTb );
3782 createTool( 713, meshTb );
3783 createTool( separator(), meshTb );
3784 createTool( 801, meshTb );
3785 createTool( 806, meshTb );
3786 createTool( 802, meshTb );
3787 createTool( 803, meshTb );
3788 //createTool( 815, meshTb );
3789 createTool( separator(), meshTb );
3790 createTool( 900, meshTb );
3791 //createTool( 902, meshTb );
3792 //createTool( 903, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
3793 createTool( 904, meshTb );
3794 createTool( separator(), meshTb );
3796 createTool( 6005, ctrlTb );
3797 createTool( 6028, ctrlTb );
3798 createTool( separator(), ctrlTb );
3799 createTool( 6002, ctrlTb );
3800 createTool( 6003, ctrlTb );
3801 createTool( 6001, ctrlTb );
3802 createTool( 6004, ctrlTb );
3803 createTool( 6029, ctrlTb );
3804 createTool( separator(), ctrlTb );
3805 createTool( 6021, ctrlTb );
3806 createTool( 6025, ctrlTb );
3807 createTool( 6027, ctrlTb );
3808 createTool( 6018, ctrlTb );
3809 createTool( 6019, ctrlTb );
3810 createTool( 6011, ctrlTb );
3811 createTool( 6012, ctrlTb );
3812 createTool( 6013, ctrlTb );
3813 createTool( 6014, ctrlTb );
3814 createTool( 6015, ctrlTb );
3815 createTool( 6016, ctrlTb );
3816 createTool( 6022, ctrlTb );
3817 createTool( 6030, ctrlTb );
3818 createTool( separator(), ctrlTb );
3819 createTool( 6017, ctrlTb );
3820 createTool( 6009, ctrlTb );
3821 createTool( 6023, ctrlTb );
3822 createTool( 6024, ctrlTb );
3823 createTool( 6026, ctrlTb );
3824 createTool( 6031, ctrlTb );
3825 createTool( separator(), ctrlTb );
3827 createTool( 4000, addRemTb );
3828 createTool( 4009, addRemTb );
3829 createTool( 4010, addRemTb );
3830 createTool( 4021, addRemTb );
3831 createTool( 4022, addRemTb );
3832 createTool( 4023, addRemTb );
3833 createTool( 4031, addRemTb );
3834 createTool( 4032, addRemTb );
3835 createTool( 4133, addRemTb );
3836 createTool( 4134, addRemTb );
3837 createTool( 4135, addRemTb );
3838 createTool( 4033, addRemTb );
3839 createTool( separator(), addRemTb );
3840 createTool( 4034, addRemTb );
3841 createTool( 4035, addRemTb );
3842 createTool( 4036, addRemTb );
3843 createTool( 4136, addRemTb );
3844 createTool( 4037, addRemTb );
3845 createTool( 4038, addRemTb );
3846 createTool( 4039, addRemTb );
3847 createTool( 4040, addRemTb );
3848 createTool( 4140, addRemTb );
3849 createTool( separator(), addRemTb );
3850 createTool( 4041, addRemTb );
3851 createTool( 4042, addRemTb );
3852 createTool( 4044, addRemTb );
3853 createTool( 4043, addRemTb );
3854 createTool( separator(), addRemTb );
3855 createTool( 4051, addRemTb );
3856 createTool( 4052, addRemTb );
3857 createTool( separator(), addRemTb );
3858 createTool( 4061, addRemTb );
3859 createTool( 4062, addRemTb );
3860 createTool( 4063, addRemTb );
3861 createTool( 4068, addRemTb );
3862 createTool( 4064, addRemTb );
3863 createTool( 4065, addRemTb );
3864 createTool( 4066, addRemTb );
3865 createTool( 4069, addRemTb );
3866 createTool( separator(), addRemTb );
3868 createTool( 4067,modifyTb );
3869 createTool( 407, modifyTb );
3870 createTool( 408, modifyTb );
3871 createTool( 409, modifyTb );
3872 createTool( 410, modifyTb );
3873 createTool( 411, modifyTb );
3874 createTool( 419, modifyTb );
3875 createTool( 412, modifyTb );
3876 createTool( 413, modifyTb );
3877 createTool( 416, modifyTb );
3878 createTool( 414, modifyTb );
3879 createTool( 415, modifyTb );
3880 createTool( 417, modifyTb );
3881 createTool( 418, modifyTb );
3883 createTool( 214, dispModeTb );
3885 QString lc = "$"; // VSR : instead of QtxPopupSelection::defEquality();
3886 QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()
3889 QString OB = "'ObjectBrowser'",
3890 View = "'" + SVTK_Viewer::Type() + "'",
3892 mesh = pat.arg( SMESHGUI_Selection::typeName( MESH ) ),
3893 group = pat.arg( SMESHGUI_Selection::typeName( GROUP ) ),
3894 hypo = pat.arg( SMESHGUI_Selection::typeName( HYPOTHESIS ) ),
3895 algo = pat.arg( SMESHGUI_Selection::typeName( ALGORITHM ) ),
3896 elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
3897 arg( SMESHGUI_Selection::typeName( SUBMESH_VERTEX ) ).
3898 arg( SMESHGUI_Selection::typeName( SUBMESH_EDGE ) ).
3899 arg( SMESHGUI_Selection::typeName( SUBMESH_FACE ) ).
3900 arg( SMESHGUI_Selection::typeName( SUBMESH_SOLID ) ).
3901 arg( SMESHGUI_Selection::typeName( SUBMESH_COMPOUND ) ).
3902 arg( SMESHGUI_Selection::typeName( SUBMESH ) ),
3904 mesh_part = mesh + " " + subMesh + " " + group,
3905 mesh_group = mesh + " " + group,
3906 hyp_alg = hypo + " " + algo;
3908 // popup for object browser
3910 isInvisible("not( isVisible )"),
3911 isEmpty("numberOfNodes = 0"),
3912 isNotEmpty("numberOfNodes <> 0"),
3914 // has nodes, edges, etc in VISIBLE! actor
3915 hasNodes("(numberOfNodes > 0 )"),//&& isVisible)"),
3916 hasElems("(count( elemTypes ) > 0)"),
3917 hasDifferentElems("(count( elemTypes ) > 1)"),
3918 hasElems0d("({'Elem0d'} in elemTypes)"),
3919 hasEdges("({'Edge'} in elemTypes)"),
3920 hasFaces("({'Face'} in elemTypes)"),
3921 hasVolumes("({'Volume'} in elemTypes)");
3923 createPopupItem( 150, OB, mesh, "&& selcount=1 && isImported" ); // FILE INFORMATION
3924 createPopupItem( 703, OB, mesh, "&& isComputable"); // CREATE_SUBMESH
3925 createPopupItem( 704, OB, mesh, "&& isComputable"); // EDIT_MESHSUBMESH
3926 createPopupItem( 704, OB, subMesh, "&& isComputable" ); // EDIT_MESHSUBMESH
3927 createPopupItem( 803, OB, group ); // EDIT_GROUP
3928 createPopupItem( 815, OB, group, "&& groupType != 'Group'" ); // EDIT AS STANDALONE
3930 popupMgr()->insert( separator(), -1, 0 );
3931 createPopupItem( 701, OB, mesh, "&& isComputable" ); // COMPUTE
3932 createPopupItem( 711, OB, mesh, "&& isComputable && isPreComputable" ); // PRECOMPUTE
3933 createPopupItem( 712, OB, mesh, "&& isComputable" ); // EVALUATE
3934 createPopupItem( 713, OB, mesh, "&& isComputable" ); // MESH ORDER
3935 createPopupItem( 214, OB, mesh_part ); // UPDATE
3936 createPopupItem( 900, OB, mesh_part ); // ADV_INFO
3937 createPopupItem( 904, OB, mesh_group ); // FIND_ELEM
3938 popupMgr()->insert( separator(), -1, 0 );
3939 createPopupItem( 801, OB, mesh ); // CREATE_GROUP
3940 createPopupItem( 806, OB, mesh ); // CREATE_GEO_GROUP
3941 createPopupItem( 802, OB, subMesh ); // CONSTRUCT_GROUP
3942 popupMgr()->insert( separator(), -1, 0 );
3943 createPopupItem( 1100, OB, hypo); // EDIT HYPOTHESIS
3944 createPopupItem( 1102, OB, hyp_alg ); // REMOVE HYPOTHESIS / ALGORITHMS
3945 popupMgr()->insert( separator(), -1, 0 );
3946 createPopupItem( 4043, OB, mesh ); // CLEAR_MESH
3947 popupMgr()->insert( separator(), -1, 0 );
3948 createPopupItem( 417, OB, mesh + " " + subMesh ); // convert to quadratic
3949 createPopupItem( 418, OB, mesh + " " + group, // create 2D mesh from 3D
3951 popupMgr()->insert( separator(), -1, 0 );
3953 QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
3954 QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );
3955 QString only_one_2D = only_one_non_empty + " && dim>1";
3957 createPopupItem( 125, OB, mesh_group, multiple_non_empty ); // EXPORT_MED
3958 createPopupItem( 126, OB, mesh_group, only_one_non_empty ); // EXPORT_UNV
3959 createPopupItem( 141, OB, mesh_group, only_one_2D ); // EXPORT_STL
3961 createPopupItem( 143, OB, mesh_group, multiple_non_empty ); // EXPORT_CGNS
3963 createPopupItem( 145, OB, mesh_group, multiple_non_empty ); // EXPORT_SAUV
3964 createPopupItem( 33, OB, mesh_part + " " + hyp_alg ); // DELETE
3965 popupMgr()->insert( separator(), -1, 0 );
3968 createPopupItem( 803, View, group ); // EDIT_GROUP
3969 createPopupItem( 804, View, elems ); // ADD
3970 createPopupItem( 805, View, elems ); // REMOVE
3972 popupMgr()->insert( separator(), -1, 0 );
3973 createPopupItem( 214, View, mesh_part ); // UPDATE
3974 createPopupItem( 900, View, mesh_part ); // ADV_INFO
3975 createPopupItem( 904, View, mesh ); // FIND_ELEM
3976 popupMgr()->insert( separator(), -1, 0 );
3978 createPopupItem( 1136, OB + " " + View, mesh, "&& (not isAutoColor)" ); // AUTO_COLOR
3979 createPopupItem( 1137, OB + " " + View, mesh, "&& isAutoColor" ); // DISABLE_AUTO_COLOR
3980 popupMgr()->insert( separator(), -1, 0 );
3983 QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
3984 QString aType = QString( "%1type in {%2}" ).arg( lc );
3985 aType = aType.arg( mesh_part );
3986 QString aMeshInVTK = aClient + "&&" + aType;
3988 aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
3989 QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
3990 QString aSelCount = QString( "%1 > 0" ).arg( dc );
3992 //-------------------------------------------------
3994 //-------------------------------------------------
3995 anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );
3997 popupMgr()->insert( action( 9010 ), anId, -1 );
3998 popupMgr()->setRule( action( 9010 ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
3999 popupMgr()->setRule( action( 9010 ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );
4001 popupMgr()->insert( action( 9011 ), anId, -1 );
4002 popupMgr()->setRule( action( 9011 ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
4003 popupMgr()->setRule( action( 9011 ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );
4005 popupMgr()->insert( separator(), -1, -1 );
4007 //-------------------------------------------------
4009 //-------------------------------------------------
4010 anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );
4012 popupMgr()->insert( action( 211 ), anId, -1 ); // WIRE
4013 popupMgr()->setRule( action( 211 ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
4014 popupMgr()->setRule( action( 211 ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );
4016 popupMgr()->insert( action( 212 ), anId, -1 ); // SHADE
4017 popupMgr()->setRule( action( 212 ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
4018 popupMgr()->setRule( action( 212 ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );
4020 popupMgr()->insert( action( 215 ), anId, -1 ); // POINTS
4021 popupMgr()->setRule( action( 215 ), aMeshInVTK + "&&" + hasNodes, QtxPopupMgr::VisibleRule );
4022 popupMgr()->setRule( action( 215 ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );
4024 popupMgr()->insert( separator(), anId, -1 );
4026 popupMgr()->insert( action( 213 ), anId, -1 ); // SHRINK
4027 popupMgr()->setRule( action( 213 ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
4028 popupMgr()->setRule( action( 213 ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );
4030 //-------------------------------------------------
4032 //-------------------------------------------------
4033 QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;
4035 anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );
4037 popupMgr()->insert( action(216), anId, -1 ); // ELEMS 0D
4038 popupMgr()->setRule(action(216), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
4039 popupMgr()->setRule(action(216), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);
4041 popupMgr()->insert( action( 217 ), anId, -1 ); // EDGES
4042 popupMgr()->setRule( action( 217 ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
4043 popupMgr()->setRule( action( 217 ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );
4045 popupMgr()->insert( action( 218 ), anId, -1 ); // FACES
4046 popupMgr()->setRule( action( 218 ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
4047 popupMgr()->setRule( action( 218 ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );
4049 popupMgr()->insert( action( 219 ), anId, -1 ); // VOLUMES
4050 popupMgr()->setRule( action( 219 ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
4051 popupMgr()->setRule( action( 219 ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );
4053 popupMgr()->insert( separator(), anId, -1 );
4055 popupMgr()->insert( action( 220 ), anId, -1 ); // ALL
4056 popupMgr()->setRule( action( 220 ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );
4059 //-------------------------------------------------
4060 // Representation of the 2D Quadratic elements
4061 //-------------------------------------------------
4062 anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
4063 popupMgr()->insert( action( 231 ), anId, -1 ); // LINE REPRESENTATION
4064 popupMgr()->setRule( action( 231 ), aMeshInVTK + "and isVisible",QtxPopupMgr::VisibleRule );
4065 popupMgr()->setRule( action( 231 ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );
4067 popupMgr()->insert( action( 232 ), anId, -1 ); // ARC REPRESENTATION
4068 popupMgr()->setRule( action( 232 ), aMeshInVTK + "and isVisible", QtxPopupMgr::VisibleRule );
4069 popupMgr()->setRule( action( 232 ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );
4071 //-------------------------------------------------
4072 // Orientation of faces
4073 //-------------------------------------------------
4074 popupMgr()->insert( action( 221 ), -1, -1 );
4075 popupMgr()->setRule( action( 221 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
4076 popupMgr()->setRule( action( 221 ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );
4078 //-------------------------------------------------
4080 //-------------------------------------------------
4081 popupMgr()->insert( action( 1132 ), -1, -1 );
4082 popupMgr()->setRule( action( 1132 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4084 //-------------------------------------------------
4086 //-------------------------------------------------
4087 popupMgr()->insert( action( 1133 ), -1, -1 );
4088 popupMgr()->setRule( action( 1133 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );
4090 //-------------------------------------------------
4092 //-------------------------------------------------
4094 aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
4095 aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
4096 aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
4097 aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
4099 anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );
4101 popupMgr()->insert( action( 200 ), anId, -1 ); // RESET
4102 popupMgr()->setRule( action( 200 ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4104 popupMgr()->insert( separator(), anId, -1 );
4106 int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS
4108 popupMgr()->insert( action( 6005 ), aSubId, -1 ); // FREE_NODE
4109 popupMgr()->setRule( action( 6005 ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4110 popupMgr()->setRule( action( 6005 ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );
4112 popupMgr()->insert ( action( 6028 ), aSubId, -1 ); // EQUAL_NODE
4113 popupMgr()->setRule( action( 6028 ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
4114 popupMgr()->setRule( action( 6028 ), "controlMode = 'eCoincidentNodes'", QtxPopupMgr::ToggleRule);
4116 aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS
4118 popupMgr()->insert( action( 6002 ), aSubId, -1 ); // FREE_EDGE
4119 popupMgr()->setRule( action( 6002 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4120 popupMgr()->setRule( action( 6002 ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );
4122 popupMgr()->insert( action( 6003 ), aSubId, -1 ); // FREE_BORDER
4123 popupMgr()->setRule( action( 6003 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4124 popupMgr()->setRule( action( 6003 ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );
4126 popupMgr()->insert( action( 6001 ), aSubId, -1 ); // LENGTH
4127 popupMgr()->setRule( action( 6001 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4128 popupMgr()->setRule( action( 6001 ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );
4130 popupMgr()->insert( action( 6004 ), aSubId, -1 ); // CONNECTION
4131 popupMgr()->setRule( action( 6004 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4132 popupMgr()->setRule( action( 6004 ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );
4133 popupMgr()->insert ( action( 6029 ), aSubId, -1 ); // EQUAL_EDGE
4134 popupMgr()->setRule( action( 6029 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
4135 popupMgr()->setRule( action( 6029 ), "controlMode = 'eCoincidentElems1D'", QtxPopupMgr::ToggleRule);
4137 aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS
4139 popupMgr()->insert ( action( 6021 ), aSubId, -1 ); // FREE_FACE
4140 popupMgr()->setRule( action( 6021 ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
4141 QtxPopupMgr::VisibleRule );
4142 popupMgr()->setRule( action( 6021 ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );
4144 popupMgr()->insert ( action( 6018 ), aSubId, -1 ); // LENGTH_2D
4145 popupMgr()->setRule( action( 6018 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4146 popupMgr()->setRule( action( 6018 ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );
4148 popupMgr()->insert ( action( 6019 ), aSubId, -1 ); // CONNECTION_2D
4149 popupMgr()->setRule( action( 6019 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4150 popupMgr()->setRule( action( 6019 ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );
4152 popupMgr()->insert ( action( 6011 ), aSubId, -1 ); // AREA
4153 popupMgr()->setRule( action( 6011 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4154 popupMgr()->setRule( action( 6011 ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );
4156 popupMgr()->insert ( action( 6012 ), aSubId, -1 ); // TAPER
4157 popupMgr()->setRule( action( 6012 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4158 popupMgr()->setRule( action( 6012 ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );
4160 popupMgr()->insert ( action( 6013 ), aSubId, -1 ); // ASPECT
4161 popupMgr()->setRule( action( 6013 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4162 popupMgr()->setRule( action( 6013 ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );
4164 popupMgr()->insert ( action( 6014 ), aSubId, -1 ); // MIN_ANG
4165 popupMgr()->setRule( action( 6014 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4166 popupMgr()->setRule( action( 6014 ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );
4168 popupMgr()->insert ( action( 6015 ), aSubId, -1 ); // WARP
4169 popupMgr()->setRule( action( 6015 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4170 popupMgr()->setRule( action( 6015 ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );
4172 popupMgr()->insert ( action( 6016 ), aSubId, -1 ); // SKEW
4173 popupMgr()->setRule( action( 6016 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4174 popupMgr()->setRule( action( 6016 ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );
4176 popupMgr()->insert ( action( 6022 ), aSubId, -1 ); // MAX_ELEMENT_LENGTH_2D
4177 popupMgr()->setRule( action( 6022 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4178 popupMgr()->setRule( action( 6022 ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );
4180 popupMgr()->insert ( action( 6025 ), aSubId, -1 ); // BARE_BORDER_FACE
4181 popupMgr()->setRule( action( 6025 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4182 popupMgr()->setRule( action( 6025 ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );
4184 popupMgr()->insert ( action( 6027 ), aSubId, -1 ); // OVER_CONSTRAINED_FACE
4185 popupMgr()->setRule( action( 6027 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4186 popupMgr()->setRule( action( 6027 ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
4187 popupMgr()->insert ( action( 6030 ), aSubId, -1 ); // EQUAL_FACE
4188 popupMgr()->setRule( action( 6030 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
4189 popupMgr()->setRule( action( 6030 ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
4191 aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
4193 popupMgr()->insert ( action( 6017 ), aSubId, -1 ); // ASPECT_3D
4194 popupMgr()->setRule( action( 6017 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4195 popupMgr()->setRule( action( 6017 ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
4197 popupMgr()->insert ( action( 6009 ), aSubId, -1 ); // VOLUME_3D
4198 popupMgr()->setRule( action( 6009 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4199 popupMgr()->setRule( action( 6009 ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
4201 popupMgr()->insert ( action( 6023 ), aSubId, -1 ); // MAX_ELEMENT_LENGTH_3D
4202 popupMgr()->setRule( action( 6023 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4203 popupMgr()->setRule( action( 6023 ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );
4205 popupMgr()->insert ( action( 6024 ), aSubId, -1 ); // BARE_BORDER_VOLUME
4206 popupMgr()->setRule( action( 6024 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4207 popupMgr()->setRule( action( 6024 ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );
4209 popupMgr()->insert ( action( 6026 ), aSubId, -1 ); // OVER_CONSTRAINED_VOLUME
4210 popupMgr()->setRule( action( 6026 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4211 popupMgr()->setRule( action( 6026 ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );
4213 popupMgr()->insert ( action( 6031 ), aSubId, -1 ); // EQUAL_VOLUME
4214 popupMgr()->setRule( action( 6031 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
4215 popupMgr()->setRule( action( 6031 ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
4217 popupMgr()->insert( separator(), anId, -1 );
4219 popupMgr()->insert( action( 201 ), anId, -1 ); // SCALAR_BAR_PROP
4220 popupMgr()->setRule( action( 201 ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );
4222 popupMgr()->insert( separator(), anId, -1 );
4224 aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS
4226 popupMgr()->insert( action( 2021 ), aSubId, -1 ); // SAVE_DISTRIBUTION
4227 popupMgr()->setRule( action( 2021 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4229 popupMgr()->insert( action( 2022 ), aSubId, -1 ); // SHOW_DISTRIBUTION
4230 popupMgr()->setRule( action( 2022 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4231 popupMgr()->setRule( action( 2022 ), aMeshInVTK + "&& isNumFunctor && isDistributionVisible", QtxPopupMgr::ToggleRule);
4233 #ifndef DISABLE_PLOT2DVIEWER
4234 popupMgr()->insert( action( 2023 ), aSubId, -1 ); // PLOT_DISTRIBUTION
4235 popupMgr()->setRule( action( 2023 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
4238 //-------------------------------------------------
4240 //-------------------------------------------------
4241 popupMgr()->insert( separator(), -1, -1 );
4242 QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
4243 aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
4244 popupMgr()->insert( action( 301 ), -1, -1 ); // DISPLAY
4245 popupMgr()->setRule( action( 301 ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );
4247 popupMgr()->insert( action( 300 ), -1, -1 ); // ERASE
4248 popupMgr()->setRule( action( 300 ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );
4250 popupMgr()->insert( action( 302 ), -1, -1 ); // DISPLAY_ONLY
4251 popupMgr()->setRule( action( 302 ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );
4253 popupMgr()->insert( separator(), -1, -1 );
4255 //-------------------------------------------------
4257 //-------------------------------------------------
4258 popupMgr()->insert( action( 1134 ), -1, -1 );
4259 popupMgr()->setRule( action( 1134 ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );
4261 popupMgr()->insert( separator(), -1, -1 );
4263 connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
4264 this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );
4266 connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
4267 this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
4270 //================================================================================
4272 * \brief Return true if SMESH or GEOM objects are selected.
4273 * Is called form LightApp_Module::activateModule() which clear selection if
4274 * not isSelectionCompatible()
4276 //================================================================================
4278 bool SMESHGUI::isSelectionCompatible()
4280 bool isCompatible = true;
4281 SALOME_ListIO selected;
4282 if ( LightApp_SelectionMgr *Sel = selectionMgr() )
4283 Sel->selectedObjects( selected );
4285 SALOME_ListIteratorOfListIO It( selected );
4286 for ( ; isCompatible && It.More(); It.Next())
4288 ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
4289 ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );
4291 return isCompatible;
4295 bool SMESHGUI::reusableOperation( const int id )
4297 // compute, evaluate and precompute are not reusable operations
4298 return ( id == 701 || id == 711 || id == 712 ) ? false : SalomeApp_Module::reusableOperation( id );
4301 bool SMESHGUI::activateModule( SUIT_Study* study )
4303 bool res = SalomeApp_Module::activateModule( study );
4305 setMenuShown( true );
4306 setToolShown( true );
4308 // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
4309 PyGILState_STATE gstate = PyGILState_Ensure();
4310 PyObject* pluginsmanager=PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
4311 if(pluginsmanager==NULL)
4315 PyObject* result=PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toStdString().c_str(),tr("SMESH_PLUGINS_OTHER").toStdString().c_str());
4320 PyGILState_Release(gstate);
4321 // end of GEOM plugins loading
4323 // Reset actions accelerator keys
4324 action(111)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_B)); // Import DAT
4325 action(112)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_U)); // Import UNV
4326 action(113)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_M)); // Import MED
4328 action( 33)->setEnabled(true); // Delete: Key_Delete
4330 // 0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
4331 GetSMESHGen()->SetCurrentStudy(SALOMEDS::Study::_nil());
4332 if ( SalomeApp_Study* s = dynamic_cast<SalomeApp_Study*>( study ))
4333 if ( _PTR(Study) aStudy = s->studyDS()) {
4334 GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
4335 updateObjBrowser(); // objects can be removed
4338 // get all view currently opened in the study and connect their signals to
4339 // the corresponding slots of the class.
4340 SUIT_Desktop* aDesk = study->application()->desktop();
4342 QList<SUIT_ViewWindow*> wndList = aDesk->windows();
4343 SUIT_ViewWindow* wnd;
4344 foreach ( wnd, wndList )
4351 bool SMESHGUI::deactivateModule( SUIT_Study* study )
4353 setMenuShown( false );
4354 setToolShown( false );
4356 EmitSignalCloseAllDialogs();
4358 // Unset actions accelerator keys
4359 action(111)->setShortcut(QKeySequence()); // Import DAT
4360 action(112)->setShortcut(QKeySequence()); // Import UNV
4361 action(113)->setShortcut(QKeySequence()); // Import MED
4363 action( 33)->setEnabled(false); // Delete: Key_Delete
4365 return SalomeApp_Module::deactivateModule( study );
4368 void SMESHGUI::studyClosed( SUIT_Study* s )
4370 SMESH::RemoveVisuData( s->id() );
4371 SalomeApp_Module::studyClosed( s );
4374 void SMESHGUI::OnGUIEvent()
4376 const QObject* obj = sender();
4377 if ( !obj || !obj->inherits( "QAction" ) )
4379 int id = actionId((QAction*)obj);
4384 SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen()
4386 _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
4387 if ( CORBA::is_nil( myComponentSMESH ) )
4389 SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
4391 aGUI.myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4392 return aGUI.myComponentSMESH;
4395 myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
4396 return myComponentSMESH;
4399 QString SMESHGUI::engineIOR() const
4401 CORBA::ORB_var anORB = getApp()->orb();
4402 CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
4403 return QString( anIOR.in() );
4406 void SMESHGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title )
4408 SalomeApp_Module::contextMenuPopup( client, menu, title );
4410 selectionMgr()->selectedObjects( lst );
4411 if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
4412 Handle(SALOME_InteractiveObject) io = lst.First();
4413 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
4414 _PTR(Study) study = appStudy->studyDS();
4415 _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
4417 QString aName = QString( obj->GetName().c_str() );
4418 while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
4419 aName.remove( (aName.length() - 1), 1 );
4425 LightApp_Selection* SMESHGUI::createSelection() const
4427 return new SMESHGUI_Selection();
4430 void SMESHGUI::windows( QMap<int, int>& aMap ) const
4432 aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
4433 aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
4436 void SMESHGUI::viewManagers( QStringList& list ) const
4438 list.append( SVTK_Viewer::Type() );
4441 void SMESHGUI::onViewManagerActivated( SUIT_ViewManager* mgr )
4443 if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
4444 SMESH::UpdateSelectionProp( this );
4446 QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
4447 for(int i = 0; i < aViews.count() ; i++){
4448 SUIT_ViewWindow *sf = aViews[i];
4454 void SMESHGUI::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
4456 if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
4457 myClippingPlaneInfoMap.erase( theViewManager );
4460 void SMESHGUI::addActorAsObserver( SMESH_Actor* theActor )
4462 theActor->AddObserver( SMESH::DeleteActorEvent,
4463 myEventCallbackCommand.GetPointer(),
4467 void SMESHGUI::ProcessEvents( vtkObject* theObject,
4468 unsigned long theEvent,
4469 void* theClientData,
4472 if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
4473 if( theObject && theEvent == SMESH::DeleteActorEvent ) {
4474 if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
4475 SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
4476 SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
4477 for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
4478 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
4479 SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
4480 for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
4481 SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
4482 std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
4483 SMESH::TActorList::iterator anIter3 = anActorList.begin();
4484 for ( ; anIter3 != anActorList.end(); anIter3++ ) {
4485 if( anActor == *anIter3 ) {
4486 anActorList.erase( anIter3 );
4497 void SMESHGUI::createPreferences()
4499 // General tab ------------------------------------------------------------------------
4500 int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );
4502 int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
4503 int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
4504 setPreferenceProperty( lim, "min", 0 );
4505 setPreferenceProperty( lim, "max", 100000000 );
4506 setPreferenceProperty( lim, "step", 1000 );
4507 setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4509 int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
4510 setPreferenceProperty( qaGroup, "columns", 2 );
4511 addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
4512 addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
4513 int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
4514 setPreferenceProperty( prec, "min", 0 );
4515 setPreferenceProperty( prec, "max", 16 );
4516 int doubleNodesTol = addPreference( tr( "PREF_EQUAL_NODES_TOL" ), qaGroup, LightApp_Preferences::DblSpin, "SMESH", "equal_nodes_tolerance" );
4517 setPreferenceProperty( doubleNodesTol, "precision", 10 );
4518 setPreferenceProperty( doubleNodesTol, "min", 0.0000000001 );
4519 setPreferenceProperty( doubleNodesTol, "max", 1000000.0 );
4520 setPreferenceProperty( doubleNodesTol, "step", 0.0000001 );
4522 int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE" ), genTab );
4523 setPreferenceProperty( dispgroup, "columns", 2 );
4524 int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
4526 modes.append( tr("MEN_WIRE") );
4527 modes.append( tr("MEN_SHADE") );
4528 modes.append( tr("MEN_NODES") );
4529 modes.append( tr("MEN_SHRINK") );
4530 QList<QVariant> indices;
4531 indices.append( 0 );
4532 indices.append( 1 );
4533 indices.append( 2 );
4534 indices.append( 3 );
4535 setPreferenceProperty( dispmode, "strings", modes );
4536 setPreferenceProperty( dispmode, "indexes", indices );
4538 int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), genTab );
4539 setPreferenceProperty( arcgroup, "columns", 2 );
4540 int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
4541 QStringList quadraticModes;
4542 quadraticModes.append(tr("MEN_LINE_REPRESENTATION"));
4543 quadraticModes.append(tr("MEN_ARC_REPRESENTATION"));
4545 indices.append( 0 );
4546 indices.append( 1 );
4547 setPreferenceProperty( quadraticmode, "strings", quadraticModes );
4548 setPreferenceProperty( quadraticmode, "indexes", indices );
4550 int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
4551 "SMESH", "max_angle" );
4552 setPreferenceProperty( maxAngle, "min", 1 );
4553 setPreferenceProperty( maxAngle, "max", 90 );
4557 int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
4558 setPreferenceProperty( exportgroup, "columns", 2 );
4559 addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
4560 addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );
4562 int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
4563 setPreferenceProperty( computeGroup, "columns", 2 );
4564 int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
4566 modes.append( tr( "PREF_NOTIFY_NEVER" ) );
4567 modes.append( tr( "PREF_NOTIFY_ERROR" ) );
4568 modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
4570 indices.append( 0 );
4571 indices.append( 1 );
4572 indices.append( 2 );
4573 setPreferenceProperty( notifyMode, "strings", modes );
4574 setPreferenceProperty( notifyMode, "indexes", indices );
4576 int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
4577 setPreferenceProperty( infoGroup, "columns", 4 );
4578 int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
4580 modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
4581 modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
4583 indices.append( 0 );
4584 indices.append( 1 );
4585 setPreferenceProperty( elemInfo, "strings", modes );
4586 setPreferenceProperty( elemInfo, "indexes", indices );
4587 int nodesLim = addPreference( tr( "PREF_GPP_NODES_LIMIT" ), infoGroup, LightApp_Preferences::IntSpin, "SMESH", "info_groups_nodes_limit" );
4588 setPreferenceProperty( nodesLim, "min", 0 );
4589 setPreferenceProperty( nodesLim, "max", 10000000 );
4590 setPreferenceProperty( nodesLim, "step", 10000 );
4591 setPreferenceProperty( nodesLim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );
4593 int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
4594 setPreferenceProperty( segGroup, "columns", 2 );
4595 int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
4596 "SMESH", "segmentation" );
4597 setPreferenceProperty( segLen, "min", 1 );
4598 setPreferenceProperty( segLen, "max", 10000000 );
4599 int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
4600 "SMESH", "nb_segments_per_edge" );
4601 setPreferenceProperty( nbSeg, "min", 1 );
4602 setPreferenceProperty( nbSeg, "max", 10000000 );
4604 int loadGroup = addPreference( tr( "SMESH_PREF_MESH_LOADING" ), genTab );
4605 addPreference( tr( "PREF_FORGET_MESH_AT_HYP_MODIF" ), loadGroup, LightApp_Preferences::Bool,
4606 "SMESH", "forget_mesh_on_hyp_modif" );
4609 // Quantities with individual precision settings
4610 int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
4611 setPreferenceProperty( precGroup, "columns", 2 );
4613 const int nbQuantities = 6;
4614 int precs[nbQuantities], ii = 0;
4615 precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
4616 LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
4617 precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
4618 LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
4619 precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
4620 LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
4621 precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
4622 LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
4623 precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
4624 LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
4625 precs[ii ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
4626 LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );
4628 // Set property for precision value for spinboxes
4629 for ( ii = 0; ii < nbQuantities; ii++ ){
4630 setPreferenceProperty( precs[ii], "min", -14 );
4631 setPreferenceProperty( precs[ii], "max", 14 );
4632 setPreferenceProperty( precs[ii], "precision", 2 );
4635 int previewGroup = addPreference( tr( "SMESH_PREF_GROUP_PREVIEW" ), genTab );
4636 setPreferenceProperty( previewGroup, "columns", 2 );
4637 int chunkSize = addPreference( tr( "PREF_PREVIEW_CHUNK_SIZE" ), previewGroup, LightApp_Preferences::IntSpin, "SMESH", "preview_actor_chunk_size" );
4638 setPreferenceProperty( chunkSize, "min", 0 );
4639 setPreferenceProperty( chunkSize, "max", 1000 );
4640 setPreferenceProperty( chunkSize, "step", 50 );
4642 int pyDumpGroup = addPreference( tr( "PREF_PYTHON_DUMP" ), genTab );
4643 addPreference( tr( "PREF_HISTORICAL_PYTHON_DUMP" ), pyDumpGroup, LightApp_Preferences::Bool, "SMESH", "historical_python_dump" );
4645 // Mesh tab ------------------------------------------------------------------------
4646 int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
4647 int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
4648 setPreferenceProperty( nodeGroup, "columns", 3 );
4650 addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );
4652 int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );
4654 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
4655 QList<QVariant> aMarkerTypeIndicesList;
4656 QList<QVariant> aMarkerTypeIconsList;
4657 for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
4658 QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
4659 QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
4660 aMarkerTypeIndicesList << i;
4661 aMarkerTypeIconsList << pixmap;
4663 setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
4664 setPreferenceProperty( typeOfMarker, "icons", aMarkerTypeIconsList );
4666 int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );
4668 QList<QVariant> aMarkerScaleIndicesList;
4669 QStringList aMarkerScaleValuesList;
4670 for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
4671 aMarkerScaleIndicesList << i;
4672 aMarkerScaleValuesList << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
4674 setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
4675 setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );
4677 int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
4678 setPreferenceProperty( elemGroup, "columns", 2 );
4680 int ColorId = addPreference( tr( "PREF_FILL" ), elemGroup, LightApp_Preferences::BiColor, "SMESH", "fill_color" );
4681 addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );
4683 addPreference( tr( "PREF_OUTLINE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
4684 addPreference( tr( "PREF_WIREFRAME" ), elemGroup, LightApp_Preferences::Color, "SMESH", "wireframe_color" );
4686 setPreferenceProperty( ColorId, "text", tr("PREF_BACKFACE") );
4688 int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
4689 setPreferenceProperty( grpGroup, "columns", 2 );
4691 addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );
4693 int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
4694 LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
4695 int elemW = addPreference(tr("PREF_WIDTH"), elemGroup,
4696 LightApp_Preferences::IntSpin, "SMESH", "element_width");
4697 int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
4698 LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");
4700 setPreferenceProperty( size0d, "min", 1 );
4701 setPreferenceProperty( size0d, "max", 10 );
4703 setPreferenceProperty( elemW, "min", 1 );
4704 setPreferenceProperty( elemW, "max", 5 );
4706 setPreferenceProperty( shrink, "min", 0 );
4707 setPreferenceProperty( shrink, "max", 100 );
4709 int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
4710 setPreferenceProperty( orientGroup, "columns", 1 );
4712 addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
4713 int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );
4715 setPreferenceProperty( orientScale, "min", 0.05 );
4716 setPreferenceProperty( orientScale, "max", 0.5 );
4717 setPreferenceProperty( orientScale, "step", 0.05 );
4719 addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );
4721 // Selection tab ------------------------------------------------------------------------
4722 int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );
4724 int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
4725 setPreferenceProperty( selGroup, "columns", 2 );
4727 addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
4728 addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
4730 int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
4731 setPreferenceProperty( preGroup, "columns", 2 );
4733 addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
4735 int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
4736 setPreferenceProperty( precSelGroup, "columns", 2 );
4738 addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
4739 addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
4740 addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );
4742 // Scalar Bar tab ------------------------------------------------------------------------
4743 int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
4744 int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
4745 setPreferenceProperty( fontGr, "columns", 2 );
4747 addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
4748 addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );
4750 addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
4751 addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );
4753 int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
4754 setPreferenceProperty( colorsLabelsGr, "columns", 2 );
4756 int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
4757 setPreferenceProperty( numcol, "min", 2 );
4758 setPreferenceProperty( numcol, "max", 256 );
4760 int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
4761 setPreferenceProperty( numlab, "min", 2 );
4762 setPreferenceProperty( numlab, "max", 65 );
4764 int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
4765 setPreferenceProperty( orientGr, "columns", 2 );
4766 int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
4767 QStringList orients;
4768 orients.append( tr( "SMESH_VERTICAL" ) );
4769 orients.append( tr( "SMESH_HORIZONTAL" ) );
4770 indices.clear(); indices.append( 0 ); indices.append( 1 );
4771 setPreferenceProperty( orient, "strings", orients );
4772 setPreferenceProperty( orient, "indexes", indices );
4774 int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
4775 setPreferenceProperty( posVSizeGr, "columns", 2 );
4776 int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
4777 int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
4778 int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
4779 int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
4780 setPreferenceProperty( xv, "step", 0.1 );
4781 setPreferenceProperty( xv, "min", 0.0 );
4782 setPreferenceProperty( xv, "max", 1.0 );
4783 setPreferenceProperty( yv, "step", 0.1 );
4784 setPreferenceProperty( yv, "min", 0.0 );
4785 setPreferenceProperty( yv, "max", 1.0 );
4786 setPreferenceProperty( wv, "step", 0.1 );
4787 setPreferenceProperty( wv, "min", 0.0 );
4788 setPreferenceProperty( wv, "max", 1.0 );
4789 setPreferenceProperty( hv, "min", 0.0 );
4790 setPreferenceProperty( hv, "max", 1.0 );
4791 setPreferenceProperty( hv, "step", 0.1 );
4793 int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
4794 setPreferenceProperty( posHSizeGr, "columns", 2 );
4795 int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
4796 int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
4797 int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
4798 int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
4799 setPreferenceProperty( xv, "min", 0.0 );
4800 setPreferenceProperty( xv, "max", 1.0 );
4801 setPreferenceProperty( xv, "step", 0.1 );
4802 setPreferenceProperty( xh, "min", 0.0 );
4803 setPreferenceProperty( xh, "max", 1.0 );
4804 setPreferenceProperty( xh, "step", 0.1 );
4805 setPreferenceProperty( yh, "min", 0.0 );
4806 setPreferenceProperty( yh, "max", 1.0 );
4807 setPreferenceProperty( yh, "step", 0.1 );
4808 setPreferenceProperty( wh, "min", 0.0 );
4809 setPreferenceProperty( wh, "max", 1.0 );
4810 setPreferenceProperty( wh, "step", 0.1 );
4811 setPreferenceProperty( hh, "min", 0.0 );
4812 setPreferenceProperty( hh, "max", 1.0 );
4813 setPreferenceProperty( hh, "step", 0.1 );
4815 int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
4816 int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
4817 setPreferenceProperty( distributionGr, "columns", 3 );
4819 types.append( tr( "SMESH_MONOCOLOR" ) );
4820 types.append( tr( "SMESH_MULTICOLOR" ) );
4821 indices.clear(); indices.append( 0 ); indices.append( 1 );
4822 setPreferenceProperty( coloringType, "strings", types );
4823 setPreferenceProperty( coloringType, "indexes", indices );
4824 addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );
4828 void SMESHGUI::preferencesChanged( const QString& sect, const QString& name )
4830 if( sect=="SMESH" ) {
4831 float sbX1,sbY1,sbW,sbH;
4832 float aTol = 1.00000009999999;
4833 std::string aWarning;
4834 SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
4835 if( name=="selection_object_color" || name=="selection_element_color" ||
4836 name=="highlight_color" ||
4837 name=="selection_precision_node" || name=="selection_precision_element" ||
4838 name=="selection_precision_object")
4839 SMESH::UpdateSelectionProp( this );
4840 else if (name == QString("scalar_bar_vertical_x") || name == QString("scalar_bar_vertical_width")){
4841 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
4842 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
4843 if(sbX1+sbW > aTol){
4844 aWarning = "Origin and Size Vertical: X+Width > 1\n";
4847 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
4848 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
4851 else if(name == QString("scalar_bar_vertical_y") || name == QString("scalar_bar_vertical_height")){
4852 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
4853 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
4854 if(sbY1+sbH > aTol){
4855 aWarning = "Origin and Size Vertical: Y+Height > 1\n";
4856 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
4857 aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
4860 else if(name == QString("scalar_bar_horizontal_x") || name == QString("scalar_bar_horizontal_width")){
4861 sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
4862 sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
4863 if(sbX1+sbW > aTol){
4864 aWarning = "Origin and Size Horizontal: X+Width > 1\n";
4867 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
4868 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
4871 else if(name == QString("scalar_bar_horizontal_y") || name == QString("scalar_bar_horizontal_height")){
4872 sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
4873 sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
4874 if(sbY1+sbH > aTol){
4875 aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
4878 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
4879 aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
4882 else if ( name == "segmentation" ) {
4883 int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
4884 myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
4886 else if ( name == "nb_segments_per_edge" ) {
4887 int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
4888 myComponentSMESH->SetDefaultNbSegments( nbSeg );
4890 else if ( name == "historical_python_dump" ||
4891 name == "forget_mesh_on_hyp_modif") {
4892 QString val = aResourceMgr->stringValue( "SMESH", name );
4893 myComponentSMESH->SetOption( name.toLatin1().constData(), val.toLatin1().constData() );
4896 if(aWarning.size() != 0){
4897 aWarning += "The default values are applied instead.";
4898 SUIT_MessageBox::warning(SMESHGUI::desktop(),
4899 QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
4900 QObject::tr(aWarning.c_str()));
4905 //================================================================================
4907 * \brief Update something in accordance with update flags
4908 * \param theFlags - update flags
4910 * Update viewer or/and object browser etc. in accordance with update flags ( see
4911 * LightApp_UpdateFlags enumeration ).
4913 //================================================================================
4914 void SMESHGUI::update( const int flags )
4916 if ( (flags & UF_Viewer) | (flags & UF_Forced) )
4917 SMESH::UpdateView();
4919 SalomeApp_Module::update( flags );
4922 //================================================================================
4924 * \brief Set default selection mode
4926 * SLOT called when operation commited. Sets default selection mode
4928 //================================================================================
4929 void SMESHGUI::onOperationCommited( SUIT_Operation* )
4931 SVTK_ViewWindow* vtkWnd =
4932 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
4934 vtkWnd->SetSelectionMode( ActorSelection );
4937 //================================================================================
4939 * \brief Set default selection mode
4941 * SLOT called when operation aborted. Sets default selection mode
4943 //================================================================================
4944 void SMESHGUI::onOperationAborted( SUIT_Operation* )
4946 SVTK_ViewWindow* vtkWnd =
4947 dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
4949 vtkWnd->SetSelectionMode( ActorSelection );
4952 //================================================================================
4954 * \brief Creates operation with given identifier
4955 * \param id - identifier of operation to be started
4956 * \return Pointer on created operation or NULL if operation is not created
4958 * Virtual method redefined from the base class creates operation with given id.
4959 * It is called called automatically from startOperation method of base class.
4961 //================================================================================
4962 LightApp_Operation* SMESHGUI::createOperation( const int id ) const
4964 LightApp_Operation* op = 0;
4965 // to do : create operation here
4968 case 417: //convert to quadratic
4969 op = new SMESHGUI_ConvToQuadOp();
4971 case 418: // create 2D mesh as boundary on 3D
4972 op = new SMESHGUI_Make2DFrom3DOp();
4974 case 701: // Compute mesh
4975 op = new SMESHGUI_ComputeOp();
4977 case 702: // Create mesh
4978 op = new SMESHGUI_MeshOp( true, true );
4980 case 703: // Create sub-mesh
4981 op = new SMESHGUI_MeshOp( true, false );
4983 case 704: // Edit mesh/sub-mesh
4984 op = new SMESHGUI_MeshOp( false );
4986 case 711: // Precompute mesh
4987 op = new SMESHGUI_PrecomputeOp();
4989 case 712: // Evaluate mesh
4990 op = new SMESHGUI_EvaluateOp();
4992 case 713: // Evaluate mesh
4993 op = new SMESHGUI_MeshOrderOp();
4995 case 806: // Create group on geom
4996 op = new SMESHGUI_GroupOnShapeOp();
4998 case 904: // Find element
4999 op = new SMESHGUI_FindElemByPointOp();
5001 case 4067: // make mesh pass through point
5002 op = new SMESHGUI_MakeNodeAtPointOp();
5009 op = SalomeApp_Module::createOperation( id );
5013 //================================================================================
5015 * \brief Stops current operations and starts a given one
5016 * \param id - The id of the operation to start
5018 //================================================================================
5020 void SMESHGUI::switchToOperation(int id)
5022 if ( _PTR(Study) aStudy = SMESH::GetActiveStudyDocument() )
5023 activeStudy()->abortAllOperations();
5024 startOperation( id );
5027 LightApp_Displayer* SMESHGUI::displayer()
5030 myDisplayer = new SMESHGUI_Displayer( getApp() );
5034 SALOMEDS::Color SMESHGUI::getUniqueColor( const QList<SALOMEDS::Color>& theReservedColors )
5037 int aTolerance = 64;
5038 int anIterations = 0;
5044 if( anIterations % aPeriod == 0 )
5047 if( aTolerance < 1 )
5051 aHue = (int)( 360.0 * rand() / RAND_MAX );
5054 QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
5055 QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
5056 for( ; it != itEnd; ++it )
5058 SALOMEDS::Color anAutoColor = *it;
5059 QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );
5062 aQColor.getHsv( &h, &s, &v );
5063 if( abs( h - aHue ) < aTolerance )
5075 aColor.setHsv( aHue, 255, 255 );
5077 SALOMEDS::Color aSColor;
5078 aSColor.R = (double)aColor.red() / 255.0;
5079 aSColor.G = (double)aColor.green() / 255.0;
5080 aSColor.B = (double)aColor.blue() / 255.0;
5085 const char gSeparator = '_'; // character used to separate parameter names
5086 const char gDigitsSep = ':'; // character used to separate numeric parameter values (color = r:g:b)
5087 const char gPathSep = '|'; // character used to separate paths
5090 * \brief Store visual parameters
5092 * This method is called just before the study document is saved.
5093 * Store visual parameters in AttributeParameter attribue(s)
5095 void SMESHGUI::storeVisualParameters (int savePoint)
5097 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5098 if (!appStudy || !appStudy->studyDS())
5100 _PTR(Study) studyDS = appStudy->studyDS();
5102 // componentName is used for encoding of entries when storing them in IParameters
5103 std::string componentName = myComponentSMESH->ComponentDataType();
5104 //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
5105 //if (!aSComponent) return;
5108 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5109 componentName.c_str(),
5111 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5113 // store map of custom markers
5114 const VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5115 if( !aMarkerMap.empty() )
5117 VTK::MarkerMap::const_iterator anIter = aMarkerMap.begin();
5118 for( ; anIter != aMarkerMap.end(); anIter++ )
5120 int anId = anIter->first;
5121 VTK::MarkerData aMarkerData = anIter->second;
5122 std::string aMarkerFileName = aMarkerData.first;
5123 VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
5124 if( aMarkerTexture.size() < 3 )
5125 continue; // should contain at least width, height and the first value
5127 QString aPropertyName( "texture" );
5128 aPropertyName += gSeparator;
5129 aPropertyName += QString::number( anId );
5131 QString aPropertyValue = aMarkerFileName.c_str();
5132 aPropertyValue += gPathSep;
5134 VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
5135 ushort aWidth = *aTextureIter++;
5136 ushort aHeight = *aTextureIter++;
5137 aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
5138 aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
5139 for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
5140 aPropertyValue += QString::number( *aTextureIter );
5142 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5146 // viewers counters are used for storing view_numbers in IParameters
5149 // main cycle to store parameters of displayed objects
5150 QList<SUIT_ViewManager*> lst;
5151 QList<SUIT_ViewManager*>::Iterator it;
5152 getApp()->viewManagers(lst);
5153 for (it = lst.begin(); it != lst.end(); it++)
5155 SUIT_ViewManager* vman = *it;
5156 QString vType = vman->getType();
5158 // saving VTK actors properties
5159 if (vType == SVTK_Viewer::Type())
5161 // store the clipping planes attached to the view manager
5162 SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
5163 SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
5164 if( anIter != myClippingPlaneInfoMap.end() )
5165 aClippingPlaneInfoList = anIter->second;
5167 if( !aClippingPlaneInfoList.empty() ) {
5168 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
5169 for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
5171 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
5172 SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;
5174 QString aPropertyName( "ClippingPlane" );
5175 aPropertyName += gSeparator;
5176 aPropertyName += QString::number( vtkViewers );
5177 aPropertyName += gSeparator;
5178 aPropertyName += QString::number( anId );
5180 QString aPropertyValue = QString::number( (int)aPlane->GetOrientation() ).toLatin1().constData();
5181 aPropertyValue += gDigitsSep;
5182 aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
5183 aPropertyValue += gDigitsSep;
5184 aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
5185 aPropertyValue += gDigitsSep;
5186 aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();
5188 ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
5192 QVector<SUIT_ViewWindow*> views = vman->getViews();
5193 for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
5195 if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
5197 VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
5198 vtkActorCollection* allActors = aCopy.GetActors();
5199 allActors->InitTraversal();
5200 while (vtkActor* actor = allActors->GetNextActor())
5202 if (actor->GetVisibility()) // store only visible actors
5204 SMESH_Actor* aSmeshActor = 0;
5205 if (actor->IsA("SMESH_Actor"))
5206 aSmeshActor = SMESH_Actor::SafeDownCast(actor);
5207 if (aSmeshActor && aSmeshActor->hasIO())
5209 Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
5212 // entry is "encoded" = it does NOT contain component adress,
5213 // since it is a subject to change on next component loading
5214 std::string entry = ip->encodeEntry(io->getEntry(), componentName);
5216 std::string param, vtkParam = vType.toLatin1().data();
5217 vtkParam += gSeparator;
5218 vtkParam += QString::number(vtkViewers).toLatin1().data();
5219 vtkParam += gSeparator;
5222 param = vtkParam + "Visibility";
5223 ip->setParameter(entry, param, "On");
5226 param = vtkParam + "Representation";
5227 ip->setParameter(entry, param, QString::number
5228 ((int)aSmeshActor->GetRepresentation()).toLatin1().data());
5231 param = vtkParam + "IsShrunk";
5232 ip->setParameter(entry, param, QString::number
5233 ((int)aSmeshActor->IsShrunk()).toLatin1().data());
5235 // Displayed entities
5236 unsigned int aMode = aSmeshActor->GetEntityMode();
5237 bool isE = aMode & SMESH_Actor::eEdges;
5238 bool isF = aMode & SMESH_Actor::eFaces;
5239 bool isV = aMode & SMESH_Actor::eVolumes;
5241 QString modeStr ("e");
5242 modeStr += gDigitsSep; modeStr += QString::number(isE);
5243 modeStr += gDigitsSep; modeStr += "f";
5244 modeStr += gDigitsSep; modeStr += QString::number(isF);
5245 modeStr += gDigitsSep; modeStr += "v";
5246 modeStr += gDigitsSep; modeStr += QString::number(isV);
5248 param = vtkParam + "Entities";
5249 ip->setParameter(entry, param, modeStr.toLatin1().data());
5251 // Colors (surface:edge:)
5252 vtkFloatingPointType r, g, b;
5255 aSmeshActor->GetSufaceColor(r, g, b, delta);
5256 QString colorStr ("surface");
5257 colorStr += gDigitsSep; colorStr += QString::number(r);
5258 colorStr += gDigitsSep; colorStr += QString::number(g);
5259 colorStr += gDigitsSep; colorStr += QString::number(b);
5261 colorStr += gDigitsSep; colorStr += "backsurface";
5262 colorStr += gDigitsSep; colorStr += QString::number(delta);
5265 aSmeshActor->GetEdgeColor(r, g, b);
5266 colorStr += gDigitsSep; colorStr += "edge";
5267 colorStr += gDigitsSep; colorStr += QString::number(r);
5268 colorStr += gDigitsSep; colorStr += QString::number(g);
5269 colorStr += gDigitsSep; colorStr += QString::number(b);
5271 aSmeshActor->GetNodeColor(r, g, b);
5272 colorStr += gDigitsSep; colorStr += "node";
5273 colorStr += gDigitsSep; colorStr += QString::number(r);
5274 colorStr += gDigitsSep; colorStr += QString::number(g);
5275 colorStr += gDigitsSep; colorStr += QString::number(b);
5277 aSmeshActor->GetOutlineColor(r, g, b);
5278 colorStr += gDigitsSep; colorStr += "outline";
5279 colorStr += gDigitsSep; colorStr += QString::number(r);
5280 colorStr += gDigitsSep; colorStr += QString::number(g);
5281 colorStr += gDigitsSep; colorStr += QString::number(b);
5283 param = vtkParam + "Colors";
5284 ip->setParameter(entry, param, colorStr.toLatin1().data());
5286 // Sizes of lines and points
5287 QString sizeStr ("line");
5288 sizeStr += gDigitsSep; sizeStr += QString::number((int)aSmeshActor->GetLineWidth());
5289 sizeStr += gDigitsSep; sizeStr += "shrink";
5290 sizeStr += gDigitsSep; sizeStr += QString::number(aSmeshActor->GetShrinkFactor());
5292 param = vtkParam + "Sizes";
5293 ip->setParameter(entry, param, sizeStr.toLatin1().data());
5298 VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
5299 if( aMarkerType == VTK::MT_USER ) {
5300 markerStr += "custom";
5301 markerStr += gDigitsSep;
5302 markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
5306 markerStr += gDigitsSep;
5307 markerStr += QString::number( (int)aMarkerType );
5308 markerStr += gDigitsSep;
5309 markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
5312 param = vtkParam + "PointMarker";
5313 ip->setParameter(entry, param, markerStr.toLatin1().data());
5316 param = vtkParam + "Opacity";
5317 ip->setParameter(entry, param,
5318 QString::number(aSmeshActor->GetOpacity()).toLatin1().data());
5321 param = vtkParam + "ClippingPlane";
5323 if( !aClippingPlaneInfoList.empty() ) {
5324 SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
5325 for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
5327 const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
5328 std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
5329 SMESH::TActorList::iterator anIter2 = anActorList.begin();
5330 for ( ; anIter2 != anActorList.end(); anIter2++ ) {
5331 if( aSmeshActor == *anIter2 ) {
5332 ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
5333 QString::number( anId ).toLatin1().constData() );
5340 ip->setParameter( entry, param, "Off" );
5341 } // if (io->hasEntry())
5342 } // SMESH_Actor && hasIO
5344 } // while.. actors traversal
5348 } // if (SVTK view model)
5349 } // for (viewManagers)
5352 // data structures for clipping planes processing
5355 vtkIdType Orientation;
5356 vtkFloatingPointType Distance;
5357 vtkFloatingPointType Angle[2];
5359 typedef std::list<TPlaneData> TPlaneDataList;
5360 typedef std::map<int, TPlaneDataList> TPlaneDataMap;
5362 typedef std::list<vtkActor*> TActorList;
5365 TActorList ActorList;
5366 SUIT_ViewManager* ViewManager;
5368 typedef std::list<TPlaneInfo> TPlaneInfoList;
5369 typedef std::map<int, TPlaneInfoList> TPlaneInfoMap;
5372 * \brief Restore visual parameters
5374 * This method is called after the study document is opened.
5375 * Restore visual parameters from AttributeParameter attribue(s)
5377 void SMESHGUI::restoreVisualParameters (int savePoint)
5379 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
5380 if (!appStudy || !appStudy->studyDS())
5382 _PTR(Study) studyDS = appStudy->studyDS();
5384 // componentName is used for encoding of entries when storing them in IParameters
5385 std::string componentName = myComponentSMESH->ComponentDataType();
5386 //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
5387 //if (!aSComponent) return;
5390 _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
5391 componentName.c_str(),
5393 _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
5395 // restore map of custom markers and map of clipping planes
5396 VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
5397 TPlaneDataMap aPlaneDataMap;
5399 std::vector<std::string> properties = ip->getProperties();
5400 for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
5402 std::string property = *propIt;
5403 QString aPropertyName( property.c_str() );
5404 QString aPropertyValue( ip->getProperty( property ).c_str() );
5406 QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
5407 if( aPropertyNameList.isEmpty() )
5410 QString aPropertyType = aPropertyNameList[0];
5411 if( aPropertyType == "texture" )
5413 if( aPropertyNameList.size() != 2 )
5417 int anId = aPropertyNameList[1].toInt( &ok );
5418 if( !ok || anId < 1 )
5421 QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
5422 if( aPropertyValueList.size() != 2 )
5425 std::string aMarkerFileName = aPropertyValueList[0].toStdString();
5426 QString aMarkerTextureString = aPropertyValueList[1];
5427 QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
5428 if( aMarkerTextureStringList.size() != 3 )
5432 ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
5437 ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
5441 VTK::MarkerTexture aMarkerTexture;
5442 aMarkerTexture.push_back( aWidth );
5443 aMarkerTexture.push_back( aHeight );
5445 QString aMarkerTextureData = aMarkerTextureStringList[2];
5446 for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
5448 QChar aChar = aMarkerTextureData.at( i );
5449 if( aChar.isDigit() )
5450 aMarkerTexture.push_back( aChar.digitValue() );
5453 aMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
5455 else if( aPropertyType == "ClippingPlane" )
5457 if( aPropertyNameList.size() != 3 )
5461 int aViewId = aPropertyNameList[1].toInt( &ok );
5462 if( !ok || aViewId < 0 )
5466 int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
5467 if( !ok || aClippingPlaneId < 0 )
5470 QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
5471 if( aPropertyValueList.size() != 4 )
5474 TPlaneData aPlaneData;
5475 aPlaneData.Id = aClippingPlaneId;
5478 aPlaneData.Orientation = aPropertyValueList[0].toInt( &ok );
5483 aPlaneData.Distance = aPropertyValueList[1].toDouble( &ok );
5488 aPlaneData.Angle[0] = aPropertyValueList[2].toDouble( &ok );
5493 aPlaneData.Angle[1] = aPropertyValueList[3].toDouble( &ok );
5497 TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
5498 aPlaneDataList.push_back( aPlaneData );
5502 TPlaneInfoMap aPlaneInfoMap;
5504 std::vector<std::string> entries = ip->getEntries();
5506 for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
5508 // entry is a normal entry - it should be "decoded" (setting base adress of component)
5509 QString entry (ip->decodeEntry(*entIt).c_str());
5511 // Check that the entry corresponds to a real object in the Study
5512 // as the object may be deleted or modified after the visual state is saved.
5513 _PTR(SObject) so = studyDS->FindObjectID(entry.toLatin1().data());
5514 if (!so) continue; //Skip the not existent entry
5516 std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
5517 std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );
5519 std::vector<std::string>::iterator namesIt = paramNames.begin();
5520 std::vector<std::string>::iterator valuesIt = paramValues.begin();
5522 // actors are stored in a map after displaying of them for
5523 // quicker access in the future: map < viewID to actor >
5524 NCollection_DataMap<int, SMESH_Actor*> vtkActors;
5526 for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
5528 // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
5529 // '_' is used as separator and should not be used in viewer type or parameter names.
5530 QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
5531 if (lst.size() != 3)
5534 QString viewerTypStr = lst[0];
5535 QString viewIndexStr = lst[1];
5536 QString paramNameStr = lst[2];
5539 int viewIndex = viewIndexStr.toUInt(&ok);
5540 if (!ok) // bad conversion of view index to integer
5544 if (viewerTypStr == SVTK_Viewer::Type())
5546 SMESH_Actor* aSmeshActor = 0;
5547 if (vtkActors.IsBound(viewIndex))
5548 aSmeshActor = vtkActors.Find(viewIndex);
5550 QList<SUIT_ViewManager*> lst;
5551 getApp()->viewManagers(viewerTypStr, lst);
5553 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
5554 SUIT_ViewManager* vman = NULL;
5555 if (viewIndex >= 0 && viewIndex < lst.count())
5556 vman = lst.at(viewIndex);
5558 if (paramNameStr == "Visibility")
5560 if (!aSmeshActor && displayer() && vman)
5562 SUIT_ViewModel* vmodel = vman->getViewModel();
5563 // SVTK view model can be casted to SALOME_View
5564 displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
5566 // store displayed actor in a temporary map for quicker
5567 // access later when restoring other parameters
5568 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
5569 vtkRenderer* Renderer = vtkView->getRenderer();
5570 VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
5571 vtkActorCollection* theActors = aCopy.GetActors();
5572 theActors->InitTraversal();
5573 bool isFound = false;
5574 vtkActor *ac = theActors->GetNextActor();
5575 for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
5576 if (ac->IsA("SMESH_Actor")) {
5577 SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
5578 if (aGeomAc->hasIO()) {
5579 Handle(SALOME_InteractiveObject) io =
5580 Handle(SALOME_InteractiveObject)::DownCast(aGeomAc->getIO());
5581 if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) {
5583 vtkActors.Bind(viewIndex, aGeomAc);
5589 } // if (paramNameStr == "Visibility")
5592 // the rest properties "work" with SMESH_Actor
5595 QString val ((*valuesIt).c_str());
5598 if (paramNameStr == "Representation") {
5599 aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
5602 else if (paramNameStr == "IsShrunk") {
5604 if (!aSmeshActor->IsShrunk())
5605 aSmeshActor->SetShrink();
5608 if (aSmeshActor->IsShrunk())
5609 aSmeshActor->UnShrink();
5612 // Displayed entities
5613 else if (paramNameStr == "Entities") {
5614 QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
5615 if (mode.count() == 6) {
5616 if (mode[0] != "e" || mode[2] != "f" || mode[4] != "v") {
5617 MESSAGE("Invalid order of data in Entities, must be: "
5618 "e:0/1:f:0/1:v:0/1");
5621 unsigned int aMode = aSmeshActor->GetEntityMode();
5622 unsigned int aNewMode =
5623 (int(SMESH_Actor::eEdges ) * mode[1].toInt()) |
5624 (int(SMESH_Actor::eFaces ) * mode[3].toInt()) |
5625 (int(SMESH_Actor::eVolumes) * mode[5].toInt());
5626 if (aNewMode != aMode)
5627 aSmeshActor->SetEntityMode(aNewMode);
5632 else if (paramNameStr == "Colors") {
5633 QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
5634 if (colors.count() == 16 || colors.count() == 18 ) {
5635 if (colors[0] != "surface" || colors[4] != "backsurface" ||
5636 (colors[8] != "edge" && colors[6] != "edge" ) || (colors[12] != "node" && colors[10] != "node") ||
5637 (colors.count() == 18 && colors[14] != "outline")) {
5638 MESSAGE("Invalid order of data in Colors, must be: "
5639 "surface:r:g:b:backsurface:r:g:b:edge:r:g:b:node:r:g:b or surface:r:g:b:backsurface:delta:edge:r:g:b:node:r:g:b:outline:r:g:b");
5645 vtkFloatingPointType otr,otg,otb;
5646 //Old case backsurface color is independent
5647 if( colors.count() == 16 ) {
5649 SMESH::GetColor( "SMESH", "fill_color", ffc, delta, "0,170,255|-100" ) ;
5650 er = colors[9].toFloat();
5651 eg = colors[10].toFloat();
5652 eb = colors[11].toFloat();
5654 nr = colors[13].toFloat();
5655 ng = colors[14].toFloat();
5656 nb = colors[15].toFloat();
5657 SMESH::GetColor("SMESH", "outline_color", otr, otg, otb, QColor( 0, 70, 0 ) );
5659 //New case backsurface color depends on surface color
5660 delta = colors[5].toInt();
5662 er = colors[7].toFloat();
5663 eg = colors[8].toFloat();
5664 eb = colors[9].toFloat();
5666 nr = colors[11].toFloat();
5667 ng = colors[12].toFloat();
5668 nb = colors[13].toFloat();
5670 otr = colors[15].toFloat();
5671 otg = colors[16].toFloat();
5672 otb = colors[17].toFloat();
5674 aSmeshActor->SetSufaceColor(colors[1].toFloat(), colors[2].toFloat(), colors[3].toFloat(), delta);
5675 aSmeshActor->SetEdgeColor(er,eg,eb);
5676 aSmeshActor->SetNodeColor(nr,ng,nb);
5677 aSmeshActor->SetOutlineColor(otr,otg,otb);
5681 // Sizes of lines and points
5682 else if (paramNameStr == "Sizes") {
5683 QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
5684 if (sizes.count() == 4) {
5685 if (sizes[0] != "line" || sizes[2] != "shrink") {
5686 MESSAGE("Invalid order of data in Sizes, must be: "
5687 "line:int:shrink:float");
5690 aSmeshActor->SetLineWidth(sizes[1].toInt());
5691 aSmeshActor->SetShrinkFactor(sizes[3].toFloat());
5694 else if (sizes.count() == 6) { // just to support old format
5695 if (sizes[0] != "line" || sizes[2] != "node" || sizes[4] != "shrink") {
5696 MESSAGE("Invalid order of data in Sizes, must be: "
5697 "line:int:node:int:shrink:float");
5700 aSmeshActor->SetLineWidth(sizes[1].toInt());
5701 //aSmeshActor->SetNodeSize(sizes[3].toInt()); // made obsolete
5702 aSmeshActor->SetShrinkFactor(sizes[5].toFloat());
5707 else if (paramNameStr == "PointMarker") {
5708 QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
5709 if( data.count() >= 2 ) {
5711 int aParam1 = data[1].toInt( &ok );
5713 if( data[0] == "std" && data.count() == 3 ) {
5714 int aParam2 = data[2].toInt( &ok );
5715 aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
5717 else if( data[0] == "custom" ) {
5718 VTK::MarkerMap::const_iterator markerIt = aMarkerMap.find( aParam1 );
5719 if( markerIt != aMarkerMap.end() ) {
5720 VTK::MarkerData aMarkerData = markerIt->second;
5721 aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
5728 else if (paramNameStr == "Opacity") {
5729 aSmeshActor->SetOpacity(val.toFloat());
5732 else if (paramNameStr.startsWith("ClippingPlane")) {
5733 QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
5734 // old format - val looks like "Off" or "0:0.5:0:0" (orientation, distance, two angles)
5735 // new format - val looks like "Off" or "0" (plane id)
5736 // (note: in new format "Off" value is used only for consistency,
5737 // so it is processed together with values in old format)
5738 bool anIsOldFormat = ( vals.count() == 4 || val == "Off" );
5739 if( anIsOldFormat ) {
5740 if (paramNameStr == "ClippingPlane1" || val == "Off")
5741 aSmeshActor->RemoveAllClippingPlanes();
5743 SMESH::Orientation anOrientation = (SMESH::Orientation)vals[0].toInt();
5744 double aDistance = vals[1].toFloat();
5745 vtkFloatingPointType anAngle[2];
5746 anAngle[0] = vals[2].toFloat();
5747 anAngle[1] = vals[3].toFloat();
5749 QList<SUIT_ViewManager*> lst;
5750 getApp()->viewManagers(viewerTypStr, lst);
5751 // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
5752 if (viewIndex >= 0 && viewIndex < lst.count()) {
5753 SUIT_ViewManager* vman = lst.at(viewIndex);
5754 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
5756 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];
5758 SMESH::TActorList anActorList;
5759 anActorList.push_back( aSmeshActor );
5760 SMESH::OrientedPlane* aPlane =
5761 SMESHGUI_ClippingDlg::AddPlane(anActorList, vtkView, anOrientation, aDistance, anAngle);
5763 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
5764 aClippingPlaneInfo.Plane = aPlane;
5765 aClippingPlaneInfo.ActorList = anActorList;
5766 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
5773 int aPlaneId = val.toInt( &ok );
5774 if( ok && aPlaneId >= 0 ) {
5775 bool anIsDefinedPlane = false;
5776 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
5777 TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
5778 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
5779 TPlaneInfo& aPlaneInfo = *anIter;
5780 if( aPlaneInfo.PlaneId == aPlaneId ) {
5781 aPlaneInfo.ActorList.push_back( aSmeshActor );
5782 anIsDefinedPlane = true;
5786 if( !anIsDefinedPlane ) {
5787 TPlaneInfo aPlaneInfo;
5788 aPlaneInfo.PlaneId = aPlaneId;
5789 aPlaneInfo.ActorList.push_back( aSmeshActor );
5790 aPlaneInfo.ViewManager = vman;
5792 // to make the list sorted by plane id
5793 anIter = aPlaneInfoList.begin();
5794 for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
5795 const TPlaneInfo& aPlaneInfoRef = *anIter;
5796 if( aPlaneInfoRef.PlaneId > aPlaneId )
5799 aPlaneInfoList.insert( anIter, aPlaneInfo );
5804 } // if (aSmeshActor)
5805 } // other parameters than Visibility
5807 } // for names/parameters iterator
5808 } // for entries iterator
5810 // take into account planes with empty list of actors referred to them
5811 QList<SUIT_ViewManager*> aVMList;
5812 getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);
5814 TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
5815 for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
5816 int aViewId = aPlaneDataIter->first;
5817 if( aViewId >= 0 && aViewId < aVMList.count() ) {
5818 SUIT_ViewManager* aViewManager = aVMList.at( aViewId );
5820 const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;
5822 TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
5823 TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
5824 for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
5825 const TPlaneData& aPlaneData = *anIter2;
5826 int aPlaneId = aPlaneData.Id;
5828 bool anIsFound = false;
5829 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
5830 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
5831 const TPlaneInfo& aPlaneInfo = *anIter3;
5832 if( aPlaneInfo.PlaneId == aPlaneId ) {
5839 TPlaneInfo aPlaneInfo; // ActorList field is empty
5840 aPlaneInfo.PlaneId = aPlaneId;
5841 aPlaneInfo.ViewManager = aViewManager;
5843 // to make the list sorted by plane id
5844 TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
5845 for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
5846 const TPlaneInfo& aPlaneInfoRef = *anIter4;
5847 if( aPlaneInfoRef.PlaneId > aPlaneId )
5850 aPlaneInfoList.insert( anIter4, aPlaneInfo );
5856 // add clipping planes to actors according to the restored parameters
5857 // and update the clipping plane map
5858 TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
5859 for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
5860 int aViewId = anIter1->first;
5861 const TPlaneInfoList& aPlaneInfoList = anIter1->second;
5863 TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
5864 if( anIter2 == aPlaneDataMap.end() )
5866 const TPlaneDataList& aPlaneDataList = anIter2->second;
5868 TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
5869 for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
5870 const TPlaneInfo& aPlaneInfo = *anIter3;
5871 int aPlaneId = aPlaneInfo.PlaneId;
5872 const TActorList& anActorList = aPlaneInfo.ActorList;
5873 SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
5877 SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
5881 SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];
5883 TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
5884 for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
5885 const TPlaneData& aPlaneData = *anIter4;
5886 if( aPlaneData.Id == aPlaneId ) {
5887 SMESH::OrientedPlane* aPlane =
5888 SMESHGUI_ClippingDlg::AddPlane( anActorList,
5890 (SMESH::Orientation)aPlaneData.Orientation,
5891 aPlaneData.Distance,
5894 SMESH::ClippingPlaneInfo aClippingPlaneInfo;
5895 aClippingPlaneInfo.Plane = aPlane;
5896 aClippingPlaneInfo.ActorList = anActorList;
5897 aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
5905 // update all VTK views
5906 QList<SUIT_ViewManager*> lst;
5907 getApp()->viewManagers(lst);
5908 for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
5909 SUIT_ViewModel* vmodel = (*it)->getViewModel();
5910 if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
5911 SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
5912 vtkView->getRenderer()->ResetCameraClippingRange();
5919 \brief Adds preferences for dfont of VTK viewer
5921 \param pIf group identifier
5922 \param param parameter
5923 \return identifier of preferences
5925 int SMESHGUI::addVtkFontPref( const QString& label, const int pId, const QString& param )
5927 int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );
5929 setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );
5932 fam.append( tr( "SMESH_FONT_ARIAL" ) );
5933 fam.append( tr( "SMESH_FONT_COURIER" ) );
5934 fam.append( tr( "SMESH_FONT_TIMES" ) );
5936 setPreferenceProperty( tfont, "fonts", fam );
5938 int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
5939 setPreferenceProperty( tfont, "features", f );
5945 \brief Actions after hypothesis edition
5946 Updates object browser after hypothesis edition
5948 void SMESHGUI::onHypothesisEdit( int result )
5951 SMESHGUI::Modified();
5952 updateObjBrowser( true );
5957 \brief Signal handler closing(SUIT_ViewWindow*) of a view
5958 \param pview view being closed
5960 void SMESHGUI::onViewClosed( SUIT_ViewWindow* pview ) {
5961 #ifndef DISABLE_PLOT2DVIEWER
5962 //Crear all Plot2d Viewers if need.
5963 SMESH::ClearPlot2Viewers(pview);
5967 void SMESHGUI::message( const QString& msg )
5970 QStringList data = msg.split("/");
5971 if ( data.count() > 0 ) {
5972 if ( data.first() == "mesh_loading" ) {
5974 QString entry = data.count() > 1 ? data[1] : QString();
5975 if ( entry.isEmpty() )
5978 _PTR(Study) study = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() )->studyDS();
5980 _PTR(SObject) obj = study->FindObjectID( entry.toLatin1().constData() );
5983 name = obj->GetName().c_str();
5984 if ( name.isEmpty() )
5987 if ( data.last() == "stop" )
5988 application()->putInfo( tr( "MESH_LOADING_MSG_FINISHED" ).arg( name ) );
5990 application()->putInfo( tr( "MESH_LOADING_MSG" ).arg( name ) );
5991 QApplication::processEvents();
5997 \brief Connects or disconnects signals about activating and cloning view on the module slots
5998 \param pview view which is connected/disconnected
6000 void SMESHGUI::connectView( const SUIT_ViewWindow* pview ) {
6004 SUIT_ViewManager* viewMgr = pview->getViewManager();
6006 disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6007 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6009 connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
6010 this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
6015 \brief Return \c true if object can be renamed
6017 bool SMESHGUI::renameAllowed( const QString& entry) const {
6018 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6022 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6026 SalomeApp_DataObject* obj = dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry));
6031 if(appStudy->isComponent(entry) || obj->isReference())
6034 // check type to prevent renaming of inappropriate objects
6035 int aType = SMESHGUI_Selection::type(qPrintable(entry), SMESH::GetActiveStudyDocument());
6036 if (aType == MESH || aType == GROUP ||
6037 aType == SUBMESH || aType == SUBMESH_COMPOUND ||
6038 aType == SUBMESH_SOLID || aType == SUBMESH_FACE ||
6039 aType == SUBMESH_EDGE || aType == SUBMESH_VERTEX ||
6040 aType == HYPOTHESIS || aType == ALGORITHM)
6047 Rename object by entry.
6048 \param entry entry of the object
6049 \param name new name of the object
6050 \brief Return \c true if rename operation finished successfully, \c false otherwise.
6052 bool SMESHGUI::renameObject( const QString& entry, const QString& name) {
6054 SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
6058 SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( anApp->activeStudy() );
6063 _PTR(Study) aStudy = appStudy->studyDS();
6068 bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
6070 SUIT_MessageBox::warning ( anApp->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") );
6075 _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
6076 _PTR(GenericAttribute) anAttr;
6077 _PTR(AttributeName) aName;
6079 if ( obj->FindAttribute(anAttr, "AttributeName") ) {
6081 // check type to prevent renaming of inappropriate objects
6082 int aType = SMESHGUI_Selection::type( qPrintable(entry), SMESH::GetActiveStudyDocument() );
6083 if (aType == MESH || aType == GROUP ||
6084 aType == SUBMESH || aType == SUBMESH_COMPOUND ||
6085 aType == SUBMESH_SOLID || aType == SUBMESH_FACE ||
6086 aType == SUBMESH_EDGE || aType == SUBMESH_VERTEX ||
6087 aType == HYPOTHESIS || aType == ALGORITHM) {
6088 if ( !name.isEmpty() ) {
6089 SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
6091 // update name of group object and its actor
6092 Handle(SALOME_InteractiveObject) IObject =
6093 new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
6095 SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
6096 if( !aGroupObject->_is_nil() ) {
6097 aGroupObject->SetName( qPrintable(name) );
6098 if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
6099 anActor->setName( qPrintable(name) );